IOS系列swift语言之课时三

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

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

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

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

类的定义

class 类名{

　　//需要定义的属性

}

结构体的定义

struct 结构体名{

　　//需要定义的属性

}

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

我们先来学习闭包：

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

 var str = "Hello, playground"

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

     let x = 

     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(,)

     print(re)

 }

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

     print("test...")

     return a + b

 })

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

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

 let arr = [,,,,]

 //最完整的闭包写法

 //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{  $ < $}

 filtered

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

 let filtered2 = arr.sorted(by: >)

 print(filtered2)

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

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

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

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

     let s = f()

     print(s)

 }

 outer3(f: )

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

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

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

     farr.append(f)

 }

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

 farr.first?()

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

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

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

 class SomeClass {

     let a =  //存储属性

     var b = 

 }

 struct SomeStruct {

     let a = 

     var b = 

 }

  let lei = SomeClass()

 //不行：lei = SomeClass()

 //lei.a = 333 不能改

 lei.b = 

 let jiegou = SomeStruct()

 //jiegou.a = 5555

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

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

 var jiegou2 = SomeStruct()

 //jiegou2.a = 222

 jiegou2.b = 

 jiegou2.b

 /*

  类与结构：

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

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

  什么时候用结构？

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

  用结构的案例：

  矩形：长，宽

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

  */

最后面就是属性

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

 //存储属性（stored property）

 //class SomeClass2 {

 //    var p1 = 6

 //}

 class SomeClass2 {

    var p1 =  {

       willSet {

          print("before\(newValue)")

       }

       didSet {

            print("after\(oldValue)")

        }

   }

 }

 let ins = SomeClass2()

 ins.p1 = 

 //计算属性

  class SomeClass2 {

     var other =  

     var p: Int {

         get {

             return other

         }

         set {

             other = newValue

         }

     }  

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

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

     var p1: Int {

         print("asdf")

            return 

     }//p1 end

 }

  //属性的demo

 class Person  {

     var name = ""

     var _age = 

     var chengnianren = false

     var age: Int {

         get{

             return _age

         }

         set {

             if newValue >=  {

                 chengnianren = true

             } else {

                 chengnianren  = false

             }

             _age = newValue       

         }

     }

 }

 let p = Person()

 p.age = 

 p.chengnianren

 p.age = 

 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 = 

     var sp2 = 

     class var sp3: Int {

         get{

             return 

         }

         set{

             sp = newValue

         }

     }

 }

 C.sp

 C.sp3 = 

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