一.集合

1.集合的基本定義：

var a : Set<Int> = [1,2,3,4,2,3]

如果你打印出來(lái)，并不會(huì)有相同的元素出現(xiàn)

print(a)

結(jié)果就會(huì)是：[1,2,3,4]

2.遍歷集合

for x in a{
    print(x)
    }

遍歷出來(lái)也不會(huì)有相同的元素出現(xiàn)

3.添加元素和刪除元素

就一上面的a數(shù)組為例,添加元素：

a.insert(9)

同理刪除元素：

a.remove(2)

4.并集，交集贷币，差集诚卸，判斷子集

仍然以還是那個(gè)面的a集合為例

var b:Set<Int> = [2,3,4,7,9,11]

print(a.intersect(b))//并集
print(a.union(b))//交集
print(a.subtract(b))//差集（a有而b沒(méi)有的元素）
print(b.isSubsetOf(a))//判斷子集

二.字典（Dictionaries）

1.定義和組成：

存放鍵值對(duì)組合的容器斟珊，字典中的每一個(gè)元素都是由兩部分構(gòu)成的怎静，冒號(hào)前面是鍵完疫，冒號(hào)后面是值

var dict = ["abacus":"算盤","abnormal":"異常的","hello":"你好","good":"你好"]

通過(guò)鍵獲取對(duì)應(yīng)的值（可空類型断医，因?yàn)榻o的鍵有可能沒(méi)有與之對(duì)應(yīng)的值）:key-->value

####2.在字典中加鍵滞乙，刪除鍵，修改元素
print(dict["hello"]!)
print(dict["ashdg"])
dict["shit"] = "狗屎" //在字典里面加一個(gè)鍵
dict.removeValueForKey("hello")//刪除一個(gè)鍵
dict["hello"] = nil//這樣也是闊以的
//修改里面的元素
dict["shit"] = "牛糞"

3.遍歷字典中的值鉴嗤，鍵酷宵，值和鍵

遍歷字典中所有的值

for value in dict.values{
    print(value)
}

遍歷字典中所有的鍵

for key in dict.keys{
    print("\(key)--->\(dict[key])")
}

遍歷字典中所有的鍵和對(duì)應(yīng)的值

for (key,value) in dict{
    print("\(key)--->\(value)")
}

三.函數(shù)

1.函數(shù)的定義

獨(dú)立的，能重復(fù)的使用的功能模塊躬窜。
基本形式：func 函數(shù)名 （參數(shù)列表） -> 返回元素{函數(shù)的執(zhí)行體}浇垦。
函數(shù)名 （外部參數(shù)名 內(nèi)部參數(shù)名：類型，外部參數(shù)名荣挨，內(nèi)部參數(shù)名：類型）
注：可以使用_來(lái)作為外部參數(shù)名表示省略外部參數(shù)名男韧。

func sayHello( personName: String,
    alreadyGreeted:Bool = false) ->String{
    //let greeting = "Hello, " + personName + "!"
    //如果函數(shù)的返回類型不是void，那么函數(shù)中一定有return語(yǔ)句
    //return greeting
    //personName:"王小錘"   會(huì)產(chǎn)生編譯錯(cuò)誤
    if alreadyGreeted{
        return"怎么又是你默垄， " + personName + "!"
    }
    else{
        return "你好此虑，" + personName + "!"
    }
   return "Hello, " + personName + "!"
}
//調(diào)用函數(shù)，寫出函數(shù)的名字口锭，加上參數(shù)的值就可以了


print(sayHello("王大錘", alreadyGreeted: true))
let str = (sayHello("蔣渣渣"))//可以給參數(shù)指定默認(rèn)值朦前，如果函數(shù)的使用的時(shí)候沒(méi)有給參數(shù)輔值就直接使用默認(rèn)值，就像這里的false

2.函數(shù)的基本使用方法

func min1(x: Int,b y: Int) -> Int{
    return x < y ? x : y
}
//調(diào)用時(shí)要用外部參數(shù)名b鹃操，如果不寫b韭寸，內(nèi)外參數(shù)名一致的
print(min1( 3,b: 5))

func sum(nums: Int...) -> Int{//可變參數(shù)列表，參數(shù)的數(shù)量可以為任意個(gè)...
    var total = 0
    for num in nums {
        total += num
    }
    return total
}
print(sum())
print(sum(999))
print(sum(1,2,3,5,6))

