Kotlin 中的接口 Interface : so much betterKotlin 开发者社区

Interface was introduced in Java as a new programming feature. It describes CAN-BE instead of IS-A relationship. That also enables it to perform multiple inheritance (e.g. something can be many things, but only is a thing).

However as we know even up to Java 7 (which once was the main language for native Android Development), Interface does have various drawbacks, making it not as attractive, and at times, some have to resort back to abstract class.

With Kotlin in place, let me share with you how Kotlin made Inheritance better.

Kotlin made Interface extensible. In Java 7, inheritance function declaration can’t have implementation. Hence those class implements an interface, need to have all it’s function implemented.

This is a problem, as this makes interface inextensible.

Imagine we have the below Movable interface.

interface Movable { int legsCount(); } class Horse implements Movable { @Override public int legsCount() { return 4; } } Then we realize that other than legs, we need to count wings too. So we add wingsCount().

It is unfortunate those that implemented this interface i.e. Horse will also need to change.

interface Movable { int legsCount(); int wingsCount(); } class Horse implements Movable { @Override public int legsCount() { return 4; } @Override public int wingsCount() { return 0; } } In Kotlin We initially have

interface Movable { fun legsCount(): Int } class Horse : Movable { override fun legsCount() = 4 } Then we could easily extend it.

interface Movable { fun legsCount(): Int fun wingsCount(): Int { return 0 } } class Horse : Movable { override fun legsCount() = 4 } Or even more, without need to modify Horse class at all!

interface Movable { fun legsCount(): Int { return 0 } fun wingsCount(): Int { return 0 } fun canFly(): Boolean { return wingsCount() > 1 } fun canWalk(): Boolean { return legsCount() > 1 } } class Horse : Movable { override fun legsCount() = 4 } Kotlin made Interface truly override. The definition of override according to Cambridge Dictionary is

to decide against or refuse to accept a previous decision, an order, a person, etc. In the Java world, Interface is overriding nothing.

But in Kotlin world, look at the example below

interface Movable { fun legsCount(): Int { return 0 } fun wingsCount(): Int { return 0 } fun canFly(): Boolean { return wingsCount() > 1 } fun canWalk(): Boolean { return legsCount() > 1 } } class Horse : Movable { var isSick = false override fun legsCount() = 4 override fun canWalk(): Boolean { if (isSick) { return false } return super.canWalk() } } If we set horse.isSick = true, the canWalk() function will return false, regardless of the leg counts. A truly overriding capability.

Kotlin made Interface more object like In Java world (I believe including Java 8 and 9), Interface are not allowed to have property other than final constant variable (hmm… constant variable sounds oxymoron, perhaps should be called constant value).

At most we could make an accessor function e.g. legCount().

In Kotlin With Kotlin, one could have a property in Interface.

Instead of writing

interface Movable { fun legsCount(): Int fun canWalk() = legsCount() > 1 } class Horse : Movable { override fun legsCount() = 4 } One could write as

interface Movable { val legsCount : Int fun canWalk(): Boolean = legsCount > 1 } class Horse : Movable { override val legsCount = 4 } There’s some limitation for the property in Interface though, as it can’t have backfield property, which means it can’t be change. So it is still stateless. Besides, it also can’t be initialized in the interface itself. Kotlin made Interface a better composition You might have heard Composition over Inheritance principle. Kotlin made this even more simpler

Imagine you have Horse and Dog. Both are 4 legs animal.

One way to program is as below

interface Movable { val legsCount : Int fun canWalk() = legsCount > 1 } class Horse : Movable { override val legsCount = 4 } class Dog : Movable { override val legsCount = 4 } This is so cumbersome as we have to

replicate the code override val legsCount = 4 for each of them.

If we have more functions to override, or more class object that is 4 legs animal, we’ll have to do the same.

If one day we change to 4 to “four”, or add more functionality…

It would be a nightmare to change . So inextensible.

