抽象方法是隻有方法簽名，沒有方法實現的方法。

有abstract修飾的成員，無須使用open修飾，當使用abstract修飾類時，表明這個類需要被繼承；當使用abstract修飾方法、屬性時，表明這個方法、屬性必須由子類提供實現。

一、抽象成員和抽象類

抽象成員和抽象類必須使用abstract修飾符來定義，包含抽象成員的類智慧被定義成抽象類，抽象類中可以沒有抽象成員。

抽象方法和抽象類的規則如下：

• 抽象類必須使用abstract修飾符來修飾，抽象愛你個成員也必須使用abstract修飾符來修飾，抽象方法不能有方法體。
• 抽象類不能被例項化，無法呼叫抽象類的構造器建立抽象類的例項。即使抽象類中不包含任何抽象成員，這個抽象類也不能建立例項。
• 抽象類可以包含屬性、方法、構造器、初始化塊、巢狀類5種成員。
• 含有抽象成員的類智慧被定義成抽象類。

定義抽象方法，只需在普通方法上增加abstract修飾符，並把普通方法的方法體全部去掉即可。

abstract class Shape {
  init {
    println("執行Shape的初始化塊......")
  }

  var color = ""
  abstract fun calPerimeter(): Double

  abstract val type: String

  constructor() {}

  constructor(color: String) {
    println("執行Shape的構造器...")
    this.color = color
  }
}

抽象類不能用於建立例項，只能當作父類被其子類繼承。

class Triangle(
  color: String,var a: Double,var b: Double,var c: Double
) : Shape(color) {
  fun setSides(a: Double,b: Double,c: Double) {
    if (a >= b + c || b >= a + c || c >= a + b) {
      println("三角形兩邊之和必須大於第三邊")
      return
    }
    this.a = a
    this.b = b
    this.c = c
  }

  //重寫Shape類的計算周長的抽象方法
  override fun calPerimeter(): Double {
    return a + b + c
  }

  //重寫Shape類的代表形狀的抽象屬性
  override val type: String = "三角形"
}

class Circle(color: String,var radius: Double) : Shape(color) {
  override fun calPerimeter(): Double = 2 * Math.PI * radius

  override val type: String = "圓形"
}

fun main(args: Array<String>) {
  var s1: Shape = Triangle("黑色",3.0,4.0,5.5)
  var s2: Shape = Circle("黃色",4.0)
  println(s1.type)
  println(s2.type)

  println(s1.calPerimeter())
  println(s2.calPerimeter())
}

輸出結果：

執行Shape的初始化塊......
執行Shape的構造器...
執行Shape的初始化塊......
執行Shape的構造器...
三角形
圓形
12.5
25.132741228718345

利用抽象類和抽象方法的優勢，可以更好地發揮多型的優勢，使得程式更加靈活。

注意：

• abstract不能用於修飾區域性變數，Kotlin中沒有抽象變數的說法；
• abstract也不能用於修飾構造器，沒有抽象構造器，抽象類中定義的構造器只能是普通構造器。
• 使用abstract關鍵字修飾的方法必須被其子類重寫才有意義；
• private和abstract不能同時修飾方法。

二、抽象類的作用

抽象類體現的就是一種模板模式的設計，抽象類作為多個子類的通用模板，子類在抽象類的基礎上進行擴充套件、改造，但子類總體上會大致保留抽象類的行為方式。

//定義帶轉速屬性的主構造器
abstract class SpeedMeter(var turnRate: Double) {
  //把返回車輪半徑的方法定義成抽象方法
  abstract fun calGirth(): Double

  //定義計算速度的通用演算法
  fun getSpeed(): Double {
    //速度等於車輪周長*轉速
    return calGirth() * turnRate
  }
}

public class CarSpeedMeter(var radius: Double) : SpeedMeter(0.0) {
  override fun calGirth(): Double {
    return radius * 2 * Math.PI
  }
}

fun main(args: Array<String>) {
  val csm = CarSpeedMeter(0.28)
  csm.turnRate = 15.0
  println(csm.getSpeed())
}

輸出結果：

26.389378290154266

下面是模板模式的一些簡單規則：

• 抽象父類可以只定義需要使用的某些方法，把不能實現的部分抽象成抽象方法，留給其子類去實現。
• 父類中可能包含需要呼叫其他系列方法的方法，這些被調方法既可以由父類實現，也可以由其子類實現。

三、密封類

密封類是一種特殊的抽象類，轉麼用於派生子類。

密封類與普通抽象類的區別在於：密封類的子類是固定的。密封類的子類必須與密封類本身在同一個檔案中，在其他檔案中則不能為密封類派生子類。

//定義一個密封類
sealed class Apple {
  abstract fun taste()
}

open class RedFuji : Apple() {
  override fun taste() {
    println("紅富士蘋果今年真貴，但是還是很甜。")
  }
}

data class Gala(var weight: Double) : Apple() {
  override fun taste() {
    println("嘎啦蘋果也不便宜，但更清脆，重量為${weight}")
  }
}

fun main(args: Array<String>) {
  var ap1: Apple = RedFuji()
  var ap2: Apple = Gala(3.5)
  ap1.taste()
  ap2.taste()
}

輸出結果：

紅富士蘋果今年真貴，但是還是很甜。
嘎啦蘋果也不便宜，但更清脆，重量為3.5

• 密封類的本質就是抽象類。
• 密封類的所有構造器都必須是private的，無論是否使用private修飾，系統都會自動新增private修飾。
• 密封類的直接子類必須與密封類位於同一個檔案中，但密封類的間接子類則無需在同一個檔案中。

使用密封類的好處：

密封類的子類是固定的，可以清楚地知道密封類只可能有固定數量的子類。

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支援我們。