Swift类与结构、存储属性、计算属性、函数与方法、附属脚本等

写了12个Person来复习，不过完成同样的代码需要敲键盘的次数相比OC确实少了很多，这很多应该归功于Swift中不写分号，以及少了OC中的中括号。

一、类与结构体

两者在Swift中差不了多少了

类与结构体有很多相同的地方: (第2,3点是其他语言中不存在的)

1)都可以定义属性/方法/下标(结构体也可以定义方法了)

2)都能初始化(通过构造方法)

3)都能使用扩展(extension)与协议(protocol)

 

4)类与结构体(枚举)中的全局属性/方法:在类中用class关键字,但在结构体中用static

 

类比结构体多的功能:

1)能继承

2)运行时能检查类对象的类型

3)析构释放资源

4)引用计数允许一个类实例有多个引用

 

[java] view plaincopy
 
  1. class Person1{  
  2.     var name = "jack"  
  3. //    class var height:Int = 10   //错误! 类中不能有全局存储属性的, 只能是计算属性. 见下文说明  
  4. }  
  5.   
  6. struct Person2{   //结构体更像Java中的类  
  7.     var age:Int  
  8. //    static var height:Int = 10  //可以设定全局属性, 需要初始化.  
  9. }  
  10.   
  11. //1.1实例化类与结构, 默认构造器  
  12. let p1 = Person1()  
  13. let p2 = Person2(age: 10)  //当使用默认构造器时, 必须初始化里面所有的属性  

 

二、属性(存储属性--计算属性--类属性)

2.1存储属性: 就是存储一个常量或变量,类似Java中的成员变量

[java] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. class Person3{  
  2.     var name:String = "xuneng"  //需要手动初始化  
  3.     var age:Int = 10  
  4.     let height = 175  
  5.     lazy var p1:Person1 = Person1() //延迟, 必须是var  
  6. }  
  7.   
  8. var p3 = Person3()  
  9. p3.name   //通过点语法来访问  
  10. p3.age = 11   //设置  
  11.   
  12. //延迟lazy存储属性: 当使用改属性时才进行初始化, 好处是避免空间浪费  
  13. println(p3.p1)   //这句调用时, p1才进行初始化  

2.2计算属性: 不直接存储值,而是用get/set来做.可用来操作其他属性值的变化

get: 取, 用来封装取值的过程

set: 设, 用来封装设值的过程

 

[java] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. class Person4{  
  2.     var name:String = "jack"  
  3.     var jjLength:Int = 10  
  4.     var age:Int{  //只能是var  
  5.         get{  
  6.             return jjLength * 2  
  7.         }  
  8.         set(newAge){  
  9.             jjLength = newAge / 2  
  10.         }  
  11.     }  
  12. }  
  13. var p4 = Person4()  
  14. p4.age = 10   //当设age为10时,jjLength变为5  

2.2.1 简便的计算属性写法

[java] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. //默认参数newValue, 表示新赋给的值  
  2. class Person5{  
  3.     //用newValue  
  4.     var jjLength:Int = 10  
  5.     var age:Int{  //只能是var  
  6.         get{  
  7.             return jjLength * 2  
  8.         }  
  9.         set{  
  10.             jjLength = newValue / 2  
  11.         }  
  12.     }  
  13.       
  14.     //只读计算属性  
  15.     var height:Int{  
  16.         get{  
  17.             return jjLength * 4  
  18.         }  
  19.     }  
  20.       
  21.     var height2:Int{  //只读直接可以省略get  
  22.         return jjLength * 4  
  23.     }  
  24. }  
  25.   
  26. var p5 = Person5()  
  27. p5.height  
  28. //p5.height = 10  //只读的不能赋值  



2.2.2 注意计算属性的死循环情况

计算属性的值是不固定的,因此不能用let修饰,只能用var

计算属性不能直接赋值

 

[java] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. class Person6{  
  2.     //用newValue  
  3.     var jjLength:Int = 10  
  4.       
  5. //    var height2:Int = 10{  //不能直接赋值, 否则成存储属性了  
  6. //        return jjLength * 4  
  7. //    }  
  8.       
  9.     var age:Int{  
  10.         get{  
  11.             return age   //死循环.  age会调用get方法  
  12.         }  
  13.         set{  
  14.            age = newValue    //死循环.  age设值时会调用set方法  
  15.         }  
  16.     }  
  17. }  

2.3 类属性(或者叫做类型属性)用class关键字修饰.类属性只能是计算属性.

类属性就是类似java中static修饰的属性.一个类只有一份,且多个实例对象共享.可直接用类名调用

[java] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. class Person7{  
  2.     class var name:String{  
  3.         return "xuneng"  
  4.     }  
  5. }  
  6. Person7.name  

2.4 属性监视器: 可用来监视属性变化的2个方法willSet, didSet

计算属性因为有get和set方法,因此监视器其实对计算属性没多大用处.对存储属性用处大

初始化值时, 不会调用willSet与didSet

willSet, didSet和set, get不能共存

[java] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. class Person8{  
  2.     var name:String = "xuneng"{  
  3.         willSet{  
  4.             println("新值为:(newValue)")    //newValue新值  
  5.         }  
  6.         didSet{  
  7.             println("新值为:(oldValue)")   //oldValue表示旧值  
  8.         }  
  9.     }  
  10. }  
  11. var p8 = Person8()  
  12. p8.name = "jack"    //这句调用  


三、函数与方法

3.1 对象方法

类中的方法与函数的一点区别: 方法的第一个参数以后,全是外部参数.名字即为参数名

[java] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. class Person9{  
  2.     func sum(num1:Int , num2:Int){  
  3.         println(num1 + num2)  
  4.     }  
  5. }  
  6. var p9 = Person9()  
  7. p9.sum(10, num2: 10)  //第一个参数以后, 全是外部参数. 相当于加了#  

3.2 类方法. 用class修饰

[java] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. class Person10{  
  2.     class func sum(num1:Int , num2:Int){  
  3.         println(num1 + num2)  
  4.     }  
  5. }  
  6. Person10.sum(10, num2: 10)  

3.3 self与super, 与OC相同

[java] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. class Person11{  
  2.     func sum(num1:Int , num2:Int){  
  3.         self.fun()   //对象方法调用对象方法, 类方法调用类方法  
  4.     }  
  5.       
  6.     func fun(){  
  7.         println("hello")  
  8.     }  
  9. }  


四、下标（附属脚本）

下标, 有的叫附属脚本(subscript)， 新东西。

可以定义在 类/结构体/枚举中，进行快速访问。

[java] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. //格式：也可以设定set/get  
  2. /* 
  3. subscript(index:Int) -> Int{ 
  4.     get{ 
  5.          
  6.     } 
  7.     set{ 
  8.          
  9.     } 
  10. } 
  11. */  
[java] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. struct Person12{   //官方很多用的结构体  
  2.     let jjLength:Int      //结构体在这里可以不初始化  
  3.       
  4.     subscript(index:Int) -> Int{  
  5.         return jjLength * index  
  6.     }  
  7. }  
  8.   
  9. var p12 = Person12(jjLength: 10)  
  10. p12[3]     //直接像访问数组一样访问.  根据jj长度,index为3,值为30  

示例代码见：http://github.com/xn4545945/SwiftLearning

参考：

The Swift Programming Language  

Apple Dev Center

 

转载请注明出处：http://blog.csdn.net/xn4545945  

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/Free-Thinker/p/5076711.html