Kotlin-基本数据-整型与浮点型

基本数据类型：整型

• Byte：占8个字节数
• Short：占16个字节数
• Int：占32个字节数（默认类型）
• Long：占64个字节数

fun main(){
        val one = 1
    println(one.javaClass.name)//int。默认赋值一个整数，他的类型是Int类型

    val threeBillion = 3000000000
    println(threeBillion.javaClass.name)//long，默认赋值一个整数超过了int类型范围，他的类型是Long类型

    val oneLong = 1L
    println(oneLong.javaClass.name)//long，如果指定数值是Long类型，方法1，需要在数值后面加入L或l

    val twoLong: Long = 2
    println(twoLong.javaClass.name)//long，如果指定数值是Long类型，方法2，指定变量类型

    val oneByte: Byte = 1
    println(oneByte.javaClass.name)//byte，指定变量类型，通过“变量名：类型”指定

}

基本数据类型：浮点数

• Float：占32位字节数
• Double：占64位字节数（默认类型）

fun main(){
        val pi = 3.14
    println(pi.javaClass.name)//double，不指定类型默认是double类型

//    val oneDouble1:Double = 1//错误：类型不匹配
    val oneDouble2: Double = 1.0
    println(oneDouble2.javaClass.name)//double

    val piFloat1 = 3.14f
    println(piFloat1.javaClass.name)//float，如果指定类型为float，数值后面必须加F或f

    val eFloat = 2.7155555555555f//如果使用float，超过float类型将会降低数据精度
    val eDouble = 2.7155555555555
    println("eFloat is $eFloat , eDouble is $eDouble")//eFloat is 2.7155557 , eDouble is 2.7155555555555
}

注意

注意：Kotlin与其他语法不同，没有数字隐式扩宽转换，例如具有Double参数的函数只能对Double值进行调用，不能对其他类型的数值进行调用

fun main(){
        fun printDouble(d: Double) {
        println("print Double : $d")
    }
    printDouble(1.0)
//    printDouble(1) 错误：类型不匹配
//    printDouble(1.0f)错误：类型不匹配
}

数字特征

• 数值可以使用下划线，使数字特征更易读。

fun main(){
    val oneMillion = 1_000_000
    val cardNumber = 1232_4567_4865_8421_15
    println("oneMillion is $oneMillion")//1000000
    println("cardNumber is $cardNumber")//123245674865842115
}

JVM 平台的数字表示

• 对相同数字的可为空引用可能是不同的对象：

fun main(){
    val a: Int = 100
    val boxedA: Int? = a
    val anotherboxedA: Int? = a
    println("boxedA vs anotherboxedA ${boxedA === anotherboxedA} ")//boxedA vs anotherboxedA true

    val b: Int = 10086
    val boxedB: Int? = b
    val anotherboxedB: Int? = b
    println("boxedB vs anotherboxedB ${boxedB === anotherboxedB} ")//boxedB vs anotherboxedB false

}

由于 JVM 对 -128 到 127 的整数（Integer）应用了内存优化，因此，a 的所有可空引用实际上都是同一对象。但是没有对 b 应用内存优化，所以它们是不同对象。

显式转换

看一段代码，这段代码无法运行：

    val aa: Int? = 1
//    val bb: Long? = a//本段代码不能运行
//    println(b == a)//本段代码不能运行

因此，把这种值的类型不能隐式转换的类型必须显示的类型转换。我们需要使用toXXX()方法进行转换。

* toByte()：转换为byte类型
* toShort()：转换为short类型
* toInt()：转换位int类型
* toLong()：转换为long类型
* toFloat()：转换为float类型
* toDouble()：转换为double类型
* toChar()：转换为char类型

实例：

val mByte: Byte = 1
val mDouble: Double = mByte.toDouble()
val mFloat: Float = mByte.toFloat()
println(mByte.javaClass.name)//byte
println(mDouble.javaClass.name)//double
println(mFloat.javaClass.name)//float