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

类世袭【时时app平台注册网站】

2019-11-08 01:32

 语法:

重写静态属性
在类中静态属性定义使用class或static关键字,但是使用哪一个要看子类中是否重写该属性。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
    }
}

    func sleep()

let student1 = Student()
print("学生年龄:(student1.age)")
Student1.age = 6    
print("学生年龄:(student1.age)")
代码Student1.age = 6修改了age属性,修改前后的输出结果如下:
学生年龄新值:6
学生年龄旧值:18

        }

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

        set{

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: "Tony", age: 18, school: "清华大学")
    }
   
    init (name: String, age: Int, school: String) {
        self.school = school
        super.init(name: name, 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: "Tony", age: 18, school: "清华大学")
    }
   
    init (name: String, age: Int, school: String) {
        self.school = school
        super.init(name: name, age: age)
    }
}

class SuperMan2: Man2 {

原创文章,欢迎转载。转载请注明:关东升的博客
重写实例属性
我们可以在子类中重写从父类继承来的属性,属性有实例属性和静态属性之分,他们在具体实现也是不同的。
实例属性的重写一方面可以重写getter和setter访问器,另一方面可以重写属性观察者。
计算静态属性需要使用getter和setter访问器,而存储属性不需要。子类在继承父类后,也可以通过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
    }
}

}

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

    func eat()

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 Man {

 */

        willSet{

            print("super get")

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

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

    {

 继承缺点: 增加程序耦合度, 父类改变会影响子类

class Man4 {

}

            return 20.0

}

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

var sm2 = SuperMan2()

        get{

    }

 

sm4.name = "Hello!!!!"

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

            print("super get")

    }

var m = Man()

    }

        set{

 2.不能给lazy的属性设置属性观察器.

var m6 = SuperMan6()

 

    }

        didSet{

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

    var power: Int = 200

    {

 重写属性观察器

            return "han"

/*

m6.age = 50

        set{

            print("child new (newValue)")

            return 30

m6.height = 20.0

    var power: Int = 100

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

 只能给非 lazy 属性的变量存储属性设定属性观察器,

            print("SuprMan new age (newValue)")

 

            return 30

//继承Man的子类

}

        get{

 注意:Swift和OC一样没有多继承

        }

    func fly()

class SuperMan6: Man6 {

    {

 

 

            print("child height willSet")

}

*/

}

 

    func eat()

    func fly() {

    var age: Int = 20

    }

print(m6.age)

 

        get{

    //2.所以如果要重写父类方法, 必须加上ovrride关键字.

        }

 

 

    var age: Int = 23

 */

m.sleep()

 继承优点: 代码重用

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

    }

        get{

            return 20

        print("睡吧!")

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

    }

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

    var age: Int{

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

        print("睡觉")

        get{

        //正确姿势

    func sleep()

            print("old (oldValue)")

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

    final func eat()

        print("睡觉

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

关键词: