Kotlin抽象类与接口：相爱相杀的编程“CP”

小码哥_常
13 阅读8分钟

一、开篇引入

在 Kotlin 的编程世界里，你是否常常在定义一些通用行为或属性时，纠结于到底该使用抽象类还是接口呢？就像在建造一座大厦时，选择合适的建筑材料至关重要，在 Kotlin 编程中，正确选用抽象类和接口，对于构建健壮、可维护的代码结构同样意义非凡 。今天，我们就一起来深入探讨 Kotlin 中抽象类以及它与接口的区别。

二、Kotlin 抽象类详解

（一）抽象类定义

在 Kotlin 中，抽象类是一种不能被直接实例化的类，就像是一个还未完成的 “蓝图”，它主要的作用是作为其他类的基类（父类） ，为子类提供通用的属性和方法定义，而将具体的实现细节留给子类去完成。我们使用abstract关键字来声明一个抽象类。例如：


abstract class AbstractClass {
    // 这里可以定义抽象属性和抽象方法
    // 也可以定义非抽象属性和非抽象方法
}

抽象类不能被直接实例化，比如不能写成val abstractObj = AbstractClass()，这就如同你不能直接使用一个未完成的蓝图来建造实际的建筑一样。它存在的意义更多是为了提供一种通用的结构和规范，让子类基于它进行扩展和实现 。

（二）抽象类示例

以一个图形相关的程序为例，我们定义一个Shape抽象类：


abstract class Shape {
    // 抽象属性，没有初始化值，必须在子类中重写
    abstract val name: String

    // 抽象方法，没有方法体，必须在子类中重写
    abstract fun calculateArea(): Double

    // 非抽象方法，有具体实现，可以被子类继承或重写
    fun printName() {
        println("形状名称: $name")
    }
}

在这个Shape抽象类中，name是一个抽象属性，它代表图形的名称，每个具体的图形（如圆形、矩形）名称都不同，所以需要在子类中具体实现；calculateArea()是一个抽象方法，用于计算图形的面积，不同图形的面积计算方式不同，也需要子类去实现；而printName()是一个非抽象方法，它会打印出图形的名称，这个方法有具体的实现，子类可以直接继承使用，如果有特殊需求也可以重写。

（三）继承抽象类

当子类继承抽象类时，必须使用override关键字重写所有抽象属性和方法。例如，我们定义Circle（圆形）和Rectangle（矩形）类来继承Shape类：


// 子类Circle继承自抽象类Shape
class Circle(val radius: Double) : Shape() {
    // 重写抽象属性
    override val name: String = "圆形"

    // 重写抽象方法
    override fun calculateArea(): Double {
        return Math.PI * radius * radius
    }
}

// 子类Rectangle继承自抽象类Shape
class Rectangle(val width: Double, val height: Double) : Shape() {
    override val name: String = "矩形"
    override fun calculateArea(): Double {
        return width * height
    }
}

在Circle类中，我们重写了name属性为 “圆形”，并实现了calculateArea()方法来计算圆形的面积；在Rectangle类中，同样重写了name属性为 “矩形”，并实现calculateArea()方法来计算矩形面积。通过这种方式，抽象类的抽象成员在子类中得到了具体的实现 。

（四）抽象类特点总结

  1. 不能实例化：抽象类不能直接创建对象，它主要为子类提供一个通用的框架。就像我们不能直接使用一个抽象的 “交通工具” 类来创建一个具体的交通工具，而是需要基于它创建 “汽车”“飞机” 等具体子类的对象。

  2. 可包含抽象和非抽象成员：抽象类中既可以有抽象属性和抽象方法，这些需要子类去实现；也可以有非抽象属性和非抽象方法，子类可以直接继承使用，也可以根据需求重写。

  3. 子类必须实现所有抽象成员：如果一个子类继承了抽象类，那么它必须重写抽象类中的所有抽象属性和方法，否则这个子类也必须声明为抽象类。例如，下面这个只重写了部分抽象成员的类，就必须声明为抽象类：


abstract class Square(val sideLength: Double) : Shape() {
    // 只重写了抽象属性，没有重写抽象方法calculateArea()
    override val name: String = "正方形"
    // 因此Square类也必须是抽象的
}
  1. 可以继承其他类：抽象类可以继承自另一个非抽象类或抽象类，进一步扩展和定制自己的行为和属性。例如：

