Kotlin学习笔记（5）- 类

系列文章全部为本人的学习笔记，若有任何不妥之处，随时欢迎拍砖指正。如果你觉得我的文章对你有用，欢迎关注我，我们一起学习进步！
Kotlin学习笔记（1）- 环境配置
Kotlin学习笔记（2）- 空安全
Kotlin学习笔记（3）- 语法
Kotlin学习笔记（4）- 流程控制
Kotlin学习笔记（5）- 类
Kotlin学习笔记（6）- 属性
Kotlin学习笔记（7）- 接口
Kotlin学习笔记（8）- 扩展
Kotlin学习笔记（8）- 扩展（续）
Kotlin学习笔记（9）- 数据类
Kotlin学习笔记（10）- 泛型
Kotlin学习笔记（11）- 内部类和嵌套类
Kotlin学习笔记（12）- 委托
Kotlin学习笔记（13）- 函数式编程
Kotlin学习笔记（14）- lambda

一、类

1.类修饰符

修饰符分为属性修饰符和访问权限修饰符。

// 属性修饰符
annotation  //注解类
abstract   //抽象类
final     //类不可继承，默认属性
enum     //枚举类
open    //类可继承，类默认是final的

// 访问权限修饰符
private   //仅在同一个文件中可见
protected //同一个文件中或子类可见
public    //所有调用的地方都可见
internal  //同一个模块中可见

2.类定义

kotlin默认唯一构造器，暨类定义同时也是构造器。

class Person(name : String， age : int) {
} 

翻译成java为：

final public class Person {
    public Person(String name, int age){
    }
}

3.构造函数

仔细看会发现，翻译成的java类定义前面有final修饰符，因为在kotlin中类默认为final的，也就是不可继承的。如果要继承，需要声明为open，或者abstract。

class Person(name : String， age : int)

如果连参数也没有，也可以这么写

class Person

4.类初始化

因为kotlin中的类定义同时也是构造函数，这个时候是不能进行操作的，所以kotlin增加了一个新的关键字init用来处理类的初始化问题，init模块中的内容可以直接使用构造函数的参数。

class Person(name : String， age : int){
    init{
        // to do something
    }
}

5.次级构造函数

我们知道，java中可以有多个不同类型、不同个数的同名构造函数，以此满足我们的各种需求。而上面我们说过，kotlin中的类定义同时也是构造函数，kotlin中也默认只有这一个构造函数，那我们怎么办呢？很常见的一个问题是，View的自定义。根据android系统版本不同，View有3到4个构造函数，如果只用kotlin中的默认构造函数，我们确实可以在普通代码中正常使用，那么如何在xml中进行定义呢？旧版的kotlin没有处理这个问题，我们只能在java中自定义View，然后再进行调用。而在新版的kotlin已经解决了这个问题，那就是次级构造函数constructor。

次级构造函数用constructor加上参数，后面用this加上主构造函数的参数。同时次级构造函数中可以直接进行代码操作，所以没有init模块

class ParentClass(name: String) {
    var a = 1
    init {
        log("This is --> primary constructor, a=$a, name=$name")
    }

    constructor(name : String, age : Int) : this(name) {
        log("This is --> secondry constructor, a=${++a}, age=$age")
    }
}

// 翻译成java

final class ParentClass{
    int a = 1;
    public ParentClass(String name){
        log("This is --> primary constructor, a=$a, name=$name")
    }
    
    public ParentClass(String name, int age){
        this(name);
        log("This is --> secondry constructor, a=${++a}, age=$age")
    }
}

// 也就是说，如果新建一个类ParentClass("name", age)，那么就会进行两次log输出

6.参数默认值

kotlin中支持类定义的时候，参数可以设置默认值。

// 含有默认值的参数，可以不传，也就是说ParentClass("xiaoming", 22, 1)和ParentClass("xiaoming", 22)这两种调用方式都是可以的
constructor(name : String, age : Int, sex : Int = 0) : this(name) {
    log("This is --> secondry constructor, a=${++a}, age=$age, sex=$sex")
}

如果构造函数中的所有参数都有默认值，则kotlin会多创建一个无参数的构造函数。

