函數(shù)聲明

聲明函數(shù)要用用 fun 關(guān)鍵字，就像聲明類要用 class 關(guān)鍵字一樣
「函數(shù)參數(shù)」的「參數(shù)類型」是在「參數(shù)名」的右邊
函數(shù)的「返回值」在「函數(shù)參數(shù)」右邊使用 : 分隔，沒有返回值時(shí)可以省略

• 聲明沒有返回值的函數(shù)：

 fun main(){println("123")}

• 聲明有返回值的參數(shù)：

 fun sum(x:Int,y:Int):Int{println("123")}

變量聲明

• 聲明變量需要通過關(guān)鍵字， var 聲明可讀可寫變量， val 聲明只讀變量

• 「類型」在「變量量名」的右邊，用 : 分割，同時(shí)如果滿足「類型推斷」，類型可以省略

• 創(chuàng)建對象直接調(diào)用構(gòu)造器，不需要 new 關(guān)鍵字

• 聲明可讀可寫變量：

var x: Int= 1

• 聲明只讀變量：

val username:String = "username"

• 聲明對象

val user:User = User()

類型推斷

在變量聲明的基礎(chǔ)上，如果表達(dá)式右邊的類型是可以推斷出來，那么類型可以省略:

var age = 18
val name = "Hello"
val user = User()

繼承類/實(shí)現(xiàn)接口

繼承類和實(shí)現(xiàn)接口都是用的 : ，如果類中沒有構(gòu)造器 ( constructor )，需要在父類類名后面加上 () ：

class MainActivity : AppCompatActivity(),View.OnClickListener{}

Java中是這樣的

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
}

空安全設(shè)計(jì)

Kotlin 中的類型分為「可空類型」和「不可空類型」：

• 不可空類型

val username: EditText

• 可空類型

val username: EditText?

調(diào)用符

• !! 強(qiáng)行調(diào)用符
• ?. 安全調(diào)用符

lateinit 關(guān)鍵字

lateinit 關(guān)鍵字表示變量可以在其初始化表達(dá)式被執(zhí)行之后進(jìn)行初始化

• lateinit 只能修飾 var 可讀可寫變量，因?yàn)?val 定義了變量是不可變的，必須在聲明時(shí)進(jìn)行初始化
• lateinit 關(guān)鍵字聲明的變量的類型必須是「不可空類型」
• lateinit 聲明的變量不能有「初始值」
• lateinit 聲明的變量不能是「基本數(shù)據(jù)類型」
  在構(gòu)造器中初始化的屬性不需要 lateinit 關(guān)鍵字

平臺類型

在類型后面面加上一個(gè)感嘆號的類型是「平臺類型」，Java 中可以通過注解減少這種平臺類型的產(chǎn)生

• @Nullable 表示可空類型
• @NotNull @NonNul l 表示不可空類型

類型判斷

• is 判斷屬于某類型
  

• !is 判斷不屬于某類型
  

• as 類型強(qiáng)轉(zhuǎn)，失敗時(shí)拋出類型強(qiáng)轉(zhuǎn)失敗異常
  

• as? 類型強(qiáng)轉(zhuǎn)，但失敗時(shí)不會拋出異常而是返回 null

獲取 Class 對象

• 使用 類名::class 獲取的是 Kotlin 的類型是 KClass

MainActivity::class

• 使用 類名::class.java 獲取的是 Java 的類型

startActivity(Intent(this,test::class.java))

setter/getter

在 Kotlin 聲明屬性的時(shí)候(沒有使用 private 修飾)，會自動生成一個(gè)私有屬性和一對公開的 setter/getter 函數(shù)。
在寫 setter/getter 的時(shí)候使用 field 來代替內(nèi)部的私有屬性(防止遞歸棧溢
出)

class User {
var username : String?= null
var password : String?= nullset(value) {field = value}get() {return field}//構(gòu)造器constructor(){}constructor(username : String?,password : String?){this.username = usernamethis.password = password}
}

為什么 EditText.getText() 的時(shí)候可以簡化，但是 EditText.setText() 的時(shí)候不能和
TextView.setText() 一樣簡化?
因?yàn)?EditText.getText() 獲得的類型是 Editable ，對應(yīng)的如果EditText.setText() 傳入的參數(shù)也是 Editable 就可以簡化了。

val newEditable= Editable.Factory.getInstance().newEditable("Kotlin") et_username.text = newEditable 

構(gòu)造器

使用 constructor 關(guān)鍵字聲明構(gòu)造器

    //構(gòu)造器constructor(){}constructor(username : String?,password : String?){this.username = usernamethis.password = password}

如果我們在構(gòu)造器主動調(diào)用了了父類構(gòu)造，那么在繼承類的時(shí)候就不能在類的后面加上小括號

constructor(context: Context) : this(context, null)
// 主動調(diào)用用了父類的構(gòu)造器
constructor(context: Context, attr: AttributeSet?) :
super(context, attr)

@JvmField 生成屬性

通過 @JvmField 注解可以讓編譯器只生成一個(gè) public 的成員屬性，不生成對應(yīng)的 setter/getter 函數(shù)

   @JvmField
var username : String?= null

 User user = new User();String username = user.username;

Any 和 Unit

• Any
  Kotlin 的頂層父類是 Any ，對應(yīng) Java 當(dāng)中的 Object ，但是比Object 少了 wait()/notify() 等函數(shù)

class User : Any {}

• Unit
  Kotlin 中的 Unit 對應(yīng) Java 中的 void

 fun get():Unit{}

數(shù)組

使用 arrayof() 來創(chuàng)建數(shù)組，基本數(shù)據(jù)類型使用對應(yīng)的 intArrayOf() 等

val list:Array<String> = arrayOf("1", "2", "3", "4")

val Intlist:IntArray = intArrayOf(1, 2, 3, 4)

靜態(tài)函數(shù)和屬性

• 頂層函數(shù)
  頂層函數(shù)，它并不依賴于任何特定對象或類。頂層函數(shù)可以在任何地方直接使用，不需要創(chuàng)建類的實(shí)例

類名.調(diào)用方法

class MyClass {fun greet(name: String): String {return "Hello, $name"}
}

然后你可以這樣創(chuàng)建一個(gè)類的實(shí)例并調(diào)用它的方法：

val myClass = MyClass()  // Create an instance of MyClass
val greeting = myClass.greet("John")  // Call the greet() method on the instance
println(greeting)  // Prints: Hello, John

• object
  
  
  
• companion object
  
  
  其中，「頂層函數(shù)」直接在文件中定義函數(shù)和屬性，會直接生成靜態(tài)的，在 Java 中通過「文件名Kt」來 訪問，同時(shí)可以通過 @file:JvmName 注解來修改這個(gè)「類名」。需要注意，這種頂層函數(shù)不要聲明在 module 內(nèi)最頂層的包中，至少要在一個(gè)包中例如 com 。不然不能方便使用。object 和 companion object 都是生成單例例對象，然后通過單例對象訪問函數(shù)和屬性的。

@JvmStatic

通過這個(gè)注解將 object 和 companion object 的內(nèi)部函數(shù)和屬性，真正生成為靜態(tài)的。
通常使用 @JvmStatic 注解來標(biāo)記那些需要在 JVM 中直接訪問的靜態(tài)方法或變量。當(dāng) Kotlin 代碼被編譯為 JVM 字節(jié)碼時(shí)，注解處理器會將這些靜態(tài)方法和變量插入到生成的 Java 類中

使用 @JvmStatic 注解標(biāo)記了 greet() 方法。當(dāng)這個(gè) Kotlin 類被編譯為 Java 類時(shí)，greet() 方法會被插入到生成的 Java 類中，并且可以直接通過類名來訪問，而不需要創(chuàng)建 Kotlin 類的實(shí)例。

在 Java 中，你可以像這樣調(diào)用 currentApplication() 方法：

單例模式/匿名內(nèi)部類

通過 object 關(guān)鍵字實(shí)現(xiàn)

// 單例
object Singleton {
}

// 匿名內(nèi)部類
object : Callback {
}

字符串

字符串模版

通過 ${} 的形式來作為字符串模版

val number = 100000000
val text = "支付寶收款${number}元。"
// 如果只是單一的變量，可以省略掉 {}
val text2 = "支付寶收款$number元。

多行字符串

val s = """
我是第一行
我是第二行
我是第三行
""".trimIndent()

區(qū)間