open class Animal {
    open fun makeSound() {
        println("动物发出声音")
    }
}

abstract class Dog : Animal() {
    override abstract fun makeSound() // 重写并声明为抽象方法，子类必须实现
}

class Puppy : Dog() {
    override fun makeSound() {
        println("小狗汪汪叫")
    }
}

在这个例子中，Dog抽象类继承自Animal类，并重写了makeSound()方法并声明为抽象方法，Puppy类再继承Dog类并实现了makeSound()方法 。

三、Kotlin 接口详解

（一）接口定义

在 Kotlin 中，接口是一种强大的抽象机制，它使用interface关键字来定义。与抽象类不同，接口主要用于定义一组方法的签名，这些方法可以是抽象的，也可以有默认实现 。接口无法存储状态，它就像是一份 “行为契约”，规定了实现它的类应该具备哪些行为 。接口可以包含抽象方法声明和方法实现 ，接口中的属性默认是抽象的，或必须提供getter实现 。例如：


interface MyInterface {
    // 抽象方法，没有方法体，实现接口的类必须实现这个方法
    fun abstractMethod()

    // 带默认实现的方法，实现接口的类可以选择重写这个方法，也可以使用默认实现
    fun methodWithDefaultImplementation() {
        println("这是一个带有默认实现的方法")
    }
}

（二）接口示例

以Vehicle接口为例，展示接口中抽象方法和带默认实现方法的定义：


interface Vehicle {
    // 抽象方法，启动车辆，必须在实现接口的类中实现
    fun start()

    // 抽象方法，停止车辆，必须在实现接口的类中实现
    fun stop()

    // 带默认实现的方法，车辆鸣笛，实现接口的类可以选择重写，也可以使用默认实现
    fun honk() {
        println("嘟嘟！")
    }
}

在这个Vehicle接口中，start()和stop()是抽象方法，因为不同类型的车辆启动和停止的方式可能不同，需要具体的实现类去实现；而honk()是一个带默认实现的方法，默认情况下车辆鸣笛输出 “嘟嘟！”，如果有特殊的鸣笛需求，实现类也可以重写这个方法 。

（三）实现接口

一个类或对象可以实现一个或多个接口。当一个类实现接口时，它必须实现接口中所有的抽象方法（除非这个类本身也是抽象类） 。以Car类实现Vehicle接口为例：


class Car : Vehicle {
    override fun start() {
        println("汽车启动")
    }

    override fun stop() {
        println("汽车停止")
    }

    // 这里没有重写honk()方法，所以会使用接口中honk()的默认实现
}

在Car类中，通过override关键字重写了Vehicle接口中的start()和stop()抽象方法，来实现汽车的启动和停止逻辑 。而对于honk()方法，由于没有重写，所以当调用Car对象的honk()方法时，会执行接口中honk()的默认实现，输出 “嘟嘟！” 。

（四）接口继承与解决覆盖冲突

接口可以继承其他接口，通过继承，接口可以扩展和增强自身的功能 。例如：


interface Moveable {
    fun move()
}

interface Flyable : Moveable {
    fun fly()
}

在这个例子中，Flyable接口继承了Moveable接口，这意味着实现Flyable接口的类不仅要实现fly()方法，还要实现Moveable接口中的move()方法 。

当一个类实现多个接口时，如果这些接口中定义了相同签名的方法，就会出现方法覆盖冲突 。例如：


interface A {
    fun foo() {
        println("A中的foo方法")
    }
}

interface B {
    fun foo() {
        println("B中的foo方法")
    }
}

class C : A, B {
    // 必须重写foo()方法来解决冲突
    override fun foo() {
        // 调用A接口中的foo()方法
        super<A>.foo()
        // 调用B接口中的foo()方法
        super<B>.foo()
        println("C中重写的foo方法")
    }
}

在上述代码中，C类实现了A和B两个接口，而这两个接口都定义了foo()方法，所以在C类中必须重写foo()方法 。在重写的foo()方法中，通过super<A>.foo()和super<B>.foo()分别调用了A和B接口中的foo()方法，并添加了自己的逻辑 。这样就解决了方法覆盖冲突的问题 。

