构造方法,学习笔记

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

/*

/*

原创小说,招待转发。转发请注脚:关东升的博客
重写实例属性
咱俩得以在子类中重写从父类承继来的属性,属性有实例属性和静态属性之分,他们在切实可行落实也是分歧的。
实例属性的重写一方面能够重写getter和setter访问器,另一方面可以重写属性观看者。
测算静态属性须求运用getter和setter访问器,而存款和储蓄属性不要求。子类在此起彼伏父类后,也能够透过getter和setter访问重视写父类的储存属性和测算属性。
上边看3个示范:
class Person {   
    var name: String  //存款和储蓄属性
    var age: Int   //存款和储蓄属性
   
    func description() -> String {
        return “\(name) 年龄是: \(age)”
    }
   
    init (name: String, age: Int) {
        self.name = name
        self.age  = age
    }
}

/*

 承袭语法

 承接语法

class Student: Person {
   
    var school: String   
   
    override var age: Int { //重写属性前边要加多override关键字
      get {
         return super.age 
      }
      set {
         super.age = newValue < 8 ? 8: newValue 
      }
    }        
  
    convenience init() {
        self.init(name: “托尼”, age: 18, school: “武大东军政大学学”)
    }
   
    init (name: String, age: Int, school: String) {
        self.school = school
        super.init(name: name, age: age)
    }
}

 承继与构造方法:

 承袭是面向对象最醒目的三个特点, 承袭是从已经有的类中派生出新的类

 承继是面向对象最鲜明的1个特点, 承继是从已经局地类中派生出新的类

let student1 = Student()
print(“学生年龄:\(student1.age)”)
student1.age = 6
print(“学生年龄:\(student1.age)”)
从属性重写可知,子类本人并不存款和储蓄数据,数据是储存在父类的贮存属性中的。
以上示例是重写属性getter和setter访问器,大家还足以重写属性阅览者,代码如下:
class Person {
   
    var name: String
    var age: Int
   
    func description() -> String {
        return “\(name) 年龄是: \(age)”
    }
   
    init (name: String, age: Int) {
        self.name = name
        self.age  = age
    }
}

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

 新的类能够继续已有类的性质和措施, 并能增加新的力量

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

class Student: Person {
   
    var school: String
   
    override var age: Int {  //重写了age属性观望者
     willSet {    //即使只关怀修改此前的调用,能够只重写willSet观看者
         print(“学生年龄新值:\(newValue)”)  

 */

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

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

     }
     didSet{     //假使只关怀修改未来的调用,能够只重写didSet阅览者
         print(“学生年龄旧值:\(oldValue)”) 
     }
    }         
   
    convenience init() {
        self.init(name: “托尼”, age: 18, school: “南开东军事和政院学”)
    }
   
    init (name: String, age: Int, school: String) {
        self.school = school
        super.init(name: name, age: age)
    }
}

 

 语法:

 语法:

let student1 = Student()
print(“学生年龄:\(student1.age)”)
Student1.age = 6    
print(“学生年龄:\(student1.age)”)
代码Student一.age = 陆修改了age属性,修改前后的出口结果如下:
学生年龄新值:陆
学员年龄旧值:1八

class Person {

 class 子类: 父类{

 class 子类: 父类{

重写静态属性
在类中静态属性定义使用class或static关键字,可是使用哪1个要看子类中是还是不是重写该属性。class修饰的质量能够被重写,static关键字就不能够被重写。
示范代码如下:
class Account {
   
    var amount: Double = 0.0                // 账户金额
    var owner: String = “”                  //账户名
   
    var interestRate: Double = 0.0668     //利率
   
    //class不能换来static
    class var staticProp: Double {    //静态属性staticProp
        return 0.0668 * 1_000_000
    }
   
    var instanceProp: Double {
        return self.interestRate * self.amount
    }
}

    var name:String

 }

 }

class TermAccount: Account {
   
    //class换成static
    override class var staticProp: Double {  //重写静态属性staticProp
        return 0.0700 * 1_000_000
    }
}

    var age:Int

 

 

//访问静态属性
print(Account.staticProp) 
print(TermAccount.staticProp)
出于要被重写所以代码class var staticProp: Double
中的class不能换到static。代码override class var staticProp:
Double中的静态属性staticProp可以运用class或static,除非在TermAccount的子类中重写属性staticProp。

    //钦定构造方法都是以init开首

 承继优点: 代码重用

 承袭优点: 代码重用

    init(name:String, age:Int)

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

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

    {

 注意:斯维夫特和OC一样未有多三番五次

 注意:Swift和OC一样未有多两次三番

        self.name = name

 */

 */

        self.age = age

 

 

    }

class Man {

class Man {

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

    var name: String = “hjq”

    var name: String = “hjq”

    //二.不过只借使引用类型报错, 供给在目前加上 convenience关键字;

    var age: Int = 23

    var age: Int = 23

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

    func sleep()

    func sleep()

    //肆.反来讲之, 便利构造器中一定是调用任何构造方法初步化的,
一定要出新self.init

    {

    {

    convenience init()

        print(“睡觉”)

        print(“睡觉”)

    {

    }

    }

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

}

}

    }

//继承Man的子类

//继承Man的子类

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

class SuperMan: Man {

class SuperMan: Man {

    init(name:String)

    var power: Int = 100

    var power: Int = 100

    {

    func fly() {

    func fly() {

        self.name = name

        //子类能够继续父类的性质

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

        self.age = 0

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

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

        //无法再内定构造方法中调用便利构造器方法

    }

    }

        //换言之,钦赐构造方法中不能现身self.init

}

}

//        self.init()

var m = Man()

var m = Man()

    }

m.sleep()

m.sleep()

    

//父类无法利用子类的秘技

//父类不得以行使子类的措施

    convenience init(age:Int)

//m.fly()

//m.fly()

    {

 

 

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

var sm = SuperMan()

var sm = SuperMan()

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

//子类能够三番五次父类的办法

//子类能够持续父类的主意

        self.init()

sm.sleep()

sm.sleep()

    }

sm.fly()

sm.fly()

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

 

 

    //    convenience init(name:String)

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

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

    //    {

 

 

    //    }

/*

/*

}

 super关键字:

 super关键字:

 

 

构造方法,学习笔记。 

 

 派生类(子类)中得以通过super关键字来引用父类的习性和措施

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

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

 */

 */

 

 

 

class Man {

class Man2  {

class Man2  {

    var name:String

    var name: String = “HaRi”

    var name: String = “HaRi”

    //钦点构造方法

    var age: Int = 20

    var age: Int = 20

    init(name:String)

    func sleep()

    func sleep()

    {

    {

    {

        self.name = name

        print(“睡吧!”)

        print(“睡吧!”)

    }

    }

    }

    convenience init(){

}

}

        self.init(name: “hjq”)

 

 

    }

class SuperMan2: Man2 {

class SuperMan2: Man2 {

}

    var power: Int = 100

    var power: Int = 100

class SuperMan: Man {

    func eat()

    func eat()

    var age:Int

    {

    {

    

        print(“吃饭喽!”)

        print(“吃饭喽!”)

    // 注意:

    }

    }

    // 一.暗许情状下构造方法不会被一连

    func fly()

    func fly()

    // 2.基类的仓库储存属性只可以通过基类的构造方法起首化

    {

    {

    // 3.开头化存款和储蓄属性时必须先开首化当前类再初始化父类

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

        //子类能够持续父类的性质

    // 四.不能够透过便民构造方法开端化父类,
只可以由此调用钦赐构造方法开端化父类

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

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

    //内定构造器

    }

    }

    init(age:Int) {

    func eatAndSleep()

    func eatAndSleep()

        self.age = age

    {

    {

        super.init(name: “han”)

        eat()

        eat()

//        super.init()

        //1.如若未有写super, 那么会在时下类中找寻,
借使找不到才会再去父类中寻找;

        //1.假使没有写super, 那么会在当下类中追寻,
假若找不到才会再去父类中查找;

    }

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

        //二.即便写了super, 会间接去父类中查找.

}

        super.sleep()

        super.sleep()

 

    }

    }

/*

}

}

 构造器间的调用规则:

var sm2 = SuperMan2()

var sm2 = SuperMan2()

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

sm2.eatAndSleep()

sm2.eatAndSleep()

 二.便利构造器必须调用同类中的其余便利构造器(内定或许福利)

 

 

 三.便利构造器必须最后调用1个钦命构造器甘休(无论钦赐如故有利,
最终必将调用2个钦命构造器)

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

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

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

 

 

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

/*

/*

 */

 方法重写: override

 方法重写: override

 

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

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

class Man2 {

 */

 */

    var name:String

 

 

    //钦赐构造器

class Man3 {

class Man3 {

