构造方法

By admin in 4858.com on 2019年4月22日

/*

/*

/*

/*

 承袭与构造方法:

 承接与构造方法:

 承袭语法

 承继语法

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

 钦点构造与便利构造器方法

 承接是面向对象最引人注目的2本本性, 继承是从已经有的类中派生出新的类

 承继是面向对象最了解的2个特征, 承接是从已经有的类中派生出新的类

 */

 */

 新的类能够连续已有类的天性和艺术, 并能增添新的力量

 新的类能够继续已有类的习性和章程, 并能扩展新的力量

 

 

 术语: 基类(父类, 超类), 派生类(子类, 继承类)

 术语: 基类(父类, 超类), 派生类(子类, 继承类)

class Person {

class Person {

 语法:

 语法:

    var name:String

    var name:String

 class 子类: 父类{

 class 子类: 父类{

    var age:Int

    var age:Int

 }

 }

    //钦命构造方法都以以init初始

    //钦命构造方法都是以init开头

 

 

    init(name:String, age:Int)

    init(name:String, age:Int)

 承袭优点: 代码重用

 承袭优点: 代码重用

    {

    {

 承袭缺点: 增添程序耦合度, 父类改换会潜移默化子类

 承接缺点: 扩展程序耦合度, 父类改造会影响子类

        self.name = name

        self.name = name

 注意:Swift和OC同样未有多再三再四

 注意:斯维夫特和OC一样未有多一连

        self.age = age

        self.age = age

 */

 */

    }

    }

 

 

    //1.如若是值类型没难点, 称之为构造器代理;

    //1.假诺是值类型没难点, 称之为构造器代理;

class Man {

class Man {

    //二.不过假设是援引类型报错, 需求在前边加上 convenience关键字;

    //二.可是假如是援引类型报错, 需求在头里加上 convenience关键字;

    var name: String = “hjq”

    var name: String = “hjq”

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

    //三.被convenience关键字修饰的构造方法称之为便利构造器,
通过调用别的构造方法来开头化;

    var age: Int = 23

    var age: Int = 23

    //四.反来讲之, 便利构造器中必定是调用别的构造方法开端化的,
一定要出新self.init

    //四.反来讲之, 便利构造器中必然是调用别样构造方法开始化的,
一定要出新self.init

    func sleep()

    func sleep()

    convenience init()

    convenience init()

    {

    {

    {

    {

        print(“睡觉”)

        print(“睡觉”)

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

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

    }

    }

    }

    }

}

}

    //类能够具有三个构造方法

    //类能够享有三个构造方法

//继承Man的子类

//继承Man的子类

    init(name:String)

    init(name:String)

class SuperMan: Man {

class SuperMan: Man {

    {

    {

    var power: Int = 100

    var power: Int = 100

        self.name = name

        self.name = name

    func fly() {

    func fly() {

        self.age = 0

        self.age = 0

        //子类可以继续父类的性质

        //子类能够一而再父类的天性

        //不能够再钦命构造方法中调用便利构造器方法

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

        print(“飞 \(name) \(age)”)

        print(“飞 \(name) \(age)”)

        //换言之,钦赐构造方法中不能够冒出self.init

        //换言之,钦赐构造方法中不能够冒出self.init

    }

    }

//        self.init()

//        self.init()

}

}

    }

    }

var m = Man()

var m = Man()

    

    

m.sleep()

m.sleep()

    convenience init(age:Int)

    convenience init(age:Int)

//父类无法使用子类的方法

//父类不能利用子类的办法

    {

    {

//m.fly()

//m.fly()

        //能够在便利构造器中调用内定构造器

        //能够在便利构造器中调用钦命构造器

 

 

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

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

var sm = SuperMan()

var sm = SuperMan()

        self.init()

        self.init()

//子类能够连续父类的格局

//子类能够承接父类的法子

    }

    }

sm.sleep()

sm.sleep()

    // 便利构造器不能和点名构造器同名

