Kotlin系列一(快速入门,kotlin的数据类型)
一.快速入门KontlinScript脚本
[*]kontlin可以写脚本
[*]创建一个"script.kts"文件
[*]编写脚本内容
//一个kotlin编写的脚本
println("一个kotlin编写的脚本");
println(2+3);
println(2-3);
[*]使用kotlinc -script script.kts命令运行kotlin脚本
http://tuchuang.anyi.website/imgs/Snipaste_2024-01-06_20-25-07.png
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运行编译后的字节码
http://tuchuang.anyi.website/imgs/Snipaste_2024-01-06_20-32-37.png
二.变量和常量
[*]使用"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;
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 数据类型别名 =数据类型;
typealiasMyInt = Int;
//使用Int类型的别名
val n:MyInt = 12;
println("使用别名定义的变量n=$n 是${n.javaClass}类型");
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
页:
[1]