Kotlin的学习日志（三）class construcor,interface,abstract class

如果有错误的地方，多谢指出

/**
 * Created by Gray on 2017/5/28.
 */
/*

    kotlin中的类的关键字是class
        由类名，类头（类型参数，主构造函数等）和类体组成，如果class没有身体，可以省略花括号
                clasa A

         class中可以有一个主构造函数或者一个或多个辅助构造函数
               1.主构造函数
                class A constructor(s:String)

                如果没有注释或者可见修饰符
                class A(s:String)

                主构造函数中不能有任何代码，初始化的代码放在Inti中,
                可以在其中使用主构函数的参数
                class A(s:String){
                    init{
                         val s1 = s
                     }
                }

                通常我们可以使用下列方式来初始化他们
                class A(val s:String)

                如果有注释或者可见修饰符(后续详细介绍)
                class A public @Inject constructor(s:String){}


                2.二级构造函数
                    class A{
                        constructor(parent:A){
                            parent.child.add(this)
                        }
                    }

                    类如果存在主构函数，那么就要使用this来将这个辅助构造函数
                    通过另一个直接或间接委派给主构函数
                    class A{
                        constructor(i:Int,parent:A):this(i){
                            parent.child.add(this)
                        }
                    }

                    如果一个非抽象类没有声明任何构造函数,那么它将具有没有参数的生成的主构造函数
                    如果你不希望你的类是由公共构造函数，那么就要声明一个不可见的构造函数
                    class A private constructor(){}

                    如果主构函数的参数都具有默认值，那么就会为你生成一个无参数的构造函数

                    如何创建类的实例
                    val A = A()
                    val A = A("Hello")


        在Kotlin中所有类的父类是Any，如果你的类没有继承任何类，那么就会默认继承Any
            Any与java中的Object不相同，，Any中只有equals(),hashCode(),toString()

            要声明一个显式的超类型，我们将冒号后面的类型放在类头中
            open class A(a:Int)
            class B(a:Int):A(a)


            如果类没有主构造函数，则每个辅助构造函数必须使用super关键字初始化基类型，或者委托给另一个构造函数

            Kotlin中所有的都是final，所以需要在class加上open使得这个类可以被继承

            如果父类的某些方法需要被重写，需要也写成open,在重写方法上则要写上override
            上面的规则在属性上也同样通用
 */

/**
 * Created by Gray on 2017/5/28.
 */

class Person1{
    var name:String? = null
    init {
        name=""
    }
}

class Person2 constructor(name:String){
    init {
        println(name)
    }
}

class Person3(var name:String,var age:Int = 17){
    init {
        println("name:$name,age:$age")
    }
}

class Person4{
    constructor(name:String){
        println(name)
    }
    constructor(name:String,firstname:String,lastname:String){}
    constructor(name:String,firstname:String,lastname:String,age:Int){}
}

//调用主构造器，自构造器重载
class Person5 constructor(name:String){
    constructor(name:String,firstname:String,lastname:String):this(name)
    constructor(name:String,firstname:String,lastname:String,age:Int):this(name)
}

class Person6 private constructor(name:String){
    constructor(name:String,firstname:String,lastname:String):this(name)
    constructor(name:String,firstname:String,lastname:String,age:Int):this(name,firstname,lastname)
}


open class A(a:Int){
}

class B(b:Int):A(b){}


open class View{
    init {

    }
}

class MyView: View {
    constructor()
}


open class Animal{
    open fun eat(){
        println("Animal eat")
    }
    fun sleep(){}
}

class People():Animal(){
    override fun eat() {
        super.eat()
    }
}
fun main(args:Array<String>){
    var people = People()
    people.eat()
}

/**
 * Created by Gray on 2017/5/29.
 */
//接口不能存储状态
interface Family {
    val id:Int
    fun name(name:String){}
    fun isFamily(){}
}

class MyFamily(override val id: Int = 0):Family{
    override fun name(name: String) {
        super.name(name)
    }

    override fun isFamily() {
        //<Family>指定是哪个接口中的方法
        super<Family>.isFamily()
    }
}

//抽象类
abstract class Base{
    abstract fun f()
}