Kotlin系列一(快速入门,kotlin的数据类型)

2024-01-08 23:54 由杨逸发表于 #后端开发

一.快速入门

KontlinScript脚本

kontlin可以写脚本

创建一个"script.kts"文件

编写脚本内容

//一个kotlin编写的脚本
println("一个kotlin编写的脚本");
println(2+3);
println(2-3);

使用kotlinc -script script.kts命令运行kotlin脚本

Kotlin程序

创建一个文件"HelloWorld.kt"

编写内容

fun main(args:Array<String>){
	//在kotlin1.3版本后可以省略main方法中的参数"args:Array<String>"
	//args:Array<String> --> 参数名:参数类型<泛型>
	println("Hello,World!");
}

使用kotlinc HelloWorld.kt编译kotlin代码
使用kotlin HelloWorldKt运行编译后的字节码

二.变量和常量

使用"var"关键字定义变量,变量定义后值可以改变,且可以在定义时不进行赋值
使用"val"关键字定义常量,常量定义后值不可改变,必须在定义时进行赋值

//定义变量variable,Int类型的变量a
var a:Int = 10;
//定义常量value,Int类型的常量b
val b:Int = 20;

三.Kontlin中的数据类型

整型

Byte:8bit整型,在kotlin中Byte类型是一种特殊的数据类型,不强制转换为其他的数值类型
Short:16bit整型
Int:32bit整型
Long:64bit整形
UByte:8bit无符号整型
UShort:16bit无符号整型
UInt:32bit无符号整型
ULong:64bit无符号整型
- 注意定义Long类型时,数值后缀必须是大写的L,不能是小写的l,也不能没有

        println("kotlin中的整形");

        //8bit的整形
        var a:Byte = 10;
        println("a=$a,8bit整形的最大值${Byte.MAX_VALUE},最小值${Byte.MIN_VALUE}");

        //16bit的整形
        var b:Short = 10;
        println("b=$b,16bit整形的最大值${Short.MAX_VALUE},最小值${Short.MIN_VALUE}");

        //32bit的整形
        var c:Int = 10;
        println("c=$c,32bit整形的最大值${Int.MAX_VALUE},最小值${Int.MIN_VALUE}");

        //64bit的整形,注意定义Long类型时,数值后缀必须是大写的L,不能是小写的l,也不能没有
        var d:Long = 10L;
        println("d=$d,64bit整形的最大值${Long.MAX_VALUE},最小值${Long.MIN_VALUE}");

        //无符号整型,后缀为U
        var e:UInt = 100U;
        println("无符号整型e=$e,最大值${UInt.MAX_VALUE},最小值${UInt.MIN_VALUE}");

        //无符号长整型,后缀为UL
        var f:ULong = 100UL;
        println("无符号长整型h=$f,最大值${ULong.MAX_VALUE},最小值${ULong.MIN_VALUE}");

        //带分割符的数字型
        var g:Int = 100_908_990;
        println("带分割符的数字型$g");

        //二进制数值,前缀为0b
        var h:Int = 0b10101010;
        println("二进制数值$h");

        //十六进制数值,前缀为0x
        var i:Int = 0x10101010;
        println("十六进制数值$i");

浮点型

Float:单精度浮点型
Double:双精度浮点型
科学计数法

println("kotlin中的浮点型");

//Float单精度浮点型,后缀为f或F
var f1:Float = 1.1f;
var f2:Float = 1.1F;
println("单精度浮点型,f1=$f1,f2=$f2,最大值${Float.MAX_VALUE},最小值${Float.MIN_VALUE}");

//Double双精度浮点型,默认没有后缀的浮点数都是双精度浮点型
var d1:Double = 1.12;
var d2:Double = 1.1;
println("双精度浮点型,d1=$d1,d2=$d2,最大值${Double.MAX_VALUE},最小值${Double.MIN_VALUE}");

//科学计数法,后缀使用e或E,数据类型为Double
//112.0
var e1:Double = 1.12e2;
//113.0
var e2:Double = 1.13E2;
println("科学计数法,e1=$e1,e2=$e2");

字符和字符串