//可以使用元組（tuple）來(lái)讓一個(gè)函數(shù)返回多個(gè)數(shù)據(jù)
func minMax(array: [Int]) -> (min: Int, max: Int)? {
    if array.count == 0 {
        return nil
    }
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        }
        else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
    }if let b =     minMax([4823,34,849,8440,9498,]){

print(b.min)   //print(b.0)
print(b.max)   //print(b.1)
}
else{
    print("數(shù)組中沒(méi)有元素＞０６魉拧！")
}

func swap(inout a: Int,inout b: Int) -> Void{
//    let temp = a
//    a = b
//    b = temp
    (a,b) = (b,a)
}
//函數(shù)調(diào)用的傳參都是傳值
var a = 5, b = 10
swap(&a, &b)
print("a = \(b)")
print("b = \(a)")

func createX(inout x : Int){//inout - 輸入輸出參數(shù)（不僅將數(shù)據(jù)傳入函數(shù)中還要從函數(shù)中取出數(shù)據(jù)）
    x = 1000
}
var x = 1
createX(&x)
print(x)

3.相關(guān)練習(xí)：

練習(xí)一：設(shè)計(jì)一個(gè)函數(shù)傳入兩個(gè)整數(shù)m和n（n>m）,計(jì)算m加到n的和

func sum(m:Int,_ n:Int) -> Int{
    let (a,b) = m > n ? (n,m) : (m,n)
        var value = 0
        for i in a...b{
           value +=  i
        }
    return value
    }
print(sum(1,100)

練習(xí)二：設(shè)計(jì)一個(gè)函數(shù)輸入三條變得長(zhǎng)度椰拒，判斷能不能構(gòu)成三角形

func triangle(a: Double,_ b:Double,_ c:Double ) ->Bool{
    assert(a > 0 && b > 0 && c > 0,"三角形的邊長(zhǎng)必須大于0")
    if a + b > c && a - b < c {
        return true
    }
    else{
        return false
    }
}
print(triangle(3.0,2.0,5.0))

練習(xí)三：
設(shè)計(jì)一個(gè)函數(shù)傳入年月日返回該日期是這一年的第幾天

func daysofYear(year: Int,month: Int,day: Int) ->Int{
    var day1 = 0
    var array = [31,28,31,30,31,30,31,31,30,31,31,30]
    if year % 4 == 0 && year % 100 != 0 || year % 400 == 0 {
        array[1] = 29
    }
    for i in 0..<month - 1{
        day1 += array[i]
    }
    day1 += day
    return day1
}
print(daysofYear(200, month: 3, day: 1))

練習(xí)四
設(shè)計(jì)一個(gè)函數(shù)計(jì)算組合數(shù)c（m晶渠，n） = m!/n!/(m-n)！

//求階乘
func factorial(n: Int) -> Double{
    var val = 1.0
    var i = 2
    while i <= n{
        val *= Double(i)
        i += 1
    }
    return 0.0
}
func combine(m:Int,n:Int) -> Double{
    assert(m >= n,"m必須大于等于n")//斷言
    var b:Double
    b = factorial(m) / factorial(n) / factorial(m-n)
    return b
}
func factorial(a: Int) -> Double{
    var val = 1.0
    var i = 1                  //函數(shù)的遞歸調(diào)用（一個(gè)函數(shù)直接或者間接的調(diào)用自身）
                               //1.遞歸公式 2.收斂條件
    while i <= a{             //if n == 0 || n == 1{
                            //return 1
                            //  }
    val *= Double(i)     //  return Double(n) * f (n - 1)
        i += 1
    }
    return val
}
print(combine(3, n: 2))

4.函數(shù)的擴(kuò)展（函數(shù)也可以作為參數(shù)使用燃观，閉包）

func sum(a: Int,_ b: Int) -> Int {
    return a + b
}
func mul(a: Int,_ b: Int) -> Int{
    return a * b
}
//var fn: (Int,Int) ->Int = sum
//fn(2,3)
//fn = mul
//fn(2,3)
func foo(array: [Int],fn: (Int,Int) ->Int) -> Int {
    var sum = array[0]
    for x in array[1..<array.count] {
        sum = fn(sum,x)
    }
    return sum
}
let a = [1,2,3,4,5]

// 1.所有自定義的（Int褒脯，Int）-> Int類型的函數(shù)
print(foo(a, fn: sum))
// 2.傳入二元運(yùn)算符：+—*/%(因?yàn)檫\(yùn)算符也是函數(shù))
print(foo(a, fn: +))
// 3.傳入匿名函數(shù)（閉包）
// 3.1 完整的閉包寫法
print(foo(a, fn: { (a: Int,b: Int) -> Int in
    return a + b
}))
// 3.2 省略掉類型和不必要的括號(hào)
print(foo(a, fn: {a, b in a+b}))
// 3.3 省略參數(shù)名
print(foo(a, fn: {$0 + $1}))
// 3.4 尾隨閉包
print(foo(a) {$0 + $1})
print(foo(a) { (a, b) -> Int in
    return a + b
})

var array = ["game","abacus","hello","cat","good","dislike"]
array.sortInPlace(>)
array.sortInPlace({$0 > $1})
array.sortInPlace() {$0 > $1}
array.sortInPlace {$0 > $1}

4.尾隨閉包

如果函數(shù)的最后一個(gè)參數(shù)是閉包可以寫成尾隨閉包的形式
也就是將閉包放到函數(shù)參數(shù)的圓括號(hào)外面寫在一堆花括號(hào)中
如果函數(shù)后面有尾隨閉包且函數(shù)的圓括號(hào)中沒(méi)有參數(shù)
那么函數(shù)的圓括號(hào)也可以省略（僅限于有尾隨閉包的場(chǎng)景）

array.sortInPlace {
    if $0.characters.count == $1.characters.count{
          return $0 < $1
    }
   return $0.characters.count < $1.characters.count
}
print(array)

5.補(bǔ)充

.數(shù)組的過(guò)濾，映射缆毁，縮減

let array = [37,23,49,93,54,81,29]
1.過(guò)濾

let newArray = array.filter {$0 > 50}
print(newArray)
let newArray1 = array.filter {$0 % 2 == 0}

print(newArray1)

2.映射

let newArray2 = array.map { $0 * $0}
 print(newArray2)
let newArray5 = array.map{sqrt((Double)($0))}
print(newArray5)

3.縮減

let result1 = array.reduce(0, combine: +)
print(result1)
let result2 = array.reduce(1, combine: *)
print(result2)

let result3 = array.reduce(array[0]){
    $1 > $0 ? $1 : $0
}
print(result3)
let strArray = ["I","love","you"]
let result4 = strArray.reduce(""){
    $0 + " " + $1
}
print(result4)

四.面向?qū)ο?/h2>

