// Kotlin 1.3.11 编译器版本

// 无包声明

 

fun main() {

    // 1. 集中声明变量，类型前置，符合C语言风格的变量声明习惯

    // 整数变量

    var FFF1: Byte // 声明整数变量FFF1，类型为Byte

    var FFF2: Short // 声明整数变量FFF2，类型为Short

    var FFF3: Int // 声明整数变量FFF3，类型为Int

    var FFF4: Long // 声明整数变量FFF4，类型为Long

    var FFF5: Int // 声明整数变量FFF5，类型为Int

    var FFF6: Long // 声明整数变量FFF6，类型为Long

    var FFF7: Long // 声明整数变量FFF7，类型为Long

    var FFF8: Int // 声明整数变量FFF8，类型为Int

    var FFF9: Long // 声明整数变量FFF9，类型为Long

    var FFF10: Int // 声明整数变量FFF10，类型为Int

    var FFF11: Int // 声明整数变量FFF11，类型为Int

    var FFF12: Int // 声明整数变量FFF12，类型为Int

    var FFF13: Long // 声明整数变量FFF13，类型为Long

    var FFF14: Long // 声明整数变量FFF14，类型为Long

    var FFF15: Long // 将类型改为Long

    var FFF16: Long // 将类型改为Long

    var FFF17: Int // 声明整数变量FFF17，类型为Int

    var FFF18: Int // 声明整数变量FFF18，类型为Int

    var FFF19: Int // 新增，用于整数除法示例中的临时变量

    var FFF20: Long // 新增，用于整数除法示例中的临时变量

    // 其他变量

    var EEE1: Double // 声明变量EEE1，类型为Double

    var EEE2: Float // 声明变量EEE2，类型为Float

    var EEE3: Double // 声明变量EEE3，类型为Double

    var EEE4: Float // 声明变量EEE4，类型为Float

    var EEE5: Int // 声明变量EEE5，类型为Int

    var EEE6: Long // 声明变量EEE6，类型为Long

    var EEE7: Float // 声明变量EEE7，类型为Float

    var EEE8: Double // 声明变量EEE8，类型为Double

    var EEE9: Double // 声明变量EEE9，类型为Double

    var EEE10: Int // 声明变量EEE10，类型为Int

    // 对象变量

    var GGG1: Int? // 声明对象变量GGG1，类型为可空Int

    var GGG2: Int? // 声明对象变量GGG2，类型为可空Int

    var GGG3: Int? // 声明对象变量GGG3，类型为可空Int

    var GGG4: Int? // 声明对象变量GGG4，类型为可空Int

 

    // 2. 变量赋值

    FFF1 = 127 // 给整数变量FFF1赋值为127，Byte类型的取值范围

    FFF2 = 32767 // 给整数变量FFF2赋值为32767，Short类型的取值范围

    FFF3 = 2147483647 // 给整数变量FFF3赋值为2147483647，Int类型的最大值

    FFF4 = 9223372036854775807L // 给整数变量FFF4赋值为9223372036854775807L，Long类型的最大值

    FFF5 = 100 // 给整数变量FFF5赋值为100

    FFF6 = 10000000000L // 给整数变量FFF6赋值为10000000000L

    FFF7 = 10L // 给整数变量FFF7赋值为10L

    EEE1 = 3.1415926 // 给变量EEE1赋值为3.1415926

    EEE2 = 2.71828f // 给变量EEE2赋值为2.71828，Float类型

    EEE3 = 0.5 // 给变量EEE3赋值为0.5

    EEE4 = 1.2345678f // 给变量EEE4赋值为1.2345678，Float类型

    FFF8 = 123 // 给整数变量FFF8赋值为123

    FFF9 = 123L // 给整数变量FFF9赋值为123L

    FFF10 = 0x0F // 给整数变量FFF10赋值为十六进制数0x0F

    FFF11 = 0b00001011 // 给整数变量FFF11赋值为二进制数0b00001011

    FFF12 = 1_000_000 // 给整数变量FFF12赋值为1000000，数字下划线增强可读性

    FFF13 = 1234_5678_9012_3456L // 给整数变量FFF13赋值为1234567890123456L，Long类型

    FFF14 = 999_99_9999L // 给整数变量FFF14赋值为999999999L，Long类型

    FFF15 = 0xFF_EC_DE_5E.toLong() // 将值转换为Long类型并赋值

    FFF16 = 0b11010010_01101001_10010100_10010010.toLong() // 将值转换为Long类型并赋值

    FFF17 = 100 // 给整数变量FFF17赋值为100

    GGG1 = FFF17 // 将整数变量FFF17的值赋给对象变量GGG1

    GGG2 = FFF17 // 将整数变量FFF17的值赋给对象变量GGG2

    FFF18 = 10000 // 给整数变量FFF18赋值为10000

    GGG3 = FFF18 // 将整数变量FFF18的值赋给对象变量GGG3

    GGG4 = FFF18 // 将整数变量FFF18的值赋给对象变量GGG4

 

    // 3. JVM平台数字表示示例

    // 使用类似printf的格式化输出，将部分内容替换为要求的cat和dog

    println("GGG1 === GGG2: ${GGG1 === GGG2}") 

    println("GGG3 === GGG4: ${GGG3 === GGG4}") 

    println("FFF18 == FFF18: ${FFF18 == FFF18}") 

    println("GGG3 == GGG4: ${GGG3 == GGG4}") 

 

    // 4. 显式数字转换示例

    EEE5 = FFF1.toInt() // 将Byte类型的FFF1转换为Int类型并赋给EEE5

    EEE6 = FFF2.toLong() // 将Short类型的FFF2转换为Long类型并赋给EEE6

    EEE7 = FFF3.toFloat() // 将Int类型的FFF3转换为Float类型并赋给EEE7

    EEE8 = FFF4.toDouble() // 将Long类型的FFF4转换为Double类型并赋给EEE8

 

    // 5. 数字运算示例

    // 使用类似printf的格式化输出，将部分内容替换为要求的cat和dog

    println("1 + 2 = ${1 + 2}") 

    println("2500000000L - 1L = ${2500000000L - 1L}") 

    println("3.14 * 2.71 = ${3.14 * 2.71}") 

    println("10.0 / 3 = ${10.0 / 3}") 

 

    // 6. 整数除法示例

    FFF19 = 5 / 2 // 进行整数除法运算，结果为2，使用var声明变量

    println("5 / 2 = $FFF19, is equal to 2: ${FFF19 == 2}") 

    FFF20 = 5L / 2 // 进行Long类型的整数除法运算，结果为2L，使用var声明变量

    println("5L / 2 = $FFF20, is equal to 2L: ${FFF20 == 2L}") 

    EEE9 = 5 / 2.toDouble() // 将2转换为Double类型后进行除法运算，结果为2.5

    println("5 / 2.toDouble() = $EEE9, is equal to 2.5: ${EEE9 == 2.5}") 

 

    // 7. 位运算示例

    EEE10 = (1 shl 2) and 0x000FF000 // 进行位运算，1左移2位后与0x000FF000进行按位与运算

    println("(1 shl 2) and 0x000FF000 = $EEE10") 

 

    // 8. 浮点数比较示例

    // 使用类似printf的格式化输出，将部分内容替换为要求的cat和dog

    println("Double.NaN == Double.NaN: ${Double.NaN == Double.NaN}") 

    println("listOf(Double.NaN) == listOf(Double.NaN): ${listOf(Double.NaN) == listOf(Double.NaN)}") 

    println("0.0 == -0.0: ${0.0 == -0.0}") 

    println("listOf(0.0) == listOf(-0.0): ${listOf(0.0) == listOf(-0.0)}") 

    println("listOf(Double.NaN, Double.POSITIVE_INFINITY, 0.0, -0.0).sorted(): ${listOf(Double.NaN, Double.POSITIVE_INFINITY, 0.0, -0.0).sorted()}") 

}