单引号括起来的单个字符,使用Char类型
使用双引号号括起来的字符串,使用String类型
模板字符串,可以在字符串中使用变量,完整写法是${变量名或表达式},如何大括号中的是变量则可以写成$变量名
- 注意在模板字符串中无法直接输出 $ 字符,需要使用${'$'}进行转义
使用三个双引号括起来的字符串,格式化的字符串,可以保持原有格式
字符串的拼接
- 在kotlin中 + 的左边是字符串,则 + 视为字符串拼接
- 如果 + 左边是数字,则视为加法运行
遍历字符串
根据索引获取字符串中的字符
字符串的截取
字符串的替换

        println("kotlin中的字符型");

        //1.单引号括起来的单个字符,使用Char类型
        var a:Char = 'a';
        println("字符型a=$a,a的ASCII码值${a.toInt()}");

        //2.使用双引号号括起来的字符串,使用String类型
        var b:String = "abc";
        println("字符串型b=$b");

        //3.模板字符串,可以在字符串中使用变量,完整写法是${变量名或表达式},如何大括号中的是变量则可以写成$变量名
        //注意在模板字符串中无法直接输出 $ 字符,需要使用${'$'}进行转义
        var c:String = "abc${b}";
        println("模板字符串,完整写法c=${c},简写c=$c,\n在模板字符串中使用${'$'}字符");

        //4.使用三个双引号括起来的字符串,格式化的字符串,可以保持原有格式
        var d:String = """
            第一行
            第二行
            第三行
            ${b}
        """;
        println("格式化的字符串型d=$d");

        //5.字符串的拼接
        var e:String = "abc" + "def";
        //注意,在kotlin中 + 的左边是字符串,则 + 视为字符串拼接;如果 + 左边是数字,则视为加法运行
        //合法的字符串拼接
        var f:String = "abc" + 123;
        //非法的字符串拼接
//        var g:String = 123 + "abc";
        println("字符串的拼接e=$e");

        //6.遍历字符串
        var count = 0;
        for(c:Char in b){
            println("遍历字符串$b,第${++count}个字符=$c")
        }

        //7.根据索引获取字符串中的字符
        var index = 1;
        var h:Char = b[index];
        println("字符串b中索引${index}的字符h=$h");

        //8.字符串的截取
        var i:String = "截取字符串";
        println("截取字符串i=$i,一个参数表示从指定索引截取到最后=${i.substring(2)},两个参数表示从指定索引截取到指定索引=${i.substring(2,4)}");


        //9.字符串的替换
        var j:String = "我在学Java";
        println("字符串j=$j,字符串的替换=${j.replace("Java","Kotlin")}");

        //10.字符串不可变,使用StringBuilder或StringBuffer拼接字符串,StringBuilder是线程不安全的,StringBuffer是线程安全的
        //常规写法
        var k:String = StringBuilder().append("我").append("在").append("学").append("Java").toString();
        //Lambda表达式写法,函数式编程
        var l:String = buildString {
            append("我");
            append("在");
            append("学");
            append("Kotlin");
            toString();
        };
        println("字符串k=$k,字符串l=$l");

布尔类型

在kotlin中使用Boolean表示布尔类型
kotlin为了类型安全,Boolean类型只有两种值,"true或者false"
不支持使用数字非0时表示true,不支持对象存在表示true
不支持使用数字0表示false,不支持对象不存在表示false

println("kotlin中的布尔类型");
var a:Boolean = true;
var b:Boolean = false;
//不支持下面两种写法,也不支持对象存在时表示true和对象不存在时表示false,Boolean只有两种值,true和false
//var c:Boolean = 1;
//var d:Boolean = 0;
println("布尔值a=$a,布尔值b=$b");

"可空类型"和"不可空类型"

不可空类型,默认定义变量是不可空类型的变量
- 可空类型不能为null,否则编译报错
可空类型,定义变量时在数据类型后面加 ? 字符表示可空类型
- 可空类型可以赋值为null
- 可控类型变量只能赋值给可空类型变量
安全操作符,在kotlin中使用可空类型时,必须使用安全操作符 ? ,使用变量时在变量后加上 ? 字符
- 安全操作符 ? 表示如果变量不为null,则执行 ? 后面的操作,如果变量为null,则不执行 ? 后面的操作
- 可空类型变量操作的返回值也是可空类型
强制调用操作符,在kotlin中希望强制调用一个可空类型的变量,可以使用 !! 操作符,在变量后面加上两个感叹号
- !! 强制操作符表示如果变量不为null,则执行 !! 后面的操作,如果变量为null,则抛出NullPointerException空指针异常
- "!!"操作符底层是调用Java的非空断言,如果为空就会抛出空指针异常,如果断言通过程序就会正常继续执行
- 使用强制调用操作符 !! 返回的是不可空的类型

        println("Kotlin中的空类型");
        //1.不可空类型,默认定义变量是不可空类型的变量
        //1.1不可空类型不能为null,否则编译报错
        var a:String = "不可空类型";

        //2.可空类型,定义变量时在数据类型后面加 ? 字符表示可空类型
        //2.1可空类型可以赋值为null
        //2.2可控类型变量只能赋值给可空类型变量
        var b:String? = null;
        println("不可空类型a=$a,可空类型b=$b");

        //3.安全操作符,在kotlin中使用可空类型时,必须使用安全操作符 ? ,使用变量时在变量后加上 ? 字符
        //3.1安全操作符 ? 表示如果变量不为null,则执行 ? 后面的操作,如果变量为null,则不执行 ? 后面的操作
        //可空类型变量操作的返回值也是可空类型,此时的变量 len 也是可空类型
        var len = b?.length;
        println("可空类型b的长度=$len");

        //4.强制调用操作符,在kotlin中希望强制调用一个可空类型的变量,可以使用 !! 操作符
        //4.1 !! 操作符表示如果变量不为null,则执行 !! 后面的操作,如果变量为null,则抛出NullPointerException空指针异常
        //4.使用强制调用操作符 !! 返回的是不可空的类型
        try{
        var len2 = b!!.length;
        println("可空类型b的长度=$len2");
        }catch (e:NullPointerException){
            println("空指针异常");
            e.printStackTrace();
        }

