带你踏入Kotlin大门(六)|基本功_接口和特殊类篇

持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第19天，点击查看活动详情

带你踏入Kotlin大门(一)|kotlin初识 - 掘金 (juejin.cn)

带你踏入kotlin大门(二)|基本功_变量篇 - 掘金 (juejin.cn)

带你踏入kotlin大门(三)|基本功_函数篇 - 掘金 (juejin.cn)

带你踏入kotlin大门(四)|基本功_逻辑控制篇 - 掘金 (juejin.cn)

带你踏入kotlin大门(五)|基本功_类和继承篇 - 掘金 (juejin.cn)

带你踏入Kotlin大门(六)|基本功_接口和特殊类篇 - 掘金 (juejin.cn)

前置知识

已学习 Kotlin 变量、函数和类的知识
有 Java 编程基础

前言

这篇文章是我们 Kotlin 基础章系列的最后一文了，前面我们利用了5篇文章讲解了 Java 开发者如何学好 Kotlin 的基本用法，每篇文章的篇幅都不长，可以在空余时间快速阅读，笔者希望学习完前五篇，再来学习这最后一篇文章，会更加的容易理解。

没有阅读前文也没关系，这一篇文章内容不会很难，我们可以很快的理解和学习。本篇将带大家学习 Kotlin 中的接口，以及如何使用接口实现解耦和接口隔离，还会学习一些 Kotlin 中独有的一些类。

Kotlin的接口

在 Java 中，我们会经常使用到接口，利用接口做一些抽象、解耦和规范等等。所以说，接口之于 Java，就如同关羽之于刘备一般，那么 Kotlin 含有接口这一特性的必要性也就不言而喻了。

首先，我们来看一下 Java 中的接口代码。(代码复用处)

public interface Flyable {
  void fly()；
}
public class FlyAbility implements Flyable {
  @Override
  public void fly() { //... }
}

下面，我们将这段代码转化为 Kotlin 代码。可以看出，接口的定义和 Java 基本是一致的，只是实现的关键字稍有不同，Kotlin 的实现关键字和继承是一样的，都是使用的冒号：。还有一点不同的就是重写的注解，可以实现同行首位标明。

interface Flyable {
  fun fly()
}

class FlyAbility: Flyable{
    override fun fly(){
        //...
    }
}

上面是接口的简单使用，下面我们可以使用其来实现多态和多重继承

多态

下面的 action 方法中，其参数声明的是接口类型，也理解为抽象类型；传入不同的实现该接口的实现类，即为实现了多态。这里的实现理念和 Java 中的多态也是一样的，我们只是做了一些不同语言语法的变更。

fun main(){
    val flyAbility = FlyAbility()
    action(flyAbility)
}

fun action(flyable: Flyable){
    flyable.fly()
}

多重继承

我们所说的多重继承，是指优雅的实现多重继承。依旧是使用设计模式专栏里面的例子和代码，在此用 Kotlin 复现一次。

实现的方式是：组合+接口+委托。

如下方代码，使用这种方式，就可以利用组合和接口，完成各特性组合简单快捷且解耦的实现新类的特性了。

fun main(){
    val flyAbility = FlyAbility()
    action(flyAbility)
}

fun action(flyable: Flyable){
    flyable.fly()
}
//省略Tweetable/TweetAbility/EggLayable/EggLayAbility

class Ostrich: Tweetable, EggLayable {//鸵鸟
  val tweetAbility = TweetAbility(); //组合
  val eggLayAbility = EggLayAbility(); //组合
  //... 省略其他属性和方法...

  override fun tweet() {
    tweetAbility.tweet(); // 委托
  }

  override fun layEgg() {
    eggLayAbility.layEgg(); // 委托
  }
}

关于接口的知识，我们还有一点需要注意的就是，Kotlin 的接口和 JDK1.8 之后的 Java 一样，可以实现在接口的抽象函数中，加入默认实现了。他们的使用是一样的，这里不再做过多赘述。

特殊类

Kotlin 中的特殊类其实是基于多年的 Java 业务经验衍生出来的。他把 Java 中最经常使用到的两种类进行默认实现，然后提供简单的使用给我们，帮助我们减少了很多的模板代码。这两种类就是 数据类和单例类 。

数据类

以往在 Java 中我们创建一个数据类，会借用一些插件，帮助我们编写 getter 和 setter 代码，还有实现 equals()、hashCode() 、toString()这些代码。很多时候，我们的这些业务都是模板型的，不会有很多变化的。那么这些工作就会显得很多余，Kotlin 作为一门新的语言，对这个问题进行了解决，出现了数据类。

/* Java 实现
* private String cityName;
    private String cityId;
    private String cnty;
    private String location;
    private String parentCity;
    private String adminArea;
    private boolean isFavor;
*
* */
data class CityBean(
    var cityName: String = "",
    var cityId: String = "",
    var cnty: String = "",
    val location: String = "",
    val parentCity: String = "",
    var adminArea: String = "",
    val isFavor: Boolean = false
)

上述的数据类中，已默认实现了上文提到的三个方法，直接使用即可。

单例类

单例模式是我们在开发中最常使用到的模式，而 Kotlin 有单例类这种特殊类，可以直接帮助我们实现单例模式。下面我们来看一下 Java 的实现和 Kotlin 中使用单例类的实现有何不同。

Java 实现(安全的懒汉模式)

public class SingleLazy {
    private static SingleLazy instance;

    private SingleLazy() {
    }

    public static synchronized SingleLazy getInstance() {
        if (instance == null) {
            instance = new SingleLazy();
        }
        return instance;
    }
    
    public void test(){
        //...
    }
}

上述 Java 的实现，有接近10行代码，且是需要思考得出的。我们接下来看一下 Kotlin 中的实现。

//普通实现
class SingleLazy private constructor() {
    fun test() {
        //...
    }

    companion object {
        @get:Synchronized
        var instance: SingleLazy? = null
            get() {
                if (field == null) {
                    field = SingleLazy()
                }
                return field
            }
            private set
    }
}

//单例类
object SingleLazy {
    fun test() {
        //...
    }
}