**用户基类**/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范型去选择性地调用父类的实现。

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

C 继承自 a() 或 b(), C 不仅可以从 A 或者 B 中继承函数，而且 C 可以继承 A()、B() 中共有的函数。此时该函数在中只有一个实现，为了消除歧义，该函数必须调用A()和B()中该函数的实现，并提供自己的实现。

输出结果为:

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) : Fooclass Bar2 : Foo {
    override var count: Int = 0}