11：kotlin 类和对象 — 普通类

本文介绍: 前面粗咯的讲了类，这篇详细介绍类及相关的概念定义类使用关键字类声明由（指定其类型参数、主构造函数等）和由{}包围的组成。类头和类体都是可选的；如果类没有体，可以省略。

前面粗咯的讲了类，这篇详细介绍类及相关的概念

定义类使用关键字class

class Person { /*...*/ }

类声明由类名、类头（指定其类型参数、主构造函数等）和由{}包围的类体组成。类头和类体都是可选的；如果类没有体，可以省略{}

class Empty

在kotlin中，一个类有一个主构造函数和零个或多个次构造函数。主构造函数在类头中声明，它位于类名和可选类型参数之后

class Person constructor(firstName: String) { /*...*/ }

如果主构造函数没有任何注解或可见性修饰符，可以省略 c on struct or关键字

class Person(firstName: String) { /*...*/ }

主构造函数在类头中初始化类实例及其属性。类头不能包含任何可运行的代码。如果你想在创建对象时运行一些代码，可以在类体内使用初始化块。初始化块是用init 关键字声明的，后面跟着花括号。在花括号内编写你想要运行的任何代码

class InitOrderDemo(name: String) {
    val firstProperty = "第一个属性: $name".also(::println)

    init {
        println("第一个init块 $name")
    }

    val secondProperty = "第二个属性: ${name.length}".also(::println)

    init {
        println("第二个init块 ${name.length}")
    }
}
fun main(){
    InitOrderDemo("张三")
//    第一个属性 张三
//    第一个init块 张三 
//    第二个属性: 2
//    第二个init块 2
}

class Customer(name: String) {
    val customerKey = name.uppercase()
}

kotlin有一种简洁的语法，用于声明属性并从主构造函数中初始化它们，声明也可以包括类属性的默认值

class Person(val firstName: String, val lastName: String, var isEmployed: Boolean = true)

就像常规属性一样，主构造函数中声明的属性可以是可变的var或只读的val

如果构造函数有注解或可见性修饰符，constructor关键字是必需的，修饰符位于它之前

class Customer public @Inject constructor(name: String) { /*...*/ }

一个类也可以声明次要构造函数，它们以constructor为前缀

class Person(val pets: MutableList<Pet&gt; = mutableListOf())

class Pet {
    constructor(owner: Person) {
        owner.pets.add(this)
    }
}

如果类有主构造函数，则每个次要构造函数都需要直接或间接地通过另一个次要构造函数将其委托给主构造函数。使用this关键字完成对同一类的另一个构造函数的委托

class Person(val name: String) {
    val children: MutableList<Person> = mutableListOf()
    
    constructor(name: String, parent: Person) : this(name) {    // 委托主构造函数
        parent.children.add(this)
    }
}

class Constructors {
    init {
        println("Init block")
    }

    constructor(i: Int) {
        println("Constructor $i")
    }
}

fun main(){
    Constructors(1)
}
//    Init block
//    Constructor 1

如果没有定义任何构造函数，则会自动生成一个public修饰的无参主构造函数

如果不想要有一个public修饰的无参构造函数，需要手动定义一个private修饰的构造函数

class DontCreateMe private constructor(){
}

fun main(){
    val dontCreateMe = DontCreateMe()  // 报错 - Cannot access '<init>': it is private in 'DontCreateMe'
}

当所有主构造函数参数都具有默认值时，在JVM上，编译器将生成一个额外的无参数构造函数，该构造函数将使用默认值。这使得使用Kotlin与创建通过无参数构造函数的类实例的库（例如Jackson或JPA）更容易。
class Customer(val customerName: String = "")

class Customer(var username: String) {
}

fun main() {
    val customer = Customer("Joe Smith")
}

使用abstract关键字定义一个抽象类以及所有或者部分类成员，抽象成员在类中没有被实现

abstract class Polygon {
   abstract fun draw() // 未实现的方法
}

class Rectangle : Polygon() {   // 继承Polygon类,实现deaw方法
   override fun draw() {
       // 方法实现
   }
}

如果是一个非抽象类或者方法，如果想要被重写或者继承，则需要使用open关键字修饰

open class Polygon {
    open fun draw() {
        // some default polygon drawing method
    }
}

abstract class WildShape : Polygon() {
    abstract override fun draw()
}