Kotlin 是一门在 Java 虚拟机上运行的静态类型编程语言,由 JetBrains 设计开发并开源,被称为 Android 世界的 Swift。它简洁、安全,可与 Java 及其他语言互操作,并支持在多个平台间复用代码。
其核心思想是**以更简洁、更安全的语法在完全兼容 Java 生态的前提下提升开发效率**,并于 Google I/O 2017 中被宣布为 Android 官方开发语言。
1. 概述
Kotlin 是一门运行在 JVM 上、由 JetBrains 设计开源的静态类型语言,被称为 Android 世界的 Swift。它以更简洁、更安全的语法在完全兼容 Java 生态的前提下提升开发效率,并于 Google I/O 2017 成为 Android 官方开发语言。相比传统 Java 样板代码冗长、空指针风险高的问题,Kotlin 通过空安全、类型推断与函数式特性显著降低出错概率并提升编码效率。
2. 内置数据类型
1.1 基本类型
| 类型 | 说明 |
|---|---|
| String | 字符串 |
| Char | 字符 |
| Boolean | 布尔 |
| Int | 整型 |
| Double | 浮点数 |
| List | 集合 |
| Set | 无重复的元素集合 |
| Map | 键值对的集合 |
fun main{
var name:string = "Array"
}
fun main{
var name:string = "Array"
}
const val PI = 3.1415
fun main{
var name:string = "Array"
}
1.2 数字类型
| 类型 | 说明 |
|---|---|
| Byte | 字节型 |
| Short | 短整型 |
| Int | 整型 |
| Long | 长整型,可用 _ 分隔计数,如 100_000_000 |
| UByte / UShort / UInt / ULong | 无符号类型,在数字后加 u 或 U,长整型类似(如 123UL) |
| Float | 单精度浮点,需加 f 或 F |
| Double | 双精度浮点,默认类型 |
var n1:Long =10L
var n2:Long =100_000_000
var n3:UInt = 123u
var n4:UInt = 123U
var n5:ULong = 123UL
var m1:Float = 1.12F
var m2:Double = 1.12
var m3:Float = 1.12f
1.3 Boolean 类型
0、false、null为假,其他为真。- 逻辑运算:
&&、||、!。
1.4 字符类型
- 使用
.code获取 ASCII 码。 \u转义为字符(Unicode 编码)。
val c1:Char = 'a'
println(c1.code)
val c2:Char ='\u2C77'
println(c2)
1.5 字符串
- 用三引号
"""包裹字符串 -> 原始字符串。 .trimIndent()去掉缩进空格。$变量名用于格式化字符串。
val s2:String = """
aha
sjs
dld
kjl
""".trimIndent()
println(s2)
val s3:String = "$PI1 圆"
println(s3)
val s3:String = "${PI1} 圆" //可以用{}此时后面不用再加空格,{}里面也可以写表达式
1.6 运算符
| 运算 | 说明 |
|---|---|
and |
与 |
or |
或 |
xor |
异或 |
shl |
左移位 |
shr |
右移位 |
ushr |
无符号右移位 |
3. 条件语句
2.1 when(类似 switch)
when (c) {
1 -> {
println("1")
}
2 -> {
println("2")
}
3 -> {
println("3")
}
else -> {
println("0")
}
}
2.2 for 循环
区间运算符 ..:20..100 相当于 20 <= a <= 100。
val Range1 = 5..10
val Range2 = 5..10
for (i in Range1 step 2){//一次+2
println(i)
}
for (i in 10 DownTo 1){//从10到1
println(i)
}
4. 函数
- 函数可以嵌套:在函数内部声明的函数只能在函数内部调用,并且可以使用嵌套该函数的函数体内的变量。
fun main(){
outer()
}
fun outer(){
val value = 10
fun inner(){
println(value)
}
inner()
}
3.1 形参类型与返回值
message:String指定形参类型。():Unit指定返回值类型,Unit相当于void(即无返回值,可省略不写)。
fun test(message:String):Unit{
println(message)
}
3.2 默认参数
fun test1(a:Int=3,b:Int=6):Int{
return a+b
}
//如果要指定第二个参数
test1(b=9)
3.3 简洁写法
返回值为 a+b:
fun test2(a:Int,b:Int) = a+b
引用函数
fun main(){
val test2 = ::test1
test2()
}
fun test1(){
println("hahha")
}
5. 变量作用域
4.1 get / set
var v:Int = 10
get() = field * 100
set(value) {
println("赋值")
field = 12
}
fun main(){
println(v)
}
4.2 常用库函数
var value1 = readln()相当于 Java 的Scanner。
//n次方
println(2.0.pow(4))
//绝对值
println(abs(value2))
//最小值
println(min(10,20))
//最大值
println(max(10,20))
//求根
println(sqrt(9.0))
//e
println(Math.E)
//pai
println(Math.PI)
println(sin(0.5*Math.PI))
println(cos(0.5*Math.PI))
println(tan(Math.PI))
println(asin(1.0));
println(acos(1.0));
println(atan(1.0));
6. 函数类型变量
5.1 ()-> 函数类型
() 括号里为参数类型,-> 后为返回值类型。
fun main(){
val fun1:(Int)->String = outer("Hello")
val name = fun1(10)
println(name)
}
fun outer(name:String):(Int)->String{
//匿名函数
return fun(number:Int):String{
return number.toString()+"个"+name
}
}
可以嵌套使用:
fun fu1(n1:Int,n2:Int):((String)->String,String) -> String{
}
5.2 Lambda 表达式
//it代指第一个参数
val func1:(String)->Int = {
println(it)
10 //返回的值s
}
var func:(String,String)->Int = { a,b ->
println(a)
println(b)
10
}
println(func("1","2"))
尾随 lambda:
fun main(){
test{
println(it)
10
}
}
fun test(func:(String)->Int){
println(func("Hello"))
}
小实验:
val v1 = fu1(10,20)
val f1 = v1("Hello"){
"1"
}
println(f1)
fun fu1(n1:Int,n2:Int):(String,(String)->String) -> String{
println(n1+n2)
return fun(s2:String, fun2:(String)->String):String{
return fun2("1234")+s2
}
}
val fun2:(Int) -> Int = mytest@{
if (it >10 ) return@mytest 10
20
}
5.3 内联函数
声明内联函数:
inline fun mytest() = {
println("1")
}
fun main(){
mytest {
return //内联高级函数的lamda参数可以直接写return不指定标签
}
println("Hi")
}
inline fun mytest(func: (String) -> Int):Unit{
println("1")
func("2")
}
- 在不需要内联的函数形参上添加
noinline关键字,可以防止函数调用内联。 - 标签可以指定为外部的函数名称。
7. 类和对象
6.1 类的创建
var可改,val不可改。
class Student constructor(var name:String,val age:Int){
}
如果在类中定义,要赋值:
class Student {
var name:String = "Jack"
var age:Int = 18
}
class Student(name:String,age:Int) {
var name:String = name
var age:Int = age
}
懒加载,在使用之前必须初始化:
class Teacher{
lateinit var name: String
lateinit var age:Integer
}
6.2 对象的创建
val s1 = Student("Jerry",44);
println(s1.age)
println(s1.name)
s1.name = "Tom"
println(s1.name)
constructor:当类有主构造函数时,其他次要构造函数都要调用主构造函数;主构造函数可以省略constructor不写。
//主构造函数
class Student1(var name:String,var age:Int){
//次要构造函数
constructor(name:String):this(name,90)
}
class Student1{
constructor(name:String)
}
6.3 对象的初始化
- 在创建对象时会执行
init里的代码。 - 可以写多个
init,相当于主构造函数的函数体。
class Teacher1(var name:String,var age:Int){
init {
println("创建成功")
}
}
6.4 基本数据类型常用方法
val v1:String = "10"
println(v1.toInt())
val v2:String = "samll"
println(v2.uppercase())
val v3:String = "BIG"
println(v3.lowercase())
val v4:String = "how are you"
println(v4.replace('o','m'))
//获取长度(字符串)
println(v4.length)
6.5 运算符重载
重载二元运算符 +:
class Student constructor(var name:String,var age:Int){
operator fun plus(another:Student):Student{
return Student(this.name+another.name,another.age+this.age)
}
}
重载一元运算符 !:
operator fun not():Student{
return Student(this.name.reversed(),this.age)
}
| 表达式 | 对应方法 |
|---|---|
+a |
a.unaryPlus() |
-a |
a.unaryMinus() |
!a |
a.not() |
a-- |
a.dec() |
a++ |
a.inc() |
operator fun inc():Student{
return Student(name,age++)
}
operator fun dec():Student{
return Student("name",age++)
}
| 表达式 | 对应方法 |
|---|---|
a+=b |
a.plusAssign(b) |
a-=b |
a.minusAssign(b) |
a*=b |
a.timesAssign(b) |
a/=b |
a.divAssign(b) |
a%=b |
a.remAssign(b) |
| 表达式 | 对应方法 |
|---|---|
a>b |
a.compareTo(b) > 0 |
a<b |
a.compareTo(b) <= 0 |
a>=b |
a.compareTo(b) > 0 |
a<=b |
a.compareTo(b) <= 0 |
()对应invoke。
6.6 中缀函数
println(10 shl 2)左移位。- 调用可以省略点和括号。
- 要求:
- 必须是成员函数。
- 只能有一个参数。
- 参数不能有默认值。
class Student constructor(var name:String,var age:Int){
operator fun plus(another:Student):Student{
return Student(this.name+another.name,another.age+this.age)
}
operator fun not():Student{
return Student(this.name.reversed(),this.age)
}
operator fun inc():Student{
return Student(name,age++)
}
operator fun dec():Student{
return Student("name",age++)
}
infix fun test(string:String):String{
return name+string
}
}
package demo2
fun main(){
val stu = Student("zs",11)
println(stu test "hahaha")
//也可以当成普通函数调用
println(stu.test("hahaha"))
}
6.7 空值和空类型
- 直接给一个变量赋值
null,Kotlin 在编译阶段就会报错。
// val ss:String = null ---> XXXX
- 加上
?表明这是一个可空的类型。
val ss:String ?= null
- 加上
!!强制调用。
ss!!.getdata()
- 安全访问方法。
ss?.getdata()
val s:Student? = null
val a = s?.getdata() ?: "hahah"
println(a)
6.8 解构
component1即为第一个解构的参数。- 解构
()里的变量名可随意取。
class Car(var name:String,var price:Int) {
operator fun component1() = name
operator fun component2() = price
}
fun main(){
val car:Car = Car("ll",1000)
val (a,b) = car
println(a)
println(b)
//如果不需要第一个解构的值
val (_,b) = car
}
应用:在 lambda 表达式中使用。
val func1:(Car)->String = { (a,b) ->
a+b.toString()
}
println(func1(car))
8. 类与继承
7.1 权限声明
| 修饰符 | 说明 |
|---|---|
public |
公开 |
private |
私有 |
protected |
受保护 |
internal |
只能在当前项目内访问,当别人引用我们的项目时,不能使用 |
7.2 类的继承
- 声明继承;被继承的类要声明
open。
public open class Car(internal var name:String, public var price:Int) {
operator fun component1() = name
operator fun component2() = price
}
public class SuperCar:Car("1",1000){
}
public open class Car(internal var name:String, public var price:Int) {
operator fun component1() = name
operator fun component2() = price
}
public class SportCar(name:String,price: Int):Car("1",1000){
}
当子类未声明主构造函数:
public open class Car(internal var name:String, public var price:Int) {
operator fun component1() = name
operator fun component2() = price
}
public class SportCar:Car{
constructor(name:String,price: Int):super("1",1000)
}
7.3 方法的重写(覆盖)
可以通过 super 关键字调用父类的方法:
public open class Car(internal var name:String, public var price:Int) {
operator fun component1() = name
operator fun component2() = price
open fun run(data:String){
println(data+"1")
}
}
public class SuperCar:Car("1",1000){
override fun run(data: String) {
super.run(data)
}
}
重写成员变量:
public open class Car() {
open var name:String = "zs"
}
public class sportcar: Car(){
override var name: String = "ls"
}
7.4 顶层 Any 类
- 相当于 Java 的
Object。 ===判断是否是同一个引用对象。
7.5 抽象类
abstract class annimal{
abstract var name:String
abstract fun say()
}
class cat(override var name: String) :annimal(){
override fun say() {
println("miao")
}
}
abstract class annimal{
abstract var name:String
abstract fun say()
}
class cat :annimal(){
override var name:String = "cat"
override fun say() {
println("miao")
}
}
7.6 接口
- 接口的所有成员变量和类方法都是抽象的,因此可以省略
abstract不写。
interface A{
val name:String
fun run1():String
}
interface B{
val age:Int
fun run2():String
}
class stu() :A,B{
override val age: Int = 16
override val name: String ="NAME"
override fun run1(): String {
return "1"
}
override fun run2(): String {
return "2"
}
}
接口也可以实现默认方法:
interface A{
val name:String
fun run1():String
}
interface B{
val age:Int
fun run2():String = "AGE"
}
class stu() :A,B{
override val age: Int = 16
override val name: String ="NAME"
override fun run1(): String {
return "1"
}
override fun run2(): String {
return "2"
}
}
如果继承的两个接口有重复函数,可以使用 <> 消除歧义:
interface A{
fun run():String = "NAME"
}
interface B{
fun run():String = "AGE"
}
class stu() :A,B{
override fun run(): String = super<A>.run();
override fun run(): String = super<B>.run();
}
7.7 类的扩展
class animal{
fun test(){
println("HAHAHA")
}
}
fun animal.test() = println("HELLO")
fun main(){
animal().test()
}
- 添加属性,此时
field无法使用;类的扩展会受到访问权限的影响。
var animal.NAME: String
get() = ""
set(value){
println("SET")
}
- 在扩展的函数中可以直接使用类的成员变量,可以不使用
this关键字。
class animal{
val name:String = "JKL"
}
fun animal.test() = {
println(name)
}
指定调用的函数:
class A{
fun hello(){
println("Hello")
}
}
class B(private val a:A){
fun A.test(){
hello()
this.hello()
this@B.hello()
}
fun hello(){
println("HELLO")
}
}
将一个扩展函数作为参数传递到一个函数类型变量,在具体操作前要增加类型名称:
fun main(){
val func:String.() -> Int = {
this.length
}
println("hahahahhaha".func())
println(func("hello"))
}
9. 泛型
8.1 泛型
可以直接接收数值,自动转换类型:
class Score<T>(var name:T){
}
fun main(){
val stu = Score("123")
}
8.2 官方高阶扩展函数
apply:传入一个 lambda 表达式,即我们要如何操作这个对象。let:执行一个 lambda 表达式并将得到的结果作为返回值。also:与apply类似。run:与let类似。
fun main(){
val a:Any = Any()
a.apply { }
}
8.3 协变和逆变
class Num<T>(var name:T)
fun main(){
val v1:Num<Int> = Num<Int>(1)
val v2:Num<Number> = v1 //报错
}
| 概念 | 说明 |
|---|---|
| 协变 | 父类接收子类 |
| 逆变 | 子类接收父类 |
| 不变 | 类型不相关,Test<Int> 与 Test<Number> 无关 |
- 使用
out开启协变,使用in开启逆变。
//协变
class Num<T>(var name:T)
fun main(){
val v1:Num<Int> = Num<Int>(1)
val v2:Num<out Number> = v1
}
//逆变
class Num<T>(var name:T)
fun main(){
val v1:Num<Any> = Num<Any>(1)
val v2:Num<in Number> = v1
}
可以使用 * 来代指任意类型。
8.4 泛型的界限
限制泛型的类型:
//限制上界为Number
class Num<T : Number>(var name:T)
fun main(){
val v1:Num<Int> = Num<Int>(1)
val v2:Num<out Number> = v1
}
class Num<T>(var name:T)
where T:C,T:D
open class C
open class D
也可以直接在类或接口的参数中声明:
interface Test<out T>{
fun test():T
}
8.5 类型擦除
- 内联函数的类型擦除与普通函数不同。
reified通过该关键字具化类型。
inline fun <reified T> test(value:Any):Boolean{
return value is T
}
fun main(){
val result = test<String>("1")
println(result)
}
10. 数组
9.1 定义和遍历数组
fun main(){
val array:Array<Int> = arrayOf(1,2,3,4,6,5)
for (element in array){
println(element)
}
}
- 获取长度:
array.size。 - 数组在创建完成后,数组容量和元素类型是固定不变的,后续无法修改。
fun main(){
val array:Array<Int> = arrayOf(1,2,3,4,6,5)
//遍历下标和元素
for ((index,element) in array.withIndex()){
println(array[index])
println(index)
println(element)
}
}
数组的创建和使用:
array.forEach { println(it) }
//第一个参数为间隔符,第二个参数为开始字符串,第三个为结束字符串
println(array.joinToString(",","[","]"))
//创造一个长度为5,值都为123的字符串数组
val array:Array<String> = Array(5){"1234"}
9.2 数组的操作
==号判断内容是否相同。
val array1:Array<String> = Array(5){"1234"}
val array2:Array<String> = Array(5){"1234"}
println(array1.contentEquals(array2)) //=>true
拷贝数组:可以指定参数(拷贝的数量),如果数量大于数组大小会用空填充。
//执行拷贝
var array3:Array<String> = array2.copyOf()
//指定拷贝范围
var array4:Array<String> = array2.copyOfRange(2,3)
分割数组:
var array5:Array<String> = array2.sliceArray(1..3)
- 数组可以用加号进行合并。
- 判断指定元素在不在数组。
array2.contains("1234")
"1234" in array2
快速查找元素在哪一位置
array2.indexOf("1234")
reversedArray()反转数组;sort()排序,sortDesc()倒排序。- 可以重写一个类的
compareTo方法指定排序规则。
class B():Comparable<B>{
override fun compareTo(other: B): Int {
return B.age - A.age
}
}
vararg可以接收任意个同类型的参数。
9.3 基本数组类型
| Kotlin 类型 | 对应 Java 类型 |
|---|---|
| ByteArray | byte[] |
| CharArray | char[] |
| ShortArray | short[] |
| IntArray | int[] |
| LongArray | long[] |
| DoubleArray | double[] |
| FloatArray | float[] |
| BooleanArray | boolean[] |
9.4 List
- 可变的列表,可以插入和删除。
fun main(){
val list:MutableList<String> = mutableListOf("1","2","3");
list.add("4")
list.add(1,"5")
list.remove("1")
list.removeAt(1)
println(list)
}
- 不可变的列表,无法插入删除。
val list1:List<Int> = listOf(1,2,3)
- 可以用
{}进行初始化赋值;使用for in进行遍历。
val list2:List<Int> = List<Int>(3){10}
for (ele in list2){
println(ele)
}
9.5 Set
- 没有重复元素,可用于去重;不能在指定位置插入。
var set:MutableSet<Int> = mutableSetOf(1,2,3)
//简单的获取元素
println(set.elementAt(0))
集合的运算:
//并集
println(set1 union set2)
println(set1 + set2)
//交集
println(set1 intersect set2)
//差集
println(set1 - set2)
println(set1 subtract set2)
不同类型的 Set:
val set1:SortedSet<Int> = sortedSetOf(9,5,3,19) //自动排序
println(set1)
val set2:HashSet<Int> = hashSetOf(1,2,3) // 无序且不重复
println(set2)
9.6 Map
Pair:
val pair:Pair<Int,String> = 10001 to "zs"
- 创建 Map;
map[键]获取值。
val map:MutableMap<Int,String> = mutableMapOf(
1001 to "zs",
1002 to "ls"
)
//获取所有的键
println(map.keys)
//获取所有的值
println(map.values)
遍历(for in / for each):
map.forEach{(k,v) -> println(k.toString()+v) }
- 可以直接
+=添加新键值对。 - 键不能重复,否则数据会被覆盖。
map.put()
map.putAll()
9.7 迭代器
val iterator:Iterator<String> = array1.iterator()
println(iterator.next())
println(iterator.next())
println(iterator.next())
println(iterator.next())
遍历数组:
val iterator:Iterator<String> = array1.iterator()
while(iterator.hasNext()){
println(iterator.next())
}
ListIterator可以实现双向遍历。MutableIterable迭代器可以在遍历的时候进行删除。
9.8 数组的扩展操作
map类似于 JS 的 map,对每一个元素进行操作并且返回一个值。
val list:MutableList<String> = mutableListOf("AAA","BB","DDD")
val list2 : MutableList<Int> = list.map { it.length }.toMutableList()
println(list2.joinToString())
遍历 Map:
val map:Map<String,Int> = mapOf(
"AAA" to 1,
"BB" to 2,
"CCCC" to 3
)
val map1: Map<Int, Int> = map.mapKeys { it.key.length }
val map2 : Map<String,String> = map.mapValues { it.value.toString() }
zip/unzip:
val zipmap: List<Pair<String, Int>> = list1.zip(list2)
println(zipmap)
val pair:Pair<List<String>, List<Int>> = zipmap.unzip()
println(pair)
associate将列表映射为一个 map 集合:
val associates : Map<String,Int> = list1.associate { it to it.length }
println(associates)
- 扁平化处理多维数组:
val array= Array(10, {Array(10){0}})
val list = List(10,{List(10){0} })
//展平
println(array.flatten())
array.flatMap { }在遍历的同时映射。filter过滤操作:
list1.filter { it >= 10 }
//过滤不为空的元素
list1.filterNotNull()
11. 序列
- 在使用时才会执行其中的语句。
val sequence:Sequence<Int> = generateSequence {
println("构造")
10 //返回值
}
println(sequence.iterator().next())
普通的 list,在执行操作时就会调用函数:
val list:List<String> = mutableListOf("AAA","BB","CCC","dd","EEE","FF")
val result = list.filter {
println("执行1")
it.length > 2
}.map {
println("执行2")
it.lowercase()
}.take(2)
println(result)
优化:在调用使用时才会执行内部,数据量庞大时推荐使用:
val list:List<String> = mutableListOf("AAA","BB","CCC","dd","EEE","FF")
val result = list.asSequence().filter {
println("执行1")
it.length > 2
}.map {
println("执行2")
it.lowercase()
}.take(2)
println(result.joinToString())
12. 特殊的类型
11.1 数据类型
本质是 class
data class Data(val name:String,val age:Int){
}
加上 data 关键字后,自动生成:
.equals()/.hashCode().toString().componentN().copy()方法数据类不能是抽象类。
主构造函数必须有一个参数。
主构造函数变量必须是
var或者val。
11.2 枚举类型
- 加上
enum关键字。 - 枚举类可以重写内部的抽象函数,当继承了一个接口时,可以在每个枚举类中重写,或者在定义枚举类的类中重写。
fun main(){
println(Status.ERR.code)
}
enum class Status(var code:String){
ERR("0"),SUCC("1"),COMP("2")
}
可以定义成员函数:
fun main(){
val status = Status.ERR
println(status.code)
println(status.isERR())
}
enum class Status(var code:String){
ERR("0"),SUCC("1"),COMP("2"); //使用;进行分隔
fun isERR() = this == ERR
}
定义成员变量
fun main(){
println(status.state)
}
enum class Status(var code:String){
ERR("0"),SUCC("1"),COMP("2");
val state:Int = 10
}
使用 when:
val message:String = when(status){
Status.ERR -> "错误"
Status.SUCC -> "成功"
Status.COMP -> "运行"
}
println(message)
entries获取整个枚举类:
val statuslist = Status.entries
println(statuslist.joinToString())
13. 匿名类
12.1 匿名类
- 使用
object关键字声明匿名类,并且可以用变量接收。
fun main(){
val stu = object {
fun test():String{
return "123"
}
}
val message = stu.test()
println(message)
}
如果接口只有一个函数,可以采用简洁写法实现匿名类:
fun interface Krunnerable{
fun test()
}
fun main(){
val stu = object {
fun test():String{
return "123"
}
}
val message = stu.test()
println(message)
val runnerable = Krunnerable{
println("1234")
}
}
单例对象:
object Run{ // 通过 object 关键字
val name:String = "name"
override fun toString(): String {
return super.toString()
}
}
fun main(){
val run = Run //单例对象直接使用类型得到实例化对象
println(run.toString()) //可以直接使用内部的方法
}
12.2 伴生对象
- 使用
companion关键字。
class Animal(val name:String){
//使用 companion 关键字定义伴生对象
companion object Cat{
val age:Int = 90
fun test(){
println("test")
}
}
}
fun main() {
//可以直接使用外面的类名访问内部的方法
Animal.test()
}
14. 委托模式
- 使用
by关键字。
//定义接口
interface Base{
fun test()
}
//接口实现
class BaseImpl():Base{
override fun test() {
println("test")
}
}
//委托代理
class Work(val base:BaseImpl) : Base by base //实现Base接口,但是让base帮忙重写
fun main() {
//可以直接使用外面的类名访问内部的方法
val work = Work(BaseImpl())
work.test()
}
使用预设代理 lazy 在调用时赋值:
class Exe(){
val per:String by lazy { "geren" }
}
fun main() {
val message:String = Exe().per
println(message)
}
属性可以委托(属性代理):
class Exe1(val name:String){
val per:String by ::name
}
设置观察者:
//设置观察者
class Exe2(val name:String){
val per:String by Delegates.observable("初始值"){
prop,new,old -> println("属性值为${prop},新值为${new},旧值为${old}")
}
}
15. 密封对象
sealed class A。- 不能在外部继承使用以及实例化(模块内部)。
- 密封类是可以被继承的,密封类的子类也可以是密封类。
16. 异常机制
15.1 异常的定义
Exception in thread "main" java.lang.ArithmeticException: / by zero
at demo1.Test5Kt.div(test5.kt:47)
at demo1.Test5Kt.main(test5.kt:42)
at demo1.Test5Kt.main(test5.kt)
自定义 Exception:
class myException(override val message: String?):Exception(message)
private fun div(x:Int, y:Int):Int{
if (y==0) throw myException("div by zero")
return x / y
}
15.2 捕获异常
val array:MutableList<Int> = mutableListOf(1,2,9)
try{
println(array[3])
}catch (e:IndexOutOfBoundsException){
e.printStackTrace()
}
println("after")
多个 catch:
val array:MutableList<Int> = mutableListOf(1,2,9)
try{
println(array[3])
}catch (e:IndexOutOfBoundsException){
e.printStackTrace()
}catch (e:Exception){
e.printStackTrace()
}
一句话总结:Kotlin 是一门在 JVM 上运行、与 Java 完全互操作且具备空安全与函数式特性的现代静态语言,自 Google I/O 2017 起成为 Android 官方开发语言。