constructor(name : String = "", age : Int = 12, sex : Int = 0) : this(name) {
    log("This is --> secondry constructor, a=${++a}, age=$age, sex=$sex")
}

如果有多个构造函数，且某个或某几个构造函数中有默认值，则kotlin会选择最符合条件的一个作为构造函数。在下面的示例中，第三个构造函数的第三个参数是有默认值的，可以不传，这就和第二个构造函数有了相同的假象。kotlin的规则是，选择最符合条件的一个，也就是如果你这样创建：ParentClass("xiaoming", 22)，kotlin会先去找只有这两参数类型的构造函数，也就是第二种。

class ParentClass(name: String) {
    var a = 1
    init {
        log("This is --> primary constructor, a=$a, name=$name")
    }

    constructor(name : String, age : Int) : this(name) {
        log("This is --> secondry constructor, a=${++a}, age=$age")
    }

    constructor(name : String, age : Int, sex : Int = 0) : this(name) {
        log("This is --> secondry constructor, a=${++a}, age=$age, sex=$sex")
    }
}

二、继承

1.继承的基本使用

在kotlin中，类默认是final类型的，也就是不可继承的。如果需要继承，需要显式的将类声明为open。我觉得这其实也表现出kotlin不推荐使用继承的一种态度，毕竟在面向对象设计中，是推荐多用组合、少用继承的。kotlin使用冒号:代替java中的extend来表示继承关系，如果父类的构造函数有参数，则在继承时也要注明。

open class ParentClass(name: String) {
    var a = 1
    init {
        log("This is --> primary constructor, a=$a, name=$name")
    }
}
class Child(name: String, age : Int) : ParentClass(name){
}

2.多构造函数的继承

次级构造函数初始化使用super关键字，类似于java中的super

class Child2 : ParentClass {
    constructor(name : String) : super(name){
        log("Child2 age : $name")
    }
    // 可以对参数进行扩展
    constructor(name: String, age: Int) : super(name){
    }
}

3.方法重载

同样的，秉承着多用组合、少用继承的原则，类中的方法默认也是final的，父类如果想要某个方法可以被子类重载，那么这个方法也要显式的被声明为open；而子类如果要重载父类的方法，则该方法必须使用override关键字。

open class ParentClass(name: String) {
    open fun publicMethod(){
        log("I am public")
    }
}
class Child(name: String, age : Int) : ParentClass(name){
    override fun publicMethod() {
        super.publicMethod()
    }
}

成员标记为override的本身是开放的，也就是说，它可以在子类中重写。如果你想禁止重写的，使用final关键字。

class Child(name: String, age : Int) : ParentClass(name){
    final override fun publicMethod() {
        super.publicMethod()
    }
}

4.同名方法

我们可能还会遇到一种问题：类实现了多个接口，其中某些接口中恰好有相同的方法。kotlin中使用尖括号对父类进行标记，以示区分。

open class ParentClass(name: String) {
    open fun publicMethod(){
        log("I am public from ParentClass")
    }
}
interface ParentInterface(name: String) {
    fun publicMethod(){
        log("I am public from ParentInterface")
    }
}
class Child(name: String, age : Int) : ParentClass(name),ParentInterface{
    override fun publicMethod() {
        super<ParentClass>.publicMethod()
        super<ParentInterface>.publicMethod()
    }
}

三、抽象

和java一样，抽象也使用abstract关键字。抽象类中可以没有抽象方法，但抽象方法一定在抽象类中。那么既然是抽象的，那么肯定是需要继承的，所以abstract自动包含open属性，这也是不言而喻的。

abstract class ParentClass(name: String) {
    abstract fun abstractMethod()
}
class Child(name: String, age : Int) : ParentClass(name){
    override fun abstractMethod() {
        //To implemented it
    }
}

其实抽象用到的也是继承，但是为什么没有放到第二部分里呢？这里有一点个人的理解。我觉得抽象和单纯的继承在使用目的上是有本质区别的。抽象是为了封装变化，将不同的实现交给不同的子类去完成。而单纯的继承和方法重载反而破坏了封装的美感，既然需要通过重载父类方法来实现目的，那很可能你在设计父类的时候就已经做出了不恰当的决定。