Swift - 继承

Quiz

继承是面向对象编程中最常用的特性，它允许一个 class（子类或派生类）继承另一个 class（基类或超类）的 methods、properties 和功能。它提供了一种组织和重用代码的机制，还用于在 class 之间创建层次关系。Swift 还提供了访问控制修饰符来控制基类和子类中 properties 和 methods 的可见性。

在 Swift 中，classes 可以进一步分为子类和超类 −

子类 − 当一个 class 从另一个 class 继承 properties、methods 和 functions 时，它被称为子类或派生类。
超类 − 一个包含 properties、methods 和 functions 以供其他 class 继承的 class 被称为超类或基类。

基类

一个不从另一个 class 继承 methods、properties 或 functions 的 class 被称为基类。或者可以说，基类是为其他从它派生的 class 提供基础的 class。基类也被称为超类。它提供了一组可以在其子类之间共享的 methods、properties 和行为。基类的定义方式与普通 class 相同，即使用 class 关键字。

语法

以下是基类的语法 −

class BaseClassName{
   // Properties
   // Methods
}

示例

Swift 程序演示如何创建基类。

// 基类
class StudDetails {

   // Properties
   var stname: String
   var mark1: Int
   var mark2: Int
   var mark3: Int
    
   // Initializer
   init(stname: String, mark1: Int, mark2: Int, mark3: Int) {
      self.stname = stname
      self.mark1 = mark1
      self.mark2 = mark2
      self.mark3 = mark3
   }
}

// 基类的实例
let stObj = StudDetails(stname: "Swift", mark1: 98, mark2: 89, mark3: 76)

// 访问 Properties
print(stObj.stname)
print(stObj.mark1)
print(stObj.mark2)
print(stObj.mark3)

输出

它将产生以下输出 −

Swift
98
89
76

子类

从基类创建的类或从现有类派生的类称为子类。子类继承基类的属性和方法，并且可以拥有自己的属性和方法。它还可以重写从超类继承的属性和方法。子类也可以有自己的子类，这些子类继承或重写直接基类（子类）和基类的属性和方法，并且拥有自己的额外属性和方法。

子类通过 class 关键字后跟子类名、冒号和从中派生的基类名来定义。在子类的初始化器中，必须使用 super.init 来确保基类的初始化代码在子类的初始化代码之前执行。

语法

以下是子类的语法 −

class SubClassName : BaseClassName{
   // Properties
   // Methods
}

示例

Swift 程序演示子类。

// 基类
class StudDetails
{

   // 属性
   var name: String
   var age: Int
   var className: String  
    
   // 初始化器
   init(name: String, age: Int, className: String)
   {
      self.name = name
      self.age = age
      self.className = className
   }
    
   // 方法
   func Show()
   {
      print("Name: \(name), Age: \(age), className: \(className)")
   }
}

// 子类
class Marks: StudDetails{

   // 属性
   var mark1: Int
   var mark2: Int
    
   // 初始化器
   init(mark1: Int, mark2: Int, name: String)
   {
      self.mark1 = mark1
      self.mark2 = mark2
        
      // 此初始化器将在子类的初始化器之前执行
      super.init(name: name, age: 18, className: "3rd")
        
   }
    
   // 重写基类的方法
   override func Show()
   {
      print("Mark1: \(mark1) and Mark2: \(mark2)")
   }
}
// 创建子类的实例
let obj = Marks(mark1: 23, mark2: 45, name: "Mohita")

// 访问方法
obj.Show()

// 使用子类实例访问基类的属性
print("Name:", obj.name)
print("Age:", obj.age)

输出

它将产生以下输出 −

Mark1: 23 and Mark2: 45
Name: Mohita
Age: 18

继承类型

Swift 支持以下类型的继承 −

单继承
多级继承
层次继承

Swift class 不支持多重继承，以避免一些复杂性和挑战，例如钻石问题、增加的耦合以及初始化挑战。但我们可以使用 Protocols 来实现多重继承。

单继承

单继承是指一个 class 只从一个 superclass 派生而来，subclass 可以访问 superclass 的所有属性和方法。例如，Class Y 从 Class X 派生。

示例

演示单继承的 Swift 程序。

// 基类
class Employee
{

   // 属性
   var name: String
   var age: Int   
    
   // 初始化器
   init(name: String, age: Int)
   {
      self.name = name
      self.age = age
   }
    
   // 方法
   func Show()
   {
      print("Name: \(name), Age: \(age)")
   }
}

// 子类
class EmpDetails: Employee{

   // 属性
   var department: String
   var salary: Int
   var joiningYear: Int
    
   // 初始化器
   init(department: String, salary: Int, joiningYear: Int)
   {
      self.department = department
      self.salary = salary
      self.joiningYear = joiningYear
        
      // 调用父类初始化器
      super.init(name: "Rohit", age: 23)
   }
    
