kotlin简单笔记

ext.kotlin_version = '1.3.20'
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"

apply plugin: 'kotlin-android'
apply plugin: 'kotlin-android-extensions'
apply plugin: 'kotlin-kapt'
implementation"org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"

app的build.gradle
// Kotlin
implementation "org.jetbrains.kotlin:kotlin-stdlib:1.4.32"
// 协程核心库
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.3"
// 协程Android支持库
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.4.3"

var 变量　　
var a: Int = 1 
var是一个可变变量，这是一个可以通过重新分配来更改为另一个值的变量。这种声明变量的方式和java中声明变量的方式一样。
val 常量
val a: Int = 1　// 常量值不能再次更改
val是一个只读变量，这种声明变量的方式相当于java中的final变量。一个val创建的时候必须初始化，因为以后不能被改变。

类的声明 & 实例化
// 格式
class 类名（参数名1：参数类型，参数名2：参数类型...）{
                // to do 
}
// 示例
class User(userName: String, age: Int){
               // to do 
}
// 实例化，Kotlin没有new关键字，所以直接创建类的实例（无参情况 & 有参）：
var user = User()
var user = User("ABC" , 123)
// 使用属性 = 名称 + 引用
User().sex  // 使用该属性 = Java的getter方法
User().userName = "hjc"  // 设置该属性 = Java的setter方法

继承 & 重写
类似于Java，Kotlin是单继承 = 只有一个父类
区别：Kotlin使用冒号“ : ”继承 & 默认不允许继承（若想让类可被继承，需用open关键字来标识）
// 用open关键字标识该类允许被继承
open class Food 
// 类Fruits继承类Food
class Fruits : Food()
对于子类重写父类的方法，在Kotlin中，方法也是默认不可重写的
若子类要重写父类中的方法，则需在父类的方法前面加open关键字，然后在子类重写的方法前加override关键字
// 父类
// 在类 & 方法前都加了关键字open，为了被继承 & 方法重写
open class Food {
    open fun banana() {}
}
// 子类 
class Fruits : Food(){
    // 重写了父类的方法
    override fun banana() {
        super.banana()
    }
}

接口：关键字interface
// 声明
interface A{}
interface B{}
// 方法体
// 接口中的方法可以有默认方法体，有默认方法体的方法可不重写
// 区别于Java：Java不支持接口里的方法有方法体。
interface UserImpl{
    fun getName(): String // 无默认方法体，必须重写
    fun getAge(): Int{    // 有默认方法体，可不重写
        return 22
    }
}
// 实现接口UserImpl：需重写getName() & 可不重写getAge()
// 实现接口：冒号:
class Food : A, B {} // Kotlin是多实现
class Fruits: Food, A, B {} // 继承 + 实现接口

函数
1. 采用 “fun” 标识
2. 括号里的是传入函数的参数值和类型
fun 函数名（参数名：参数类型）：返回值类型{
    函数体
    return 返回值
}
// 示例：一个函数名为“abc”的函数，传入参数的类型是Int，返回值的类型是String
 fun abc(int: Int): String {
    return "carson_ho"
}
// 或返回Unit（类似Java的void，无意义）
      fun 函数名（参数名：参数类型）：Unit{
        函数体
    }
// 或返回Unit（类似Java的void，无意义）
      fun 函数名（）：Unit{
        函数体
    }
    
