1-6-数据类型

fun main() {
    // Byte 类型，8 位，范围 -128 ~ 127
    val b: Byte = 100
    println("Byte b = $b")

    // Short 类型，16 位，范围 -32768 ~ 32767
    val s: Short = 30000
    println("Short s = $s")

    // Int 类型，32 位，范围 -2^31 ~ 2^31-1
    val i: Int = 2_000_000_000
    println("Int i = $i")

    // Long 类型，64 位，范围 -2^63 ~ 2^63-1
    val l: Long = 9_000_000_000_000_000_000L
    println("Long l = $l")

    // 类型转换示例：
    val iToLong: Long = i.toLong()  // Int 转 Long
    println("Int to Long: $iToLong")

    val lToInt: Int = l.toInt()     // Long 转 Int（会溢出）
    println("Long to Int (可能溢出): $lToInt")

    val iToByte: Byte = i.toByte()  // Int 转 Byte（可能溢出）
    println("Int to Byte (可能溢出): $iToByte")
}

// Int 变量不支持 null 值
var notNull: Int = null //错误
Int? 相当于支持 null 值的 Int 型
var nullable : Int? = null //正确

var pml ：Int = 200 // pml 的类型是 Java 的 int 类型
var pm2: Int = 200  // pm2 的类型是 Java 的 int 类型
println(pml === pm2) // 基本类型比较，输出 true
var obl : Int? = 200  // obl 的类型是 Java 的 Integer 类型
var ob2 : Int? = 200  // ob2 的类型是 Java 的 Integer 类型
println(obl === ob2) // 引用类型比较，输出 false
//当这两个引用比较时，idea会报出警告(翻译如下)
/*禁止对类型为“Int？”和“Int？”的参数进行恒等性*/

val price = 234_234 234 // 对应的值为234234234

fun main() {
 1/0
}//Exception in thread "main" java.lang.ArithmeticException: / by zero

fun main() {
    // 赋值为 Float 类型
    var af1 = 5.2345556f
    // 下面将看到 af1 的值已经发生了改变
    println("af1 的值为：$af1")

    // 声明 af2 是 Float 类型，但 25.2345 默认是 Double 类型，因此下行代码会报错
    // var af2: Float = 25.2345  // ❌ 编译错误：类型不匹配

    // fl 的类型被推断为 Double
    var fl = 5.12e2
    println("fl 的值为：$fl")

    var a = 0.0

    // 5.0 除以 0.0 将出现正无穷大数值
    println("5.0 / a 的值为：${5.0 / a}")

    // 所有的正无穷大数值都相等，所以输出 true
    println(5.0 / a == 50000 / 0.0)

    // -5.0 除以 0.0 将出现负无穷大数值
    println("-5.0 / a 的值为：${-5.0 / a}")

    // 所有的负无穷大数值都相等，所以输出 true
    println(-5.0 / a == -50000 / 0.0)

    // 0.0 除以 0.0 将出现 NaN（非数）
    var nan: Double = a / a
    println("a / a 的值为：$nan")

    // NaN 与自己都不相等，所以输出 false
    println(nan == nan)
}

fun main() {
    val aChar = 'a'
    println(aChar)
}

fun main() {
    val a: Int = 42
    val b: Long = a.toLong()      // Int → Long
    val c: Double = a.toDouble()  // Int → Double
    val d: Byte = a.toByte()      // Int → Byte（可能会溢出）
    val e: Char = a.toChar()      // Int → Char（按 Unicode 编码转换）
    val f: Float = b.toFloat()    // Long → Float

    println("Int: $a")
    println("Int → Long: $b")
    println("Int → Double: $c")
    println("Int → Byte: $d")
    println("Int → Char: $e")
    println("Long → Float: $f")
}
/**
  * Int: 42
  * Int → Long: 42
  * Int → Double: 42.0
  * Int → Byte: 42
  * Int → Char: *
  * Long → Float: 42.0
  */

fun main() {
   val bookPrice : Byte = 79
   val itemPrice : Short = 120
   //算术表达式中的 bookPrice、itemPrice 会自动提升为 Int 类型
   var total = bookPrice + itemPrice
   println("total的值为: $total")
   //可以看到 total 映射的 Java 类型为Int
   println("total 的类型为：${total.javaClass}")
   //由于一个是 Long，另一个是 Byte，Byte 会自动提升为 Long，相加的结果也是 Long
   val tot = bookPrice.toLong() + itemPrice.toByte()
   println("total 的值为：$tot")
   //可以看到 total 映射的 Java 类型为 long
   println("total 的类型为：$｛tot.javaClass｝")
}

fun main() {
    val int = 97
    val char = (int+4).toChar() //char='e'
    println(int.toChar()) //a
    println(char) //e
}

fun main() {
    val c1 = 'i'
    val c2 = 'k'
    println(c1+4) // m
    println(c1-4) // e
    println(c1-c2) //-2
}

fun main() {
    val num = 2/3
    println(num) // 0
}

fun main() {
    val b = 60.toByte()
    val s = 80.toShort()
    val i = 100
    val l = 125.toLong()
    val f = 125.5.toFloat()
    val d = 256.6

    val res = b+s+i+l+f+d
    println(res)
    println(res.javaClass)
}//输出:
/*47.1
  *double
  */

println("hello"+'a'+7)
println('a'+7+"hello")