We can make an class inheritance of that perhaps? interface Movable { val legsCount: Int fun canWalk() = legsCount > 1 } open class FourLegged : Movable { override val legsCount = 4 } class Horse : FourLegged() class Dog : FourLegged() But this violates the Composition over Inheritance principle. Horse and Dogare not only FourLegged, but could be something else, making them very inextensible to other type anymore (e.g. Pet).

This is also inextensible ☹️

So let’s apply Composite over Inheritance (the traditional way) interface Movable { val legsCount: Int fun canWalk() = legsCount > 1 } object FourLegged : Movable { override val legsCount = 4 } class Horse : Movable { private val movable = FourLegged override val legsCount get() = movable.legsCount } class Dog : Movable { private val movable = FourLegged override val legsCount get() = movable.legsCount } I don’t know about you, I dislike this equally, So let’s enhance it better to as below…

interface Movable { val legsCount: Int fun canWalk() = legsCount > 1 } object FourLegged : Movable { override val legsCount = 4 } open class MovableImpl(private val movable: Movable) : Movable { override val legsCount get() = movable.legsCount } class Horse : MovableImpl(FourLegged) class Dog : MovableImpl(FourLegged) Now this is better, as it is more extensible, as in the future we have FourLegged or TwoLegged etc, we could easily add to it.

But I still dislike it, as I need to have the intermediate class MovableImpl. So let’s check out further what how Kotlin could made our interface better…

The Kotlin provided way: By … delegate to composition made easy With the interface in Kotlin, we could use the By keyword to generate the Delegate pattern so easily. Check it out

interface Movable { val legsCount: Int fun canWalk() = legsCount > 1 } object FourLegged : Movable { override val legsCount = 4 } class Horse : Movable by FourLegged class Dog : Movable by FourLegged So much nicer! ?. Hopes you see how good that is.

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏逍遥剑客的游戏开发

WOW小地图生成

2953
来自专栏小樱的经验随笔

用Metaclass实现一个精简的ORM框架

存档: 1 # -*- coding: utf-8 -*- 2 class Field(object): 3 4 def __init__(s...

3145
来自专栏ml

Java之线程———GUI线程(包含打字游戏和计时器俩个GUI实列)

     当java程序包含图形用户界面(GUI)时,Java虚拟机在运行应用程序时会自动启动更多的线程,其中有两个重要的线程:AWT-EventQuecue ...

5556
来自专栏函数式编程语言及工具

SDP(2):ScalikeJDBC-Connection Pool Configuration

  scalikeJDBC可以通过配置文件来设置连接池及全局系统参数。对配置文件的解析是通过TypesafeConfig工具库实现的。默认加载classpath...

3454
来自专栏数据结构与算法

HDU 4786Fibonacci Tree(最小生成树)

Problem Description   Coach Pang is interested in Fibonacci numbers while Un...

3796
来自专栏DT乱“码”

接口测试类(http,post请求)参数 json格式

package RMI; import java.io.BufferedReader; import java.io.DataOutputStream; im...

2339
来自专栏技术之路

WPF MVVM实现TreeView

今天有点时间,做个小例子WPF MVVM 实现TreeView 只是一个思路大家可以自由扩展 文章最后给出了源码下载地址 图1 ?    图2     ? 模...

2579
来自专栏cmazxiaoma的架构师之路

你真的会用HttpMessageConverter吗?

1.6K6
来自专栏猿人谷

du熊学斐波那契I

du熊学斐波那契I Time Limit : 2000/1000ms (C/Other)   Memory Limit : 65535/32768K (C/Ot...

19110
来自专栏函数式编程语言及工具

FunDA(11)- 数据库操作的并行运算:Parallel data processing

   FunDA最重要的设计目标之一就是能够实现数据库操作的并行运算。我们先重温一下fs2是如何实现并行运算的。我们用interleave、merge、eith...

1958

扫码关注云+社区

领取腾讯云代金券