四、抽象类与接口的区别

通过前面的介绍，我们对 Kotlin 中的抽象类和接口都有了一定的了解 。接下来，我们来详细对比一下它们之间的区别，以便在实际开发中能够更准确地选择使用。

（一）构造函数

抽象类可以有构造函数，包括主构造函数和次构造函数，用于初始化抽象类中的属性和状态 。例如，我们在Shape抽象类中添加一个主构造函数：


abstract class Shape(val color: String) {
    abstract val name: String
    abstract fun calculateArea(): Double

    fun printName() {
        println("形状名称: $name")
    }
}

在这个例子中，Shape抽象类有一个主构造函数，接受一个color参数，用于表示图形的颜色 。

而接口不能有构造函数 。这是因为接口主要用于定义行为，不存储状态，所以不需要构造函数来初始化 。不过，从 Kotlin 1.9 + 开始，虽然支持接口中定义带默认实现的属性，但仍然不能有构造函数 。

（二）多重继承

在 Kotlin 中，一个类只能继承一个抽象类，即抽象类是单继承的 。这是为了避免多重继承带来的复杂性和冲突 。例如：


abstract class Animal {
    open fun makeSound() {
        println("动物发出声音")
    }
}

abstract class Dog : Animal() {
    override abstract fun makeSound()
}

这里Dog抽象类继承自Animal抽象类，一个类不能同时继承多个抽象类 。

而接口则不同，一个类可以实现多个接口，通过实现多个接口，一个类可以拥有多个不同的行为集合 。例如：


interface Flyable {
    fun fly()
}

interface Runable {
    fun run()
}

class Bird : Flyable, Runable {
    override fun fly() {
        println("鸟儿飞翔")
    }

    override fun run() {
        println("鸟儿奔跑")
    }
}

在这个例子中，Bird类实现了Flyable和Runable两个接口，从而具备了飞翔和奔跑的行为 。

（三）属性

抽象类可以包含非抽象属性，这些属性可以有初始值，也可以在构造函数中初始化 。例如，我们在Shape抽象类中添加一个非抽象属性borderWidth：


abstract class Shape(val color: String) {
    abstract val name: String
    abstract fun calculateArea(): Double

    val borderWidth: Int = 1

    fun printName() {
        println("形状名称: $name")
    }
}

在这个例子中，borderWidth是一个非抽象属性，它有初始值1 。

接口中的属性默认是抽象的，必须在实现接口的类中重写并提供具体实现，除非该属性提供了getter的默认实现 。例如：


interface ShapeInterface {
    val name: String
    val borderWidth: Int
        get() = 1
}

class Rectangle : ShapeInterface {
    override val name: String = "矩形"
    override val borderWidth: Int
        get() = super.borderWidth
}

在这个例子中，ShapeInterface接口中的name属性是抽象的，没有默认实现，必须在实现类Rectangle中重写；而borderWidth属性提供了getter的默认实现，在Rectangle类中如果不需要修改其行为，可以直接使用默认实现 。

（四）方法实现

抽象类可以包含非抽象方法的实现，子类可以继承这些方法，也可以根据需要重写它们 。例如，我们在Shape抽象类中的printName()方法就是一个非抽象方法，有具体的实现 。

接口中的方法默认是抽象的，没有方法体，必须在实现接口的类中实现 。不过，从 Kotlin 1.4 + 开始，接口支持方法的默认实现 。例如，我们在Vehicle接口中添加一个带默认实现的方法startEngine()：


interface Vehicle {
    fun start()
    fun stop()

    fun honk() {
        println("嘟嘟！")
    }

    fun startEngine() {
        println("发动机启动")
    }
}

在这个例子中，start()和stop()方法是抽象的，必须在实现类中实现；而honk()和startEngine()方法是带默认实现的方法，实现类可以选择重写这些方法，也可以使用默认实现 。

（五）访问修饰符

抽象类可以使用private、protected、public等访问修饰符来控制成员的访问权限 。private修饰的成员只能在抽象类内部访问，protected修饰的成员可以在抽象类及其子类中访问，public修饰的成员可以在任何地方访问 。例如：


abstract class Shape {
    private val privateProperty: String = "私有属性"
    protected val protectedProperty: String = "受保护属性"
    val publicProperty: String = "公共属性"

