Kotlin中的抽象类实现

Kotlin中的抽象类实现

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

有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

) http://: 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) {

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不能同时修饰方法。

二、抽象类的作用

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会http://大致保留抽象类的行为方式。

//定义带转速属性的主构造器

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) {

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) {

var ap1: Apple = RedFuji()

var ap2: Apple = Gala(3.5)

ap1.taste()

ap2.taste()

}

输出结果：

红富士苹果今年真贵，但是还是很甜。

嘎啦苹果也不便宜，但更清脆，重量为3.5

密封类的本质就是抽象类。

密封类的所有构造器都必须是private的，无论是否使用private修饰，系统都会自动添加private修饰。

密封类的直http://接子类必须与密封类位于同一个文件中，但密封类的间接子类则无需在同一个文件中。

使用密封类的好处：

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

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。