Kotlin语言基础（上）

1、基本数据类型

// Byte-8位（1个字节） Short-16位 Int-32位 Long-64位 Float-32位 Double-64位  
val aInt: Int = 55 // 默认的整数是Int类型，默认的小数是Double类型
val bInt: Int = 0xf250 // 十六进制表示整数，kotlin没有八进制
val cInt: Int = 0b01000110 // 二进制表示整数
val maxInt: Int = Int.MAX_VALUE // 2的32次方-1，2147483647
val minInt: Int = Int.MIN_VALUE // -2的32次方，-2147483648

// 字符占两个字节，16位的Unicode字符集
val aChar: Char = 'A'
val bChar: Char = '中'
val cChar: Char = '\n' // 转义符号换行，\'表示单引号 \"表示双引号 \\表示一条斜杠 \$表示美元符号
val dChar: Char = '\uff25' // 通过四位十六进制具体的数值，找出对应的字符

2、字符串模板

val name: String = "Duncan"
val str1 = "我的名字是$name"
val str2 = "我的名字的长度是${name.length}"
val salary: Int = 1000;
// 转义字符
//\t => 表示制表符
//\n => 表示换行符
//\b => 表示退格键（键盘上的Back建）
//\r => 表示键盘上的Enter键
//\\ => 表示反斜杠
//\' => 表示单引号
//\" => 表示双引号
//\$ => 表示美元符号，如果不转义在kotlin中就表示变量的引用了
println("工资是\$$salary") // 工资是$1000
// """表示原始字符串，里面的格式照样输出，转义字符在里面会失效。但是字符串模板还是有用的
val str3 = """测试多行内容
    哈哈哈
    哈哈哈
        啊哈哈哈哈
"""
println(str3)
// trimMargin表示去空格，>前的空格都会被去掉
val str4 = """测试多行内容
    >哈哈哈
    >哈哈哈
        >啊哈哈哈哈
""".trimMargin(">")
println(str4)

3、变量、常量初始化

// 表示变量name1，类型是String，初始值是abc
var name1: String = "abc"
// 表示变量name2，类型是String，类型后加了?表示这个值有可能是空的，初始化的值我们设为null
var name2: String? = null
// lateinit表示延迟初始化，只能用于var不能用于val。声明后在使用前必须给它赋值才能使用，否则会报错。
lateinit var name3: String
// 下面写法是错误的，不能用于基本类型变量(Int Float Double等)
lateinit var age3: Int
// 下面写法是错误的，不能用于可空的变量。如果可空的变量初始化直接设为null就完事了，没变要延迟初始化
lateinit var name4: String?

// 常量，不允许重新被赋值，系统推断出类型，所以没写具体类型。
// 相当于Java里的public final String name1 = "ABC"
val name1 = "ABC"
val name2: String = "ABC"
// 常量的延迟初始化，当我们用到name3的时候，才会把"ABC"赋值给name3
val name3: String by lazy {
    "ABC"
}
// 运行时常量
// 最后换转换成java里的private static final long name = (new Date()).getTime();
val time = Date().time
// const关键字会提前让其变成编译时常量，即在编译阶段，这个值已知，所有引用这个常量的地方都会替换成这个值。
// 最后换转换成java里的public static final String name = "Duncan";
// java里的那两段代码因为都是final关键字修饰的，只能证明都是常量。但是要区分运行还是编译时，
// 站在java的角度，如果final后的类型是基本类型或者String，就是编译时常量。否则就是运行时常量
// 因此，kotlin里const因为是编译时常量，所以后面的字段类型必然只能是基本类型或者String
const val name: String = "Duncan"

// Nothing类型
    var v = null;
//  v = "aaa"; 报错，因为v没有声明任何类型，又根据类型推断不了，
// 所以是Nothing类型。给Nothing类型赋值字符串必然报错

4、双等号和===

// number1相当于java里的int类型，当然在kotlin并没有基本类型数据类型这个概念，万物皆对象，
// 这个选择究竟是java里的int还是装箱后的Integer是交由编译器来决定的
val number1: Int = 200
// number2是引用对象类型，因为可null，相当于Java里的Integer
val number2: Int? = number1

fun main(args: Array<String>) {
    // ==号相当于Java里的equals，表示判断内容是否一致
    println(number1 == number2) // true
    // ===相当于Java里的==，表示引用的内存地址是否一样
    // 当这个值在-128 ~ 127之间时，number1 === number2 的结果是true
    // 当这个值不在-128 ~ 127之间时，number1 === number2 的结果是false
    // 可以理解为值在-128 ~ 127时，有一套缓存机制，不需要重新创建一个地址，指向都是同一个地方.
    println(number1 === number2) // false
}

5、数组的创建

// 基本数据类型，Byte Short Int Long Float Double Char都有已封装好创建数组的方式
fun main(array: Array<String>) {
    // 相当于Java的静态初始化
    val a = arrayOf(5, 10, 20)
    val b = intArrayOf(5, 10, 10)
    // 相当于Java的静态初始化，不过可以随意根据函数来设置默认值
    val d = Array<Int>(3) {
            i : Int -> i * 5
    }
    for (e in d) {
        println(e) // 0 5 10
    }
    // 相当于Java的动态初始化
    val c = arrayOfNulls<Int>(5)
    c[0] = 5
    c[1] = 10
    c[2] = 20
}

