Kotlin 继承
一.Kotlin 中所有类都继承该 Any 类,它是所有类的超类,对于没有超类型声明的类是默认超类:
class Example // 从 Any 隐式继承
Any 默认提供了三个函数:
equals()
hashCode()
toString()
Kotlin中没有Object这个类。Any是不是和Java中的Object是非常相似的。并且Object也是只提供上面三个方法。
注意:Any 不是 java.lang.Object。
如果一个类要被继承,可以使用 open 关键字进行修饰。
open class Base(p: Int) // 定义基类
class Derived(p: Int) : Base(p) //继承Base的类的参数要包含Base类的参数
二.构造函数
1.子类有主构造函数
如果子类有主构造函数, 则基类必须在主构造函数中立即初始化。
open class Person(var name : String, var age : Int){// 父类
}
class Student(name : String, age : Int, var no : String, var score : Int) : Person(name, age) { //子类
}
// 测试
fun main(args: Array<String>) {
val s = Student("Runoob", 18, "S12346", 89)//子类实现的时候,进行初始化数据
println("学生名: ${s.name}")
println("年龄: ${s.age}")
println("学生号: ${s.no}")
println("成绩: ${s.score}")
}
运行结果:
学生名: Runoob
年龄: 18
学生号: S12346
成绩: 89
2.子类没有主构造函数
如果子类没有主构造函数,则必须在每一个二级构造函数中用 super 关键字初始化基类,或者在代理另一个构造函数。
初始化基类时,可以调用基类的不同构造方法。
class Student : Person {
constructor(ctx: Context) : super(ctx) {
}
constructor(ctx: Context, attrs: AttributeSet) : super(ctx,attrs) {
}
}
实例
/**用户基类**/
open class Person(name:String){ //父类
/**次级构造函数**/
constructor(name:String,age:Int):this(name){
//初始化
println("-------基类次级构造函数---------")
}
}
/**子类继承 Person 类**/
class Student:Person{ //子类没有主构造方法
/**次级构造函数**/
constructor(name:String,age:Int,no:String,score:Int):super(name,age){
println("-------继承类次级构造函数---------")
println("学生名: ${name}")
println("年龄: ${age}")
println("学生号: ${no}")
println("成绩: ${score}")
}
}
fun main(args: Array<String>) {
var s = Student("Runoob", 18, "S12345", 89)
}
输出结果:
-------基类次级构造函数---------
-------继承类次级构造函数---------
学生名: Runoob
年龄: 18
学生号: S12345
成绩: 89
这个没什么好说的,看一遍也基本能理解。
三.重写
在基类中,使用fun声明函数时,此函数默认为final修饰,不能被子类重写。如果允许子类重写该函数,那么就要手动添加 open 修饰它, 子类重写方法使用 override 关键词:
/**用户基类**/
open class Person{
open fun study(){ // 允许子类重写
println("我毕业了")
}
}
/**子类继承 Person 类**/
class Student : Person() {
override fun study(){ // 重写方法
println("我在读大学")
}
}
//测试
fun main(args: Array<String>) {
val s = Student()
s.study();
}
输出结果为:
我在读大学
如果有多个相同的方法(继承或者实现自其他类,如A、B类),则必须要重写该方法,使用super范型去选择性地调用父类的实现。
package hello
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{
override fun f() { //重写方法
super<A>.f()//调用 A.f(),用到super关键字
super<B>.f()//调用 B.f()
}
fun doOther(){ //自定义方法
a() //这里a()方法虽然不能重写,但是在子类中调用是没有问题的
b()
}
}
?
fun main(args: Array<String>) {
val c = C()
c.f();
c.doOther()
}
C 继承自 a() 或 b(), C 不仅可以从 A 或则 B 中继承函数,而且 C 可以继承 A()、B() 中共有的函数。
此时该函数在中只有一个实现,为了消除歧义,该函数必须调用A()和B()中该函数的实现,并提供自己的实现。
输出结果为:
ABab
其实这个重写Kotlin和java的方式差不多的,就是会有关键字的不同。
四.属性重写
属性重写使用 override 关键字,属性必须具有兼容类型,每一个声明的属性都可以通过初始化程序或者getter方法被重写:
open class Foo {//父类
open val x: Int get { …… }//定义属性
}
class Bar1 : Foo() {//子类
override val x: Int = …… //覆盖属性,重写属性
}
你可以用一个var属性重写一个val属性,但是反过来不行。
因为val属性本身定义了getter方法,重写为var属性会在衍生类中额外声明一个setter方法
这个跟我刚开始理解的居然有点不一样。
其实可以像java那样理解,父类的方法的修饰符如果是protect,那么子类中重写这个方法,修饰符只能是protect或者public,总之要不父类的范围广。
你可以在主构造函数中使用 override 关键字作为属性声明的一部分:
package hello // 可选的包头
interface Foo {//父类
val count: Int
var number:Int
}
class Bar1(override val count: Int,override var number:Int) : Foo //子类,在构造方法中重写属性
class Bar2 : Foo {
override var count: Int = 0 //在类中重写属性,使用var重写val属性是没有问题的
override var number:Int=2 //如果这里使用val就会报错
}
fun main(args: Array<String>) {
val bar2=Bar2()
var c= bar2.count //后面类型是无所谓的
println("c=$c")
val d=bar2.number //后面类型是无所谓的
println("d=$d")
}
运行结果:
c=0
d=2
上面示例中父类是接口,所以每一个属性都是要必须被重写的。如果父类是简单的类,可以只重写open的属性和方法。
但是我感觉这样写,如果Kotlin中接口的属性比较多,这不是很坑吗!
继承关系到这里就简单介绍完毕了,大家也可以测试一下:
https://blog.csdn.net/wenzhi20102321/article/details/79859347