Swift - 繼承

上一頁
下一頁

繼承是面向物件程式設計中最常用的特性之一，它允許一個類（子類或派生類）繼承另一個類（基類或超類）的方法、屬性和功能。它提供了一種組織和重用程式碼的機制。它也用於在類之間建立層次結構關係。Swift 還提供了訪問控制修飾符來控制基類和子類中屬性和方法的可見性。

在 Swift 中，類可以進一步分為子類和超類：

  • 子類 - 當一個類繼承另一個類的屬性、方法和函式時，它被稱為子類或派生類。

  • 超類 - 一個包含屬性、方法和函式的類，其他類可以從中繼承，稱為超類或基類。

基類

不繼承其他類的方法、屬性或函式的類稱為基類。或者我們可以說基類是其他從中派生的類的基礎類。基類也稱為超類。它提供了一組可以在其子類之間共享的方法、屬性和行為。基類的定義方式與普通類相同，即使用 class 關鍵字。

語法

以下是基類的語法：

class BaseClassName{
   // Properties
   // Methods
}

示例

Swift 程式演示如何建立基類。

// Base class
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
   }
}

// Instance of the base class
let stObj = StudDetails(stname: "Swift", mark1: 98, mark2: 89, mark3: 76)

// Accessing the 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 程式演示子類。

// Base Class
class StudDetails
{

   // Properties
   var name: String
   var age: Int
   var className: String  
    
   // Initializer
   init(name: String, age: Int, className: String)
   {
      self.name = name
      self.age = age
      self.className = className
   }
    
   // Method
   func Show()
   {
      print("Name: \(name), Age: \(age), className: \(className)")
   }
}

// Sub class
class Marks: StudDetails{

   // Properties
   var mark1: Int
   var mark2: Int
    
   // Initializer
   init(mark1: Int, mark2: Int, name: String)
   {
      self.mark1 = mark1
      self.mark2 = mark2
        
      // This Initializer will execute before the Initializer of sub-class
      super.init(name: name, age: 18, className: "3rd")
        
   }
    
   // Overriding method of base class
   override func Show()
   {
      print("Mark1: \(mark1) and Mark2: \(mark2)")
   }
}
// Creating an instance of a subclass
let obj = Marks(mark1: 23, mark2: 45, name: "Mohita")

// Accessing the method
obj.Show()

// Accessing the properties of the base class using the subclass instance
print("Name:", obj.name)
print("Age:", obj.age)

輸出

它將產生以下輸出：

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

繼承型別

Swift 支援以下型別的繼承：

  • 單一繼承
  • 多級繼承
  • 層次繼承

Swift 類不支援多重繼承，以避免一些複雜性和挑戰，例如菱形問題、耦合增加和初始化挑戰。但是，我們可以使用協議來實現多重繼承。

單一繼承

單一繼承是指一個類僅從一個超類派生的繼承，子類可以訪問超類所有屬性和方法。例如，類 Y 派生自類 X。

Single Inheritance

示例

Swift 程式演示單一繼承。

// Base Class
class Employee
{

   // Properties
   var name: String
   var age: Int   
    
   // Initializer
   init(name: String, age: Int)
   {
      self.name = name
      self.age = age
   }
    
   // Method
   func Show()
   {
      print("Name: \(name), Age: \(age)")
   }
}

// Subclass
class EmpDetails: Employee{

   // Properties
   var department: String
   var salary: Int
   var joiningYear: Int
    
   // Initializer
   init(department: String, salary: Int, joiningYear: Int)
   {
      self.department = department
      self.salary = salary
      self.joiningYear = joiningYear
        
      // Calling superclass initializer
      super.init(name: "Rohit", age: 23)
   }
    
   // Method 
   func Display()
   {
      print("Department: \(department), Salary: \(salary), and Joining Year: \(joiningYear)")
   }
}
// Creating an instance of a subclass
let obj = EmpDetails(department: "HR", salary: 23000, joiningYear: 2021)

