iOS学习笔记43-Swift(三)类

时间  2019-12-05
标签 ios 学习 笔记 swift 栏目 iOS 繁體版
原文   原文链接

1、Swift的类class

做为一门面向对象语言，类也是Swift的很是重要的类型，咱们先来看下一个简单的类swift

//Swift中一个类能够不继承于任何其余基类，那么此类自己就是一个基类
class Person {
    //定义属性
    var name:String
    var height = 0.0
    //构造器方法，注意若是不编写构造方法默认会自动建立一个无参构造方法
    init(name:String){
        self.name = name
    }
    //析构器方法，在对象被释放时调用，相似于ObjC的dealloc，注意这里没有括号和参数，没法直接调用
    deinit{
        println("deinit...")
    }
    //定义对象方法
    func showMessage(){
        println("name=\(name),height=\(height)")
    }    
}
//建立类的对象
var p = Person(name: "Liuting")
p.height = 170.0
p.showMessage() //结果：name=Liuting,height=170.0
 
//类是引用类型
var p2 = p
p2.name = "XiaoMing"
println(p.name) //结果：XiaoMing
//“===”表示等价于，这里不能使用等于“==”，等于用于比较值相等，p和p2是不一样的值，可是指向的对象相同
if p === p2 { 
    println("p===p2") //p等价于p2,表示两者指向同一个对象
}

2、属性

Swift中淡化了成员属性的概念，把属性分为两种：ide

  1. 存储属性：
    不管从概念上仍是定义方式上来看，存储属性更像其余语言中的成员变量，可是不一样的是：
  • 能够控制读写操做（var表示可读可写，let表示只读）
  • 经过属性监视器来属性的变化（willSet、didSet）
  • 快速实现懒加载功能（lazy修饰）
  1. 计算属性：
    计算属性并不直接存储一个值，而是提供getter来获取一个值，或者利用setter来间接设置其余属性。
下面是对象属性使用实例：
class Account {
    //定义存储属性，设置默认值，添加属性监听器
    var balance:Double = 0.0{
        //即将赋值时调用
        willSet{
            //注意此时修改balance的值没有用
            self.balance = 2.0
            //newValue表示即将赋值的新值,而且在属性监视器内部调用属性不会引发监视器循环调用
            println("Account.balance willSet,newValue=\(newValue),value=\(self.balance)")
        }
        //赋值完成后调用
        didSet{
            //注意此时修改balance的值将做为最终结果
            self.balance = 3.0
            //oldValue表示已经赋值的旧值,而且在属性监视器内部调用属性不会引发监视器循环调用
            println("Account.balance didSet,oldValue=\(oldValue),value=\(self.balance)")
        }
    }
}
class Person {
    //firstName、lastName、age是存储属性
    var firstName:String //var定义表示该存储属性可读可写
    var lastName:String
    let age:Int //let定义表示该存储属性只读
    
    //属性的懒加载，第一次访问才会初始化
    lazy var account = Account()//在Swift中懒加载的属性不必定就是对象类型，也能够是基本类型
     
    //fullName是一个计算属性，在get、set方法中不能直接访问计算属性，不然会引发循环调用
    var fullName:String{
        //获取该计算属性时调用
        get{
            return firstName + "." + lastName
        }
        //设置该计算属性时调用
        set{
            //set方法中的newValue表示即将赋值的新值，这里是分割字符串
            let array = split(newValue, maxSplit: Int.max, 
                                allowEmptySlices: false, 
                                     isSeparator: {$0=="."})
            if array.count == 2 {
                firstName = array[0]
                lastName = array[1]
            }
        }
    }
    //构造器方法，注意若是不编写构造方法默认会自动建立一个无参构造方法
    init(firstName:String, lastName:String, age:Int){
        self.firstName = firstName
        self.lastName = lastName
        self.age = age
    }
    //定义方法
    func showMessage(){
        println("name=\(self.fullName)，age=\(self.age)")
    }
}
//建立对象
var p = Person(firstName: "Liu", lastName: "Ting", age:22)
p.showMessage() //结果：name=Liu.Ting，age=22
p.fullName = "Liu.HAHA" //设置计算属性
p.showMessage() //结果：name=Liu.HAHA，age=22

