一.快速入门
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}类型");
