Swift－指定构造方法和便利构造方法

太过爱你忘了你带给我的痛 2023-10-17 09:59 29阅读 0赞

指定构造方法和便利构造方法

/*
     1、指定构造方法和便利构造方法（Designated Initializer and Convenience Initializers）
     便利构造：类类型（针对类class）
     */
    print("1、指定构造方法和便利构造方法")
    class AB {
        var a:Int
        var b:Int
        //指定构造方法，不允许出现构造代理器，self.init(...)
        init(a:Int,b:Int) {
            self.a = a
            self.b = b
            print("class AB init")
        }
        //便利构造方法 －－ 一定是通过调用其他的构造方法来实现初始化，self.init（...）
        convenience init(a:Int) {
    //        self.a = a
    //        b = 0
            self.init(a:a,b:0)
        }
        //便利构造方法也可以通过调用其他的 便利构造方法实现初始化
        convenience init() {
            self.init(a:0)
        }
    }
    
    /*
     2、派生类的构造方法
     */
    
    /*
     3、构造器链－－指定构造器和便利构造器之间的调用规则
      （1）指定构造器必须调用其直接父类的指定构造器
      （2）便利构造器必须调用同类中定义的其他构造器（指定／便利）
      （3）便利构造器最终以调用一个指定构造器结束
       指定构造器总是向上代理
       便利构造器总是横向代理
     */
    print("\n2、派生类的构造方法")
    class CD: AB {
        var c:Int
        var d:Int
        //构造方法默认是不会被继承，基类的存储属性只能通过基类的构造方法来初始化
        //派生类引入的存储属性要先被初始化，然后再调用父类的构造方法对父类的属性进行初始化
        //只能通过调用父类的指定构造方法来对父类的属性进行初始化，不能通过便利构造方法
        init(c:Int,d:Int) {
            self.c = c
            self.d = d
            super.init(a: 0, b: 0)
        }
        //便利构造器，只能通过调用本类中的构造器完成初始化，不允许出现super.init()
        convenience init(a:Int,b:Int,c:Int,d:Int) {
            self.init(c:c,d:d)
        }
    }
    
    /*
     4、两段式构造－－构造过程分为两个阶段
     （1）第一阶段：确保所有存储属性都初始化完毕
     （2）第二阶段：对父类存储属性作进一步处理
        可以防止属性在被初始化之前访问，也可以防止属性被另外一个构造器意外赋值
     */
    print("\n4、两段式构造")
    
    /*
     5、派生类构造方法定义时的编译器安全性检查
     （1）首先应该将派生类引入的存储属性初始化，然后再向上代理父类的指定构造方法
     （2）首先调用父类中的指定构造器实现父类中属性的初始化之后，才可以访问父类中的属性
     （3）在编写便利构造器方法时，首先要调用同类中的其他构造方法，才可以访问任意属性
     （4）在第一阶段完成之前，不能调用任何实例方法，不能访问父类中定义的任何存储属性，也不能使用self
     */
    class A{
        var a:Int
        init(a:Int) {
            self.a = a
        }
    }
    
    class B:A{
        var b:Int
        init(a:Int,b:Int) {
            //派生类引入的属性进行初始化
            print("类B第一阶段初始化开始")
            self.b = b
            //从父类的指定构造器方法对父类属性进行初始化
            super.init(a: a)
            print("类B第二阶段初始化开始")
        }
    }
    
    class C:B{
        var c:Int
        init(a:Int,b:Int,c:Int) {
            //派生类引入的属性进行初始化
            print("类C第一阶段初始化开始")
            self.c = c
            //从父类的指定构造器方法对父类属性进行初始化
            super.init(a: a,b: b)
            print("类C第二阶段初始化开始")
        }
    }
    
    class D:C{
        var d:Int
        init(a:Int,b:Int,c:Int,d:Int) {
            //派生类引入的属性进行初始化
            print("类D第一阶段初始化开始")
            self.d = d
            //从父类的指定构造器方法对父类属性进行初始化
            super.init(a: a,b: b,c: c)
            print("类D第二阶段初始化开始")
        }
        convenience init(){
            self.init(a:0,b:0,c:0,d:0)
            a = 1
            b = 2
            c = 3
            d = 4
        }
    }
    var d = D(a:0,b:0,c:0,d:0)
    
    /*
     6、重写指定构造方法（子类中构造方法与父类中构造方法的参数列表一模一样）
        便利构造方法不存在重写
     */
    print("\n6、重写指定构造方法")
    class Human {
        let name:String
        var age:Int
        init(name:String,age:Int) {
            self.name = name
            self.age = age
        }
    }
    
    class Woman: Human {
        var haveBaby:Bool = false
    //    //派生类中定义一个构造方法，它跟父类中的某个指定构造方法一样
    //    override init(name: String, age: Int) {
    //        haveBaby = false
    //        super.init(name: name, age: age)
    //    }
        init(name: String, age: Int,haveBaby:Bool) {
            self.haveBaby = haveBaby
            super.init(name: name, age: age)
        }
        convenience override init(name: String, age: Int) {
            self.init(name: name, age: age,haveBaby:false)
        }
    }
    
    /*
     7、构造器的自动继承
     （1）如果子类中没有定义任何的构造方法，且子类中所有的存储属性都有默认缺省值，子类会自动继承父类中所有的构造方法（包括便利构造方法）
     （2）如果子类中只是重写了父类中的某些（不是全部）指定构造方法，不管子类中的存储属性是否有缺省值，都不会继承父类中的其他构造方法
     （3）如果子类中重写了父类中所有的指定构造方法，不管子类中存储属性是否有缺省值，都同时会继承父类中所有的便利构造方法
     */
    print("\n7、构造器的自动继承")
    class XY {
        var x:Int
        var y:Int
        init(x:Int,y:Int) {
            self.x = x
            self.y = y
        }
        init(x:Int) {
            self.x = x
            self.y = 0
        }
        convenience init(){
            self.init(x:0,y:0)
        }
    }
    
    class XYZ: XY {
        var z:Int = 0
    }
    var xyz = XYZ()
    var xyz1 = XYZ(x:10)
    var xyz2 = XYZ(x:5,y:5)
    
    /*
     8、必须构造器（构造方法所属类的后续子类必须也得实现这个构造方法）
     */
    print("\n8、必须构造器")
    class Require{
        var a:Int
        //required 关键字
        required init(){
            a = 0
        }
    }
    
    class ChildOfRequire:Require{
        var sub:Int
        init(sub:Int){
            self.sub = sub
            super.init()
        }
        required init() {
            sub = 0
        }
    }

![Center][]

![Center 1][]

[Center]: https://img-blog.csdn.net/20170106174003332?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvTWluZ2dlUWluZ2NodW4=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 1]: https://img-blog.csdn.net/20170106174012410?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvTWluZ2dlUWluZ2NodW4=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center