1.面向?qū)ο蟮膸讉€(gè)步驟：

步驟一：定義類（如果你要用的類蘋果都沒(méi)有提供出來(lái)番川，就執(zhí)行第二步）

//定義類就可以創(chuàng)建出新的類型
//學(xué)生類
class Student{   //首字母都要大寫
    //變量定義到類的外面就叫變量 - variable
    //變量定義到類的里面就叫屬性 - property
    //數(shù)據(jù)抽象 - 找到和學(xué)生相關(guān)的屬性（找名詞）
    var name: String
    var age: Int
    //初始化方法(構(gòu)造方法/構(gòu)造器) - 創(chuàng)建對(duì)象要使用的方法 - constructor
    init(name: String,age: Int){
        self.name = name
        self.age = age
    }
    //行為抽象 - 找到和學(xué)生相關(guān)的方法（找動(dòng)詞）
    func eat(foodName: String) -> Void{
        print("\(name)正在吃飯.")
    }
    func study(courseName: String){
        print("\(name)正在學(xué)習(xí)\(courseName).")
    }
    func watchJapaneseAV(){
        if age >= 18{
            print("\(name)正在觀看島國(guó)愛(ài)情動(dòng)作片.")
        }
        else{
            print("親愛(ài)的\(name)快去看《熊出沒(méi)》吧！")
        }
    }
}
//寫到類里面的函數(shù)叫方法 - method，寫到類的里面一般就叫函數(shù) - function

步驟二：創(chuàng)建對(duì)象（調(diào)用初始化方法

let stu1 = Student(name: "王景亮", age: 25)

步驟三：給對(duì)象發(fā)消息（通過(guò)給對(duì)象那個(gè)發(fā)消息來(lái)解決問(wèn)題）

stu1.eat("")
stu1.study("Swift程序設(shè)計(jì)")
stu1.watchJapaneseAV()

2.類的舉例

