1、Kotlin运行流程

.java -> 编译/Java编译器   -> *.class   -> 解释/Java解释器 -> 计算机执行
.kt   -> 编译/Kotlin编译器 -> *Kt.class -> ┌─ 解释/Java解释器 -> 计算机执行
                                          └─ Kotlin运行时库 -> 计算机执行

2、Kotlin反编译成Java代码

Tools -> Kotlin -> Show Kotlin Bytecode -> Decompile

3、八大基本数据类型

fun main(){
    /**------------------ 8大基本数据类型------------------*/
    // java八大基本数据类型有对应的封装数据类型
    // kotlin没有封装数据类型
    var b: Boolean = false        //1byte=8bit
    var byte: Byte = 1            //1byte

    var char: Char = 'a'          //2byte=16bit
    var short: Short = 10         //2byte

    var int: Int = 10             //4byte=32bit
    var float: Float = 1.234f     //4byte

    var long: Long = 40L           //8byte=64bit
    var double: Double = 1.23456  //8byte


    /**------------------ 基本数据类型取值范围------------------*/
    //Boolean: true或false

    //Byte: -128 ~ 127
    val minByte = Byte.MIN_VALUE
    val maxByte = Byte.MAX_VALUE
    println("Byte: $minByte ~ $maxByte")

    //Char: 单个字符

    //Short: -32768 ~ 32767
    val minShort = Short.MIN_VALUE
    val maxShort = Short.MAX_VALUE
    println("Short: $minShort ~ $maxShort")

    //Int: -2147483648 ~ 2147483647
    val minInt = Int.MIN_VALUE
    val maxInt = Int.MAX_VALUE
    println("Int: $minInt ~ $maxInt")

    //Float: -3.4028235E38 ~ 3.4028235E38
    //val minFloat = Float.MIN_VALUE
    val minFloat = -Float.MAX_VALUE
    val maxFloat = Float.MAX_VALUE
    println("Float: $minFloat ~ $maxFloat")

    //Long: -9223372036854775808 ~ 9223372036854775807
    val minLong = Long.MIN_VALUE
    val maxLong = Long.MAX_VALUE
    println("Long: $minLong ~ $maxLong")

    //Double: -1.7976931348623157E308 ~ 1.7976931348623157E308
    val minDouble = -Double.MAX_VALUE
    val maxDouble = Double.MAX_VALUE
    println("Double: $minDouble ~ $maxDouble")
}

4、智能类型推断

fun main() {

    println("------------------ 类型推断 ------------------")
    var b = false           //智能推断为Boolean类型
    var byte: Byte = 1      //Byte类型必须显示声明
    println(b.javaClass)    //boolean
    println(byte.javaClass) //byte

    var char = 'a'          //智能推断为Char类型
    var short: Short = 10   //Short类型必须显示声明
    println(char.javaClass) //char
    println(short.javaClass)//short

    var int = 10            //智能推断为Int类型
    //int = 'a'             //错：kotlin推断出int是Int类型，故不能赋值为Char
    var float = 1.234f      //智能推断为Float类型
    println(int.javaClass)  //int
    println(float.javaClass)//float

    var long = 40L          //智能推断为Long类型
    var double = 1.23456    //智能推断为Double类型
    println(long.javaClass) //long
    println(double.javaClass) //double

    println("------------------ 类型转换 ------------------")
    println("调用toXXX方法进行类型转换")
    var type = 10

    println(type.toByte())  //10
    println(type.toChar())  //""
    println(type.toShort()) //""
    println(type.toInt())   //10
    println(type.toFloat()) //10.0
    println(type.toLong())  //10
    println(type.toDouble())//10.0

    println(type.toByte().javaClass)  //byte
    println(type.toChar().javaClass)  //char
    println(type.toShort().javaClass) //short
    println(type.toInt().javaClass)   //int
    println(type.toFloat().javaClass) //float
    println(type.toLong().javaClass)  //long
    println(type.toDouble().javaClass)//double

}

5、可变变量、不可变变量、常量

fun main() {
    //------------------ 变量 ------------------
    // var：可变变量
    // val：不可变变量，可通过反射修改
    // 项目开发中尽量使用val，实在不行再使用var
    var a = 12
    val pi = 3.1419526
    a = 20          //对：可变变量可以重新赋值
    //pi = 1.22222  //错：不可变变量不能重新赋值

    //------------------ 常量 ------------------
    // 编译器常量const，必须定义在top level或者companion object中
    //const val b = 100 //错：不能定义在这里
}

//------------------ 常量 ------------------
const val b = 100
class c{
    companion object{
        const val c = 100
    }
}

6、Kotlin调用Java

fun main() {
    //存钱
    var money: Double = 1.123456789123456789
    //取钱
    println(money)
    //发现钱不一样了

    //存钱
    var bigMoney:BigDecimal = BigDecimal("1.123456789123456789")
    //取钱
    println(bigMoney)
    //发现钱是一样的，BigDecimal是java.math包下面的，故使用的是java的类
}