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 = 

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

上一篇:.net版本发展历史


下一篇:iOS逆向开发(3):锁定APP的目标类与函数 | reveal | lldb | debugserver | 远程调试