Kotlin 类型初步 - 类和接口

1. 类

1.1 类的定义

学一个类的定义，只需要掌握他的属性和方法的定义，那么类就基本上可以使用了

1.2 类的成员

Kotlin中的变量必须初始化，让我们一定要培养这个意识，对自己定义的所有的成员负责到底，定义出来之后，就要负责初始化，不然得话就是一个不清不楚的状态，而且编译器做这种过多的工作，也会容易产生错误。 java中如果类成员没有初始化，编译器会给成员变量赋值0，如果是对象的话，赋值null.

1.3 类的构造方法

1.2.1 定义：构造方法就是我们在创建对象的时候，调用的方法，就是构造方法

1. 
class SimpleClass {
    var x: int
    
    // 构造方法不是和类名一样
    // 明确的使用constructor, 这个方法是构造器
    constructor(x: Int) {
        this.x = x
    }
    ...

}

2. 简化: 
构造器挪到类的定义这一行，上面的constructor是一个副构造器.
和类名写在一起的是主构造器
主构造器要求其他所有的构造器都要调用它，就是说要求类的实例化路径只有一条
class SimpleClass
        constructor(x: Int) {
    var x: Int = x
    ...
}

3. 再简化:
构造器和类名都放在一起了，肯定知道他是构造器，所以可以将constructor省略
把构造器提到了类声明的这一行
class SimpleClass(x:Int) {
    var x: Int = x
    ...
}

4. 还可以再简化:
 观察3中类的属性，使用构造器的参数初始化，这样的化，还可以进一步简化为
所以如果我们给构造器的参数加了一个var 或者val ,那么他定义了类的属性
class SimpleClass(var x:Int) {
    ...
}

class SimpleClass(var x: Int, val y: String)
    : AbsClass(), SimpleInf {
    
    // 再定义一个成员, 成员定义在这个位置，和定义在类构造函数中有什么区别呢?
    // 从成员的角度来看，没区别。只不过，定义在构造器中，相当于这个成员本身需要通过构造器来初始化。
    // 定义的z 在使用的时候和x, y没有区别，见main函数
    val z: Long = 0L
    

    override fun absMethod(){}
    override fun simpleMethod(){}

    fun y(){}
}


fun main(varags args: String) {

    val simpleClass = SimpleClass(9, "Hello")
    
    println(simpleClass.x)
    println(simpleClass.y)
    println(simpleClass.z)

    // 调用方法
    simpleClass.y()
}

1.4 kotlin 类的实例化和java的对比

2. 接口

2.1 接口的定义

接口中的方法默认都是public，都是提供给外部调用的

2.2 接口的实现

注意implements 和 ":"

java中的@Override可以不写

kotlin中的override必须写，不写编译会报错

3. 抽象类的定义

Kotlin中抽象类的可见性默认为public, 抽象类的抽象方法默认可复写，普通的方法不可以被复写

抽象方法一定是用来被复写的 关键字为 abstract

其他普通的方法 kotlin默认是不可以复写的, 加了关键字open才可以被复写。java默认是可以复写，加了final之后，不能被复写

4. 类的继承

kotlin中继承使用":" , 并且父类需要调用构造器

// 抽象类
abstract class AbsClass {
    // 抽象方法
    abstract fun absMethod()
    
    // 关键字open 可复写的方法
    open fun overridable(){}
    
    // 默认不可复写方法
    fun nonOverridable(){}
}

// 定义接口
interface SimpleInf {
    
    // 在kotlin中可以定义属性property
    var simpleProperty: Int

    fun simpleMethod()
}

open class SimpleClass(var x: Int, val y: String)
    : AbsClass(), SimpleInf {

    val z: Long = 0L
    
    override fun absMethod(){}
    override fun simpleMethod(){}

    // 复写抽象类的open函数
    override fun overridable() {
    }

    // overridable不想被其他类继承
    // final override fun overridable(){}
    
    fun y(){}
}

// 1. 要定义SimpleClass2继承SimpleClass, SimpleClass要声明为open。
// 2. 类SimpleClass的构造函数带有参数，所以SimpleClass2的构造函数需要传参
class SimpleClass2(var x: Int, var y: String) : SimpleClass(x, y) {

    // 复写父类的overridable函数
    // 子类SimpleClass集成同时AbsClass的open方法
    // 如果子类的overridable函数不想被继承，在SimpleClass类使用final修复方法overridable。
    override fun overridable() {}

}

fun main(vararg args: String) {
    val simpleClass = SimpleClass(9, "Hello")
    println(simpleClass.x)
    println(simpleClass.y)
    println(simpleClass.z)

    simpleClass.y()
    simpleClass.zzz("Sleeping ZZZ!")
    
}