//枚舉類型：枚舉是定義符號(hào)常量的最佳方式
          符號(hào)常量總是優(yōu)先于普通常量
enum Gender {
    case Male,Female
}
class Dog {
    var nickname : String
    var sex: Gender
    init(nickname: String, sex: Gender){
        self.nickname = nickname
        self.sex = sex
    }
    func bark(){
        print("\(nickname): 汪汪汪爽彤。。")
    }
    func mate(other: Dog) -> Bool{
        if sex != other.sex{
            print("\(nickname)和\(other.nickname)正在交配缚陷。适篙。。")
            return true
        }
        else{
            return false
        }
    }
}
let dog1 = Dog(nickname: "旺財(cái)", sex: .Male)
let dog2 = Dog(nickname: "大黃", sex: .Female)
dog1.bark()
dog2.bark()
if dog1.mate(dog2){
    print("交配成功箫爷！")
}
else{
    print("交配失斎陆凇！")
}

3.一般我們把類寫成一個(gè)文件虎锚，以便我們調(diào)用和管理

1.線的類：

class Line {
    var start : Point
    var end : Point
    init(start:Point,end:Point){
        self.start = start
        self.end = end
    }
    func intersects(other: Line) ->Bool{
        return false
    }
    var length : Double{
        get {return start.distanceTo(end) }
    }
}

2.三角形類：

class Triangle {
    var va: Point
    var vb: Point
    var vc: Point
    init(va:Point,vb:Point,vc:Point){
        self.va = va
        self.vb = vb
        self.vc = vc
    }

    var perimeter : Double{
        get {
            let ab = va.distanceTo(vb)
            let bc = vb.distanceTo(vc)
            let ac = vc.distanceTo(va)
            return ab + bc + ac
        }
    }
    var area : Double{
        get {
            let ab = va.distanceTo(vb)
            let bc = vb.distanceTo(vc)
            let ac = vc.distanceTo(va)
            let halfp = perimeter / 2
            return  sqrt(halfp * (halfp - ab) * (halfp - bc) * (halfp - ac))
        }
    }
}

3.點(diǎn)類

class Point {
    var x: Double
    var y: Double
    //我們可以在一個(gè)類中定義多個(gè)初始化方法
    convenience init(){
        self.init(x : 0,y : 0)
    }
    //便利初始化方法/便利構(gòu)造器
    //調(diào)用了其他的初始化方法的初始化方法
    convenience init(point:(Double,Double)){
        self.init(x: point.0,y: point.1)
    }
    //指派構(gòu)造器方法硫痰，指派構(gòu)造器
    //被其他初始化方法調(diào)用的初始化方法
    init(x:Double,y:Double){
        self.x = x
        self.y = y
    }
    func moveTo(m: Double,n: Double){
        self.x = m
        self.y = n
    }
    func distanceTo(other: Point) -> Double{
        let x1 = other.x - x
        let y1 = other.y - y
        return sqrt(x1 * x1 + y1 * y1)
    }
}

4.計(jì)算屬性與訪問(wèn)修飾符

-找名詞和動(dòng)詞。名詞會(huì)成為類或者類中的屬性窜护，動(dòng)詞會(huì)成為類中的方法

 // 數(shù)據(jù)抽象
  //行為抽象
 // 初始化方法
 //訪問(wèn)修飾符
 //public (公開(kāi))
 //internal(內(nèi)部的) - 默認(rèn)
 //private (私有)
public class Circle {
    //存儲(chǔ)屬性（保存和元相關(guān)的數(shù)據(jù)的屬性）
     var radius: Double
    init(radius: Double){
        self.radius = radius
    }
    //通常獲得某個(gè)計(jì)算出的值得方法效斑，通常都寫成計(jì)算屬性
     //computational property
    //計(jì)算屬性（通過(guò)對(duì)存儲(chǔ)屬性做運(yùn)算得到的屬性）
    var perimeter: Double {
        //圓的周長(zhǎng)是一個(gè)只讀屬性
        //所以此處只有g(shù)et{}沒(méi)有set{}
        get { return 2 * M_PI * radius }
    }
    var area : Double{
        get { return  M_PI * radius * radius }
    }
}

5.重載運(yùn)算符

有時(shí)在我們寫程序過(guò)程中兩個(gè)對(duì)象不能直接的做 + - * / % 等等的運(yùn)算，我們需要將運(yùn)算符根據(jù)我們的需要重載（其實(shí)這幾種常用的運(yùn)算符也是一種函數(shù)）