    // 便利构造器不可能和点名构造器同名

sm.fly()

sm.fly()

    //    convenience init(name:String)

    //    convenience init(name:String)

 

 

    //    {

    //    {

print(“==============================================”)

print(“==============================================”)

    //    }

    //    }

 

 

}

}

/*

/*

 

 

 super关键字:

 super关键字:

 

 

 

 

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

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

 派生类(子类)中能够透过super关键字来引用父类的质量和情势

 派生类(子类)中得以透过super关键字来引用父类的天性和章程

 

 

 */

 */

class Man {

class Man {

 

 

    var name:String

    var name:String

class Man2  {

class Man2  {

    //钦定构造方法

    //内定构造方法

    var name: String = “HaRi”

    var name: String = “HaRi”

    init(name:String)

    init(name:String)

    var age: Int = 20

    var age: Int = 20

    {

    {

    func sleep()

    func sleep()

        self.name = name

        self.name = name

    {

    {

    }

    }

        print(“睡吧!”)

        print(“睡吧!”)

    convenience init(){

    convenience init(){

    }

    }

        self.init(name: “hjq”)

        self.init(name: “hjq”)

}

}

    }

    }

 

 

}

}

class SuperMan2: Man2 {

class SuperMan2: Man2 {

4858.com,class SuperMan: Man {

class SuperMan: Man {

    var power: Int = 100

    var power: Int = 100

    var age:Int

    var age:Int

    func eat()

    func eat()

    

    

    {

    {

    // 注意:

    // 注意:

        print(“吃饭喽!”)

        print(“吃饭喽!”)

    // 壹.默许情形下构造方法不会被延续

    // 1.暗中同意情况下构造方法不会被接续

    }

    }

    // 二.基类的积累属性只好通过基类的构造方法开首化

构造方法。    // 二.基类的存款和储蓄属性只好通过基类的构造方法初步化

    func fly()

    func fly()

    // 三.初步化存款和储蓄属性时必须先起头化当前类再初阶化父类

    // 三.初阶化存款和储蓄属性时务必先开头化当前类再开始化父类

    {

    {

    // 四.无法通过方便人民群众构造方法开端化父类,
只好经过调用钦点构造方法初阶化父类

    // 四.无法通过便民构造方法开首化父类,
只好经过调用内定构造方法开端化父类

        //子类能够三番五次父类的习性

        //子类能够承继父类的品质

    //钦点构造器

    //钦赐构造器

        print(“飞 \(name) \(age)”)

        print(“飞 \(name) \(age)”)

    init(age:Int) {

    init(age:Int) {

    }

    }

        self.age = age

        self.age = age

    func eatAndSleep()

    func eatAndSleep()

        super.init(name: “han”)

        super.init(name: “han”)

    {

    {

//        super.init()

//        super.init()

        eat()

        eat()

    }

    }

        //1.纵然未有写super, 那么会在近期类中寻觅,
要是找不到才会再去父类中寻觅;

        //一.假诺未有写super, 那么会在时下类中搜寻,
假如找不到才会再去父类中追寻;

}

}

        //贰.假设写了super, 会直接去父类中查找.

        //二.假设写了super, 会直接去父类中查找.

 

 

        super.sleep()

        super.sleep()

/*

/*

    }

    }

 构造器间的调用规则:

 构造器间的调用规则:

}

}

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

 一.钦命构造器必须调用其向来父类的”钦定构造器”

var sm2 = SuperMan2()

var sm2 = SuperMan2()

 二.便利构造器必须调用同类中的别的便利构造器(钦赐只怕福利)

 二.便利构造器必须调用同类中的别的便利构造器(钦点也许福利)

sm2.eatAndSleep()

sm2.eatAndSleep()

 三.便利构造器必须最后调用叁个钦赐构造器停止(无论钦赐还是有利,
最后必然调用3个钦定构造器)

 叁.便利构造器必须最后调用一个点名构造器甘休(无论钦命依然有益于,
最后必将调用三个点名构造器)

 

 

 四.钦点构造器总是横向代理(父类)

 四.钦命构造器总是横向代理(父类)

print(“==============================================”)

print(“==============================================”)

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

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

 

 

 */

 */

/*

/*

 

 

 方法重写: override

 方法重写: override

class Man2 {

class Man2 {

 重写父类方法, 必须抬高 override 关键字

 重写父类方法, 必须抬高 override 关键字

    var name:String

    var name:String

 */

 */

    //钦赐构造器

    //钦点构造器

 

 

    init(name:String) {

    init(name:String) {

class Man3 {

class Man3 {

        self.name = name

        self.name = name

    var name: String = “HanJunqiang”

    var name: String = “HanJunqiang”

    }

    }

    var age: Int = 24

    var age: Int = 24

    convenience init(){

    convenience init(){

    func sleep()

    func sleep()

        self.init(name: “HaRi”)

        self.init(name: “HaRi”)

    {

    {

    }

    }

        print(“睡觉😴”)

        print(“睡觉😴”)

}

}

    }

    }

class SuperMan2: Man2 {

class SuperMan2: Man2 {

}

}

    var age:Int

    var age:Int

class SuperMan3: Man3 {

class SuperMan3: Man3 {

    //内定构造器

    //钦赐构造器

    var power: Int = 200

    var power: Int = 200

    init(age:Int) {

    init(age:Int) {

    

    

        self.age = age

        self.age = age

    //一.override关键字首假若为了分明表示重写父类方法;

    //一.override关键字首若是为了分明表示重写父类方法;

        super.init(name: “xiaohange”)

        super.init(name: “xiaohange”)

    //二.所以如若要重写父类方法, 必须抬高ovrride关键字.

    //2.所以若是要重写父类方法, 必须抬高ovrride关键字.

    }

    }

    override func sleep() {

    override func sleep() {

    convenience init()

    convenience init()

//        sleep()  // Error! 尤其注意: 不可能如此调用父类方法, 会导致递归!

//        sleep()  // Error! 特别注意: 不可能如此调用父类方法, 会导致递归!

    {

    {

        //正确姿势

        //精确姿势

        self.init(age: 25)

        self.init(age: 25)

        super.sleep()

        super.sleep()

    }

    }

        print(“子类睡觉”)

        print(“子类睡觉”)

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

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

    }

    }

        //调用子类构造器一定能够开首化全部属性

        //调用子类构造器一定能够起初化全体属性

    func eat()

    func eat()

//        self.init(age: 30)

//        self.init(age: 30)

    {

    {

        //便利构造器中只好通过self.init来开首化, 不可能使用 super.init

        //便利构造器中只可以因此self.init来开首化, 不能够运用 super.init

        print(“吃饭🍚”)

        print(“吃饭🍚”)

        //因为调用父类构造器不鲜明完全初阶化全体属性(子类持有)

        //因为调用父类构造器不必然完全伊始化全体属性(子类持有)

    }

    }

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

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

    func fly()

    func fly()

        self.init()

        self.init()

    {

    {

    }

    }

        print(“飞 \(name) \(age)”)

        print(“飞 \(name) \(age)”)

}

}

    }

    }

 

 

    func eatAndSleep()

    func eatAndSleep()

/*

/*

    {

    {

 两段式构造—-构造进程能够分开为八个等第:

 两段式构造—-构造进程能够划分为多个等第:

        eat()

        eat()

 1.承接保险当前类和父类全部存款和储蓄属性都被起头化;

 1.保障当前类和父类全部存款和储蓄属性都被开始化;

        sleep()

        sleep()

 2.做一些其余早先化操作.

 二.做一些任何开始化操作.

    }

    }

 好处:

 好处:

}

}

 壹.足避防卫属性在被开头化前走访;

 1.能够制止属性在被早先化前走访;

var sm3 = SuperMan3()

var sm3 = SuperMan3()

 二.方可防止属性被别的此外2个结构器意外赋值.

 贰.足防止止属性被其余其余八个布局器意外赋值.

//通过子类调用, 优先调用子类重写的主意

//通过子类调用, 优先调用子类重写的措施

 注意:

 注意:

//sm3.sleep()

//sm3.sleep()

 构造器的初始化永久是在全数类的首先等级初始化落成后才会起来第三阶段.

 构造器的初阶化永久是在全部类的率先品级初阶化落成后才会起首第3阶段.

sm3.eatAndSleep()

sm3.eatAndSleep()

 

 

 

 

 编译器安检:

 编写翻译器安全检查:

print(“==============================================”)

print(“==============================================”)

 1.亟须先开始化子类特有质量, 再提升代理父类钦赐构造方法早先化父类属性;

 1.不可能不先初阶化子类特有品质, 再前行代理父类钦定构造方法伊始化父类属性;

 

 

 二.只可以在调用完父类钦点构造器后才具访问父类属性;

 二.只幸亏调用完父类钦点构造器后才干访问父类属性;

/*

/*

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

 三.在便利构造器中, 必须先调用通类别的构造方法后技术访问属性;

 重写属性

 重写属性

 四.第二阶段完结前不能访问父类属性, 也无法引用 self 和调用任何实例方法

 四.先是等第达成前不可能访问父类属性, 也无法引用 self 和调用任何实例方法

 无论是存款和储蓄属性照旧合算属性, 都只好重写为总计属性

 无论是存储属性照旧合算属性, 都只好重写为计算属性

 */

