变量

变量是存储单项数据的容器，必须先声明变量，才可以使用。
常见的数据类型：Int、Double、String、Boolean

val关键字用于定义只读变量，一旦赋值就不能更改。
var关键字用于定义可变变量。
在Kotlin 中，建议尽可能使用val，而不是var

声明变量

例如：

val count: Int = 2 // 不可变变量
println("this count is $count") //$count 输出变量var number: Int = 2 // 可变变量number++

函数

声明函数时，需要使用fun 关键字，并在 {}中添加代码用于执行某个任务的指令。

声明函数

如果不指定返回值类型，默认返回值类型是Unit类型。Unit表示函数不会返回值，所以不需要使用 return语句。如果指定了返回值类型，则必须使用return语句。

例如：

fun sum(num1: Int, num2: Int): Int{return num1 + num2}// 按照形参传递
print(sum(2,1))// 调用函数时为实参命名。使用具名实参时，您可以对实参重新排序，而不会影响输出
// 按照具名实参传递print(sum(num2 = 1,num1 = 2))// 指定默认实参，以便在调用函数时省略该实参
// 如果没有传入 num1, 则num1按 10 来计算
fun sum(num1: Int = 10, num2: Int): Int{return num1 + num2}

条件语句

if/else 语句

例如 实现红绿灯

fun main() {val trafficLightColor = "Black"if (trafficLightColor == "Red") {println("Stop")} else if (trafficLightColor == "Yellow") {println("Slow")} else if (trafficLightColor == "Green") {println("Go")} else {println("Invalid traffic-light color")}}

when 语句

在 Kotlin 中，当处理多个分支时，可以使用 when 语句。类似 java 中的 switch 语句。

使用 when语句实现红绿灯

fun main() {val trafficLightColor = "Yellow"when (trafficLightColor) {"Red" -> println("Stop")"Yellow" -> println("Slow")"Green" -> println("Go")else -> println("Invalid traffic-light color")}
}

when语句中多个条件，用英文逗号 (,) 处理。
when语句中使用 in 关键字和一个值范围，如需使用某个范围内的值，请添加一个表示范围起点的数字，后跟两个不含空格的点，然后使用另一个表示范围终点的数字作为结尾。
when语句中使用 is 关键字作为条件，以检查所评估值的数据类型。

fun main() {val x: Any = 20when (x) {2, 3, 5, 7 -> println("x is a prime number between 1 and 10.")in 1..10 -> println("x is a number between 1 and 10, but not a prime number.")is Int -> println("x is an integer number, but not between 1 and 10.")else -> println("x isn't an integer number.")}
}

if/else 表达式 和 when 表达式

fun main() {val trafficLightColor = "Black"val message =if (trafficLightColor == "Red") "Stop"else if (trafficLightColor == "Yellow") "Slow"else if (trafficLightColor == "Green") "Go"else "Invalid traffic-light color"println(message)
}fun main() {val trafficLightColor = "Amber"val message = when(trafficLightColor) {"Red" -> "Stop""Yellow", "Amber" -> "Proceed with caution.""Green" -> "Go"else -> "Invalid traffic-light color"}println(message)
}

Kotlin 中的null

kotlin 不允许为变量赋值为 null,只有当您明确让某个变量可以存储 null值时，该变量才属于可为null 类型。如需在 Kotlin 中声明可为null 的变量，您需要在相应类型的末尾添加? 运算符

如果需要访问可为 null 的变量时
可使用 ?.安全调用运算符访问可为 null 变量的方法或属性
也可使用 !! 非 null 断言运算符来访问可为 null 的变量的方法或属性。⚠️ 使用!! 必须保证变量不为null，否则会在执行期间崩溃
也可结合 if/else 语句使用

