Kotlin 学习笔记（2）类和继承

以下是本人的学习笔记，入有任何不妥之处，随时欢迎拍砖指正。

谢谢

^_^

1. 类

Kotlin 中使用关键字 class 声明类

class Invoice {
}

//如果没有具体的内容甚至可以这样定义
class Invoice

2. 构造函数

在 Kotlin 中类可以有一个主构造函数和一个或多个次构造函数

class Person constructor(firstName: String) {
}

如果主构造函数没有任何注解或者可见性修饰符，可以省略这个 constructor 关键字。

class Person(firstName: String) {
}

主构造函数中不能有内容，如果需要初始化，使用

init

关键字

class Person(firstName: String) {
init {
println("Customer initialized with value ${firstName}")
}
}

我们通过以下方式创建 Person

val p = Person("12")

// 输出结果
I/System.out: Customer initialized with value 12

3. 次构造函数

也可以用

constructor

作为前缀来生成次构造函数。

class Parent {
constructor(parent: Child) {
println("Customer initialized with parent")
}
}

class Child(firstName: String) {
init {
println("Customer initialized with value ${firstName}")
}
}

通过以下方式创建

val name = Parent(Child("Xiao Ming"))
// 输出结果
I/System.out: Customer initialized with value Xiao Ming
I/System.out: Customer initialized with parent

类如果没有任何参数，那么默认是 public 的，如果需要私有就在上边加『private』 修饰符

class Person private constructor ()

当构造函数被『private』所修饰时，无法创建对象



编译会报错，提示 Person 已被私有化。

下面是构造函数上有默认的值提供，构造器会提供一个空参函数来初始化，并使用默认值。

class Person (val PersonName: String = "")

我们通过以下方式创建 Person

val p = Person()

4. 继承

Kotlin 中所有类都有一个共同的超类

Any

class Parent // 从 Any 隐式继承

被

open

关键字修饰的类允许其他类从这个类继承

open class Parent(p: Int)

class Child(p: Int) : Parent(p)

4.1 覆盖方法

当子类被

open

修饰时，才可以被继承，默认情况（即没有 open） 下是 final 修饰的无法继承。

当被

open

修饰的类中有被

open

修饰的方法时，可以被子类重写，用

override

来修饰。如下例中的 paly( )

open class Parent(p: Int) {
open fun play() {}
fun doHomeWork() {}
}

class Child(p: Int) : Parent(p) {
override fun play() {
super.play()
}
}

如果想让

play

只被重写一次那么，需要加

final

也就是说当类中的方法被 final 修饰时，子类无法继承

class Child(p: Int) : Parent(p) {
final override fun play() {
super.play()
}
}

当类没有被

open

所修饰(也就是默认 final 修饰)，那么类中的方法也不能用

open

修饰

4.2 覆盖属性

属性也可以被覆盖，可以用一个 var 属性覆盖一个 val 属性，但反之则不行。

interface Foo {
val count: Int
}

class Bar1(override val count: Int) : Foo

class Bar2 : Foo {
override var count: Int = 0
}

4.3 覆盖规则

kotlin 中，接口可选的去实现里面的方法。

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()
}
}

上面例子中类 C 继承了类 A 和接口 B ，类 C 可以调用

a()

，

b()

，而

f()

存在歧义，C 不知道他该继承谁的方法，所以我们需要对相同名称的方法进行重写覆盖，这样我们就可以通过自定义方法的形式来消除歧义。

关于我

一只成长中的图图。

感谢

参考自:

https://www.kotlincn.net/docs/tutorials/android-plugin.html

https://huanglizhuo.gitbooks.io/kotlin-in-chinese/content/GettingStarted/Basic-Syntax.html