1.继承
Kotlin 中的继承方式与 Java 类似,Java 中所有对象都继承自 Object ,而 Kotlin 中所有对象均继承自 Any。两者均不能多继承,只是表现形式不同,Kotlin 继承使用冒号 : 表示。想要复写某个方法,则也需要将方法标记为 open 的才可以被复写。
切记一个类想要被继承,必须用 open
或 abstract
关键字 声明。
示例如下;
open class person(name: String) // 必须申请为open才可以继承,
class male(name: String): Person(name)
2.抽象类
抽象类与这里与 Java 是一致的,通过 abstract 关键字标记为抽象类,抽象类中抽象方法也用 abstract 标记。有了 abstract 则不再需要使用 open 进行标注了。
示例如下:
open class person() {
open fun eat() {}
}
abstract class oldPerson(): person() {
abstract fun sleep()
override abstract fun eat() // 可以覆盖已实现的方法
}
- 抽象类和抽象方法默认是 open 关键字修饰的
- 复写抽象类中实现的方法,也必须要加 open 关键字才可复写
- 抽象类有抽象方法和方法的实现,可以有成员属性
3.接口
Kotlin 中的接口需要使用关键字 interface
进行声明,Kotlin 的接口既包含抽象方法的声明,也可以包含实现,且接口中也可以申明属性,默认属性要求是抽象的,或者是提供访问器,其接口中的属性不能有 field
属性关键字。
示例如下:
interface MyInterface {
val prop: Int // 抽象的
val propertyWithImplementation: String get() = "foo"
fun foo() { //方法实现
print(prop)
}
}
class Child : MyInterface {
override val prop: Int = 29
}
接口中已经实现的方法,在子类中进行复写不需要在加 open
关键字。
4.复写
复写关键字为 override
,与 Java 的区别是没有了 @
符号了。复写这里需要注意两点:
var
可以复写val
类型的,但是反之不行。- 想要复写父类的方法,父类方法必须加 open 关键字标识。
复写的规则中,如果继承和实现了同样的方法名,则必须在子类对该方法进行复写,因为编译器不知道该调用哪个父类的方法。示例如下:
open class A {
open fun f() { print("A") }
fun a() { print("a") }
}
interface B {
fun f() { print("B") } // 接口成员默认就是“open”的
fun b() { print("b") }
}
class C() : A(), B {
// 编译器要求覆盖 f(),因为不知道该调用哪个父类的方法
override fun f() {
super<A>.f() // 调用 A.f()
super<B>.f() // 调用 B.f()
}
}
5.data数据类
在与服务器交互中经常有数据类,在 Kotlin 中直接使用data标记为数据类,它会根据构造函数的属性生成 equals
, hashcode
, toString
方法,当然这块我们也是可以重写的。
需要注意的是:
- 数据类主构造函数至少有一个参数
- 主构造函数的所有参数需要标记为 val 或 var;
如下:
data class User(val id: String, var name: String, var age: Int)
上面的数据类,表示数据类 User 中有三个属性,其中 id 只可读,因为 id 为 val 标识,还有 name, age 两个可读可写的属性。
6.单例声明
在 Java 中写一个单例是很麻烦的事情,也有很多种不通过的写法,需要考虑多线程问题,但在 Kotlin 中单例就变得简单的多,使用 object 关键字就可以实现单例,我们看下示例代码:
object Person {
fun eat(){
print("eat")
}
}
翻译成为 Java 代码如下:
public final class Person {
public static final Person INSTANCE;
public final void eat() {
String var1 = "eat";
System.out.print(var1);
}
static {
Person var0 = new Person();
INSTANCE = var0;
}
}
看到上面代码实际为一个单例默认的饿汉模式实现。
7.对象表达式
当需要修改一个类的部分功能,可以不通过显式实现一个该类的子类方式来实现。在 Java 中,通过匿名内部类来实现;在 Kotlin 中,概括为对象表达式和对象声明。最常见的就是我们代码中设置 Listener。示例如下:
val test = object : View.OnClickListener() {
override fun onClick(p0: View?) {
Log.v("TAG","click listener")
}
}
还有这种用法
val adHoc = object {
var x: Int = 0
var y: Int = 0
}
print(adHoc.x + adHoc.y)
8.伴生对象
Kotlin 中没有静态的属性和方法的概念, Kotlin 官网建议我们使用包级别的函数,来替代静态方法。当然也可以在类内使用 companion object 关键字声明一个伴生对象。 如下:
class Test {
companion object {
val TAG = "TEST"
}
fun test(){
Log.v(Test.TAG,"test method")
}
}
object 的使用有很多种,可参考这篇文章。
http://liuqingwen.me/blog/2017/06/20/object-vs-companion-object-in-kotlin/