p.account.balance = 10
/* 下面是存储属性监听器方法打印：
Account.balance willSet,newValue=10,value=0.0
Account.balance didSet,oldValue=10,value=3.0
*/
println("p.account.balance=\(p.account.balance)") //结果：p.account.balance=3.0
  1. 计算属性并不直接存储一个值，而是提供getter来获取一个值，或者利用setter来间接设置其余属性；
  2. lazy属性必须有初始值，必须是变量不能是常量，由于常量在构造完成以前就已经肯定了值；
  3. 在构造对象方法以前存储属性必须有值（可选类型除外），不管是变量属性仍是常量属性，这个值既能够在属性建立时指定，也能够在构造方法内指定；
  4. 存储属性的默认值设置不会引发属性监视器的调用（另外在构造方法中赋值也不会引发属性监视器调用），只有在外部设置存储属性才会引发属性监视器调用；
除了上面的对象属性外，咱们还能够定义类的属性：
class Student {
    //定义类的属性只须要在前面加static关键字便可，也是分为存储属性和计算属性，这里是计算属性
    static var skin:Array<String>{
        //只定义了getter，表示该计算属性是只读的
        get{
            return ["yellow", "white", "black"]
        }
    }
}
//读取类的属性
for color in Student.skin {
    println(color)
}

3、方法

Swift的类中的方法可分为如下几个类别：
  1. 构造器方法
  • 默认构造器方法（当存在有参数的指定构造器方法，被覆盖）
  • 指定构造器方法
  • 便利构造器方法
  1. 析构器方法
  2. 对象方法
  3. 类方法
如下是方法使用实例：
class Person {
    //定义属性
    var name:String
    var height:Double
    var age = 0
    //1.2.指定构造器方法，注意若是不编写构造方法，默认会自动建立一个无参构造方法
    init(name:String, height:Double, age:Int){
        self.name = name
        self.height = height
        self.age = age
    }
    //1.3.便利构造方法，经过调用指定构造方法、提供默认值来简化构造方法实现
    convenience init(name:String){
        self.init(name:name, height:0.0, age:0)
    }
    //2.析构方法，在对象被释放时调用，注意此方法没有括号，没有参数，没法直接调用
    deinit{
        println("deinit...")
    }
    //3.对象方法
    func modifyInfoWithAge(age:Int, height:Double){
        self.age = age
        self.height = height
    }
    //4.类方法，使用class修饰的方法便是类方法
    class func showClassName(){
        println("Class name is Person")
    }      
}
//经过便利构造方法建立对象
var p = Person(name: "liuting")
//调用对象方法
p.modifyInfoWithAge(22，height: 170)
//调用类方法
Person.showClassName()
  1. 除构造方法、析构方法外，其余方法的参数默认除了第一个参数是局部参数，从第二个参数开始既是局部参数又是外部参数。可是，对于函数，默认状况下只有默认参数既是局部参数又是外部参数，其余参数都是局部参数。
  2. 构造方法的全部参数默认状况下既是外部参数又是局部参数
  3. 只有便利构造器方法才能调用当前类的指定构造方法
  4. 有参数的指定构造器方法会覆盖调用默认的无参构造器方法
  5. 一个对象被释放前，先自动调用本身的析构方法，而后一层一层往上调用父类的析构方法

4、下标脚本

下标脚本是一种访问集合的快捷方式，若是咱们自定义的类具备集合类型的功能，咱们能够定义下标脚原本快捷访问该类属性，定义下标脚本是经过关键字subscript进行的。函数