 */

 */

 */

 

 

 

 

class Man3 {

class Man3 {

class Man4 {

class Man4 {

    var name:String

    var name:String

    var name: String = “hjq9玖伍” //存款和储蓄属性

    var name: String = “hjq99伍” //存款和储蓄属性

    //内定构造方法

    //钦赐构造方法

    var age: Int{ //总计属性

    var age: Int{ //总括属性

    init(name:String) {

    init(name:String) {

        get{

        get{

        self.name = name

        self.name = name

            return 30

            return 30

    }

    }

        }

        }

    //便利构造方法

    //便利构造方法

        set{

        set{

    convenience init(){

    convenience init(){

            print(“man new age \(newValue)”)

            print(“man new age \(newValue)”)

        self.init(name: “hello world”)

        self.init(name: “hello world”)

        }

        }

    }

    }

    }

    }

}

}

    func sleep()

    func sleep()

 

 

    {

    {

class SuperMan3: Man3 {

class SuperMan3: Man3 {

        print(“睡觉”)

        print(“睡觉”)

    var age:Int

    var age:Int

    }

    }

    init(age:Int) {

    init(age:Int) {

}

}

        print(“SuperMan第一品级开头”)

        print(“SuperMan第二等级起首”)

class SuperMan4: Man4 {

class SuperMan4: Man4 {

        //对子类引进的属性初叶化

        //对子类引进的习性起头化

    var power: Int = 300

    var power: Int = 300

        self.age = age

        self.age = age

    

    

        

        

    //一.可以将父类的囤积属性重写为计算属性;

    //一.能够将父类的蕴藏属性重写为计算属性;

        //代码会报错, 因为调用self.name以前还未曾对父类的name实行开首化

        //代码会报错, 因为调用self.name在此之前还尚未对父类的name进行开首化

    //二.但不得以将父类的积累属性又重写为存款和储蓄属性, 因为如此重写未有意义.

    //二.但不得以将父类的积存属性又重写为存款和储蓄属性, 因为这么重写未有意义.

        //即使在那几个位置修改, 也会被前边的开端化语句覆盖

        //就算在那个地点修改, 也会被前面包车型客车初始化语句覆盖

    override var name: String{

    override var name: String{

//        if age > 30 {

//        if age > 30 {

        get{

        get{

//            self.name = “hjq”

//            self.name = “hjq”

            return “han”

            return “han”

//        }

//        }

        }

        }

        //对父类引入的性格实行早先化

        //对父类引进的品质实行初叶化

        set{

        set{

        super.init(name: “han”)

        super.init(name: “han”)

            print(“SuperMan new name \(newValue)”)

            print(“SuperMan new name \(newValue)”)

        

        

        }

        }

        print(“SuperMan第二等第起首”)

        print(“SuperMan第2等级起先”)

    }

    }

        if age > 30 {

        if age > 30 {

    //能够将父类的图谋属性重写为总括属性, 同样不能够重写为存款和储蓄属性

    //能够将父类的持筹握算属性重写为总计属性, 同样不可能重写为存款和储蓄属性

            self.name = “hello xiaohange”

            self.name = “hello xiaohange”

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

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

        }

        }

        get{

        get{

    }

    }

            return 20

            return 20

}

}

        }

        }

class MonkeyMan: SuperMan3 {

class MonkeyMan: SuperMan3 {

