三. Android：Kotlin詳細入門學習指南-基礎語法(一)
Kotlin的基礎語法:
1. kotlin有但是Java沒有的特點?
null safety.
Operator overloading.
Coroutines.
Range expressions.
Smart casts.
Companion objects.
java有的但kotlin沒有的？
在kotlin中沒有三元條件操作符；
kotlin不支持原始數據類型；
1.2，kotlin支持哪種編程類型?
一種是procedural編程, 另一種是面向對象的編程。
1.3, 在kotlin中如何處理null異常?
使用elvis操作符來處理null異常。
1.4, 解釋一下kotlin中數據類的作用。
數據類包含基本的數據類型, 它不包含任何功能函數。
1.5 為什么kotlin跟Java具有互相的操作性?
因為這兩門語言，對於jvm來說沒有區別。它們都是編譯成byte code, 然后在jvm上運行的。
kotlin對標准的Java庫和類提供額外的功能嗎?
kotlin程序是跑在標准的Java虛擬機上的。所以kotlin跟Java在這一層級幾乎沒有區別。Java代碼還可以直接在kotlin程序中使用。
2，在kotlin中如何比較兩個字符串?
第1種方法你可以用雙等號來比較兩個字符串。
第2種方法用String.compareTo，這個擴展函數來比較兩個字符串。
2.1 在Kotlin泛型中，*和Any的區別
List<*> 更夠包含任何類型，但只有該擦除后的類型
List<Any>可以包含任何類型。
2.2 如何在Kotlin中帶值初始化數組？
val numbers: IntArray = intArrayOf(10, 20, 30, 40, 50);
如下數組是什么類型？
val arr = arrayOf(1, 2, 3); --> Array<Int>
2.3 List和Array類型區別
最主要不同是Array固定大小， (Mutable)List可以動態調整大小。 此外Array是可變的，List不可變。
IntArray 和Array<Int> 可以相互交換么？
不能， Array<Int> = Integer[]， IntArray = int[] ， 中間要經過裝箱拆箱。
2.4.什么時候用kotlin內聯函數，什么時候不要用？
傳入函數類型參數且函數相對來說比較短時，推薦使用內聯函數。 當函數比較長且沒有使用內聯函數。
2.5 解釋一下extension函數？
extension函數用來對class的擴展，而不需要從class進行派生。
說一下kotlin中對Java.io.file的的擴展方法。
bufferedReader.
readBytes.
readText
forEachLine
readLines
2.6 什么是lateinit 和什么時候使用它？
如不想在構造函數初始化一個變量且你能保證在使用它之前初始化，可以聲明為lateinit 變量。 Lateinit不支持原始類型 例如 Int,Long
一些及其實用的案例：
1. Andorid在聲明周期實例化的變量
2. 用Dagger 去依賴注入
3. 單元測試的裝配， 在@Before函數中初始化的變量
4. Spring Boot注解（@Autowired）
3，說一下kotlin類的缺省行為。
kotlin類缺省是final的。因為kotlin支持多重類繼承。開放類的代價要比final類高很多。
3.1，在kotlin中有多少構造函數？
有兩種，一種是primary構造函數，一種是secondary構造函數。
3.1 Lazy和layinit的區別?
兩者都延遲屬性的初始。 lateinit 是用於var的修飾符， 可以用於晚點來進行賦值。 Lazy更像一個方法或者一個lambda表達式,只用於val。 在需要時被創建。
什么時候使用lateinit而不是lazy initialization？
1. 屬性是可變的 ， 如果不是只初始化一次
如何創建單例?
可用object關鍵字。 Object不能有構造函數，但可以使用init 塊
3.2 Kotlin中伴隨體的目的？
不支持static成員，所以用伴隨體來放靜態成員函數和變量及常量。
為什么kotlin中沒有static keyword?
Kotlin的理念是一切皆對象， static由伴隨體取代。 伴隨體且支持繼承，實現接口。
3.3.如何創建空構造函數
第一種方式 構造函數的默認參數
另一種方式 次要構造函數
Kotlin讓類的默認可見修飾符為final的動機是什么？ 你是否同意？
1. kotlin支持多繼承，默認定義為final可以節省開銷
2. 類設計原則中，更推薦用合成組合來取代繼承。Kotlin用final來默認修飾類。強制使用的人在使用繼承時進行進一步的考慮，是否能用其他方式實現。
3.4 kotlin中的抽象有什么作用?
抽象是面向對象編程中最重要的概念。抽象類特點是，你知道這個類會有什么功能，但是你不知道它具體如何實現這些功能和實現哪些功能。
二.Kotlin的基本用法
Kotlin是什么
Kotlin是Android開發的一級編程語言（Google官方認證）;
由JetBrains公司在2010年推出 & 開源，與Java語言互通 & 具備多種Java尚不支持的新特性;
Android Studio3.0后的版本支持Kotlin;
優點
碼更少、可讀性更強 - 花更少的時間來編寫代碼與理解他人的代碼
成熟的語言與環境 - 自 2011 年創建以來，Kotlin 不僅通過語言而且通過強大的工具在整個生態系統中不斷發展。 現在，它已無縫集成到 Android Studio 中， 並被許多公司積極用於開發 Android 應用程序。
Android Jetpack 與其他庫中的Kotlin 支持- KTX 擴展 為現有的 Android 庫添加了 Kotlin 語言特性，如協程、擴展函數、lambdas 與命名參數。
與 Java 的互操作性 - 可以在應用程序中將 Kotlin 與 Java 編程語言一起使用， 而無需將所有代碼遷移到 Kotlin。
支持多平台開發 - 不僅可以使用 Kotlin 開發 Android，還可以開發 iOS、后端與 Web 應用程序。 享受在平台之間共享公共代碼的好處。
代碼安全 - 更少的代碼與更好的可讀性導致更少的錯誤。Kotlin 編譯器檢測這些剩余的錯誤，從而使代碼安全。
易學易用 - Kotlin 非常易於學習，尤其是對於 Java 開發人員而言。
大社區 - Kotlin 得到了社區的大力支持與許多貢獻，該社區在全世界范圍內都在增長。 根據 Google 的說法，Play 商店前1000個應用中有60％以上使用 Kotlin。
使用
1、點擊Android Studio settings -> Plugins -> 搜索Kotlin Languages插件
2、在根目錄的build.gradle中加入
buildscript {
ext.kotlin_version = '1.3.61'
repositories {
mavenCentral()
}
dependencies {
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
}
}
3、在app/build.gradle中引入
apply plugin: 'com.android.application'
apply plugin: 'kotlin-android'
buildscript {
ext.kotlin_version = '1.3.61'
dependencies {
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
}
}
1.基本語法:
定義包名 - 在源文件的開頭定義包名：包名不必和文件夾路徑一致：源文件可以放在任意位置。
定義函數：
有返回值： 定義一個函數接受兩個 int 型參數，返回值為 int
fun sum(a: Int , b: Int) : Int{
return a + b
}
fun main(args: Array<String>) {
print("sum of 3 and 5 is ")
println(sum(3, 5))
}
該函數只有一個表達式函數體以及一個自推導型的返回值：
fun sum(a: Int, b: Int) = a + b
fun main(args: Array<String>) {
println("sum of 19 and 23 is ${sum(19, 23)}")
}
無返回值：返回一個沒有意義的值Unit(可省略)：
fun printSum(a: Int, b: Int): Unit {
println("sum of $a and $b is ${a + b}")
}
fun main(args: Array<String>) {
printSum(-1, 8)
}
2.定義局部變量:
聲明常量：
fun main(args: Array<String>) {
val a: Int = 1 // 立即初始化
val b = 2 // 推導出Int型
val c: Int // 當沒有初始化值時必須聲明類型
c = 3 // 賦值
println("a = $a, b = $b, c = $c")
}
變量：
fun main(args: Array<String>) {
var x = 5 // 推導出Int類型
x += 1 println("x = $x")
}
注釋：
與 java 和 javaScript 一樣，Kotlin 支持單行注釋和塊注釋。
// 單行注釋
/* 哈哈哈哈 這是塊注釋 */
與 java 不同的是 Kotlin 的 塊注釋可以級聯。
使用字符串模板
fun main(args: Array<String>) {
var a = 1 // 使用變量名作為模板:
val s1 = "a is $a" a = 2 // 使用表達式作為模板:
val s2 = "${s1.replace("is", "was")}, but now is $a" println(s2)
}
使用條件表達式:
fun maxOf(a: Int, b: Int): Int {
if (a > b) {
return a
} else {
return b
}
}
fun main(args: Array<String>) {
println("max of 0 and 42 is ${maxOf(0, 42)}")
}
把if當表達式：
fun maxOf(a: Int, b: Int) = if (a > b) a else b
fun main(args: Array<String>) {
println("max of 0 and 42 is ${maxOf(0, 42)}")
}
使用可空變量以及空值檢查:
當空值可能出現時應該明確指出該引用可空。
下面的函數是當 str 中不包含整數時返回空:
fun parseInt(str : String): Int?{ //... }
使用值檢查並自動轉換
使用 is 操作符檢查一個表達式是否是某個類型的實例。如果對不可變的局部變量或 屬性進行過了類型檢查，就沒有必要明確轉換：
fun getStringLength(obj: Any): Int? {
if (obj is String) {
// obj 將會在這個分支中自動轉換為 String 類型 return obj.length }
// obj 在種類檢查外仍然是 Any 類型 return null
}
使用循環:
fun main(args: Array<String>) {
val items = listOf("apple", "banana", "kiwi")
for (item in items) {
println(item)
}
// 或
for(index in 0..mutableList.size-1){
println(mutableList[index])
}
}
或者這樣：
fun main(args: Array<String>) {
val items = listOf("apple", "banana", "kiwi")
for (index in items.indices) {
println("item at $index is ${items[index]}")
}
}
使用 while 循環
fun main(args: Array<String>) {
val items = listOf("apple", "banana", "kiwi")
var index = 0 while (index < items.size) {
println("item at $index is ${items[index]}")
index++
}
}
使用 when 表達式
fun describe(obj: Any): String =
when (obj) {
1 -> "One"
"Hello" ->"Greeting"
is Long -> "Long"
!is String -> "Not a string"
else -> "Unknown"
}
fun main(args: Array<String>) {
println(describe(1)) println(describe("Hello"))
println(describe(1000L))
println(describe(2))
println(describe("other"))
}
使用ranges
使用 in 操作符檢查數值是否在某個范圍內：
fun main(args: Array<String>) {
val x = 10
val y = 9
if (x in 1..y+1) {
println("fits in range")
}
}
檢查數值是否在范圍外：
if (-1 !in 0..list.lastIndex) {
println("-1 is out of range")
}
使用步進
for (x in 1..10 step 2)
for (x in 9 downTo 0 step 3)
使用集合:
對一個集合進行迭代
fun main(args: Array<String>) {
val items = listOf("apple", "banana", "kiwi")
for (item in items) {
println(item)
}
}
使用 in 操作符檢查集合中是否包含某個對象
fun main(args: Array<String>) {
val items = setOf("apple", "banana", "kiwi")
when {
"orange" in items -> println("juicy")
"apple" in items -> println("apple is fine too")
}
}
使用lambda表達式過濾和映射集合
fun main(args: Array<String>) {
val fruits = listOf("banana", "avocado", "apple", "kiwi")
fruits
.filter { it.startsWith("a") }
.sortedBy { it }
.map { it.toUpperCase() }
.forEach { println(it)
}
習慣用語
創建DTOs(POJOs/POCOs) 數據類
相當於java的Bean，
data class Customer(val name: String, val email: String)
給 Customer 類提供如下方法
-為所有屬性添加 getters ，如果為 var 類型同時添加 setters -- equals() - - haseCode() -- toString() -- copy()
函數默認值
fun foo(a: Int = 0, b: String = "") {...}
過濾 list
val positives = list.filter { x -> x >0 }
或者更短：
val positives = list.filter { it > 0 }
字符串插值
println("Name $name")
實例檢查
when (x) {
is Foo -> ...
is Bar -> ...
else -> ...
}
遍歷 map/list
for ((k, v) in map) {
print("$k -> $v")
}
k,v 可以隨便命名
使用 ranges
for (i in 1..100) { ... } // 閉區間: 包括100
for (i in 1 until 100) { ... } // 半開區間: 不包括100
for (x in 2..10 step 2) { ... }
for (x in 10 downTo 1) { ... }
if (x in 1..10) { ... }
for (i in 1..100) { ... }
for (i in 2..10) { ... }
只讀 list:
val list = listOf("a", "b", "c")
只讀map:
val map = mapOf("a" to 1, "b" to 2, "c" to 3)
訪問 map
println(map["key"])
map["key"] = value
懶屬性(延遲加載):
val p: String by lazy { // 生成string的值 }
擴展函數：
fun String.spcaceToCamelCase() { ... }
"Convert this to camelcase".spcaceToCamelCase()
創建單例模式：
object Resource {
val name = "Name"
}
如果不為空則... 的簡寫：
val files = File("Test").listFiles()
println(files?.size)
如果不為空...否則... 的簡寫：
val files = File("test").listFiles()
println(files?.size ?: "empty")
如果聲明為空執行某操作？
val data = ...
val email = data["email"] ?: throw IllegalStateException("Email is missing!")
如果不為空執行某操作？
val date = ...
data?.let{ ...//如果不為空執行該語句塊 }
返回 when 判斷
fun transform(color: String): Int {
return when(color) {
"Red" -> 0 "Green" -> 1
"Blue" -> 2
else -> throw IllegalArgumentException("Invalid color pa ram value")
}
}
try-catch 表達式
f```un test() {
val result = try {
count()
}catch (e: ArithmeticException) {
throw IllegaStateException(e)
}//處理 result
}
if 表達式
fun foo(param: Int){
val result = if (param == 1) {
"one"
} else if (param == 2) {
"two"
} else {
"three"
}
}
需要泛型信息的泛型函數的方便形式
// public final class Gson {
// ...
// public <T> T fromJson(JsonElement json, Class<T> classOfT ) throws JsonSyntaxException {
// ... inline
fun <reified T: Any> Gson.fromJson(json): T = this.fromJs on(json, T::class.java)
命名風格
如有疑惑，默認為Java編碼約定，比如：
使用駱
駝命名法(在命名中避免下划線)
類型名稱首字母大寫
方法和屬性首字母小寫
縮進用四個空格
public 方法要寫說明文檔，這樣它就可以出現在 Kotllin Doc 中
冒號：
在冒號區分類型和父類型中要有空格，在實例和類型之間是沒有空格的：
interface Foo<out T : Any> : Bar {
fun foo(a: Int): T
}
Lambdas：
在 Lambdas 表達式中，大括號與表達式間要有空格，箭頭與參數和函數體間要有 空格。盡可能的把 lambda 放在括號外面傳入
list.filter { it > 10 }.map { element -> element * 2 }
在使用簡短而非嵌套的lambda中，建議使用 it 而不是顯式地聲明參數。在使用 參數的嵌套lambda中，參數應該總是顯式聲明
類聲明格式
參數比較少的類可以用一行表示：
class Person(id: Int, name: String)
具有較多的參數的類應該格式化成每個構造函數的參數都位於與縮進的單獨行中。 此外，結束括號應該在新行上。如果我們使用繼承，那么超類構造函數調用或實現 的接口列表應該位於與括號相同的行中
class Person(
id: Int,
name: String,
surname: String
) : Human(id, name) {
// ...
}
對於多個接口，應該首先定位超類構造函數調用，然后每個接口應該位於不同的行 中
class Person(
id: Int,
name: String,
surname: String
) : Human(id, name),
KotlinMaker { // ...
}
構造函數參數可以使用常規縮進或連續縮進(雙倍正常縮進)。
Unit
如果函數返回 Unit ，返回類型應該省略：
fun foo() { // ": Unit"被省略了 }
函數 vs 屬性
在某些情況下，沒有參數的函數可以與只讀屬性互換。盡管語義是相似的，但是有 一些風格上的約定在什么時候更偏向於另一個。
在下面的情況下，更偏向於屬性而不是一個函數:
不需要拋出異常 -- 擁有O(1)復雜度 -- 低消耗的計算(或首次運行結果會被緩 存) -- 返回與調用相同的結果。
一. kotlin面試第一部分
1.Kotlin的入口? main函數
函數如何聲明？ 為什么kotlin函數被稱為頂級函數 ？
fun sumOf(a:int, b:Int):Int{ return a+b};
kotlin中的函數能在kotlin根文件中聲明
2.這段代碼干了什么？
bar {
System.out.println("Guru99!")
}
該代碼傳入了一個lambda表達式函數給函數 bar()，這個函數打印 “”Guru99!”。
3.提供一個內聯類有用的實際例子
主要用於類型封裝， 減少風險，給你簡單的，安全的封裝器而不引入額外的堆內存分配。
inline fun inlined(block: () -> Unit) {
println("before")
block()
println("after")
}
inlined {
println("do something here")
}
// No Function object instance will be created, instead, the code around the
// invocation of block inside the inlined function will be copied
// to the call site
System.out.println("before");
System.out.println("do something here");
System.out.println("after");
4.Kotlin 支持field 用於干什么？
Kotlin中的類沒有字段， 然而，使用自定義訪問器的有些時候需要用到支持字段：如下
var selectedColor: Int = someDefaultValue
get() = field
set(value) {
field = value
}
5.怎么為默認數據類重寫getter
data class Test(val value: Int)
我該怎么重寫它 讓它返回0 如果值是負的
1.不要使用數據類型，用普通類
class Test(value: Int) {
val value: Int = value
get() = if (field < 0) 0 else field
override fun equals(other: Any?): Boolean {
if (this === other) return true
if (other !is Test) return false
return true
}
override fun hashCode(): Int {
return javaClass.hashCode()
}
}
2.創造一個安全的屬性
data class Test(val value: Int) {
val safeValue: Int
get() = if (value < 0) 0 else value
}
6.Kotlin中的解構聲明是什么？ 用個例子來解釋
解構聲明是一種從objects/arrays 靈活的給多個變量賦予值的方式
1.png
Inline函數和Infix函數的區別？ 每個給個例子。
內聯函數通過組織對象給匿名函數/lambda表達式調用分配空間來節省內存。 相反，它提供在運行時調用它的函數提供函數體。 這可能輕微的增加字節碼但是節省一些內存。
插入函數 用於調用沒有括號和方括號的函數。這樣做代碼看起來更像自然語言。
2.png
7. Fold和reduce的基本區別？ 且分別什么時候使用他們？
Fold接收一個初始值 listOf(1,2,3).fold(0){ sum, element -> sum + element }
第一次調用lambda將會是 0+1
Reduce不接收初始值，相反從集合的第一個元素開始
8. 如何在Kotlin中實現 建造者模式？
private constructor(builder: Builder) : this(builder.model, builder.year)
class Builder {
var model: String? = null
private set
var year: Int = 0
private set
fun model(model: String) = apply { this.model = model }
fun year(year: Int) = apply { this.year = year }
fun build() = Car(this)
}
9.Reified 關鍵字如何在kotlin 中工作？
Reified關鍵字主要用在泛型當中
10.Apply函數如何在Kotlin中使用？
創建一個對象且對這個對象進行初始化。
8. SAM 轉換是什么？
SAM 表示單個抽象函數。 SAM-type 指的是像Runnable,Callable的接口。當從kotlin中調用java函數，只要傳入的滿足單一的非默認函數的接口，可以轉換成lambda表達式
7, kotlin中的null safety是什么意思?
null safety的特性是為了去除null pointer exception在實時運行中的出現風險。它也用來區分空引用和非空引用。
6, 什么是range操作符?
Range操作符用來遍歷一個范圍。用兩個點來表示的。
for(i in 1..15)
print(i)
5, 在kotlin中定義一個volatile變量。
Volatile var x:Long?=null
4， 下面這段代碼是干什么用的?
bar{
System.out.println("haha")
}
bar作為一個函數，正在接收一個表達式為參數，這個表達式用來打印一行字符串。
3， 我們能把Java代碼轉成kotlin代碼嗎?
是的，我們可以用jetbrains ide把Java代碼轉成kotlin，也可以用Android studio轉。
2, kotlin允許macros嗎? 不允許。kotlin不支持宏。
1，什么是kotlin？
kotlin是靜態類型的編程語言，運行於jvm之上。
kotlin是由jetbrains開發的。
為什么我們應該從Java轉到kotlin?
首先，kotlin比Java要簡單。它去除了很多Java里面的冗余代碼。kotlin提供了很多Java不具有的特性。
說一下使用kotlin的三大好處。
kotlin比較容易學，因為它跟Java很接近。
kotlin是功能性編程語言，是基於jvm上的。
kotlin的代碼更易讀，更容易理解。