亲宝软件园·资讯

展开

Kotlin中的抽象类实现

人气:0

抽象方法是只有方法签名,没有方法实现的方法。

有abstract修饰的成员,无须使用open修饰,当使用abstract修饰类时,表明这个类需要被继承;当使用abstract修饰方法、属性时,表明这个方法、属性必须由子类提供实现。

一、抽象成员和抽象类

抽象成员和抽象类必须使用abstract修饰符来定义,包含抽象成员的类智能被定义成抽象类,抽象类中可以没有抽象成员。

抽象方法和抽象类的规则如下:

定义抽象方法,只需在普通方法上增加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 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

使用密封类的好处:

密封类的子类是固定的,可以清楚地知道密封类只可能有固定数量的子类。

您可能感兴趣的文章:

加载全部内容

相关教程
猜你喜欢
用户评论