1.继承

Kotlin 中所有类都继承该 Any 类，它是所有类的超类，对于没有超类型声明的类是默认超类：
class Example // 从 Any 隐式继承
Any默认提供了3个函数：equals(),hashCode(),toString()
注意：Any 不是 java.lang.Object。

如果一个类要被继承，可以使用 open 关键字进行修饰，用：代替extends
open class Base(p: Int)
class Derived(p: Int) : Base(p)

构造函数
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("wang", 18, "S12346", 89)
       println("学生名： ${s.name}")
       println("年龄： ${s.age}")
       println("学生号： ${s.no}")
       println("成绩： ${s.score}")
}
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("----基类次级构造函数----")
      }
}
/**子类**/
class Student:Person{
      /**次级构造函数**/
      constructor(name:String, age:Int, no:String, score:Int):super(name,age){
             println("----继承类次级构造函数----")
             println("学生名： ${s.name}")
             println("年龄： ${s.age}")
             println("学生号： ${s.no}")
             println("成绩： ${s.score}")
      }
}
fun main(args:Array<String>){
      var s = Student("wang", 18, "S12346", 89)
}
输出：----基类次级构造函数----
           ----继承类次级构造函数----
           学生名： wang
           年龄： 18
           学生号： S12345
           成绩： 89

2.接口

Kotlin 接口与 Java 8 类似，使用 interface 关键字定义接口，kotlin允许方法有默认实现：

例：
interface MyInterface {
       fun bar() // 未实现
       fun foo() { //已实现
              // 可选的方法体
              println("foo")
        }
}
实现接口：一个类或者对象可以实现一个或多个接口。
class Child : MyInterface {
       override fun bar() { // 方法体 }
}

接口中的属性：接口中的属性只能是抽象的，不允许初始化值，接口不会保存属性值，实现接口时，必须重写属性
interface MyInterface{
       var name:String //name 属性, 抽象的
}
class MyImpl:MyInterface{
       override var name: String = "wang" //重写属性
}
 

3.重写

方法重写
在基类中，使用fun声明函数时，此函数默认为final修饰，不能被子类重写。如果允许子类重写该函数，那么就要手动添加 open 修饰它, 子类重写方法使用 override 关键词：
open class Person{
      open fun study(){
           println("我毕业了")
      }
}
class Student:Person(){
       override fun study(){
            println("我读研了")
       }
}
fun main(args:Array<String>){
       val s=Student()
       s.study();  //我读研了
}

如果有多个相同的方法（继承或者实现自其他类，如A、B类），则必须要重写该方法，使用super范型去选择性地调用父类的实现。
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<B>.f()//调用 B.f()
          }
}
fun main(args: Array<String>) {
        val c = C()
        c.f();  //输出“AB”
}

属性重写
属性重写使用 override 关键字，属性必须具有兼容类型，每一个声明的属性都可以通过初始化程序或者getter方法被重写：
open class Foo {
         open val x: Int get { …… }
}
class Bar1 : Foo() {
         override val x: Int = ……
}
你可以用一个var属性重写一个val属性，但是反过来不行。因为val属性本身定义了getter方法，重写为var属性会在衍生类中额外声明一个setter方法
你可以在主构造函数中使用 override 关键字作为属性声明的一部分:
interface Foo {
        val count: Int
}
class Bar1(override val count: Int) : Foo
class Bar2 : Foo {
        override var count: Int = 0
}