循坏的跳转符

  private fun test14() {
        loop@ for (i in 1..10) {
            if (i == 4) {
                return
            }
            println(i)
        }

        loop@ for (i in 1..10) {
            if (i == 5) {
                continue@loop
            }
            println(i)
        }

        loop@ for (i in 1..10) {
            if (i == 4) {
                break@loop
            }
            println(i)
        }
    }

return,continue,break后面+@loop也可以省略不加,这三个关键字和java中的作用是一样的

继承

1.Kotlin中的所有类都是final的,父类必须用open修饰类

    open class Father{
    }
    class son: Father() {
    }

2.父类有构造,子类必须在主构造函数中初始化

    class son: Father {
       constructor(a:Int):super(a)
    }

    open class Father(a: Int) {
    }

    open class Father(a: Int) {
    }

    class son(a:Int): Father(a) {
    }

3.二级构造函数可以调用父类不同的构造方法

    class MyView :View{
        constructor(context:Context):super(context){
        }

        constructor(context: Context,attr: AttributeSet):super(context,attr){
        }
    }

方法重写

1.和继承一样,方法想要被重写必须加上open关键字,method2()没有用open修饰,重写会报错

    open class F {
        open fun method1() {}
        fun method2() {}
    }

    class S : F() {
        override fun method1() {
        }
    }

2.可以重写属性由只读类型变为可写类型

 open class F {
        open val age: Int get() = 0 // get() = 0 与 = 0相同
        open fun method1() {}
        fun method2() {}
    }

    class S : F() {
        override var age: Int  = 10
        override fun method1() {
        }
    }

3.可以用super关键字调用父类属性和方法

    open class F {
        open val age: Int get() = 0 // get() = 0 与 = 0相同
        open fun method1() {
            println("F method1")
        }

        fun method2() {}
    }

    class S : F() {
        override var age: Int = super.age + 23
        override fun method1() {
            super.method1()
            println("S method1")
            println(age)
        }
    }

4.类部类用super@+类名调用外部类方法和属性

    class F2 : F() {
        override fun method1() {
        }

        override val age: Int get() = 1
        inner class F3{
            fun f(){
                super@F2.method1()
                super@F2.age
            }
        }
    }

5.可以同时从A B中继承方法，而且C继承a()或b()的实现没有任何问题，因为它们都只有一个实现。但是f()有两个实现，所以要在C中必须复写f()并且提供自己的实现。

  open class A {
        open fun f() {
            println("A f")
        }

        fun a() {
            println("A a")
        }
    }

    interface B {
        fun f() {
            println("Bf")
        }

        fun b() {
            println("B b")
        }
    }

    class C() : A(), B {
        override fun f() {
        }
    }

抽象类

与Java类似，Kotlin的类或者成员都可以被声明为abstract

 open class AB{
       open fun test(){}
    }

    abstract class T:AB(){
        override abstract fun test() 
    }

枚举

    enum class STATUS{
        LOADING,SUCCESS,FAIL
    }

接口

和java一样都可以包含抽象方法以及方法的实现,必须实现接口中没有实现的方法

    interface MyINF{
        fun t1()
        fun t2(){}

    }
    class M :MyINF{
        override fun t1() {
            TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
        }
    }