构造方法 (2)正规网赌平台

    //3.也就是说子类的便利构造方法不能直接访问父类的便利构造方法,
所以不存在重写的概念

    }

class Person {

        //对子类引入的属性初始化

 

    }

        self.height = height

    override init(name: String) {

    init(name:String) {

    }

    init(name:String) {

}

    }

class Person6 {

        super.init(name: name, age: age)

    }

    convenience init(){

        self.init(age: 30)

    convenience init()

 编译器安全检查:

    var name:String

// 如果子类重写了父类中所有的指定构造器,
不管子类中的存储属性是否有缺省值, 都会同时继承父类中的所有便利方法

    init(age:Int) {

 2.可以防止属性被其他另外一个构造器意外赋值.

        //换言之,指定构造方法中不能出现self.init

    // 3.初始化存储属性时必须先初始化当前类再初始化父类

        print(“MokeyMan第二阶段开始”)

/** 重写指定构造方法:子类的构造方法和父类的一模一样 **/

    var height:Double

        self.age = 25

 1.必须先初始化子类特有属性, 再向上代理父类指定构造方法初始化父类属性;

        self.age = age

//        if age > 30 {

//早期版本中如果字符类中有同名便利构造器会报错, 现在则不会.

    var age:Int

/*

    override init(name: String, age: Int) {

    }

        self.name = name

        super.init(name: “han”)

        self.age = 50

    //类可以拥有多个构造方法

        //代码会报错, 因为调用self.name之前还没有对父类的name进行初始化

    }

    //指定构造方法都是以init开头

 */

        super.init(name: “xiaohange”)

/*

 

    // 2.基类的存储属性只能通过基类的构造方法初始化

 构造器间的调用规则:

 

    }

 只要在构造方法的前面加上一个 required 关键字,
那么所有的子类(后续子类)只要定义了构造方法都必须实现该构造方法

 

    convenience init()

    var height:Double

        }

    }

//var sm = SuperMan6(name: “han”, age: 30)

 

var sm = SuperMan5()

    }

    }

}

    convenience init(){

        self.name = name

//        super.init()

class Man5 {

 */

    //1.如果是值类型没问题, 称之为构造器代理;

}

        self.init()

class SuperMan: Man {

    convenience init(age:Int)

    //3.被convenience关键字修饰的构造方法称之为便利构造器,
通过调用其他构造方法来初始化;

        //不能再指定构造方法中调用便利构造器方法

 必须构造器:

    }

        self.age = age

 指定构造与便利构造器方法

    }

    var age:Int

 

    convenience init(){

    //指定构造方法

        self.name = name

        self.age = 0

 

        super.init(name: “han”, age: 25)

        self.name = name

 3.如果子类重写了父类中的指定构造器, 不管子类中的存储属性是否有缺省值,
都会同时继承父类中的所有便利方法.

        //调用子类构造器一定能够初始化所有属性

//            self.name = “hjq”

//        }

    //    }

/*

        self.age = age

 1.如果子类中没有定义构造器, 且子类所有的存储属性都有缺省值,
会继承父类中所有的构造方法(包括便利构造器);

        self.init(name: name)

        self.init(age: 25)

    //指定构造器

/*

        self.name = name

        self.init(name: “hello world”)

    }

        if age > 30 {

        self.age = 24

            self.name = “hello xiaohange”

        print(“SuperMan第二阶段开始”)

 

        super.init(age: 40)

    // 便利构造器不能和指定构造器同名

    {

        self.name = name

    }

    //便利构造方法

    }

        //因为调用父类构造器不一定完全初始化所有属性(子类持有)

        self.name = name

    init(name:String) {

    init() {

    init(age:Int) {

// 父类的存储属性是由父类的构造器初始化,
子类的存储属性是由缺省值初始化的

        

    init(height:Double) {

    }

    init(name:String)

    

    }

    //    {

    //将父类的指定构造器重写成一个便利构造器, 必须加上override关键字,
表示重写父类方法

 

    var name:String

//var sm = SuperMan6()

 构造器的初始化永远是在所有类的第一阶段初始化完毕后才会开始第二阶段.

    init(name:String) {

 注意:

class MonkeyMan: SuperMan3 {

        self.init(name: “HaRi”)

        //对子类引入的属性初始化

 

}

print(“name = \(sm.name)  age = \(sm.age)”)

        self.name = name

    //1.Swift中便利构造方法不存在重写, 如果加上override关键字,
系统会去查找父类中有没有和便利构造方法一样的指定构造方法, 有旧不报错,
没有就报错

        //对父类引入的属性进行初始化

}

    var name:String

}

    }

    convenience init(){

        super.init(name: “han”)

        self.init(name: “hjq”, age: 26)

    var age:Int

        self.height = 100.0

}

 

 */

 

 

var sm7 = SuperMan7(name: “hjq”)

 */

 */

//        self.init(name: “hjq”, age: 24)

 4.指定构造器总是横向代理(父类)

    init(name:String, age:Int) {

 

}

    }

    }

}

    var age:Int

    var name:String

        self.age = age

    // 4.不能通过便利构造方法初始化父类,
只能通过调用指定构造方法初始化父类

        self.height = 178.0

    convenience  init(name: String, age: Int) {

    var age:Int

    //2.但是如果是引用类型报错, 需要在前面加上 convenience关键字;

    var name:String

class SuperMan6: Person6 {

    }

 

    {

 1.确保当前类和父类所有存储属性都被初始化;

    {

class Man3 {

        //可以在便利构造器中调用指定构造器

 2.便利构造器必须调用同类中的其他便利构造器(指定或者便利)

 4.第一阶段完成前不能访问父类属性, 也不能引用 self 和调用任何实例方法

    var name:String

 

//        super.init(name: “han”)

    {

        //便利构造器中只能通过self.init来初始化, 不能使用 super.init

        self.name = name

    init(age:Int) {

    {

    required init(name:String){

    init(name:String, age:Int)

    var age:Int

        

}

 2.只能在调用完父类指定构造器后才能访问父类属性;

class Man4 {

            self.age = 40

    }

    var age:Int

        //对父类引入的属性进行初始化

    var age:Int

        self.height = 178.0

//var sm = SuperMan6(name: “hjq”)

 1.指定构造器必须调用其直接父类的”指定构造器”

var m = MonkeyMan(height: 31)

    }

var sm6 = SuperMan6()

    }

    //    convenience init(name:String)

 两段式构造—-构造过程可以划分为两个阶段:

        super.init(name: “hjq”)

        //即便在这个地方修改, 也会被后面的初始化语句覆盖

class SuperMan5: Man5 {

    

    }

}

class SuperMan3: Man3 {

// 如果子类中没有定义任何构造器, 且子类中所有的存储属性都有缺省值,
会继承父类中所有的构造方法(包括便利构造器)

 

    }

 

    convenience override init(name: String) {

        self.init(name: “HaRi”)

        if height < 110.0 {

 1.可以防止属性在被初始化前访问;

        self.name = name

    }

 继承与构造方法:

    var name:String

    }

        super.init(name: “hi”)

 构造方法的自动继承:

    init(name:String) {

    init(height:Double) {

class SuperMan7: Person7 {

/*

class Man {

}

        self.age = age

 2.如果子类中只是重写所有的指定构造器, 不管子类中的存储属性是否有缺省值,
都不会继承父类的其他构造方法;

        super.init(name: name)

        }

    //指定构造器

//print(sm.height)

    

        self.init(name: “hjq”)

        

        self.init()

    {

 好处:

// 如果子类中只是重写了父类中的某些指定构造器,
不管子类中的存储属性是否有缺省值, 都不会继承父类中的其它构造方法

/** 派生类的构造方法 **/

}

class Person7 {

 

    init(age:Int) {

}

    convenience init(){

 5.便利构造器总是横向代理(子类)

        super.init(name: “xiaohange”)

    init(name:String)

/** 便利构造方法不存在重写 **/

        print(“SuperMan第一阶段开始”)

 3.在便利构造器中, 必须先调用通类其他构造方法后才能访问属性;

}

    }

        print(“MokeyMan第一阶段开始”)

 

    convenience init()

class Man2 {

    //指定构造器

    // 注意:

    }

    {

        super.init(name: name)

 

        self.age = 0

    init() {

    //4.反而言之, 便利构造器中一定是调用其他构造方法初始化的,
一定要出现self.init

        self.init(name:”hello”)

    // 1.默认情况下构造方法不会被继承

    }

    //2.为什么便利构造器不能重写呢? 因为便利构造器只能横向代理,
只能调用当前类的其它构造方法或指定方法, 不可能调用super. 所以不存在重写

        self.age = age

//        self.init(age: 30)

        self.age = 24

//        self.init()

 

}

 

class SuperMan4: Man4 {

    //指定构造方法

    required init(name: String) {

 3.便利构造器必须最终调用一个指定构造器结束(无论指定还是便利,
最终肯定调用一个指定构造器)

 

//var sm = SuperMan(height: 198.0)

 2.做一些其他初始化操作.

class SuperMan2: Man2 {

    var name:String

相关文章