IOS系列swift语言之课时三

今天需要掌握的内容就是：闭包、类、结构体、属性（计算属性和延迟属性）

　　　　同样里面有一些题目，有兴趣的可以做一下.

首先我们需要知道什么是闭包？所谓的闭包就是一个代码块（一般是指函数以及被它捕获的成员变量和对象等）

其次我们需要掌握如何定义类和结构体，和我们学习java有什么不同点.

类的定义

class 类名{

　　//需要定义的属性

}

结构体的定义

struct 结构体名{

　　//需要定义的属性

}

大家看它们的不同就是一个是class，一个是struts，现在先不揭秘让他们的区别，在代码中，我们将会看到它们的不同.

我们先来学习闭包：

　　　　在闭包的使用中，我们会先从一个比较齐全的闭包开始，一步一步进行简化.

var str = "Hello, playground"

 

func outer() -> ()->Void{

    let x = 2

    func inner() {

        print(x)

    }

    return inner

}

 

let result = outer()

result()

//闭包：一个代码块（一般指的就是函数）以及被它捕获的一些

//成员（变量，对象等等）

 

//闭包的种类有三种

//1.就是一个普通的全局函数，这是一个有名字的闭包。

//2.内部函数，比如上面的inner，此函数可以捕获它声明的时候所用到的东西

//3.闭包表达式，类似于c#语言的lambda表达式

 

 

func outer2 (f: ()->Void) {

    f()

func outer3 (f: (Int,Int) -> Int) {

    let re = f(1,2)

    print(re)

}

 

outer3(f: {(a: Int, b: Int) in

    print("test...")

    return a + b

})

//闭包的语法：闭包等价于创建了一个匿名函数

//格式：{(参数名: 类型,参数名： 类型) in  }

 

 

let arr = [1,19,6,8,33]

 

//最完整的闭包写法

//let filtered = arr.sorted(by: {(a: Int,b: Int) in

//

//    return a < b

//})

 

//类型可以依据sorted方法的声明，推断出来，所以可以省略

//let filtered = arr.sorted(by: {(a ,b ) in

//    

//    return a < b

//})

 

 

//因为只有一行代码，自动把此行代码的结果返回出去，所以可以去掉return

//let filtered = arr.sorted(by: {(a ,b ) in

//   // print("sfda")

//    a < b

//})

 

//因为swift自动提供隐含的变量名，以$0开始，所以

//参数可以去掉，因为参数去掉in就没意义，所以in也可以去掉

//let filtered = arr.sorted(by: {  $0 < $1})

 

//因为sorted方法只有一个参数，而且是函数类型的参数

//所以可以把闭包写在小括号的外面

//let filtered = arr.sorted(by:){  $0 < $1}

 

//因为只有一个参数

let filtered = arr.sorted{  $0 < $1}

filtered

 

//swift中的一些符号其实是函数，比如下面的>

let filtered2 = arr.sorted(by: >)

print(filtered2)

 

/***  escaping(跳出，逃出)和自动闭包（autoclosure)*/

 

//自动闭包，就是把表达式自动转换为闭包

//有前提：函数的声明不能有参数，但必须有返回值，返回值的类型，没有要求

func outer3(f: @autoclosure   ()-> Int ) {

    let s = f()

    print(s)

}

outer3(f: 555)

 

//escaping : 函数传递进去时，没有使用，需要加escaping

var farr = [()-> Void]()

func  outer4(f: @escaping () -> Void ) {

    farr.append(f)

}

outer4(f: {print("escaping....")})

farr.first?()

 

//可以这样理解：闭包就是一个函数的替代，简化一些方法的使用

 

 

接下来就是类和结构体的讲解

/********类与结构********************/

 

class SomeClass {

    let a = 5 //存储属性

    var b = 6

}

struct SomeStruct {

    let a = 5

    var b = 6

}

 let lei = SomeClass()

//不行：lei = SomeClass()

//lei.a = 333 不能改

lei.b = 444

let jiegou = SomeStruct()

//jiegou.a = 5555

//jiegou.b = 6666 //a,b 都不能改变值

//a,b不能修改原因就是结构是一个值类型

 

var jiegou2 = SomeStruct()

//jiegou2.a = 222

jiegou2.b = 333

jiegou2.b

/*

 类与结构：

 1.类是引用类型，结构是值类型

 2.类可以继承，结构不能

 

 什么时候用结构？

 1.你的类型，如果只是一些数据的封装，那么可以考虑用结构

 

 用结构的案例：

 矩形：长，宽

 地址：家庭地址，办公地址

 */

 最后面就是属性

/************* 属性 ****************/

 

//存储属性（stored property）

//class SomeClass2 {

//    var p1 = 6

//}

 

class SomeClass2 {

   var p1 = 6 {

      willSet {

         print("before(newValue)")

      }

      didSet {

           print("after(oldValue)")

       }

      

  }

}

let ins = SomeClass2()

ins.p1 = 8

//计算属性

 class SomeClass2 {

    var other =  0

    var p: Int {

        get {

            return other

        }

        set {

            other = newValue

        }

    }  

    //在swift中不能有只写（只有set）

    //可以有只读属性，此时可以省略掉get{}

    var p1: Int {

        print("asdf")

           return 888

    }//p1 end

}

 //属性的demo

class Person  {

    var name = ""

    var _age = 0

    var chengnianren = false

    var age: Int {

        get{

            return _age

        }

        set {

            if newValue >= 18 {

                chengnianren = true

            } else {

                chengnianren  = false

            }

            _age = newValue       

        }

    }

}

let p = Person()

p.age = 20

p.chengnianren

p.age = 16

p.chengnianren

//*********** 延迟属性 **************** 

class A {    

    init() {

        print(" a实例化")

    }

}

let ains = A()

class B {

    let name = "cj"

    lazy var lazyp = A()

}

let bins = B()

bins.name

bins.lazyp

//静态的属性，可以用static与class修饰

//class不能修饰在存储属性上

//静态的属性里面只能访问静态的其它成员

//class修饰的成员是可以被子类所重写的而static修饰的是不能被重写的。

class C {

    static var sp = 5

    var sp2 = 6

    class var sp3: Int {

        get{

            return 555

        }

        set{

            sp = newValue

        }

    }

}

C.sp

C.sp3 = 23

闭包还是有点难理解的，但是细细品味就会有不一样的味道，就像红酒一般得细细品.