系列文章全部为本人的学习笔记，若有任何不妥之处，随时欢迎拍砖指正。如果你觉得我的文章对你有用，欢迎关注我，我们一起学习进步！
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
}
}
其实抽象用到的也是继承，但是为什么没有放到第二部分里呢？这里有一点个人的理解。我觉得抽象和单纯的继承在使用目的上是有本质区别的。抽象是为了封装变化，将不同的实现交给不同的子类去完成。而单纯的继承和方法重载反而破坏了封装的美感，既然需要通过重载父类方法来实现目的，那很可能你在设计父类的时候就已经做出了不恰当的决定。