// Accessing the method of superclass
obj.Show()

// Accessing the methods of the subclass
obj.Display()
輸出

它將產生以下輸出：

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

多級繼承

多級繼承是指一個類從另一個類派生，然後另一個類從子類派生。或者我們可以說，多級繼承是超過兩級繼承的鏈。例如，類 Y 派生自類 X，然後類 Z 派生自類 Y。

Multi-level Inheritance

示例

Swift 程式演示多級繼承。

// Base Class
class Employee
{

   // Properties
   var name: String
   var age: Int   
    
   // Initializer
   init(name: String, age: Int)
   {
      self.name = name
      self.age = age
   }
    
   // Method
   func Show()
   {
      print("Name: \(name), Age: \(age)")
   }
}

// Sub class
class EmpDetails: Employee{

   // Properties
   var department: String
   var salary: Int
    
   // Initializer
   init(department: String, salary: Int)
   {
      self.department = department
      self.salary = salary
        
      // Calling the initializer of Employee class
      super.init(name: "Rohit", age: 23)
   }
    
   // Method 
   func Display()
   {
      print("Department: \(department) and Salary: \(salary)")
   }
}

// Another sub-class derived from EmpDetails class
class EmpWork: EmpDetails{

   var joiningYear : Int
    
   // Initializer
   init(joiningYear: Int)
   {
      self.joiningYear = joiningYear
        
      // Calling the initializer of EmpDetails class
      super.init(department: "HR", salary: 23000)
   }
    
   // Method
   func DisplayData(){
    
      // Here we are accessing the Properties of Employee and EmpDetails classes
      print("Employee Name: \(name), \nDepartment: \(department), and Joining Year: \(joiningYear)")
   }
} 

// Creating an instance of EmpWork class
let obj = EmpWork(joiningYear: 2021)

// Accessing the method 
obj.DisplayData()
輸出

它將產生以下輸出：

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

混合繼承

混合繼承是指多個類從單個基類派生的繼承。這些類可以訪問和重寫基類的屬性和方法，並且可以擁有自己的屬性和方法。例如，類 Y 派生自類 X，然後類 Z 派生自類 X。

示例

Swift 程式演示混合繼承。

// Base Class
class Employee
{

   // Properties
   var name: String
   var age: Int   
    
   // Initializer
   init(name: String, age: Int)
   {
      self.name = name
      self.age = age
   }
    
   // Method
   func Show()
   {
      print("Name: \(name), Age: \(age)")
   }
}

// Subclass derived from Employee class
class EmpDetails: Employee {

   // Property
   var salary: Int
    
   // Initializer
   init(salary: Int)
   {
      self.salary = salary
        
      // Calling the initializer of Employee class
      super.init(name: "Rohit", age: 23)
   }
    
   // Method 
   func Display()
   {
      print("Employee Name: \(name) and Salary: \(salary)")
   }
}

// Subclass derived from Employee class
class EmpWork: Employee{

   // Property
   var joiningYear : Int
    
   // Initializer
   init(joiningYear: Int)
   {
      self.joiningYear = joiningYear
        
      // Calling the initializer of Employee class
      super.init(name: "Mohina", age: 22)
   }
    
   // Method
   func Display(){
    
      // Here we are accessing the properties of Employee and EmpWork classes
      print("Employee Name: \(name) and Joining Year: \(joiningYear)")
   }
} 

// Creating an instance of a subclass
let obj1 = EmpDetails(salary: 24000)
let obj2 = EmpWork(joiningYear: 2022)

// Accessing the method of EmpDetails class
obj1.Display()

// Accessing the method of EmpWork class
obj2.Display()
輸出

它將產生以下輸出：

Employee Name: Rohit and Salary: 24000
Employee Name: Mohina and Joining Year: 2022
列印頁面
上一頁
下一頁
廣告

© . All rights reserved.