fun main() {var favoriteActor: String? = "Sandra Oh"println(favoriteActor.length)//错误 执行出错println(favoriteActor?.length)//对于可为null类型的值println(favoriteActor!!.length)if (favoriteActor != null) {println("The number of characters in your favorite actor's name is ${favoriteActor.length}.")  }}val lengthOfName = if(favoriteActor != null) {favoriteActor.length} else {0}

使用 ?: Elvis 运算符

?:Elvis 运算符可以与?. 安全调用运算符搭配使用。如果搭配使用?: Elvis 运算符，您便可以在?. 安全调用运算符返回null时添加默认值。这与if/else表达式类似，但更为常用。

如果该变量不为null，则执行?: Elvis 运算符之前的表达式；如果变量为 null，则执行?: Elvis 运算符之后的表达式。

个人认为：?: 可以理解为三目运算符

   val favoriteActor: String? = "Sandra Oh"val lengthOfName = favoriteActor?.length ?: 0println("The number of characters in your favorite actor's name is $lengthOfName.")

类和对象

类定义以class 关键字开头，后面依次跟名称和一对大括号。左大括号之前的语法部分也称为类标头。在大括号之间，您可以指定类的属性和函数。

类由以下三大部分组成：
属性：用于指定类对象属性的变量。
方法：包含类的行为和操作的函数。
构造函数：一种特殊的成员函数，用于在定义类的整个程序中创建类的实例

示例：

// 定义类
class SmartDevice {// 定义类的属性val name = "Android TV"val category = "Entertainment"var deviceStatus = "online"// 定义类的方法fun turnOn(){println("Smart device is turned on.")}fun turnOff(){println("Smart device is turned off.")}
}

fun main(){// 创建类的对象val smartTvDevice = SmartDevice()//调用类的属性println("Device name is: ${smartTvDevice.name}")// 调用类的方法smartTvDevice.turnOn()smartTvDevice.turnOff()
}

构造函数

辅助构造函数声明：辅助构造函数定义以constructor关键字开头，后跟圆括号。可视情况在圆括号中包含辅助构造函数所需的形参。

主要构造函数初始化：初始化以冒号开头，后面依次跟this关键字和一对圆括号。可视情况在圆括号中包含主要构造函数所需的形参。

class SmartDevice(val name: String, val category: String) {var deviceStatus = "online"// 主要构造函数constructor(name: String, category: String, statusCode: Int) : this(name, category) {deviceStatus = when (statusCode) {0 -> "offline"1 -> "online"else -> "unknown"}}...
}

类之间的关系

Kotlin 中，所有类默认都是最终类，也就是说您无法扩展这些类，因此必须定义类之间的关系，可在父类中的 class 关键字之前，添加open 关键字对其父类进行扩展。同样，如果需要继承父类中的方法，也需要在方法前添加open关键字。

open class SmartDevice {...var deviceStatus = "online"open fun turnOn() {// function body}open fun turnOff() {// function body}
}

class SmartLightDevice(name: String, category: String) :SmartDevice(name = name, category = category) {var brightnessLevel = 0override fun turnOn() {deviceStatus = "on"brightnessLevel = 2println("$name turned on. The brightness level is $brightnessLevel.")}// override 关键字会告知 Kotlin 运行时去执行子类所定义方法中包含的代码。override fun turnOff() {deviceStatus = "off"brightnessLevel = 0println("Smart Light turned off")}fun increaseBrightness() {brightnessLevel++}
}

使用super 关键字在子类中重复使用父类代码

可见性修饰符

Kotlin 提供了以下四种可见性修饰符：

public：默认的可见性修饰符。可让系统在任何位置访问声明。对于您想在类外部使用的属性和方法，请标记为 public。

private：可让系统在相同类或源文件中访问声明。
某些属性和方法可能仅在类的内部使用，而且您不一定想让其他类使用。您可以使用 private 可见性修饰符标记这些属性和方法，以确保其他类不会意外访问它们。

protected：可让系统在子类中访问声明。对于您想在定义它们的类及其子类中使用的属性和方法，请使用 protected 可见性修饰符进行标记。

internal：可让系统在相同模块中访问声明。internal 修饰符与 private 类似，但您可以从类的外部访问内部属性和方法，只要是在相同模块中进行访问即可

定义属性委托

创建属性委托的语法是以变量声明开头，后面依次跟 by 关键字以及用于为属性处理getter和setter 函数的委托对象。

若要实现您可以委托实现的目标类，您必须熟悉接口。接口是实现它的类必须遵循的协议，侧重于操作的“内容”，而不是操作的“方式”。简而言之，接口可帮助您实现抽象。

class RangeRegulator(initialValue: Int,private val minValue: Int,private val maxValue: Int
) : ReadWriteProperty<Any?, Int> {var fieldData = initialValueoverride fun getValue(thisRef: Any?, property: KProperty<*>): Int {return fieldData}override fun setValue(thisRef: Any?, property: KProperty<*>, value: Int) {if (value in minValue..maxValue) {fieldData = value}}
}

class SmartTvDevice(deviceName: String, deviceCategory: String) :SmartDevice(name = deviceName, category = deviceCategory) {private var speakerVolume by RangeRegulator(initialValue = 0, minValue = 0, maxValue = 100)private var channelNumber by RangeRegulator(initialValue = 1, minValue = 0, maxValue = 200)...
}class SmartLightDevice(deviceName: String, deviceCategory: String) :SmartDevice(name = deviceName, category = deviceCategory) {private var brightnessLevel by RangeRegulator(initialValue = 2, minValue = 0, maxValue = 100)...}