    init(name:String) {

    var name: String = “HanJunqiang”

    var name: String = “HanJunqiang”

        self.name = name

    var age: Int = 24

    var age: Int = 24

    }

    func sleep()

    func sleep()

    convenience init(){

    {

    {

        self.init(name: “HaRi”)

        print(“睡觉😴”)

        print(“睡觉😴”)

    }

    }

    }

}

}

}

class SuperMan2: Man2 {

class SuperMan3: Man3 {

class SuperMan3: Man3 {

    var age:Int

    var power: Int = 200

    var power: Int = 200

    //钦命构造器

    

    

    init(age:Int) {

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

    //壹.override关键字首如果为着分明表示重写父类方法;

        self.age = age

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

    //贰.所以假使要重写父类方法, 必须抬高ovrride关键字.

        super.init(name: “xiaohange”)

    override func sleep() {

    override func sleep() {

    }

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

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

    convenience init()

        //准确姿势

        //准确姿势

    {

        super.sleep()

        super.sleep()

        self.init(age: 25)

        print(“子类睡觉”)

        print(“子类睡觉”)

    }

    }

    }

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

    func eat()

    func eat()

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

    {

    {

//        self.init(age: 30)

        print(“吃饭🍚”)

        print(“吃饭🍚”)

        //便利构造器中只可以经过self.init来初步化, 不能够接纳 super.init

    }

    }

        //因为调用父类构造器不断定完全伊始化全部属性(子类持有)

    func fly()

    func fly()

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

    {

    {

        self.init()

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

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

    }

    }

    }

}

    func eatAndSleep()

    func eatAndSleep()

 

    {

    {

/*

        eat()

        eat()

 两段式构造—-构造进度可以分开为三个级次:

        sleep()

        sleep()

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

    }

    }

 二.做一些别的开头化操作.

}

}

 好处:

var sm3 = SuperMan3()

var sm3 = SuperMan3()

 1.得以幸免属性在被开始化前走访;

//通过子类调用, 优先调用子类重写的方法

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

 2.能够堤防属性被别的其它1个构造器意外赋值.

//sm3.sleep()

//sm3.sleep()

 注意:

sm3.eatAndSleep()

sm3.eatAndSleep()

 构造器的早先化永世是在全部类的率先品级伊始化达成后才会开始第贰阶段.

 

 

 

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

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

 编写翻译器安检:

 

 

 1.必须先早先化子类特有总体性, 再发展代理父类钦赐构造方法起先化父类属性;

/*

/*

 ②.只可以在调用完父类钦定构造器后本领访问父类属性;

 重写属性

 重写属性

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

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

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

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

 */

 */

 */

 

 

 

class Man4 {

class Man4 {

class Man3 {

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

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

    var name:String

    var age: Int{ //总计属性

    var age: Int{ //计算属性

    //钦赐构造方法

        get{

        get{

    init(name:String) {

            return 30

            return 30

        self.name = name

        }

        }

    }

        set{

        set{

    //便利构造方法

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

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

    convenience init(){

        }

        }

        self.init(name: “hello world”)

    }

    }

    }

    func sleep()

    func sleep()

}

    {

    {

 

        print(“睡觉”)

        print(“睡觉”)

class SuperMan3: Man3 {

    }

    }

    var age:Int

}

}

    init(age:Int) {

class SuperMan4: Man4 {

class SuperMan4: Man4 {

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

    var power: Int = 300

    var power: Int = 300

        //对子类引进的品质开始化

    

    

        self.age = age

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

    //一.能够将父类的仓库储存属性重写为总括属性;

        

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

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

        //代码会报错, 因为调用self.name从前还并未有对父类的name举办早先化

    override var name: String{

    override var name: String{

        //即使在这些地点修改, 也会被前面包车型大巴先河化语句覆盖

        get{

        get{

//        if age > 30 {

            return “han”

            return “han”

//            self.name = “hjq”

        }

        }

//        }

        set{

        set{

        //对父类引进的性质实行开头化

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

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

        super.init(name: “han”)

        }

        }

        

    }

    }

        print(“SuperMan第贰等级早先”)

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

    //能够将父类的测算属性重写为计算属性, 一样不能够重写为存款和储蓄属性

        if age > 30 {

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

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

            self.name = “hello xiaohange”

        get{

        get{

        }

            return 20

            return 20

    }

        }

        }

}

        set{

        set{

class MonkeyMan: SuperMan3 {

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

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

    var height:Double

        }

        }

    init(height:Double) {

    }

    }

        print(“MokeyMan第二等级起初”)

}

}

        //对子类引进的习性发轫化

 

 

        self.height = 100.0

let sm4 = SuperMan4()

let sm4 = SuperMan4()

        //对父类引进的性质举行起初化

//通过子类对象来调用重写的品质只怕措施, 明确会调用子类中重写的版本

//通过子类对象来调用重写的品质或许措施, 分明会调用子类中重写的本子

        super.init(age: 40)

sm4.name = “Hello!!!!”

sm4.name = “Hello!!!!”

        

sm4.age = 60

sm4.age = 60

        print(“MokeyMan第1等级初叶”)

 

 

        if height < 110.0 {

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

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

            self.age = 40

 

 

        }

 

 

    }

/*

/*

}

 重写属性的限量

 重写属性的范围

var m = MonkeyMan(height: 31)

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

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

 

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

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

 

 */

 */

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

class Man5 {

class Man5 {

class Man4 {

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

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

    var name:String

    var age: Int{

    var age: Int{

    init(name:String) {

        get{

        get{

        self.name = name

            return 30

            return 30

    }

        }

        }

}

        set{

        set{

class SuperMan4: Man4 {

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

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

    var age:Int

        }

        }

    init() {

    }

    }

        self.age = 25

    func sleep()

    func sleep()

        super.init(name: “xiaohange”)

    {

    {

    }

        print(“睡觉”)

        print(“睡觉”)

    

    }

    }

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

}

}

    convenience override init(name: String) {

class SuperMan5: Man5 {

class SuperMan5: Man5 {

        self.init(name: name)

    var power: Int = 200

    var power: Int = 200

        self.age = 50

    override var name: String{

    override var name: String{

    }

        get{

        get{

}

            return “jq”

            return “jq”

 

        }

        }

 

        set{

        set{

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

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

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

class Man5 {

        }

        }

    var name:String

    }

    }

    init(name:String) {

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

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

        self.name = name

        get{

        get{

    }

            return 30

            return 30

    convenience init(){

        }

        }

        self.init(name:”hello”)

        set{

        set{

    }

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

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

}

        }

        }

 

    }

    }

class SuperMan5: Man5 {

}

}