        set{

        set{

    var height:Double

    var height:Double

            print(“SuprMan new age \(newValue)”)

            print(“SuprMan new age \(newValue)”)

    init(height:Double) {

    init(height:Double) {

        }

        }

        print(“MokeyMan第2品级开首”)

        print(“MokeyMan第二品级开始”)

    }

    }

        //对子类引入的习性开首化

        //对子类引进的属性起首化

}

}

        self.height = 100.0

        self.height = 100.0

 

 

        //对父类引进的习性进行初步化

        //对父类引进的属性进行发轫化

let sm4 = SuperMan4()

let sm4 = SuperMan4()

        super.init(age: 40)

        super.init(age: 40)

//通过子类对象来调用重写的习性或许措施, 肯定会调用子类中重写的本子

//通过子类对象来调用重写的习性只怕措施, 确定会调用子类中重写的版本

        

        

sm4.name = “Hello!!!!”

sm4.name = “Hello!!!!”

        print(“MokeyMan第一品级早先”)

        print(“MokeyMan第2等第伊始”)

sm4.age = 60

sm4.age = 60

        if height < 110.0 {

        if height < 110.0 {

 

 

            self.age = 40

            self.age = 40

print(“==============================================”)

print(“==============================================”)

        }

        }

 

 

    }

    }

 

 

}

}

/*

/*

var m = MonkeyMan(height: 31)

var m = MonkeyMan(height: 31)

 重写属性的限制

 重写属性的限量

 

 

 一.读写计算属性/存款和储蓄属性, 是或不是足以重写为只读属性? (权限变小)不可能

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

 

 

 2.只读总计属性, 是或不是能够在重写时重写为读写总括属性? (权限变大)能够

 贰.只读总括属性, 是不是能够在重写时重写为读写总括属性? (权限变大)能够

/** 重写钦点构造方法:子类的构造方法和父类的壹模同样 **/

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

 */

 */

class Man4 {

class Man4 {

class Man5 {

class Man5 {

    var name:String

    var name:String

    var name: String = “hjq” //存款和储蓄属性

    var name: String = “hjq” //存款和储蓄属性

    init(name:String) {

    init(name:String) {

    var age: Int{

    var age: Int{

        self.name = name

        self.name = name

        get{

        get{

    }

    }

            return 30

            return 30

}

}

        }

        }

class SuperMan4: Man4 {

class SuperMan4: Man4 {

        set{

        set{

    var age:Int

    var age:Int

            print(“man new age \(newValue)”)

            print(“man new age \(newValue)”)

    init() {

    init() {

        }

        }

        self.age = 25

        self.age = 25

    }

    }

        super.init(name: “xiaohange”)

        super.init(name: “xiaohange”)

    func sleep()

    func sleep()

    }

    }

    {

    {

    

    

        print(“睡觉”)

        print(“睡觉”)

    //将父类的钦命构造珍视写成3个方便人民群众构造器, 必须抬高override关键字,
表示重写父类方法

    //将父类的钦点构造注重写成贰个利于构造器, 必须抬高override关键字,
表示重写父类方法

    }

    }

    convenience override init(name: String) {

    convenience override init(name: String) {

}

}

        self.init(name: name)

        self.init(name: name)

class SuperMan5: Man5 {

class SuperMan5: Man5 {

        self.age = 50

        self.age = 50

    var power: Int = 200

    var power: Int = 200

    }

    }

    override var name: String{

    override var name: String{

}

}

        get{

        get{

 

 

            return “jq”

            return “jq”

 

 

        }

        }

/** 便利构造方法不设有重写 **/

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

        set{

        set{

class Man5 {

class Man5 {

            print(“SuperMan new name \(newValue)”)

            print(“SuperMan new name \(newValue)”)

    var name:String

    var name:String

        }

        }

    init(name:String) {

    init(name:String) {

    }

    }

        self.name = name

        self.name = name

    override var age: Int{ //总结属性

    override var age: Int{ //总结属性

    }

    }

        get{

        get{

    convenience init(){

    convenience init(){

            return 30

            return 30

        self.init(name:”hello”)

        self.init(name:”hello”)

        }

        }

    }

    }

        set{

        set{

}

}

            print(“SuperMan new age \(newValue)”)

            print(“SuperMan new age \(newValue)”)

 

 

        }

        }

class SuperMan5: Man5 {

class SuperMan5: Man5 {

    }

    }

    var age:Int

    var age:Int

}

}

    init(age:Int) {

    init(age:Int) {

 

 

        self.age = age

        self.age = age

print(“==============================================”)

print(“==============================================”)

        super.init(name: “hi”)

        super.init(name: “hi”)

 

 

    }

    }

 

 

    //壹.斯维夫特中有益构造方法不设有重写, 假如加上override关键字,
系统会去搜寻父类中有未有和造福构造方法同样的钦命构造方法, 有旧不报错,
未有就报错

    //壹.Swift中有益构造方法不存在重写, 借使加上override关键字,
系统会去搜寻父类中有没有和有利构造方法一样的钦点构造方法, 有旧不报错,
未有就报错

/*

/*

    //二.为啥便利构造器无法重写吗? 因为便利构造器只好横向代理,
只好调用当前类的其它构造方法或钦定方法, 不恐怕调用super. 所以不设有重写

    //二.为何便利构造器无法重写吧? 因为便利构造器只好横向代理,
只好调用当前类的任何构造方法或钦赐方法, 不容许调用super. 所以不存在重写

 重写属性观看器

 重写属性阅览器

    //三.也正是说子类的福利构造方法不可能一向访问父类的福利构造方法,
所以不存在重写的定义

    //三.也便是说子类的便民构造方法不可能间接待上访问父类的有利构造方法,
所以不设有重写的概念

 只好给非 lazy 属性的变量存款和储蓄属性设定属性阅览器,

 只好给非 lazy 属性的变量存款和储蓄属性设定属性观察器,

    convenience init(){

    convenience init(){

 无法给计算属性设置属性观望器, 给总括属性设置属性观察起未有别的意义

 无法给总结属性设置属性观望器, 给计算属性设置属性观望起未有其他意义

        self.init(age: 30)

        self.init(age: 30)

 属性观察器限制:

 属性观看器限制:

    }

    }

 一.无法在子类中重写父类只读的积攒属性;

 1.不能够在子类中重写父类只读的存款和储蓄属性;

}

}

 二.不可能给lazy的性格设置属性观察器.

 贰.不可能给lazy的质量设置属性观望器.

//早期版本中1旦字符类中有同名便利构造器会报错, 以后则不会.

//早期版本中假使字符类中有同名便利构造器会报错, 将来则不会.

*/

*/

var sm = SuperMan5()

var sm = SuperMan5()

 

 

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

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

class Man6 {

class Man6 {

 

 

    var name: String = “hjq”

    var name: String = “hjq”

 

 

    var age: Int = 0 { //存款和储蓄属性

    var age: Int = 0 { //存款和储蓄属性

 

 

        willSet{

        willSet{

/*

/*

            print(“super new \(newValue)”)

            print(“super new \(newValue)”)

 构造方法的活动接二连三:

 构造方法的全自动一连:

        }

        }

 1.假若子类中从不定义构造器, 且子类全部的积攒属性都有缺省值,
会承继父类中拥有的构造方法(包罗便利构造器);

 一.只要子类中未有概念构造器, 且子类全部的贮存属性都有缺省值,
会承接父类中有着的构造方法(包蕴便利构造器);

        didSet{

        didSet{

 二.举例子类中只是重写全体的钦点构造器, 不管仲类中的存款和储蓄属性是不是有缺省值,
都不会三番五次父类的别的构造方法;

 二.假如子类中只是重写全体的内定构造器, 不管仲类中的存款和储蓄属性是还是不是有缺省值,
都不会继续父类的别的构造方法;

            print(“super old \(oldValue)”)

            print(“super old \(oldValue)”)

 3.假若子类重写了父类中的钦赐构造器, 不管仲类中的存款和储蓄属性是不是有缺省值,
都会同时继续父类中的全部方便人民群众方法.

 三.如若子类重写了父类中的内定构造器, 不管敬仲类中的存款和储蓄属性是或不是有缺省值,
都会同时继续父类中的全部方便人民群众方法.

        }

        }

 */

 */

    }

    }

class Person6 {

class Person6 {

    var height: Double {

    var height: Double {

    var name:String

    var name:String

        get{

        get{

    var age:Int

    var age:Int

            print(“super get”)

            print(“super get”)

    init(name:String, age:Int) {

    init(name:String, age:Int) {

            return 100.0

            return 100.0

        self.name = name

        self.name = name

        }

        }

        self.age = age

        self.age = age

        set{

        set{

    }

    }

            print(“super set”)

            print(“super set”)

    init(name:String) {

    init(name:String) {

        }

        }

        self.name = name

        self.name = name

    }

    }

        self.age = 0

        self.age = 0

}

}

    }

    }

class SuperMan6: Man6 {

class SuperMan6: Man6 {

    convenience init()

    convenience init()

    //能够在子类中重写父类的蕴藏属性为属性观望器

    //能够在子类中重写父类的囤积属性为属性旁观器

    {

    {

    override var name: String {

    override var name: String {

        self.init(name: “HaRi”)

        self.init(name: “HaRi”)

        willSet{

        willSet{

    }

    }

            print(“new \(newValue)”)

            print(“new \(newValue)”)

}

}

        }

        }

class SuperMan6: Person6 {

class SuperMan6: Person6 {

        didSet{

        didSet{

    var height:Double

    var height:Double

            print(“old \(oldValue)”)

            print(“old \(oldValue)”)

    init(height:Double) {

    init(height:Double) {

        }

        }

        self.height = height

        self.height = height

    }

    }

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

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

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

    //能够在子类中重写父类的性质观察器

    }

    }

    override var age: Int {

    override var age: Int {

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

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

        willSet{

        willSet{

        self.height = 178.0

        self.height = 178.0

            print(“child new \(newValue)”)

            print(“child new \(newValue)”)

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

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

        }

        }

    }

    }

        didSet{

        didSet{

    override init(name: String) {

    override init(name: String) {

            print(“child old \(oldValue)”)

            print(“child old \(oldValue)”)

        self.height = 178.0

        self.height = 178.0

        }

        }

        super.init(name: name)

        super.init(name: name)

    }

    }

    }

    }

    override var height: Double {

    override var height: Double {

}

}

        willSet{

        willSet{

// 如若子类中平昔不概念任何构造器, 且子类中负有的存款和储蓄属性都有缺省值,
会承袭父类中具有的构造方法(包含便利构造器)

// 要是子类中并没有概念任何构造器, 且子类中颇具的仓库储存属性都有缺省值,
会承接父类中存有的构造方法(蕴涵便利构造器)

            print(“child height willSet”)

            print(“child height willSet”)

// 父类的贮存属性是由父类的组织器起头化,
子类的储存属性是由缺省值开端化的

// 父类的存款和储蓄属性是由父类的组织器先河化,
子类的蕴藏属性是由缺省值开头化的

        }

        }

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

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

        didSet{

        didSet{

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

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

            print(“child height didSet”)

            print(“child height didSet”)

//var sm = SuperMan6()

//var sm = SuperMan6()

        }

        }

//print(sm.height)

//print(sm.height)

    }

    }

 

 

}

}

// 假若子类中只是重写了父类中的有些钦定构造器,
不管仲类中的存款和储蓄属性是还是不是有缺省值, 都不会继续父类中的其余构造方法

// 假使子类中只是重写了父类中的某个钦赐构造器,
不管敬仲类中的存款和储蓄属性是还是不是有缺省值, 都不会延续父类中的别的构造方法

var m6 = SuperMan6()

var m6 = SuperMan6()

//var sm = SuperMan(height: 198.0)

//var sm = SuperMan(height: 198.0)

m6.age = 50

m6.age = 50

 

 

print(m6.age)

print(m6.age)

// 即便子类重写了父类中有所的内定构造器,
不管敬仲类中的存款和储蓄属性是还是不是有缺省值, 都会同时继续父类中的全体方便人民群众方法

// 借使子类重写了父类中兼有的钦赐构造器,
不管仲类中的存款和储蓄属性是或不是有缺省值, 都会同时继续父类中的全部方便人民群众方法

m6.height = 20.0

m6.height = 20.0

var sm6 = SuperMan6()

var sm6 = SuperMan6()

 

 

 

 

 

 

 

 

 

 

 

 

/*

/*

/*

/*

 利用final关键字幸免重写:

 利用final关键字幸免重写:

 必须构造器:

 必须构造器:

 壹.final至关首要字既能够修饰属性, 也足以修饰方法, 并且还足以修饰类;

 1.final主要字既可以修饰属性, 也足以修饰方法, 并且还足以修饰类;

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

 只要在构造方法的前面加上一个 required 关键字,
那么全部的子类(后续子类)只要定义了构造方法都不可能不兑现该构造方法

 二.被final关键字修饰的习性和格局不可能被重写;

 2.被final关键字修饰的性质和章程不可能被重写;

 */

