Kotlin 中的接口 Interface : so much better
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.
Kotlin 开发者社区
国内第一Kotlin 开发者社区公众号,主要分享、交流 Kotlin 编程语言、Spring Boot、Android、React.js/Node.js、函数式编程、编程思想等相关主题。
低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。
持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。
转载内容版权归作者及来源网站所有,本站原创内容转载请注明来源。
- 上一篇
c# MVC框架 对mysql数据库的查询
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/tianchao7c/article/details/83580918 using System; using System.Collections.Generic; using System.Linq; using System.Web; using System.Web.Mvc; using demo2.Models; using MySql.Data.MySqlClient; using Newtonsoft.Json; namespace demo2.Controllers { public class GetFilesController : Controller { // GET: GetFiles [HttpGet] public void GetFiles(GetFiles Parameter) { string sn = Parameter.Sn_code; string t = DateTime.Now.ToString("yyyyMMdd"); string name...
- 下一篇
Google Guice 4.2.2 发布,支持 Java 11
Guice 4.2.2 已发布了,Guice 是 Google 开发的一个基于 Java 6 以上的轻量级依赖注入框架,目标是使开发和调试更容易,更快速。 主要更新内容: 支持Java11 (updated cglib & asm). 下载地址: Guice:guice-4.2.2.jar Guice (No AOP):guice-4.2.2-no_aop.jar Guice: <dependency> <groupId>com.google.inject</groupId> <artifactId>guice</artifactId> <version>4.2.2</version> </dependency> Guice (No AOP): <dependency> <groupId>com.google.inject</groupId> <artifactId>guice</artifactId> <versio...
相关文章
文章评论
共有0条评论来说两句吧...
文章二维码
点击排行
推荐阅读
最新文章
- Docker使用Oracle官方镜像安装(12C,18C,19C)
- CentOS8编译安装MySQL8.0.19
- CentOS8,CentOS7,CentOS6编译安装Redis5.0.7
- SpringBoot2整合MyBatis,连接MySql数据库做增删改查操作
- SpringBoot2整合Redis,开启缓存,提高访问速度
- SpringBoot2配置默认Tomcat设置,开启更多高级功能
- Hadoop3单机部署,实现最简伪集群
- CentOS7,CentOS8安装Elasticsearch6.8.6
- CentOS6,7,8上安装Nginx,支持https2.0的开启
- SpringBoot2编写第一个Controller,响应你的http请求并返回结果