    var age:Int

 

 

    init(age:Int) {

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

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

        self.age = age

 

 

        super.init(name: “hi”)

 

 

    }

/*

/*

    //1.斯维夫特中有益构造方法不存在重写, 假设加上override关键字,
系统会去搜索父类中有未有和有利于构造方法同样的钦赐构造方法, 有旧不报错,
未有就报错

 重写属性观察器

 重写属性观看器

    //2.为啥便利构造器不能够重写吧? 因为便利构造器只可以横向代理,
只好调用当前类的其他构造方法或钦定方法, 相当小概调用super. 所以不设有重写

 只可以给非 lazy 属性的变量存款和储蓄属性设定属性观看器,

 只可以给非 lazy 属性的变量存款和储蓄属性设定属性观看器,

    //三.也正是说子类的造福构造方法不能够一贯访问父类的福利构造方法,
所以不存在重写的概念

 不能给计算属性设置属性观看器, 给计算属性设置属性观察起未有别的意义

 不能给总计属性设置属性观看器, 给总括属性设置属性观看起未有别的意义

    convenience init(){

 属性观看器限制:

 属性观看器限制:

        self.init(age: 30)

 一.不可能在子类中重写父类只读的蕴藏属性;

 一.不可能在子类中重写父类只读的囤积属性;

    }

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

 二.不能够给lazy的性质设置属性观望器.

}

*/

*/

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

 

 

var sm = SuperMan5()

class Man6 {

class Man6 {

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

    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)”)

/*

        }

        }

 构造方法的自发性接二连三:

        didSet{

        didSet{

 一.假使子类中平昔不定义构造器, 且子类全体的蕴藏属性都有缺省值,
会承继父类中具有的构造方法(包罗便利构造器);

            print(“super old \(oldValue)”)

            print(“super old \(oldValue)”)

 二.要是子类中只是重写全部的钦定构造器, 不管敬仲类中的存款和储蓄属性是还是不是有缺省值,
都不会继续父类的任何构造方法;

        }

        }

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

    }

    }

 */