 */

 三.被final关键字修饰的类无法被承接.

 3.被final关键字修饰的类无法被承袭.

class Person7 {

class Person7 {

 */

 */

    var name:String

    var name:String

 

 

    required init(name:String){

    required init(name:String){

final class Man7 {

final class Man7 {

        self.name = name

        self.name = name

    final var name: String = “jq”

    final var name: String = “jq”

    }

    }

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

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

}

}

        willSet{

        willSet{

class SuperMan7: Person7 {

class SuperMan7: Person7 {

            print(“super new \(newValue)”)

            print(“super new \(newValue)”)

    var age:Int

    var age:Int

        }

        }

    init() {

    init() {

        didSet{

        didSet{

        self.age = 24

        self.age = 24

            print(“super old \(oldValue)”)

            print(“super old \(oldValue)”)

        super.init(name: “hjq”)

        super.init(name: “hjq”)

        }

        }

    }

    }

    }

    }

    required init(name: String) {

    required init(name: String) {

    final var height: Double {

    final var height: Double {

        self.age = 24

        self.age = 24

        get{

        get{

        super.init(name: name)

        super.init(name: name)

            print(“super get”)

            print(“super get”)

    }

    }

            return 20.0

            return 20.0

}

}

        }

        }

var sm7 = SuperMan7(name: “hjq”)

var sm7 = SuperMan7(name: “hjq”)

        set{

        set{

 

 

            print(“super set”)

            print(“super set”)

        }

        }

    }

    }

    final func eat()

    final func eat()

    {

    {

        print(“吃饭🍚”)

        print(“吃饭🍚”)

    }

    }

}

}

 

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有