控制流语句主要包括：if、when、for 和 while。
１.if语句      
Kotlin中的if语句与Java用法类似，
区别在于：Kotlin的if语句本身是一个表达式，存在返回值   
var c = if (a > b) 3 else 4
类似于java三元表达式：
c = a > b ? 3 : 4; // 若a>b，c=3，否则c=4
// 若if后面是代码块
var c = if (a > b) {
    代码块1
} else {
    代码块2
}
2.when语句
类似Java中的switch语句
// Kotlin中的when语句
var a = 0
when (a) {
    0 -> {代码块1}
    1 -> {代码块2}
    2,3 -> {代码块3}
    else -> {代码块4}
}
// 说明：
// 当a=0时执行代码块1
// 当a=1时执行代码块2
// 当a=2，3时，执行代码块3
// 当a=其他值时，执行代码块4
// 注意：when语句在满足条件的分支执行后，会终止when语句执行
3.for语句
类似Java中的for语句
// Java中的for语句
for (int i = 0; i < 4; i++) {
    System.out.println(i);
}
// Kotlin中的for语句
for (i in 1..4){ 
    println(i)
}
// 注：关键字用于表示数字是否在目标范围内，上面的示例表示判断i是否在代表1-4范围内
// Java中的for语句
for (int i = 0; i < 4; i++) {
    System.out.println(i);
}
// Kotlin中的for语句
for (i in array.indices) {
    println(array[i])
}
4.while语句
类似Java中的while语句，分为while 和 do…while语句：
var i = 5
while(i in 1..4){
   代码块1
}

do{ 代码块2
  } while(i in 1..4) {
}

范围使用:主要用于表示范围，主要包括：in、downTo、step、until
1. in   作用：在...范围内
// 表示：若i在1-5范围内，则执行下面代码. 注：闭区间，[1,5]
if (i in 1..5) {
    println("i 在 1-5 内")
}
// 表示：若i不在1-5范围内，则执行下面代码， !in表示不在...范围内
if (i !in 1..5) {
    println("i 不在 1-5 内")
}
2. until，作用：表示开区间， 输出1234
for (i in 1 until 5) {
 println(i)
}
3. downTo，作用：倒序判断
for (i in 5 downTo 1) {
     println(i)
 }
4. step，作用：调整步长
// 设置步长为2，顺序输出1、3、5
for (i in 1..5 step 2) println(i) 
// 设置步长为2，倒序输出5、3、1
for (i in 1 downTo 5 step 2) println(i) 

类型检查 & 转换
1. is，作用：判断一个对象与指定的类型是否一致
// 判断变量a的数据类型是否是String
var a: Any = "a"
if (a is String) {
    println("a是String类型")
}
if (a !is Int) {
    println("a不是Int类型")
}
2. 智能转换
//说明： kotlin不必使用显式类型转换操作，因为编译器会跟踪不可变值的is检查以及显式转换，并在需要时自动插入（安全的）转换
var a: Any = "a"
if (a is String) {
    println("a是String类型")
    println(a.length) // a 自动转换为String类型
    //输出结果为：1
}
// 在 && 和 || 的右侧也可以智能转换：
if (a is String && a.length > 0)
if (a is String || a.length > 0)
3. 强制类型转换：as
var any: Any = "abc"
var str: String = any as String
// 强制类型转换是不安全的，若类型不兼容则会抛出一个异常
var int: Int = 123
var str: String = int as String
// 抛出ClassCastException

相等性判断:在Kotlin中，存在结构相等 & 引用相等 两种相等判断。
1. 结构相等：equals()或 == , 作用：判断两个结构是否相等
var a = "1"
var b = "1"
if (a.equals(b)) {
    println("a 和 b 结构相等")
    // 输出结果为：a 和 b 结构相等
}
var a = 1
var b = 1
if (a == b) {
    println("a 和 b 结构相等")
    // 输出结果为：a 和 b 结构相等
}
2. 引用相等：=== , 作用：判断两个引用是否指向同一对象
// 设置一个类如下
data class User(var name: String, var age: Int)

// 设置值
var a = User("Czh", 22)
var b = User("Czh", 22)
var c = b
var d = a

// 对比两个对象的结构
if (c == d) {
    println("a 和 b 结构相等")
} else {
    println("a 和 b 结构不相等")
}

// 对比两个对象的的引用
if (c === d) {
    println("a 和 b 引用相等")
} else {
    println("a 和 b 引用不相等")
}

// 输出结果：
a 和 b 结构相等
a 和 b 引用不相等

空安全：在Java中，NullPointerException异常十分常见，
而Kotlin的优点则是可以尽可能避免执行代码时出现的空指针异常