Kotlin基本类型(一)，整型、浮点、字符以及相互转换

最新推荐文章于 2023-11-14 16:25:39 发布

sunLookin

最新推荐文章于 2023-11-14 16:25:39 发布

阅读量7.2k

点赞数 1

分类专栏： Kotlin 文章标签： kotlin基本类型 kotlin浮点数 kotlin整型 kotlin空安全 kotlin字符

本文链接：https://blog.csdn.net/Stc_LOokIN/article/details/103368693

版权

Kotlin 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

与java相同，Kotlin也是一门强类型的语言，强类型包含两方面：1. 所有的变量必须先申明、后使用；2. 指定类型的变量只能接受类型与之匹配的值；强类型的语言可以在编译过程中发现源代码的错误，从而保证程序更加的健壮

注释

Kotlin的注释与java基本保持一致，Kotlin注释同样支持单行注释、多行注释和文档注释

单行注释、多行注释

单行注释就是注释一行代码，使用（//）双斜杠放在需要注释的代码前面；多行注释是指一次性地将程序中的多行代码注释掉，在Kotlin语言中，多行注释是可以进行嵌套的

package learn
//这是使用的单行注释
fun main(){
    /*
    这里使用的是
    多行注释
     */
    print("hello world!")
    /*多行注释
    /*这是使用了多行注释*/
     */
}

文档注释

package learn

/**
 * 文档注释
 */
fun main(){
    print("hello world!")
}

变量

常亮和变量的区别：常量在申请结束后就不可以进行那个修改。变量可以在代码中进行修改