// 数组的遍历
fun main(array: Array<String>) {
    val arr = arrayOf(5, 10, 20)
    // 数组的遍历方式一
    for (a in arr) {
        println(a)
    }
    // 数组的遍历方式二，获取下标
    for (b in arr.indices) {
        println(arr[b])
    }
    // 数组的遍历方式三，下标和值都要
    for ((index, value) in arr.withIndex()) {
        println("index:$index----value:$value")
    }
}

/**
 * 数组常用方法
 */
fun main(array: Array<String>) {
    val arr = arrayOf(5, 10, 20)
    val result1 = arr.all {
        // 所有的元素是否都满足这个条件，如果都满足就返回true，否则是false
        it > 10
    }
    println(result1)
    val result2 = arr.any {
        // 只要有一个元素满足这个条件，就返回true，否则是false
        it > 10
    }
    println(result2)
    // 以下两者相等，都判断是否包含该元素
    println(arr.contains(5))
    println(5 in arr)
    // 将数组里的从下标[1,3)的内容赋值为4
    arr.fill(4, 1, 3)
    for (a in arr) {
        println(a) // 5 4 4
    }
    // 根据条件，过滤某些元素，把符合条件的放到新的list里
    val list = arr.filter {
        it <= 4
    }
    for (a in list) {
        println(a)
    }
}

6、控制语句

// if表达式
fun main(args: Array<String>) {
    // if表达式，每个分支最后一个值是作为返回值的，
    // 和java不同的是这个是表达式，可以有结果的
    val age: Int = if (args[0].toInt() > 5) {
        println("args[0]>5")
        10
    } else{
        println("args[0]<=5")
        20
    }
}
fun main(args: Array<String>) {
    val b: Boolean = true
    if (b) {
        println("B is True")
        // 在这里返回了，因为if是表达式，即相当于在其外层函数/方法里使用了return一样
        return
    } else{
        println("B is not True")
    }
    // 因此，下面的代码是没有被执行的，只打印了"B is True"
    println("Main Run")
}

// 区间
fun main(args: Array<String>) {
    val range1: IntRange = 1..10 // [1, 10]
    val range2: IntRange = 1 until 10 // [1, 10)
    println(range1.contains(5)) // true
    println(5 in range1) // 等价于上面的语句
    for (i in range2) {
        println("$i,")
    }
}

// for循环的几种方式
fun main(args: Array<String>) {
    // kotlin中，废弃了java里的for(初始值;判断条件;步长)这种方式，都可以通过以下方式来实现
    // until表示[5,10)
    for (i in 5 until 10) {
        println(i) // 5,6,7,8,9
    }
    // ..表示IntRange，范围是[5,10]，两个闭区间
    for (i in 5..10) {
        println(i) // 5,6,7,8,9,10
    }
    // step 2表示步长2，我们没设置就是默认1
    for (i in 5..10 step 2) {
        println(i) // 5, 7, 9
    }
    // downTo倒序，范围是[10, 5]
    for (i in 10 downTo 5) {
        println(i) // 10,9,8,7,6,5
    }
    // 数组的遍历，关于数组的其他遍历方式在【5.数组的创建】里已经有详细讲解
    val array = arrayOf(5, 10, 20)
    for (i in array) {
        println(i)
    }
    // 迭代器的遍历
    val it = array.iterator()
    while (it.hasNext()) {
        println(it.next())
    }
}

// when表达式，和if表达式一样，每个分支最后一个语句作为整个when的返回值
val name = "Duncan"
val v = when (name) {
    "TT" -> {
        println("when $name")
        5
    }
    // 支持多个条件
    "BB","CC","DD" -> {
        print("when $name")
        2
    }
    else -> {
        println("else")
        1
    }
}
println("v==>$v")
// when后可以不接判断判断变量
val w = when {
    5 in array -> {
        println("数组包含5")
        5
    }
    else -> {
        println("数组不包含5")
        10
    }
}
println(w)

// while和do while两个控制语句和java里没有任何差别

7、可空类型及异常Exception

/**
 * 类型后面的?表示该值有可能为null
 */
fun getName(): String? {
    return null;
}
fun main(args: Array<String>) {
    // 由于getName的结果有可能为空，所以调用其方法或者属性的时候，必须使用?.调用
    // 如果getName的结果是空的，就不执行其后的方法或者属性。如果不为空，则执行
    println(getName()?.length) // 打印null出来
    // ?:表示如果getName的结果是空的，就执行后面的return表达式。不是空的就赋值给name字段
    val name:String = getName() ?: return
    println(name.length)
    // !!.表示强制调用，相当于value的值我知道肯定不是空的，所以要强制调用
    val value: String? = "Hello World"
    println(value!!.length)
    
    // 会报错，类型强转失败
    val num1: Int? = "ABC" as Int
    // 不会报错，as?表示安全强转，结果是num2=null
    val num2: Int? = "ABC" as? Int
}

fun main(array: Array<String>) {
    // 关于异常，kotlin所有的异常都是运行时异常，没有受检查的异常
    // 什么是受检查异常，Java里那些必须得try catch又或者throws出去的异常，比如IOException。
    // 什么是运行时异常，比如Java的NullPointException
    try {
        val v0 = array[0].toInt()
    } catch (e: Exception) {
        println("发生异常了")
        // 重新抛出一种异常
        throw IllegalArgumentException()
    } finally {
        println("处理完成...")
    }
}