   // 方法 
   func Display()
   {
      print("Department: \(department), Salary: \(salary), and Joining Year: \(joiningYear)")
   }
}
// 创建子类的实例
let obj = EmpDetails(department: "HR", salary: 23000, joiningYear: 2021)

// 访问父类的方法
obj.Show()

// 访问子类的方法
obj.Display()

输出

它将产生以下输出 −

Name: Rohit, Age: 23
Department: HR, Salary: 23000, and Joining Year: 2021

多级继承

多级继承是指一个 class 从另一个 class 派生，然后另一个 class 从该 subclass 派生。或者说，多级继承是超过两级的继承链。例如，Class Y 从 Class X 派生，然后 Class Z 从 Class Y 派生。

示例

演示多级继承的 Swift 程序。

// 基类
class Employee
{

   // 属性
   var name: String
   var age: Int   
    
   // 初始化器
   init(name: String, age: Int)
   {
      self.name = name
      self.age = age
   }
    
   // 方法
   func Show()
   {
      print("Name: \(name), Age: \(age)")
   }
}

// 子类
class EmpDetails: Employee{

   // 属性
   var department: String
   var salary: Int
    
   // 初始化器
   init(department: String, salary: Int)
   {
      self.department = department
      self.salary = salary
        
      // 调用 Employee 类的初始化器
      super.init(name: "Rohit", age: 23)
   }
    
   // 方法 
   func Display()
   {
      print("Department: \(department) and Salary: \(salary)")
   }
}

// 从 EmpDetails 类派生的另一个子类
class EmpWork: EmpDetails{

   var joiningYear : Int
    
   // 初始化器
   init(joiningYear: Int)
   {
      self.joiningYear = joiningYear
        
      // 调用 EmpDetails 类的初始化器
      super.init(department: "HR", salary: 23000)
   }
    
   // 方法
   func DisplayData(){
    
      // 在这里我们访问了 Employee 和 EmpDetails 类的属性
      print("Employee Name: \(name), \nDepartment: \(department), and Joining Year: \(joiningYear)")
   }
} 

// 创建 EmpWork 类的实例
let obj = EmpWork(joiningYear: 2021)

// 访问方法 
obj.DisplayData()

输出

它将产生以下输出 −

Name: Rohit, Age: 23
Department: HR, Salary: 23000, and Joining Year: 2021

混合继承

混合继承是指多个 class 从单个基类派生。这些类可以访问并覆盖基类的属性和方法，并且可以拥有自己的属性和方法。例如，Class Y 从 Class X 派生，然后 Class Z 从 Class X 派生。

示例

演示混合继承的 Swift 程序。

// 基类
class Employee
{

   // 属性
   var name: String
   var age: Int   
    
   // 初始化器
   init(name: String, age: Int)
   {
      self.name = name
      self.age = age
   }
    
   // 方法
   func Show()
   {
      print("Name: \(name), Age: \(age)")
   }
}

// 从 Employee 类派生的子类
class EmpDetails: Employee {

   // 属性
   var salary: Int
    
   // 初始化器
   init(salary: Int)
   {
      self.salary = salary
        
      // 调用 Employee 类的初始化器
      super.init(name: "Rohit", age: 23)
   }
    
   // 方法 
   func Display()
   {
      print("Employee Name: \(name) and Salary: \(salary)")
   }
}

// 从 Employee 类派生的子类
class EmpWork: Employee{

   // 属性
   var joiningYear : Int
    
   // 初始化器
   init(joiningYear: Int)
   {
      self.joiningYear = joiningYear
        
      // 调用 Employee 类的初始化器
      super.init(name: "Mohina", age: 22)
   }
    
   // 方法
   func Display(){
    
      // 在这里我们访问了 Employee 和 EmpWork 类的属性
      print("Employee Name: \(name) and Joining Year: \(joiningYear)")
   }
} 

// 创建子类的实例
let obj1 = EmpDetails(salary: 24000)
let obj2 = EmpWork(joiningYear: 2022)

// 访问 EmpDetails 类的方法
obj1.Display()

// 访问 EmpWork 类的方法
obj2.Display()

输出

它将产生以下输出 −

Employee Name: Rohit and Salary: 24000
Employee Name: Mohina and Joining Year: 2022

笙亿网络策划

Swift 继承怎么用？Swift 类继承怎么实现？

Swift - 继承

基类

语法

示例

输出

子类

语法

示例

输出

继承类型

单继承

示例

输出

多级继承

示例

输出

混合继承

示例

输出

Swift 继承怎么用？Swift 类继承怎么实现？

Swift - 继承

基类

语法

示例

输出

子类

语法

示例

输出

继承类型

单继承

示例

输出

多级继承

示例

输出

混合继承

示例

输出

相关问答