分隔符（；{}.空格这些都有分隔的作用）
- 分号(😉
  - Kotlin并不强制每条语句必须要用分号结尾，当然，使用分号也是可以的。如果单独一行内只有一条语句，那么就不需要分号。。如果一行里面有多个独立的语句，就需要使用分号进行分隔
- 花括号
  - 花括号的作用就是定义一个代码块。一个代码块就是包含一段代码，代码块在逻辑上是一个整体。对Kotlin语句来说，类体部分、枚举需要放在花括号中定义，方法体也必须放在花括号中定义。除此之外，条件语句中的条件执行体的循环通常也放在代码块里
- 方括号
  - 方括号是一个索引运算符，其主要作用是用于访问数组元素、集合元素。方括号通常紧跟数组变量名、集合变量名，而在方括号里面指定希望访问的数组元素和集合元素
- 圆括号
  - 圆括号是一个功能非常丰富的分隔符，在定义函数、方法时必须使用圆括号来包含所有形参声明，在调用函数时也必须使用圆括号来传入实参值。不仅如此，圆括号还可以将表达式中某部分阔成一个整体来表达先级
- 空格
  - 空格可以出现在程序的任何地方，但是不要使用空格把一个变量名隔开。这将导致程序出错。Kotlin中的空格包含空格符、制表符、回车键
- 圆点
  - 圆点通常用作类、结构体、枚举、实例和它的成员之间的分隔符，表明调用某个类或某个实例的指定成员
    由于Kotlin编译出来的字节码需要遵守JVM规范，因此，如果直接使用在Kotlin程序中的变量、函数，kotlinc将会自动生成一个名为“文件名首字母+Kt”的类，并将变量转换为该类的静态getter和setter方法（其中val声明的只有getter方法），函数则转换成该类的静态方法；当时用kotlinc程序编译kotlin程序所在的函数、变量时，这些函数、变量都会转换成该文件对应的静态方法

整型

与java类似，Kotlin也提供了4中整数类型
Byte：Byte型整数在内存中占8位（1个字节）。范围是-128~127.兼容Java中的byte和Byte类型
Short：Short型整数在内存中占16位（2个字节）。范围是-2^(2*8-1)~2(2*8-1)-1，兼容Java中的short和Short类型
Int: Int型整数在内存中占32位（4个字节），范围是-2^(4*8-1)~2(4*8-1)-1，兼容Java中的int和Integer类型
Long：在内存中占用65位（8个字节）。范围是-2^(8*8-1)~2(8*8-1)-1，兼容Java中的long和Long类型
相应的，给整数变量赋值的时候，需要在4中类型的所在范围之内，负责就会报错

fun main(){
    val bigInt: Long = 299999999999999999;
    println("Byte\nmin: ${Byte.MIN_VALUE} \t max: ${Byte.MAX_VALUE}")
    println("Short\nmin: ${Short.MIN_VALUE} \t max: ${Short.MAX_VALUE}")
    println("Int\nmin: ${Int.MIN_VALUE} \t max: ${Int.MAX_VALUE}")
    println("Long\nmin: ${Long.MIN_VALUE} \t max: ${Long.MAX_VALUE}")
}
# Byte
# min: -128 	 max: 127
# Short
# min: -32768 	 max: 32767
# Int
# min: -2147483648 	 max: 2147483647
# Long
# min: -9223372036854775808 	 max: 9223372036854775807

一般来说，默认的整数类型是Int类型
Kotlin的整型与Java不同，Kotlin的整型不是基本类型，而是引用类型（相当于java中的包装类），Byte、Short、Int、Long都是集成了Number类型，因此他们有可调用的方法、访问的属性
Kotlin是null安全的语言，因此Byte、Short、Int、Long型变量都不能接受null值，如果要储存null值，则应该使用Byte?、Short?、Int?、Long?

fun isNull(){
    val a: Int = null  # 错误写法
    val b: Int? = null  # 正确写法
}

由此可见，Kotlin语言允许在已有数据类型后面添加?号，添加?号后的数据类型相当于对原有类型进行扩展，带?的数据类型可支持被赋予null值。
此外，整数类型添加?和不添加?号还有一个区别。普通类型的整数变量将被映射成java基本类型，带有后缀?号的整数变量将会被映射成java的封装包形式
Kotlin的整数数值有3中表示方式。
- 十进制
- 二进制
- 十六进制
- Kotlin不支持八进制

fun scale(){
    // 二进制
    val binValue = 0b0101110
    // 十六进制
    val hexValue = 0xbb35
    println(binValue)
    println(hexValue)
}
# 46
# 47925

浮点数

浮点型数值可以包含小数部分，浮点数比整型的表述范围更大，可以储存比Long型更大或者更小的数值。Kotlin有两种浮点数（Float、Double）
Float：表示32位的浮点数，当精度要求不要时可以使用此类型
Double：表示64位的双精度浮点数，需要储存很大和很精确的浮点数时可以使用
Kotlin中的浮点数有两种表达形式（10进制形式、科学计数法）
- 10进制形式：2.1、6.3
- 科学计数法 5.12e10^2、1.23E103。
- 51200是一个整型，但是表示成5.12E10^4就是浮点数，只有浮点数支持科学计数法
Kotlin在浮点数没有明确指出是那种类型的时候，默认是Double
Kotlin还提供了3中特殊的浮点型数值(Double)：正无穷大、负无穷大、非数
使用一个正数除以0.0将得到正无穷大数值；使用负数除以0.0将得到负无穷大。使用0.0除以0.0将得到非数。切记，是除以0.0才会得到这3这个特殊的浮点型数值。除以0是会报错的哦
正负无穷大是相等的。但是非数是与任何数不相等的，包括自己

fun floatCompare(){
    val a: Double = 5 / 0.0
    val b: Double = -5 / 0.0
    val c: Double = 0.0 / 0.0
    println(a)
    println(b)
    println(c)
}
# Infinity
# -Infinity
# NaN

字符型

字符型通常用于表示单个的字符，字符型值必须使用单引号括起来，Kotlin语言使用16位的Unicode字符集作为编码方式
字符型有3中表达形式（1. 直接使用单个字符来制定；2. 通过转义字符表示特殊字符型值；3. 直接使用Unicode值来进行表示）
与java不同的是，Kotlin的Char型变量不能当做整数值使用。Char型变量或表达式不能复制给整型变量，整型变量或表达式不能赋值给Char型。也就是说Kotlin中的Char型就是一个简单的字符
也就是说，Char不能当做整数来使用，反之一样。但是可以进行显示转换

fun char(){
    val a: Char = 'p'
    val b: Char = '孙'
    val c:Char = '\u9999'
    println(a)
    println(b)
    println(c)
}
# p
# 孙
# 香

数值型之间的类型转换

kotlin是一门强类型语言，kotlin编译器对类型的检验非常的严格，这种严格保证了kotlin程序的健壮性，因此kotlin不同类型之间的值需要经常转换

整数类型的转换

不同整型的变量支持的表数范围是不一样的，如果数值超出变量所支持的表数范围，就会报错
简单来说，kotlin不支持取值范围小的数据类型隐式的转换为范围大的类型；因为整数类型所支持的表数范围不一致，所以需要选择合适的类型进行转换（从小到大，不会造成精度损失。从大到小有可能造成精度损失）
方法
- 转Int ----> toInt()
- 转Byte -----> toByte()
- 转Short ------> toShort()
- 转Long -------> toLong()
- 转Float --------> toFloat()
- 转Double --------> toDouble()
- 转Char --------> toChar()
- Kotlin要求不同类型之间或值必须显示转换

fun dataParse(){
    val byteValue: Byte = 79
    val shortValue: Short = 211
    val intValue: Int = 4561
    val longValue: Long = 556132L
    //转换为Short类型，精度不会损失
    println(byteValue.toShort())
    //转换为Int类型，精度不会损失
    println(shortValue.toInt())
    //转换为Long类型，精度不会损失
    println(intValue.toLong())
    //转换为Byte类型，精度会进行损失
    println(longValue.toByte())
}
# 79
# 211
# 4561
# 100

当从大到小进行转换时，造成精度损失的原因：比如说，long类型转换为Byte类型。Long类型占64个位，而Byte占8位，转换为Byte时，将截取Long中的后8位作为转换后的值（负数在计算机是以补码的形式存在。先将补码转换为反码，再将反码装换为原码即为我们看见的负值。）

kotlin中表达式是可以进行自动转换的

fun expressionParse(){
    val byteValue: Byte = 79
    val shortValue: Short = 211
    val valueK = byteValue.toLong() + shortValue
    println(valueK)
    println("valueK type : ${valueK.javaClass}")
    val valueI: Int = byteValue + shortValue
    println(valueI)
    println("valueI type : ${valueI.javaClass}")
}

Char类型虽然不能党最整数进行运算，但是kotlin中对Char可以进行加减运算
- Char类型和一个整数型进行加减（返回Char类型）
- Char类型互相相减（返回Int类型）。两个Char类型的运算只能减不能加
- 上面两种的运算都是对字符编码的运算

fun charOpration(){
    val a: Char = '5'
    val b: Char = '孫'
    val c: Char = '6'
    println(a + 12)
    println(b + 12)
    println(a - b)
}
# A
# 孷
# -23350

浮点数与整数之间的转换

Kotlin中浮点数之间进行需要显式转换；浮点数与整数之间转换也是显示转换；转换过程和整数之间类似

fun fdParse(){
    val width: Float = 2.3f
    val height: Double = 4.5
    val a: Double = width.toDouble()  // 将a转换为Double类型
    println("a value : $a , type ${a.javaClass}")
    val eare1 = width * height.toFloat()   // 将height转换为Float类型，width也是Float类型。故最后为Float类型
    println("a value : $eare1 , type ${eare1.javaClass}")
    val eara2 = width * height  // 因为表达式中最高的是Double类型，因此转为Double类型
    println("a value : $eara2 , type ${eara2.javaClass}")
    val mulit: Int = 5
    val eara3 = height * mulit  // 因为表达式中最高的是Double类型， 因此转为Double类型
    println("a value : $eara3 , type ${eara3.javaClass}")
    val eara4 = height.toInt() * mulit  // 将height转为整型，两个都是整型。所以表达式最后为整型
    println("a value : $eara4 , type ${eara4.javaClass}")
    println()
}
# a value : 2.299999952316284 , type double
# a value : 10.349999 , type float
# a value : 10.349999785423279 , type double
# a value : 22.5 , type double
# a value : 20 , type int

表达式类型的自动提升

当一个表达式包含多个数值型的值时，表达式的数据类型将会自动进行提升。类似于java
规则：
- 所有的Byte、Short提升到Int
- 整个表达式中的数据类型提升到表达式中等级最高的数据类型

fun expression(){
    val byte: Byte = 12
    val short: Short = 45
    val int: Int = 78
    val long: Long = 963L
    println("${byte + short + int + long}, type ${(byte + short + int + long).javaClass}")
}
# 1098, type long

必须指出，表达式的类型将严格保持和表达式中最高等级操作数相同。即使两个Int除不尽，结果也是Int

fun finallyInt(){
    val a: Int = 23
    val b: Int = 2
    println("${23 / 2}, type ${(23/2).javaClass}")
}
# 11, type int

如果表达式中包含字符串，这个时候使用+号，就不是数值的运算，而是字符串之间的连接

fun stringConnect(){
    val a: String = "zhangsan"
    val b: Int = 23
    val total = a + b
    println("$total , type ${total.javaClass}")
}
# zhangsan23 , type class java.lang.String