swift类和继承 - Swift最新教程

获取更多表单的能力被定义为继承，通常，一个类可以从另一个类继承方法、属性和功，类可以进一步分为子类和超类。

子类——当一个类从另一个类继承属性、方法和函数时，它被称为子类
包含从自身继承其他类的属性、方法和函数的超类称为超类

Swift类包含调用和访问方法、属性、函数和覆盖方法的超类，此外，属性观察者还用于添加属性和修改存储的或计算的属性方法。

基类

不从其他类继承方法、属性或函数的类称为“基类”。

class StudDetails {
    var stname: String!
    var mark1: Int!
    var mark2: Int!
    var mark3: Int!
    
    init(stname: String, mark1: Int, mark2: Int, mark3: Int) {
       self.stname = stname
       self.mark1 = mark1
       self.mark2 = mark2
       self.mark3 = mark3
    }
 }
 
 let stname = "Swift"
 let mark1 = 98
 let mark2 = 89
 let mark3 = 76
 
 print(stname)
 print(mark1)
 print(mark2)
 print(mark3)

带有classname
StudDetails的类在这里定义为一个基类，该基类用于包含学生名，三个主题标记为mark1、mark2和mark3，“let”关键字用于初始化基类的值，基类值在“print”函数的帮助下显示在操场上。

子类

将一个新类基于一个现有类的行为定义为“子类”，子类继承基类的属性、方法和函数，在基类名之前使用’:’来定义子类

class StudDetails {
    var mark1: Int;
    var mark2: Int;
    
    init(stm1:Int, results stm2:Int) {
       mark1 = stm1;
       mark2 = stm2;
    }
    func print() {
       print("Mark1:\(mark1), Mark2:\(mark2)")
    }
 }
 
 class display : StudDetails {
    init() {
       super.init(stm1: 93, results: 89)
    }
 }
 
 let marksobtained = display()
 marksobtained.print()

类“StudDetails”被定义为一个超类，其中声明了学生标记，而子类“display”用于从其超类继承标记，子类定义学生标记并调用print()方法来显示学生标记。

覆盖或重载

访问超类实例、类型方法、实例、类型属性和下标子类提供了覆盖的概念，关键字“override”用于覆盖超类中声明的方法。

访问超类方法、属性和下标

“super”关键字用作前缀，用于访问超类中声明的方法、属性和下标

重载	访问方法、属性和下标
方法	super.somemethod()
属性	super.someProperty()
下标	super[someIndex]

方法重载

继承的实例和类型方法可以被子类中定义的方法的‘override’关键字覆盖，这里在子类中覆盖了print()来访问超类print()中提到的type属性，另外cricket()超类的新实例被创建为“cricinstance”。

class cricket {
    func print() {
       print("超类")
    }
 }
 
 class tennis: cricket {
    override func print() {
       print("子类")
    }
 }
 
 let cricinstance = cricket()
 cricinstance.print()
 
 let tennisinstance = tennis()
 tennisinstance.print()

属性重写

你可以重写继承的实例或类属性，以便为该属性提供你自己的自定义getter和setter，或者添加属性观察者，以使重写的属性能够在基础属性值发生更改时进行观察。

重写属性getter和setter

Swift允许用户提供自定义的getter和setter来覆盖继承的属性，无论它是存储的还是计算的属性，子类不知道继承的属性名和类型，因此用户必须在子类中指定超类中指定的覆盖属性的名称和类型。

有两种方法可以做到这一点：

当为覆盖属性定义setter时，用户也必须定义getter。
当我们不想修改继承的属性getter时，我们可以简单地通过语法’super传递继承的值，超类的一些属性。

class Circle {
    var radius = 12.5
    var area: String {
       return "矩形 \(radius) "
    }
 }
 
 class Rectangle: Circle {
    var print = 7
    override var area: String {
       return super.area + " 重载为 \(print)"
    }
 }
 
 let rect = Rectangle()
 rect.radius = 25.0
 rect.print = 3
 print("Radius \(rect.area)")

重载所有属性观察者

当需要为继承属性添加新属性时，“属性覆盖”的概念在Swift中引入，当继承的属性值被更改时，它会通知用户，但重写不适用于继承的常量存储属性和继承的只读计算属性。

class Circle {
   var radius = 12.5
   var area: String {
     return "矩形 \(radius) "
   }
}

class Rectangle: Circle {
   var print = 7
   override var area: String {
      return super.area + " 重载为 \(print)"
   }
}

let rect = Rectangle()
rect.radius = 25.0
rect.print = 3
print("半径 \(rect.area)")

class Square: Rectangle {
   override var radius: Double {
      didSet {
         print = Int(radius/5.0)+1
      }
   }
}

let sq = Square()
sq.radius = 100.0
print("半径 \(sq.area)")

防止覆盖的final属性

当用户不希望其他人访问超类方法时，属性或下标Swift引入“final”属性来防止覆盖。一旦’final’属性被声明，下标将不允许超类方法、属性及其下标被覆盖。在“超类”中没有“最终”属性的规定，当“final”属性被声明时，用户被限制创建更多的子类。

final class Circle {
    final var radius = 12.5
    var area: String {
       return "矩形 \(radius) "
    }
 }
 
 class Rectangle: Circle {
    var print = 7
    override var area: String {
       return super.area + " 覆盖为 \(print)"
    }
 }
 
 let rect = Rectangle()
 rect.radius = 25.0
 rect.print = 3
 print("半径 \(rect.area)")
 
 class Square: Rectangle {
    override var radius: Double {
       didSet {
          print = Int(radius/5.0)+1
       }
    }
 }
 
 let sq = Square()
 sq.radius = 100.0
 print("半径 \(sq.area)")

由于超类被声明为’final’，它的数据类型也被声明为’final’，程序将不允许进一步创建子类，它将抛出错误。