您的位置:时时app平台注册网站 > 编程知识 > 类世襲

类世襲

2019-11-08 01:40

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

    var name: String = "hjq995" //存储属性

 

        }

    }

    {

    var name:String

    func eat()

}

    func sleep()

        self.name = name

 

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

        willSet{

    }

 属性观察器限制:

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

        set{

        self.age = age

            return 30

class Man2 {

        }

 */

//子类可以继承父类的方法

        

 */

//var sm = SuperMan(height: 198.0)

            return 20

        super.init(name: "han")

    }

    var name:String

        }

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

        print("飞 (name) (age)")

}

class Man5 {

    //    {

}

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

 

        self.init(name:"hello")

    var power: Int = 100

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

        get{

        }

 

    {

        }

    }

 super关键字:

        self.age = 24

}

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

        willSet{

        self.init(name: "HaRi")

        didSet{

 

        print("睡觉")

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

        set{

    var name:String

    }

        super.init(name: "han")

print(m6.age)

 

    //可以在子类中重写父类的存储属性为属性观察器

        super.init(name: "han", age: 25)

        super.sleep()

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

            print("super old (oldValue)")

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

        //2.如果写了super, 会直接去父类中查找.

var m = MonkeyMan(height: 31)

    {

    init(name:String) {

        }

    var age:Int

 

    }

 

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

    }

    init() {

/*

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

sm4.age = 60

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

            print("child old (oldValue)")

//        self.init(age: 30)

        get{

class Man5 {

 派生类(子类)中可以通过super关键字来引用父类的属性和方法

    var age:Int

 语法:

 

 1.读写计算属性/存储属性, 是否可以重写为只读属性? (权限变小)不可以

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

 重写属性的限制

    {

 

        

    }

    init(name:String)

 2.被final关键字修饰的属性和方法不能被重写;

    var age:Int

 */

 */

/*

    init(name:String, age:Int) {

        eat()

    init() {

    func sleep()

 

    func sleep()

        self.init(name: "HaRi")

    override var name: String {

    init(age:Int) {

            print("super set")

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

    final var age: Int = 0 { //存储属性

        print("SuperMan第二阶段开始")

        set{

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

print("==============================================")

        self.age = age

class Man6 {

        self.height = height

m6.age = 50

class SuperMan: Man {

    var height: Double {

 

    }

    //    }

        }

    //指定构造方法

class SuperMan5: Man5 {

    //    convenience init(name:String)

    }

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

        }

    }

    {

        self.init(name: "hjq")

    var name: String = "HaRi"

    }

 

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

        get{

    {

        didSet{

        self.age = 25

    var name: String = "hjq"

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

    var age: Int = 20

    var name:String

        }

//var sm = SuperMan6(name: "hjq")

    }

}

    //2.但不可以将父类的存储属性又重写为存储属性, 因为这样重写没有意义.

        self.name = name

var sm = SuperMan()

    var name:String

        super.sleep()

    //指定构造器

    override var age: Int {

class SuperMan7: Person7 {

        get{

//        super.init()

        }

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

        }

}

}

            self.age = 40

        }

    init(name:String) {

        didSet{

    }

            return 100.0

            self.name = "hello xiaohange"

        print("睡觉")

        print("MokeyMan第二阶段开始")

    }

    required init(name:String){

    }

 

    }

        super.init(name: "hi")

        get{

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

            return 30

        self.init()

 

    {

class Man4 {

//var sm = SuperMan6()

 */

        self.age = 0

            print("SuperMan new age (newValue)")

        self.age = age

    func fly()

/*

 

        self.init(name: name)

//父类不可以使用子类的方法

    

var m6 = SuperMan6()

}

            return "han"

//        self.init()

 3.被final关键字修饰的类不能被继承.

    init(name:String) {

        }

    var age:Int

    func eat()

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

print("==============================================")

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

    final var height: Double {

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

        }

    

    final func eat()

var sm6 = SuperMan6()

 class 子类: 父类{

        self.name = name

            return 20.0

//        }

    override var age: Int{ //计算属性

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

            print("man new age (newValue)")

    convenience init(){

            print("super get")

    init(height:Double) {

}

 注意:

        //子类可以继承父类的属性

    }

    var name: String = "hjq"

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

}

    }

            print("super get")

 

 

        super.init(name: name)

 */

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

    }

 

//继承Man的子类

 */

            print("child height willSet")

}

    

    init(age:Int) {

    var age: Int = 24

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

    override func sleep() {

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

        didSet{

/*

 重写父类方法, 必须加上 override 关键字

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

        print("睡觉

本文由时时app平台注册网站发布于编程知识,转载请注明出处:类世襲

关键词: