Kotlin中所有的类都继承自 Any 类。Any 是所有类的超类。
Any提供了三个函数
equals()、hashCode()、toString()
一个类如果希望被别的类继承，可以使用 open 关键字进行修饰。
open class Base(p: Int)
class Derived(p: Int) : Base(p)
有主构造函数的子类
子类有主构造函数的，基类在主构造函数中初始化。
package main
fun main(args: Array<String>) {
val s = Student("金龙翼", 27, "A737509111722", 100)
println("学生姓名：${s.name}")
println("年龄：${s.age}")
println("学号：${s.no}")
println("成绩：${s.score}")
}
open class Person(var name: String, var age: Int){
//基类
}
class Student(name: String, age: Int, var no: String, var score: Int): Person(name, age){
}
运行结果
学生姓名：金龙翼
年龄：27
学号：A737509111722
成绩：100
子类没有主构造函数时，必须在每一个二级构造函数中用 super 关键字初始化基类，或者在代理另一个构造函数。初始化基类时，可以调用基类的不同构造方法。
子类和基类
open class Person2(name: String){
constructor(name: String, age: Int): this(name){
//基类次级构造
println("-----------基类次级构造函数-------------")
}
}
class Student2:Person2{
constructor(name: String, age: Int, no: String, store: Int): super(name, age){
println("----------继承类次级构造函数------------")
println("学生姓名：${name}")
println("年龄：${age}")
println("学号：${no}")
println("成绩：${store}")
}
}
主函数中直接实例化
var ss = Student2("天龙", 25, "B90161015", 120)
看运行结果
-----------基类次级构造函数-------------
----------继承类次级构造函数------------
学生姓名：天龙
年龄：25
学号：B90161015
成绩：120
重写
当我们写一个 fun 函数时，此函数默认为 final 修饰。当我们需要允许子类重写该函数的，需要手动添加 open 修饰它。子类重写方法使用 override 关键字。
package main
fun main(args: Array<String>) {
val s = Student()
s.study()
}
open class Person{
open fun study(){
println("我毕业了")
}
}
open class Student: Person(){
override fun study() {
println("我在读大学")
}
}
运行这段代码，就会发现，输出的是
我在读大学
呵呵，当然我没在读大学了。只是，这里用重写 override fun study() 替换了基类内的 open fun study() 执行。
这只是继承了一个类，如果子类继承了类同时还有接口，并且这些类和接口还有相同的函数方法，子类必须要重写该函数方法，使用 super 泛型选择性地调用父类的实现。
package main
fun main(args: Array<String>) {
val s = Student()
s.study()
val c = C()
c.f()
val d = D()
d.f()
}
open class Person{
open fun study(){
println("我毕业了")
}
}
open class Student: Person(){
override fun study() {
println("我在读大学")
}
}
open class A{
open fun f(){
println("A")
}
fun a(){
println("a")
}
}
interface B{
fun f(){
println("B")
}
fun b(){
println("b")
}
}
open class DD{
open fun f(){
println("DD")
}
fun dd(){
println("dd")
}
}
class C(): A(), B{
override fun f() {
super<A>.f()
super<B>.f()
}
}
class D(): DD(), B{
override fun f() {
super<B>.f()
super<DD>.f()
}
}
运行结果
A
B
B
DD
属性重写
属性重写也需要用到 override ，属性必须具有兼容类型，每个声明的属性都可以通过初始化程序或者 getter 方法被重写。
package main
fun main(args: Array<String>) {
var s = Student()
println(s.name)
var b = Bar2()
println(b.x)
}
interface Foo{
val x:Int
}
class Bar1(override val x: Int):Foo
class Bar2 : Foo{
override var x: Int = 0
}
open class Person{
open val name: String = "Joel"
}
class Student:Person(){
override var name = "Cofox"
}
运行结果
Cofox
0