func <(one: Student,two: Student) -> Bool {
    return one.age < two.age
}
//運(yùn)算符的重載
let stuArray = [
    Student(name: "wangjingliang", age: 21),
    Student(name: "lee xiaolong", age: 49),
    Student(name: "zhang nima", age: 18),
    Student(name: "Guo jing", age: 26)
]
let newArray = stuArray.sort(<)

for stu in newArray{
    print("\(stu.name): \(stu.age)")
}

五.繼承和多肽

繼承：主要是指柱徙，在父類存在的情況下缓屠，子類能夠繼承父類的相關(guān)屬性。
父類：

enum Gender{
    case Male
    case Female
}

class Pet {
    var nickname : String
    var gender : Gender
    var age : Int
    init(nickname : String ,gender : Gender,age : Int){
        self.nickname = nickname
        self.gender = gender
        self.age = age
    }
    func eat(){
        print("\(nickname)正在吃吃吃")
    }

    func play(){
        print("\(nickname)正在玩耍")
    }
        func shout(){
        print("\(nickname)發(fā)出了叫聲")
    }
}

一個(gè)子類：

class Cat:  Pet{
    var hairColor: String?

    override func shout() {
//override表示重寫护侮，父類有的方法子類可以重新實(shí)現(xiàn)這個(gè)過(guò)程叫方法的重寫敌完，需要在方法前添加override關(guān)鍵字，重寫有時(shí)也被稱為羊初，置換滨溉，覆蓋，覆寫长赞。晦攒。。得哆。
        print("\(nickname)正在喵喵喵勤家。。柳恐。")
    }

    override func play() {
        super.play()            // 調(diào)用父類的方法
        print("\(nickname)正在玩毛線")
    }
    
    func catchmouse(){
        print("\(nickname)正在抓耗子")
    }

}

第二個(gè)子類：

class Dog : Pet {
    var isLarge : Bool
    
    init(nickname: String,gender: Gender,age: Int,isLarge: Bool){
        self.isLarge = isLarge
        super.init(nickname: nickname, gender: gender, age: age)
        
    }
    
    
    override func shout() {
        print("\(nickname)正在汪汪汪伐脖，，乐设，")
    }
    
    override func play() {
        print("\(nickname)正在玩球球")
    }
    
    override func eat() {
        print("\(nickname)正在吃粑粑")
    }
}

let petsArray = [
    Cat(nickname:"加菲",gender: .Female, age:2),
    Dog(nickname: "小王", gender: .Male, age: 3, isLarge: true),
    Dog(nickname: "王景亮", gender: .Male, age: 5, isLarge: false),
    Monkey(nickname: "小芳",gender: .Male, age: 10)
]
for pet in petsArray{
//pet.eat()
//   pet.play()
    // 同樣的對(duì)象類型（Pet類型）接受相同的消息（調(diào)用相同的方法）
    //但是做了不同的事情,這就是多肽（polymorphism）
    // 1.方法的重寫：子類在繼承父類的過(guò)程中讼庇，對(duì)父類已有的方法進(jìn)行重寫，而且不同的子類給出不同的實(shí)現(xiàn)版本
    //2.對(duì)象造型：將子類對(duì)象當(dāng)成父類型來(lái)使用
    //可以通過(guò)if+as近尚？將父類型安全的轉(zhuǎn)換成子類型然后再調(diào)用子類特有的方法
    pet.shout()
    if let dog = pet as? Dog{
        dog.eat()
    }
    else if let cat = pet as? Cat{
        cat.catchmouse()
    }
}

六.總結(jié)

        這是小編的swift學(xué)習(xí)的燒腦的第二周蠕啄，總的來(lái)說(shuō)還是收獲頗多，第一次這么認(rèn)真的學(xué)習(xí)一種編程語(yǔ)言，但是很多地方還是想不明白歼跟，我還會(huì)努力的和媳，希望在接下來(lái)的日子里做得更好，如果你覺(jué)得以上內(nèi)容對(duì)你有所幫助哈街，不妨動(dòng)一下您的貴手留瞳，
點(diǎn)一波關(guān)注，后面我還會(huì)繼續(xù)寫一些這方面的學(xué)習(xí)心得骚秦。有什么不足的地方她倘，
歡迎指出，你們的建議將是對(duì)我最大的支持作箍，謝謝硬梁！