class Record {
    //定义属性，store是Record内部的存储结构，这里是字典
    var store:[String:String]
    //指定构造方法
    init(data:[String:String]){
        self.store = data
    }
    //下标脚本，下标索引为整形（注意也能够实现只有getter的只读下标脚本）
    subscript(index:Int) -> String{
        get{
            //字典的key进行排序后根据Index整形索引获取字典的值
            var key = sorted(Array(self.store.keys))[index]
            return self.store[key]!
        }
        set{
            //字典的key进行排序后根据Index整形索引设置字典的值
            var key = sorted(Array(self.store.keys))[index]
            self.store[key] = newValue //newValue和属性同样使用
        }
    }
    //下标脚本，下标索引为字符串
    subscript(key:String) -> String{
        get{
            return store[key]!
        }
        set{
            store[key] = newValue
        }
    }
}
//建立对象
var record = Record(data:["name":"liuting","sex":"male"])
println("r[0]=\(record[0])") //结果：r[0]=liuting
record["sex"] = "female"
println(record["sex"]) //结果：female

5、继承

和ObjC同样，Swift也是单继承的（能够实现多个协议，此时协议放在后面），子类能够调用父类的属性、方法，重写父类的方法，添加属性监视器，甚至能够将只读属性重写成读写属性。code

//定义一个父类
class Person {
    var firstName:String
    var lastName:String
    var age:Int = 0
    var fullName:String{
        get{
            return firstName + " " + lastName
        }
    }
    //指定构造方法
    init(firstName:String,lastName:String){
        self.firstName = firstName
        self.lastName = lastName
    }
    //对象方法
    func showMessage(){
        println("name=\(self.fullName),age=\(self.age)")
    }
    //经过final声明，子类没法重写
    final func sayHello(){
        println("hello world.")
    }
}
//定义子类
class Student: Person {
    //重写属性，为属性添加监视器，重写都须要加override关键字
    override var firstName:String{
        willSet{
            println("firstName willSet")
        }
        didSet{
            println("firstName didSet")
        }
    }
    //添加子类属性
    var score:Double
     
    //子类指定构造方法必定要调用父类构造方法
    //而且必须在子类存储属性初始化以后调用父类构造方法
    init(firstName:String, lastName:String, score:Double){
        self.score = score
        super.init(firstName: firstName, lastName: lastName)
    }
    //便利构造方法
    convenience init(){
        self.init(firstName:"", lastName:"", score:0)
    }
    //将只读属性重写成了可写属性
    override var fullName:String{
        get{
            return super.fullName;
        }
        set{
            let array = split(newValue, maxSplit: Int.max, 
                                allowEmptySlices: false, 
                                     isSeparator: { $0 == "." })
            if array.count == 2 {
                firstName = array[0]
                lastName = array[1]
            }
        }
    }
    //重写对象方法
    override func showMessage() {
        println("name=\(self.fullName),age=\(self.age),score=\(self.score)")
    }
     
}
//建立子类对象
var p = Student()
p.firstName = "liu"
p.showMessage() //结果：name=liu,age=0,score=0
p.fullName = "Liu.Ting"
p.showMessage() //结果：name=Liu.Ting,age=0,score=0
p.sayHello()
  1. 只有指定构造方法才能调用父类的构造方法。
  2. 若是父类中存在有参数的指定构造方法，子类的指定构造方法不会自动调用父类无参的指定构造方法。
  3. 若是父类仅有一个无参构造方法（不论是否包含便利构造方法），子类的构造方法默认就会自动调用父类的无参构造方法（这种状况下能够不用手动调用）。
  4. 常量属性只能在定义它的类的构造方法中初始化，不能在子类中初始化
  5. 一个对象被释放前，先自动调用本身的析构方法，而后一层一层往上调用父类的析构方法。
  6. 便利构造方法必须调用同一个类中的其余指定构造方法（能够是指定构造方法或者便利构造方法），不能直接调用父类构造方法。

有什么问题可在下方评论区中提出！O(∩_∩)O哈！
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程