類
類的聲明
類的定義：類通過class關(guān)鍵字來聲明饶辙，類聲明由類名斑粱、類頭（指定其類型參數(shù)、主 構(gòu)造函數(shù)等）和由大括號包圍的類體構(gòu)成蹋宦。類頭和類體都是可選的； 如果一個類沒有類體冷冗，可以省略花括號。類具有一個唯一的主構(gòu)造函數(shù)拇泛，只需在類名后面寫上參數(shù)，如果需要函數(shù)體思灌，可以寫在init塊中俺叭。
//如果非抽象類沒有聲明任何主泰偿、次構(gòu)造函數(shù)，會自動生成一個無參構(gòu)造函數(shù)
class Student
class Student2 constructor(name:String,age: Int){
}
//如果主構(gòu)造函數(shù)沒有任何注解或可見性修飾符裕照，可以省略constructor關(guān)鍵字调塌。構(gòu)造函數(shù)默認是public的，如需私有负间，自己添加private等可見性修飾符姜凄。
class Student3(name:String,age: Int){
}
class Student4(name: String,age: Int){
init {
//主構(gòu)造函數(shù)體
}
}
//如果類有一個主構(gòu)造函數(shù)，每個次構(gòu)造函數(shù)需要委托給主構(gòu)造函數(shù)檀葛， 可以直接委托或者通過別的次構(gòu)造函數(shù)間接委托。委托到同一個類的另一個構(gòu)造函數(shù) 用 this 關(guān)鍵字即可：
class Person(val name: String) {
constructor(name: String, parent: Person) : this(name) {
parent.children.add(this)
}
}
類的實例化
//類的實例化不需要new關(guān)鍵字空扎，kotlin中也沒有這個關(guān)鍵字
val student1 = Student()
var student2 = Student("jack",18)
類繼承
Kotlin中所有類都有一個共同的超類Any润讥，要聲明一個顯式的超類型，我們把類型放到類頭的冒號之后：
//kotlin中的非抽象類默認是不可繼承的撮慨，如需繼承，需要自己聲明open
open class People
class Student: People()
方法也是默認為final影涉，如需繼承规伐，必須加open，同時子類的方法必須加override猖闪，且子類中的方法可以再次被覆蓋，除非聲明為final：
open class Student():People(){
final override fun name(){ }
}
屬性覆蓋與方法覆蓋類似豁陆，每個聲明的屬性可以由初始化屬性或者getter方法的屬性覆蓋：
open class People {
open val x: Int get { …… }
}
//你也可以用一個 var 屬性覆蓋一個 val 屬性吵护，但反之則不行。因為一個val 屬性本質(zhì)上聲明了一個 getter 方法进胯，而將其覆蓋為 var 只是在子類中額外聲明一個setter 方法。
class Student : People() {
override val x: Int = ……
}
對于多繼承來說胁镐，有時候會碰到超類中有同名函數(shù)盯漂，可以利用super來指明我們繼承的是哪個超類：
open class A {
open fun f() { print("A") }
fun a() { print("a") }
}
interface B {
fun f() { print("B") } // 接口成員默認就是“open”的
fun b() { print("b") }
}
class C() : A(), B {
// 編譯器要求覆蓋 f()：
override fun f() {
super<A>.f() // 調(diào)用 A.f()
super<B>.f() // 調(diào)用 B.f()
}
}
可以用抽象成員覆蓋一個非抽象的開放成員帖渠。
屬性
聲明屬性的完整語法：
var <propertyName> : [<propertyType>] [ = <property_init>]
[<getter>]
[<setter>]
其中初始值和getter空郊、setter都是可選的狞甚，如果可以從初始值或者getter返回值中推斷出類型哼审，則屬性類型也是可以省略的。上面定義的是一個可變屬性十气，也可以用val來定義一個只讀屬性桦踊，只讀屬性不允許有setter方法籍胯。
如果需要在getter和setter中訪問這個屬性自身的值杖狼，它需要創(chuàng)建一個 backing field 妖爷。可以使用 field 這個預留字段來訪問绿聘，它會在屬性初始化時自動創(chuàng)建次舌。需要注意的是，如果我們直接調(diào)用了屬性彼念，那我們會使用setter和getter而不是直接訪問這個屬性。 backing field 只能在屬性訪問器內(nèi)訪問哲思。
var name: String = "jack"
var age: Int = 18
set(value) {
//age = value//注意這種方式會觸發(fā)死循環(huán)，無限調(diào)用set拼苍，最終崩潰
field = value
}
val sex = "男"
val address
get() = "長沙"
var score: Int = 88
get() = 22 //無論什么時候調(diào)用score靠益，得到的都會是18
set(value) {
field = value
}
...
val student = Student()
println(student.age)//18
println(student.score)//22
student.age = 20
student.score = 99
println(student.age)//20
println(student.score)//22
編譯期常量
已知值的屬性可以使用 const 修飾符標記為編譯期常量崎岂，類似于java中的static final（java中的static final修飾的屬性在調(diào)用時不需要將類初始化，僅僅static修飾的值調(diào)用是需要進行類的初始化的）绩卤。 這些屬性需要滿足以下要求：
- 位于頂層（即包級屬性，不能寫在類中）或者是 object 的一個成員
- 用 String 或原生類型值初始化
- 沒有自定義 getter
const val pai = 3.1415926
object Per{
const val sex = "男"
}
fun main(args: Array<String>) {
println(pai)//3.415926
println(sex)//男
}
惰性初始化屬性
一般地何暇，屬性聲明為非空類型必須在構(gòu)造函數(shù)中初始化凛驮。但這有時候很不方便，比如我想聲明一個數(shù)據(jù)集合為非空宏胯，但在初始化時我們又得不到這個數(shù)據(jù)本姥，可以使用lateinit來修飾變量，延遲初始化婚惫。注意lateinit不能修飾val，只能修飾非空可變變量艰管，并且該變量不能為原始類型蒋川，不能不能有自定義getter或setter。
class Teacher {
var name = "YoYo"
var age: Int
init {
age = 25
}
lateinit var students: List<Student>
}
對象
對象表達式
kotlin中的對象表達式類似于java的匿名內(nèi)部類街图。object表達式可以直接訪問包含這個表達式的作用域的變量懒构，而不用像java一樣需要加final修飾耘擂。
interface Pl2303 {
fun connectSuccess()
}
class Pl2303Activity {
val s = object {//沒有超類
val i = 1
}
fun addListener(pl2303: Pl2303) {}
fun connect() {
addListener(object : Pl2303 {//有超類
override fun connectSuccess() {
}
})
}
}
請注意，匿名對象可以用作只在本地和私有作用域中聲明的類型秩霍。如果你使用匿名對象作為公有函數(shù)的返回類型或者用作公有屬性的類型蚁阳，那么該函數(shù)或?qū)傩缘膶嶋H類型會是匿名對象聲明的超類型，如果你沒有聲明任何超類型螺捐，就會是 Any 。在匿名對象中添加的成員將無法訪問赔癌，就像java中的匿名內(nèi)部類，也只能在父類里面訪問峡谊。
class C {
// 私有函數(shù)刊苍，所以其返回類型是匿名對象類型
private fun foo() = object {
val x: String = "x"
}
// 公有函數(shù)，所以其返回類型是 Any
fun publicFoo() = object {
val x: String = "x"
}
fun bar() {
val x1 = foo().x // 沒問題
val x2 = publicFoo().x // 錯誤：未能解析的引用“x”
}
}
對象聲明
object A{//對象也可以有超類贤壁，跟在冒號后面即可埠忘，多個超類用逗號隔開
fun a_1(){
}
}
class B{
fun b_1(){
A.a_1()
}
}
A是一個對象聲明，跟在object關(guān)鍵字的后面名船，對象聲明不是表達式渠驼，不能跟在等號的右邊迷扇◎严可以直接通過對象名來調(diào)用。
對象聲明不能在局部作用域（即直接嵌套在函數(shù)內(nèi)部）渺贤，但是它們可以嵌套到其他對象聲明或非內(nèi)部類中志鞍。
伴生對象
與Java不同固棚，Kotlin中并沒有靜態(tài)方法的概念唆缴。如需使用面徽，可以用companion object（其實可以簡單看成一個對象聲明趟紊，默認名為Companion）霎匈。
class Chess {
companion object {//省略了對象名Companion
val WHITE_MAX: Double = 100.0
val BLACK_MAX: Double = 100.0
val WHITE_MIN: Double = -100.0
val BLACK_MIN: Double = -100.0
val RAW_NUM = 19
val TYPE_QUICK_CHECK: String = "~DEB1#"
val GET_ALL_DATA_IN_QUICK_MODE: String = "~REQ#"
}
....
//調(diào)用方式：
Student.id//kotlin中調(diào)用
Student.Companion.getId()//java中調(diào)用,Companion為默認的伴生對象名铛嘱，也可以通過companion object 后跟一個對象名來改變墨吓。
}
三者區(qū)別：
- 對象表達式是在使用他們的地方立即執(zhí)行（及初始化）的
- 對象聲明是在第一次被訪問到時延遲初始化的
- 伴生對象的初始化是在相應的類被加載（解析）時帖烘，與 Java 靜態(tài)初始化器的語義相匹配
第三條很好理解照卦，主要看下前兩條：
class B {
init {
println("BBBBBB")
}
val s = object {
init {
println("ssssss")
}
fun p(){
print("pppppp")
}
}
object A {
init {
println("AAAAAAA")
}
fun a_1() {
println("aaaaaaa")
}
}
fun b_1() {
A.a_1()
}
}
fun main(args: Array<String>) {
val b = B()
println("------------------")
b.b_1()
}
//結(jié)果
//BBBBBB
//ssssss
//------------------
//AAAAAAA
//aaaaaaa
說明在類初始化的時候，對象表達式身為屬性已經(jīng)被執(zhí)行蹄葱，而對象聲明在被訪問的時候才被執(zhí)行惯悠。
