Swift 2.2 基础笔记

• 开发者的第一份 Swift 语言中文学习指南 Swift 学习指引
• Swift 2.2 开发者文档 Swift2.2 英文学习文档
• 关于Swift 中文学习文档(+38页对比参考) Swift2.2 中文学习文档

• 关于 Swift 2.2 学习
• Swift 2.2 学习_01:常量与变量、dynamicType(类型)、元组类型、可选类型(?!)、类型别名(typealias)、字符串、循环控制流（for_in）、条件选择（if\switch）
• Swift 2.2 学习_02:函数类型示例、闭包运用、数组、集合、字典、类
• Swift 2.2 学习_03：枚举类型、类与结构体、属性、实例化方法与类型方法、继承、析构器和构造器、扩展方法、协议
  

  ---

Switf2.2 学习

    Swift 是一种新的编程语言，用于编写 iOS，OS X 和 watchOS应用程序。Swift 结合了 C 和 Objective-C 的优点并且不受 C 兼容性的限制。Swift 采用安全的编程模式并添加了很多新特性，这将使编程更简单，更灵活，也更有趣。

Switf2.2 学习_01

//  MARK : 常量(let)/变量(var)
    let 公司名称 = "AAA";
    print(公司名称)
    // 公司名称 = "腾讯" error://常量值不可修改

    var age = 20
    age = 21

// MARK:- 类型判断
    公司名称.dynamicType   // String.Type
    age.dynamicType      // Int.Type

// MARK:- 类型标注
    var width: Float
    width = 100.0

• 数据基本类型

// MARK:- 数据基本类型
        Int     整形
        String  字符串
        Float   单精度浮点型
        Double  双精度浮点型
        BOOL    布尔类型


//初始化一个布尔类型数据
        var isLogin: Bool
        isLogin = false
        isLogin.dynamicType   //Bool.Type

//同理：
        var islogin = false
        islogin.dynamicType

• 元组类型

// 1. 声明一个元组类型(名称、区域、等级、段位)
        // 字面量初始化
        var 学生信息 = (姓名:"AAA",年龄:20,毕业院校:"中国") 
        //打印：(.0 "AAA", .1 20, .2 "中国")   
        学生信息.dynamicType   //(String, Int, String).Type

// 2. 元组类型赋值
        //var 英雄联盟信息:(String,String,Int,String) 
        英雄联盟信息 = ("群魔觉臭","艾欧尼亚",30,"最强王者")
        //(.0 "群魔觉臭", .1 "艾欧尼亚", .2 30, .3 "最强王者")

// 3. 访问/修改元组元素
        英雄联盟信息.0                 //"群魔觉臭"
        英雄联盟信息.1                //"艾欧尼亚"
        英雄联盟信息.2                //30
        英雄联盟信息.3 = "大师你懂得"  //"大师你懂得"
        英雄联盟信息                  //打印(.0 "群魔觉臭", .1 "艾欧尼亚", .2 30, .3 "大师你懂得")

        学生信息.姓名
        学生信息.年龄
        学生信息.毕业院校

// 4. 拆分元组类型
        let (角色名称,大区,等级,段位) = 英雄联盟信息
        角色名称     //"群魔觉臭"
        大区          //"艾欧尼亚"
        等级          //30
        段位          //"大师你懂得"

• 可选类型(?)

//可选类型的值允许为nil
        var name_1: String = "Admin"............................//"Admin"
        //name_1 = nil //一般数据类型不能为nil
        // error: nil cannot be assigned to type 'String'

// 1. 显示可选类型 表示方法 '?': var name: Int?
        var name_2: String? = "Admin"............................//"Admin"
        //name_2 = nil
        print(name_2)............................//"Optional("Admin")\n"
//显示可选类型解析，在选类型的变量后加上'!'
        if name_2 != nil{
            print(name_2!) ............................//"Admin\n"
        }

//可选绑定
//如果可选类型有值，那么久将其值解析出来赋给另一个常量或变量
        if let name = name_2 {
             print(name)............................//"Admin\n"
        }

// 2. 隐式可选类型 表示方法 '!': var name: Int!
        var name_3: String! = "Admin"  ............................//"Admin\n"
        //name_3 = nil
        if name_3 != nil{
             print(name_3)  ............................//"Admin"
        }

    * 总结： 显示可选类型（'?'）与隐式可选类型（'!'）的共同点在于都可将变量置为nil,不同点在于显示可选类型需要使用'!'解析数据，而隐式可选类型无需使用'!'解析数据