内置类型结构

Any类型

所有类的父类
kotlin定义的所有类都是Any类的子类
Any类的结构

public open class Any {

    public open operator fun equals(other: Any?): Boolean

    public open fun hashCode(): Int

    public open fun toString(): String
}

Nothing类型

所有类的子类
kotlin定义的所有类都是Nothing类的父类
Nothing类的结构

public class Nothing private constructor()

Unit类型

返回类型,等价于Java中的void
表示什么也不返回
Unit类的结构

public object Unit {
    override fun toString() = "kotlin.Unit"
}

类型转换和类型判断

数值类型转换

kotlin中每个数值类型都内置了以下十三种方法

方法定义	方法作用
toByte():Byte	将数值转换为Byte类型
toShort():Short	将数值转换为Short类型
toInt():Int	将数值转换为Int类型
toLong():Long	将数值转换为Long类型
toUByte():UByte	将数值转换为UByte类型
toUShort():UShort	将数值转换为UShort类型
toUInt():UInt	将数值转换为UInt类型
toULong():ULong	将数值转换为ULong类型
toFolat():Float	将数值转换为Float类型
toDouble():Double	将数值转换为Double类型
toBigInteger():BigInteger	将数值转换为BigInteger类型
toBigDecimal():BigDecimal	将数值转换为BigDecimal类型
toString(radix:Int):String	将数值转换为指定进制的字符串,没有传参默认为十进制

 //1.数值类型间的转换
        var number = 123;
        println("""
            toByte()=${number.toByte()}
            toShort()=${number.toShort()}
            toInt()=${number.toInt()}
            toLong()=${number.toLong()}
            toUByte()=${number.toUByte()}
            toUShort()=${number.toUShort()}
            toUInt()=${number.toUInt()}
            toULong()=${number.toULong()}
            toFloat()=${number.toFloat()}
            toDouble()=${number.toDouble()}
            toBigDecimal()=${number.toBigDecimal()}
            toBigInteger()=${number.toBigInteger()}
            """.trimIndent());

类型转换

自动类型转换(隐式类型转换)

在kotlin中只支持字面量的自动类型转换,不支持变量的自动类型转换

//2.自动类型转换,123可以自动转换为Short类型,但Short类型的变量a不能自动转换为Int类型
var a:Short = 123;
//var b:Int = a;

强制类型转换(显示类型转换)

在kotlin中使用"as"关键字进行强制类型转换

//3.强制类型转换,使用 as 关键字将变量a转换为Number类型
var b:Number = a as Number;
println("a=$a-${a.javaClass},b=$b-${b.javaClass}");

安全类型转换

对变量进行类型转换时,可能会出现TypeMismatch类型不匹配异常,为了避免出现该异常可以使用安全类型转换
当对可空变量进行类型转换时需要使用 as? 安全操作符进行安全类型转换

//4.安全类型转换,在数据类型的后面使用 as? 安全操作符
var c:String = "进行安全类型转换";
var d:Int? = c as? Int;
println("c=$c-${c.javaClass},d=$d-${d?.javaClass}");

类型提升

在kotlin中没有Java中的向上转型,但存在类似的操作,在kotlin叫类型提升
- 例如:一个Short类型的变量与一个Int类型的变量进行运算时,会自动将Short类型的变量转为Int类,最后运算的结果也是Int类型
- 一个Int类型的变量与一个Double类型的变量运算时,会自动将Int类型的变量转为Double类,最后运算的结果也是Double类型

//5.类型提升,两个数值类型进行运算时,数值范围小的会自动提升为数值范围大的类型
var number1:Byte = 123;
var number2:Double = 19.22;
var result = number1 + number2;
println("result=$result-数据类型${result.javaClass}");

类型判断

在kotlin中使用"is"关键字判断一个变量是否为指定的数据类型

//6.类型判断
val num = 100;
if(num is Number){
println("$num 是Number类型");
}

智能转换

例如

 fun temp1(param:Any):Unit{
        if (param is String){
            //这里如果是String类型,会自动将param转换为String类型
            println("在if代码块中,param参数的数据类型=${param.javaClass},调用String类的方法=${param.toUpperCase()}");
        }
    }

类型别名

在kotlin中可以使用"typealias"关键字给一个数据类型起别名
需要在全局作用域使用该关键字,起别名后原先的名字也可以使用

//7.给数据类型起别名使用typealias关键字,需要在全局作用域使用该关键字,起别名后原先的名字也可以使用
//typealias 数据类型别名 =  数据类型;
typealias  MyInt = Int;
//使用Int类型的别名
val n:MyInt = 12;
println("使用别名定义的变量n=$n 是${n.javaClass}类型");