200…299 表示 200 -> 299 的區(qū)間(包括 299 )

300…399 表示 300 -> 399 的區(qū)間(包括 399 )

when 關(guān)鍵字

Java 當(dāng)中的 switch 的高級版，分支條件上可以支持表達(dá)式

受檢異常

Kotlin 不需要使用 try-catch 強(qiáng)制捕獲異常

聲明接口/抽象類/枚舉/注解

// 聲明抽象類
abstract class// 聲明接口
interface// 聲明注解
annotation class// 聲明枚舉
enmu class

編譯期常量

在靜態(tài)變量上加上 const 關(guān)鍵字變成編譯期常量
const 關(guān)鍵字可以用來聲明一個(gè)編譯期常量。這個(gè)常量必須在聲明時(shí)就賦值，而且必須是字面值，不能是函數(shù)調(diào)用或者表達(dá)式。此外，const 常量必須是只讀的，不能在運(yùn)行時(shí)修改

標(biāo)簽

• 在 Java 中通過 「 類名.this 例如 Outer.this 」 獲取目標(biāo)類引用
  

• 在 Kotlin 中通過「 this@類名 例如 this@Outer 」獲取目標(biāo)類引用
  

遍歷

記得讓 IDE 來幫助生成 for 循環(huán)

for(item in items)

內(nèi)部類

在 Kotlin 當(dāng)中，內(nèi)部類默認(rèn)是靜態(tài)內(nèi)部類
通過 inner 關(guān)鍵字聲明為嵌套內(nèi)部類

可見性修飾符

默認(rèn)的可?性修飾符是 public
新增的可?性修飾符 internal 表示當(dāng)前模塊可?

注釋

注釋中可以在任意地方使用 [] 來引用目標(biāo)，代替 Java 中的 @param @link等。

非空斷言

可空類型強(qiáng)制類型轉(zhuǎn)換成不可空類型可以通過在變量后面加上 !! ，來達(dá)到類型轉(zhuǎn)換。

open/final

Kotlin 中的類和函數(shù)，默認(rèn)是被 final 修飾的 ( abstract 和 override 例外)

課后題

1. kotlin編譯器會默認(rèn)創(chuàng)建構(gòu)造函數(shù)嗎

在Kotlin中，構(gòu)造函數(shù)與類的其他部分一樣，需要進(jìn)行顯式聲明。如果你沒有聲明構(gòu)造函數(shù)，Kotlin編譯器會為你生成一個(gè)默認(rèn)的無參構(gòu)造函數(shù)。這個(gè)默認(rèn)構(gòu)造函數(shù)不會調(diào)用任何代碼，即它是一個(gè)空函數(shù)

2. var username : String?= “123”

聲明一個(gè)名為 username 的可變變量，它的類型是 String?（可空字符串），并初始化為 “123”。如果你需要改變
username 的值，你可以直接給它賦值一個(gè)新的字符串或者 null

3. public var age : Int = 0

在 Kotlin 中，public var age : Int = 0 和 @JvmField var age : Int = 0
都可以用來在 Kotlin 中聲明一個(gè)公共的、可變的、初始化為 0 的整型變量。然而，這兩者并不完全等價(jià)。 public var age : Int = 0 是直接在 Kotlin 中聲明變量，其默認(rèn)的可見性就是 public，也就是可以被任何其他代碼訪問。 而
@JvmField var age : Int = 0 是使用注解 @JvmField，這會生成一個(gè)在 Java
中可見的字段。@JvmField 的目的是讓 Kotlin 中的變量在 Java 代碼中以字段的形式表現(xiàn)出來，而不是通過
getter 和 setter 方法訪問。 這兩者的主要區(qū)別在于，如果你需要在 Java 中直接訪問 Kotlin 變量（而不是通過
getter 和 setter），那么你需要使用 @JvmField。如果你只是在 Kotlin 內(nèi)部或者在其他支持 Kotlin
的地方使用這個(gè)變量，那么你可以直接使用 public var age : Int = 0。
總的來說，這兩者并不是互為替代的關(guān)系，而是根據(jù)具體的使用場景來選擇使用哪一種。

• 舉例：
  假設(shè)你有以下 Kotlin 類定義：

class Person {var name: String = "John"@JvmField var age: Int = 0
}