• 类型别名 (typealias)

        typealias HTInt = Int
        var  a: HTInt = 10
        a.dynamicType     ..............//Int.Type

• _ 字符类型 _

// 1. 创建一个空的字符串
        let str_1: String
        var str_2 = ""
        var str_3 = String()
        ======================================================

// 2. 可变/不可变字符串
        str_1 = "123"
        //str_1 ="789" // let 声明的常量只能被初始化一次
        str_2 = "ABCD"
        ======================================================

// 3.字符串长度 or 是否为空
        str_2.characters.count //获取长度
        str_2.isEmpty
        str_3.isEmpty
        ======================================================

// 4. 字符串的拼接
        str_3 = str_2 + "F"
        var str = str_2 + "F"

        str.append(Character("G")
        str.append(CharacterOf("HIJ")
        //str.stringByAppendingString(<aString: String)
        //str.stringByAppendingFormat(format: String, arguments: CVarArgType)
        ======================================================

// 5. 字符串索引
        /*
        str.characters.count
        str.startIndex
        str.endIndex
        */
//successor() 当前下标
        str.startIndex.successor().successor()

//predecessor() 当前下标 - 1
        str.endIndex.predecessor()
        ======================================================

// 6. 字符串的插入
        str.insert("!", atIndex: str.endIndex)
        str.insert("@", atIndex: str.endIndex.advancedBy(-8))
        str.insertContentsOf("???".characters, at: str.endIndex)
        ======================================================

// 7. 字符串的截取
        var tmp = str.substringToIndex(str.endIndex.advancedBy(-8))
        tmp = tmp.substringFromIndex(str.startIndex.successor())

        //截取范围
        //a...b : [a,b]
        //a..<b : [a,b)

        let range = tmp.startIndex.successor()...tmp.endIndex.advancedBy(-2)
        tmp.substringWithRange(range)
        ======================================================


//课堂练习:截取身份证的年月日

        var IDCard = "510122199123456789"

        let rang_1 = IDCard.endIndex.advancedBy(-12)...IDCard.endIndex.advancedBy(-5)
        IDCard.substringWithRange(rang_1)

        let rang_2 = IDCard.startIndex.advancedBy(6)..<IDCard.endIndex.advancedBy(-4)
        IDCard.substringWithRange(rang_2)

        ======================================================

// 8. 字符串的删除
        //tmp.removeRange(<#T##subRange: Range<Index>##Range<Index>#>)
        //tmp.removeAtIndex(<#T##i: Index##Index#>)
        //tmp.removeAll()
        ======================================================

// 9. 字符串的比较
        // && || !
        let account = "admin"
        let password = "123"

        if account == "admin" && password == "123"{
             print("登陆成功！")
        }else{
            print("登录失败！！")
        }

        ======================================================
// 10. 字符串查询
        let net = "www.baidu.com"
        //查询是否包含
        net.containsString("baidu")
        //查询首部
        net.hasPrefix("www")
        //查询尾部
        net.hasSuffix("com")

• _ 控制流 _

//传统C语言风格的For循环在Swift 2.2 中已经被遗弃
//计算 0-100 的和

// 1. for-in
            var sum = 0
            for idx in 0...100{
                sum += idx
            }
            print(sum)
======================================================
// 2. while
            sum = 0
            var idx = 0
            while idx <= 100 {
                sum += idx
                //Switf 2.2 以后，不能使用'++''--',而是使用'+=''-='
            idx += 1
}
            sum
======================================================

// 3. repeat...whlie 
// do...while 替换成 repeat...whlie 

            idx = 0
            sum = 0
            repeat {
                sum += idx
                idx += 1
            }while idx <= 100
            sum

• _ if / Switch _

            let flag = 1
                switch flag{
                    case 1 :
                        print("星期一")
                    case 2 :
                        print("星期二")
                    case 3 :
                        print("星期三")
                    case 4 :
                        print("星期四")
                    case 5 :
                        print("星期五")
                    case 6,7 :
                        print("周末")
                    default :
                        print("异常信息")
                }
======================================================
                let  point = (0,10)
                 //'_'占位符 用户忽略某些特定的内容
                switch point{
                    case (0,0) :
                        print("在原点")
                    case (0,_) :
                        print("在Y轴")
                case (_,0) :
                        print("在X轴")
                default :
                        print("异常信息")

                }
======================================================
                let 描述 = "四大天王"
                switch 描述{
                    case "四大天王" :
                        print ("刘德华,张学友,郭富城,黎明")
                    case "小虎队" :
                        print ("苏有朋,陈志明,吴奇隆")
                    case "东北F4" :
                        print ("小沈阳,宋小宝,赵四,刘能")
                    default :
                        print ("异常信息")
                }

Switf2.2 学习_02

• _ 函数 func _

// func 关键字

// 1、函数形式
        func 函数名称(参数) -> 返回值 {
             函数体
        }
======================================================
// 2、函数示例
        // 2.1、无参数无返回值
        func sayHello() {
            print("Hello!")
        }
        sayHello()

        // 2.2、有参数无返回值
        func sayHelloWith(name: String) {
            print("Hello, \(name)!")
        }
        sayHelloWith("Tom")

        // 2.3、有参数有返回值
        func sumOf(a: Int, b: Int) -> Int {
            return a + b
        }
        sumOf(10, b: 20)
======================================================
// 3、外部参数
        // func 函数名(外部参数名 内部参数名:参数类型...)
        // 默认情况下，程序会为函数除第一个参数之外的所有参数设置外部参数，外部参数名字和内部参数的名字默认情况下是一致的。
        // 设置默认参数只需在参数后面赋值即可，如下面的‘是否加密’参数

        func isLogin(账号 account: String, 密码 password: String, 是否加密 isEncryption: Bool = true) -> Bool {
        if account == "Admin" && password == "123" {
            return true
        }else {
            return false
          }
        }

isLogin(账号: "Admin", 密码: "123", 是否加密: true) //.....true
isLogin(账号: "Admin", 密码: "123")     //.....true

// 可通过‘_’忽略外部参数
func maxOf(a: Int, _ b: Int) -> Int {
    return a > b ? a : b
}
maxOf(10, 20)


// 4、函数返回值
        // 返回元组类型的值（返回多个值）

        let nums = [3, 0, 9, 4, 6, 2]

        func maxAndMinWith(nums: [Int]) -> (Int, Int) {
            var min = nums[0]
            var max = nums[0]
            for idx in 0..<nums.count {

                min = nums[idx] < min ? nums[idx] : min;
                max = nums[idx] > max ? nums[idx] : max
            }
            return (min, max)
        }

        let (min, max) = maxAndMinWith(nums)
        min     // = 0
        max     // = 9 

// 5、函数类型

        // sumOf: (Int, Int)->Int
        // maxAndMinWith: ([Int])->(Int, Int)
        // sayHello: ()->Void

// 6、函数类型作为函数参数类型

        func maxInThreeNum(a: Int, b: Int, c: Int, function: (Int, Int) ->Int) -> Int {
            var max = function(a, b)
            max = function(max, c)
            return max
        }

        maxInThreeNum(1, b: 7, c: 3, function: maxOf)

• _ 闭包 _

// 1、形式：{(参数列表)-> 返回值 in 闭包体}

        var sum = {(a: Int, b: Int)->Int in
            return a + b
        }

        sum(10, 20)

// 2、闭包简写形式
        // 2.1、省略类型与返回值
        sum = {a, b in
        return a + b
        }
        sum(10, 20)

        // 2.2、$+下标表示第几个参数；
        sum = {
            return $0 + $1
        }
        sum(10, 20)

// 3、案例：通过闭包实现传值
        class ViewController {
            func viewDidLoad() {

                let detailVc = DetailViewController()

                detailVc.getInfo { (account, password) in
                    print("\(account), \(password)")
                }
            }
        }

        class DetailViewController {
            func getInfo(info: (String, String)->Void) {

                info("Admin", "123")
            }
        }

        let vc = ViewController()
        vc.viewDidLoad()

• 数组

// 1、数组声明
        var arr_0: Array<Int>
        var arr_1: [Int]
        var arr_2: [AnyObject]

// 2、创建一个空的数组
        var arr_3 = [Int]()
        var arr_4 = Array<Int>()

// 3、字面量
        var numbers = [1, 2, 3, 4, 5]

// 4、isEmpty、count
        numbers.isEmpty
        numbers.count

// 5、数组遍历
        numbers[0]
        numbers[0] = 8

        for idx in 0..<numbers.count {
             print(numbers[idx])
        }

        for value in numbers {
            print(value)
        }

        for (idx, value) in numbers.enumerate() {
            print("\(idx) = \(value)")
        }

// 6、添加/插入元素
        numbers.append(6)
        numbers.insert(0, atIndex: 0)

// 7、统一修改元素[需要删除对象的下标]
        numbers[2...4] = [7, 8, 9]
        numbers

        numbers[0...2] = [1, 2]
        numbers

        numbers[3...5] = []
        numbers

// 8、数组相加
        arr_0 = [1, 2]
        arr_1 = [3, 4, 5]

        numbers = arr_0 + arr_1
        numbers

// 9、移除

        //numbers.removeAll()
        //numbers.removeLast()
        //numbers.removeFirst()
        //numbers.removeAtIndex(Int)

• _ 集合 _

// 1、声明
        var set_1: Set<String>

// 2、创建一个空的集合
        var set_2 = Set<String>()

// 3、字面量初始化
        // 在使用字面量初始化集的时候，我们需要为其制定类型（Set）。
        var sets: Set = ["刘德华", "郭富城", "黎明", "张学友"]

        sets.count
        sets.isEmpty

// 4、遍历
        for value in sets {
            print(value)
        }

// 5、contains
        sets.contains("刘德华")

// 6、insert
        sets.insert("周杰伦")

// 7、remove
        sets.remove("刘德华")

    ===============================
    let sets_01: Set = [1, 2, 3, 4]
    let sets_02: Set = [2, 3, 4, 5]

    // 并集
    sets_01.union(sets_02).sort()            // ............[1, 2, 3, 4, 5]
    // 交集
    sets_01.intersect(sets_02).sort()        // ............[2, 3, 4]
    // 补集
    sets_01.exclusiveOr(sets_02).sort()      // ............[1, 5]

• 字典

// 1、声明
        var dict_1: [String:String]

// 2、创建空字典
        var dict_2 = [String: AnyObject]() //.................[:]

// 3、字面量
        var 学生信息 = ["姓名":"小x", "年龄":21, "单位": "XX科技"]

        学生信息.count
        学生信息.isEmpty

// 4、访问/修改元素
        学生信息["姓名"]
        学生信息["姓名"] = "卡特琳娜"

        学生信息["联系方式"] = 9090980
        print(学生信息)

// 5、遍历字典元素
        for (key, value) in 学生信息 {
            print("\(key):\(value)")
        }

        [String](学生信息.keys)
        [NSObject](学生信息.values)

// 6、删除
        学生信息.removeValueForKey("联系方式")

        学生信息.updateValue(18, forKey: "年龄")

• 类

        class Person {
            var name: String!
            var age: Int!
            var IDCard: Int!
            var address: String!
        }

        class Teacher: Person {
            var 科目: String!
        }

        // 创建对象
        let tea = Teacher(
        // 赋值属性
        tea.name = "AAA"
        tea.age = 18
        tea.科目 = "iOS/ Swift 开发"

        // 访问属性
        tea.name
        tea.age

        class Student {
             // 给属性添加默认值
             var name = ""
            var age  = 0

            // 实例化方法
            func buyWater() {
                print("老师，水已经买好了！")
            }
            // 类方法
            class func buyBooks() {
                print("老师，书已经买好了！")
            }

            // 自定义初始化方法
            init(name: String, age: Int) {
                self.name = name
                self.age  = age
            }
        }

        Student.buyBooks()


        let stu = Student(name: "Admin", age: 23)
        stu.buyWater()
        stu.name

Switf2.2 学习_03

• 枚举类型

enum 方向 {
    case 东方
    case 南方
    case 西方
    case 北方
}

enum 四大天王 {
    case 刘德华, 郭富城, 张学友, 黎明
}

var 逃亡的方向 = 方向.东方

逃亡的方向 = .南方


switch 逃亡的方向 {
    case .南方:
        print("南方！")
    case .北方:
        print("北方！")
    case .西方:
        print("西方！")
    case .东方:
        print("东方！")
}

switch 逃亡的方向 {
    case .东方:
        print("安全！")
    default:
        print("不安全！")
}

• 类与结构体

        class Person {
            var name = ""
            var age: Int!

            func sayHi() {
                print("Hi")
            }

            // final 关键字可防止重写
            final func buySomthing() {

            }
        }

        struct CGPoint {
            var x = 0.0
            var y = 0.0
        }

// 实例化对象
        let person = Person()

// 结构体的逐一成员初始化方法
        let point  = CGPoint(x: 100, y: 100)

// 访问类或结构体的属性
        person.name
        point.x

// 结构体是值类型，类是引用类型
        // 值类型主要是值的拷贝；
        // 引用类型主要是指针的复制；

// 值类型示例
        var p1 = point

        p1.x
        p1.y

        p1.x += 10
        p1.x

        point.x

// 引用类型示例
        person.name = "Tom"
        person.age  = 22

        let per_1 = person

        per_1.name
        per_1.age

        per_1.age = 28

        person.age

• _ 属性 _

class Dog {
    // 1、存储属性
    let id = 0         // 常量存储属性
    var name: String!  // 变量存储属性

    // 2、延迟存储属性
    // 当第一次去访问该属性的时候才会被创建。
    lazy var color = "黄色"

    // 3、计算属性 setter / getter
    var age: Int!

    var yearOfBirth: Int {
        get {
            return 2016 - self.age
        }

        set {
            self.age = 2016 - newValue
        }
    }

        // 只有get方法的属性叫只读属性；
        var food: String {
            return "狗粮" // 默认Get方法
        }
        // 4、类型属性：static
        static var 编号: Int = 0
    }

    struct CGSize {
        let width  = 120.0
        var height = 0.0
        static var 编号: Int = 0
    }

    Dog.编号 = 1001
    CGSize.编号 = 1002

    let size = CGSize(height: 100.0)

    // size.height = 200 // let 声明的结构体变量，即使属性是可变的，也不能被修改。

    let dog = Dog()
    dog.name = "小黄"
    // dog.id   = 1001 // error

    dog.age = 3
    dog.yearOfBirth

    dog.yearOfBirth = 2008
    print(dog.age)

• _ 方法 _

    class ToolsInClass {

        // 实例化方法
        func sayHi(name: String) {
            print("Hi, \(name).")
        }

        // 类型方法
        class func sayHello() {
             print("Hello, world!")
        }
    }

        struct ToolsInStruct {

        var x = 0, y = 0

        // 如果在结构体方法中，改变自身属性的值，需要在func关键字前添加‘mutating’
        mutating func moveByX(x: Int, y: Int) {
                self.x += x
                self.y += y
            }

            func sayHi(name: String) {
                print("Hi, \(name).")
            }
        }


        let toolInClass = ToolsInClass()
        var toolInStruct = ToolsInStruct(x: 10, y: 10)

        toolInClass.sayHi("Tom")
        toolInStruct.sayHi("Tom")
        toolInStruct.moveByX(3, y: 7)
        toolInStruct.x
        toolInStruct.y

        ToolsInClass.sayHello()


        func swap(inout a: Int, inout b: Int) {
            let tmp = a
            a = b
         b = tmp
        }

        var a = 10
        var b = 20

        swap(&a, b: &b)

        a
        b

• _ 继承 _

class Student: Person {
    override func sayHi() {
        print("Hi, Girl!")
    }

    /*
    override buySomthing() {

    }
     */
}

    let stu = Student()
    stu.name = "Petter"
    stu.age  = 20
    stu.sayHi()

    // MARK:- 析构器和构造器

    class Tool {

        // 属性观察器
        var value: Int! {
            willSet {
                print("将要设置‘value’属性！其值为\(newValue)")
            }

            didSet {
                print("已经设置‘value’属性，设置之前的值为\(oldValue)")
            }
        }

        // 构造器，对象创建时调用；
        init() {
            print("有一个对象正在创建！")
        }
        // 析构器，对象销毁时调用；
        deinit {
            print("有一个对象已经销毁！")
        }
    }

    var tool: Tool! = Tool()

    // tool = nil

    // MARK:- 扩展

    extension Tool {
        // 只能扩展计算属性
        var code: Int {
            get {
                return 1001
            }
        }
        func buyBooks() {
            print("买书！")
        }
    }

    tool.buyBooks()
    tool.code


    tool.value = 10
    tool.value = 20

• _ 协议 _

protocol 协议名称 {
    var money: Int { get set}
    func buySomking()
  }

class Teacher: Person, 协议名称{

   var money: Int {
        set {

           }
        get {
              return 100
           }
   }
  func buySomking() {
           print("买零食！")
      }
  }

// 可选协议
@objc protocol 可选协议 {
      optional func buyWater()
    }
class Cat: 可选协议 {

    }