    private fun privateMethod() {
        println("这是一个私有方法")
    }

    protected fun protectedMethod() {
        println("这是一个受保护方法")
    }

    fun publicMethod() {
        println("这是一个公共方法")
    }
}

在这个例子中，privateProperty和privateMethod()是私有的，只能在Shape抽象类内部访问；protectedProperty和protectedMethod()是受保护的，可以在Shape抽象类及其子类中访问；publicProperty和publicMethod()是公共的，可以在任何地方访问 。

接口成员默认是public的，不能有private修饰符 。这是因为接口的主要目的是定义一组可供其他类实现的行为，这些行为通常是对外公开的 。例如：


interface MyInterface {
    fun method1()
    fun method2()
}

在这个MyInterface接口中，method1()和method2()方法默认都是public的，不能声明为private 。

五、使用建议与场景

（一）抽象类使用场景

当你需要定义一个通用的基类，并且这个基类包含一些通用的属性、方法以及构造函数时，抽象类是一个很好的选择 。例如，在 Android 开发中，我们经常会创建一个BaseActivity抽象类，它包含了一些所有 Activity 都通用的逻辑，如设置布局、初始化视图、加载数据等：


import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity

abstract class BaseActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(getLayoutId())
        initViews()
        initData()
    }

    // 抽象方法，由子类实现，返回布局ID
    abstract fun getLayoutId(): Int

    // 抽象方法，由子类实现，初始化视图
    abstract fun initViews()

    // 抽象方法，由子类实现，加载数据
    abstract fun initData()
}

然后，具体的 Activity 类可以继承自BaseActivity，并实现其中的抽象方法 。例如：


class MainActivity : BaseActivity() {
    override fun getLayoutId(): Int {
        return R.layout.activity_main
    }

    override fun initViews() {
        // 初始化视图的具体逻辑
    }

    override fun initData() {
        // 加载数据的具体逻辑
    }
}

通过这种方式，我们可以将通用的逻辑提取到BaseActivity抽象类中，减少代码重复，提高代码的可维护性和可扩展性 。

（二）接口使用场景

当你只需要定义一组抽象的行为，并且希望一个类可以实现多个这样的行为时，接口是更合适的选择 。例如，在一个图形绘制库中，我们可以定义多个接口来表示不同的功能：


// 定义一个可绘制的接口
interface Drawable {
    fun draw()
}

// 定义一个可点击的接口
interface Clickable {
    fun onClick()
}

// 定义一个可拖动的接口
interface Draggable {
    fun drag()
    fun drop()
}

然后，一个类可以实现多个接口，以具备多种行为 。比如一个Button类可以同时实现Drawable、Clickable和Draggable接口：


class Button : Drawable, Clickable, Draggable {
    override fun draw() {
        println("绘制按钮")
    }

    override fun onClick() {
        println("按钮被点击")
    }

    override fun drag() {
        println("按钮被拖动")
    }

    override fun drop() {
        println("按钮被放下")
    }
}

通过接口，我们可以让不同的类灵活地组合不同的行为，而不受单继承的限制，使代码更加灵活和可复用 。

六、总结回顾

通过今天的学习，我们深入了解了 Kotlin 中抽象类和接口这两个重要的概念 。抽象类像是一个未完成的蓝图，不能被直接实例化，它为子类提供通用的属性和方法定义，子类继承抽象类时必须重写所有抽象成员 。而接口则是一份行为契约，定义了一组方法签名，一个类可以实现多个接口，以获得多种行为 。

它们在构造函数、多重继承、属性、方法实现以及访问修饰符等方面都存在明显的区别 。在实际的 Kotlin 开发中，我们要根据具体的需求来选择使用抽象类还是接口 。如果需要定义一个通用的基类，并且这个基类包含构造函数、非抽象属性和方法，那么抽象类是合适的选择 ；如果只是需要定义一组抽象的行为，并且希望一个类可以实现多个这样的行为，接口则更为合适 。 希望大家在今后的 Kotlin 编程中，能够熟练运用抽象类和接口，构建出更加健壮、灵活和可维护的代码 。如果对今天的内容还有任何疑问，欢迎在评论区留言交流 。

avatar
文章
阅读
粉丝