如果你使用 @JvmField，你可以在 Java 中直接訪問和修改 age 變量，如下所示：

Person person = new Person();
person.age = 25; // 可以直接修改 age 變量
int age = person.age; // 通過字段獲取 age 值

但是，如果你移除 @JvmField 并使用 public var age: Int = 0，你仍然可以在 Kotlin 中直接訪問和修改 age 變量，但是在 Java 中需要通過 getter 和 setter 方法訪問它：

Person person = new Person();
person.setAge(25); // 通過 setter 方法修改 age 值
int age = person.getAge(); // 通過 getter 方法獲取 age 值

因此，使用 @JvmField 的主要目的是為了在 Java 中直接訪問 Kotlin 屬性，而無需使用 getter 和 setter 方法。如果你只在 Kotlin 中使用該屬性，那么使用 public var age: Int = 0 就足夠了。然而，如果你需要與 Java 代碼進(jìn)行互操作，并希望在 Java 中直接訪問 Kotlin 屬性，那么使用 @JvmField 是更合適的選擇。

4. Kotlin中的this.
   在Kotlin中，this關(guān)鍵字有特殊的意義。它被用來引用當(dāng)前對象實(shí)例。
   在Kotlin中，this關(guān)鍵字有幾種用法：

• 直接引用當(dāng)前對象的實(shí)例：在類的方法中，你可以使用this關(guān)鍵字來引用當(dāng)前正在執(zhí)行的對象實(shí)例。例如：

class MyClass {var name: String? = nullfun printName() {println(this.name)}
}

在這個(gè)例子中，this關(guān)鍵字引用的是正在執(zhí)行的對象實(shí)例，該實(shí)例的name屬性被打印出來。

• 引用當(dāng)前對象的屬性或方法：當(dāng)你需要通過對象來訪問其屬性或方法時(shí)，可以使用this關(guān)鍵字。例如：

class MyClass {var name: String? = nullfun printName() {println(this.name)}
}

在這個(gè)例子中，this關(guān)鍵字引用的是正在執(zhí)行的對象實(shí)例，該實(shí)例的name屬性被打印出來。

• 在匿名函數(shù)或Lambda表達(dá)式中引用外部變量：在匿名函數(shù)或Lambda表達(dá)式中，你可以使用this關(guān)鍵字來引用外部的變量。例如：

fun outerFunction() {val x = 10val action = object : Action<Int> {override fun run(input: Int) {println("Value of x from outer function: $x") // Here, 'this' refers to the outer function's 'x' variable.}}action.run(5)
}

在這個(gè)例子中，this關(guān)鍵字引用的是外部函數(shù)的變量x。

5. 【作文題】 使用 Kotlin 獲得外部類引用的代碼

val outer = /* 外部類引用 */

如果你想在 Kotlin 中獲取對外部類的引用，你需要首先將該外部類定義為可訪問的，然后你可以在內(nèi)部類中直接引用它。
例如，假設(shè)你有一個(gè)名為 OuterClass 的外部類，并且你想在內(nèi)部類 InnerClass 中獲取該類的引用。你可以這樣做：

class OuterClass {var name: String? = null
}class InnerClass {val outer: OuterClass? = nullfun printOuterName() {outer?.let {println("Name of the outer class: ${it.name}")}}
}

在這個(gè)例子中，OuterClass 是一個(gè)外部類，InnerClass 是一個(gè)內(nèi)部類。在 InnerClass 中，我們聲明了一個(gè)
outer 變量，它是 OuterClass 的一個(gè)引用。然后，在 printOuterName 方法中，我們通過 outer
變量訪問了外部類的 name 屬性。

6. 【作文題】 下面的 Person 是不是 interface，為什么？

class User : Person()

在您提供的代碼中，Person 并不是一個(gè)接口，而是一個(gè)類。您使用的是 Kotlin 語言，它支持通過冒號（:）來實(shí)現(xiàn)接口或類的繼承。
在這段代碼中，User 類通過使用 : 來繼承 Person 類。這表示 User 是 Person 的子類，它繼承了 Person 的屬性和方法。
如果 Person 是一個(gè)接口，那么應(yīng)該使用 interface Person 來聲明。所以在這個(gè)代碼片段中，Person 不是接口，它是一個(gè)類。