    var height: Double {

    var height: Double {

class Person6 {

        get{

        get{

    var name:String

            print(“super get”)

            print(“super get”)

    var age:Int

            return 100.0

            return 100.0

    init(name:String, age:Int) {

        }

        }

        self.name = name

        set{

        set{

        self.age = age

            print(“super set”)

            print(“super set”)

    }

        }

        }

    init(name:String) {

    }

    }

        self.name = name

}

}

        self.age = 0

class SuperMan6: Man6 {

class SuperMan6: Man6 {

    }

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

    //能够在子类中重写父类的仓库储存属性为属性阅览器

    convenience init()

    override var name: String {

    override var name: String {

    {

        willSet{

        willSet{

        self.init(name: “HaRi”)

            print(“new \(newValue)”)

            print(“new \(newValue)”)

    }

        }

        }

}

        didSet{

        didSet{

class SuperMan6: Person6 {

            print(“old \(oldValue)”)

            print(“old \(oldValue)”)

    var height:Double

        }

        }

    init(height:Double) {

    }

    }

        self.height = height

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

    //能够在子类中重写父类的天性观望器

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

    override var age: Int {

    override var age: Int {

    }

        willSet{

        willSet{

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

            print(“child new \(newValue)”)

            print(“child new \(newValue)”)

        self.height = 178.0

        }

        }

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

        didSet{

        didSet{

    }

            print(“child old \(oldValue)”)

            print(“child old \(oldValue)”)

    override init(name: String) {

        }

        }

        self.height = 178.0

    }

    }

        super.init(name: name)

    override var height: Double {

    override var height: Double {

    }

        willSet{

        willSet{

}

            print(“child height willSet”)

            print(“child height willSet”)

// 假若子类中并未有定义任何构造器, 且子类中颇具的仓库储存属性都有缺省值,
会承继父类中兼有的构造方法(包含便利构造器)

        }

        }

// 父类的囤积属性是由父类的组织器开首化,
子类的仓储属性是由缺省值初阶化的

        didSet{

        didSet{

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

            print(“child height didSet”)

            print(“child height didSet”)

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

        }

        }

//var sm = SuperMan6()

    }

    }

//print(sm.height)

}

}

 

var m6 = SuperMan6()

var m6 = SuperMan6()

// 假诺子类中只是重写了父类中的某个钦点构造器,
不管仲类中的存款和储蓄属性是不是有缺省值, 都不会三番五次父类中的其余构造方法

m6.age = 50

m6.age = 50

//var sm = SuperMan(height: 198.0)

print(m6.age)

print(m6.age)

 

m6.height = 20.0

m6.height = 20.0

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

 

 

var sm6 = SuperMan6()

 

 

 

 

 

 

/*

/*

 

 利用final关键字幸免重写:

 利用final关键字幸免重写:

/*

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

 1.final根本字既能够修饰属性, 也足以修饰方法, 并且还足以修饰类;

 必须构造器:

 2.被final关键字修饰的本性和章程无法被重写;

4858.com , 二.被final关键字修饰的习性和方法不能够被重写;

 只要在构造方法的眼下加上叁个 required 关键字,
那么富有的子类(后续子类)只要定义了构造方法都不能够不贯彻该构造方法

 叁.被final关键字修饰的类不能够被承接.

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

 */

 */

 */

class Person7 {

 

 

    var name:String

final class Man7 {

final class Man7 {

    required init(name:String){

    final var name: String = “jq”

    final var name: String = “jq”

        self.name = name

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

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

    }

        willSet{

        willSet{

}

            print(“super new \(newValue)”)

            print(“super new \(newValue)”)

class SuperMan7: Person7 {

        }

        }

    var age:Int

        didSet{

        didSet{

    init() {

            print(“super old \(oldValue)”)

            print(“super old \(oldValue)”)

        self.age = 24

        }

        }

        super.init(name: “hjq”)

    }

    }

    }

    final var height: Double {

    final var height: Double {

    required init(name: String) {

        get{

        get{

        self.age = 24

            print(“super get”)

            print(“super get”)

        super.init(name: name)

            return 20.0

            return 20.0

    }

        }

        }

}

        set{

        set{

var sm7 = SuperMan7(name: “hjq”)

            print(“super set”)

            print(“super set”)

 

        }

        }

    }

    }

    final func eat()

    final func eat()

    {

    {

        print(“吃饭🍚”)

        print(“吃饭🍚”)

    }

    }

}

}

 

 

发表评论

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

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