Kotlin--学习总结

声明对象

// 声明常量
val name: String = "wu"
// 会自动判断对象的类型
val name = "wu"
val age = 18

// 声明变量
var age: Int = 20
var age = 20
// 初始化为null的对象
var age: Int? = null
// lateinit 表示延后赋值该对象
lateinit var name: String  
// ?表示该对象可以为空
var name: String? = "name"

数组和集合

// 数组
// Array创建数组，大小为10，所有元素都为1的数组
var array = Array(10) { 1 }
var array = Array<Int>(10) { 1 }
// 使用arrayOf创建数组
var array = arrayOf(1, 2, 3, 4, 5)
var array = arrayOf<Int>(1, 2, 3, 4, 5)
var array = arrayOf<String>("java", "kotlin", "c++")
var array = arrayOf(1, 2, 3, "java", "kotlin")
// 使用intArrayOf、booleanArrayOf、charArrayOf等创建数组
var array = intArrayOf(1, 2, 3)
var array : IntArray = intArray(1, 2, 3)
var array = booleanArrayOf(true, false, true)
var array = charArrayOf('k', 'j', 'c')
// kotlin数组有'set()'和'get()'函数，可以分别直接修改和访问数组的特定元素
// set
array.set(1, 1)
array[1] = 1
// get
array.get(1)
array[1]
// 遍历数组
for (elements in array) {}


// 集合
// 分不可变集合和可变集合
// 不可变集合也叫集合，只支持可读功能
// list
// List是一个接口和通用的元素集合。List接口继承了'Collection<T>'类。它是不可变的，只支持读写功能
// List的元素按顺序插入排序，包含与数组相同的索引号。
var list1 = listOf<String>()
var list2 : List<String> = listOf()
// map
var map1 = mapOf<String, String>()
var map2 : Map<String, String> = mapOf()
// set
// Set接口是一个通用的无序元素集合，不支持重复元素。
var set1 = setOf<String>()
var set2 : Set<String> = setOf()

// 可变集合支持读写功能
// List
// ArrayList用于创建动态数组，可以根据需要增加或减少ArrayList类的大小。
// ArrayList提供读写功能，非同步的，它可能包含重复元素。
var list : ArrayList<String> = arrayListOf()
var list = ArrayList<String>()
// arrayListOf是ArrayList类的函数
var list = arrayListOf<String>()
// MutableList的元素按顺序插入排序
var list = mutableListOf<String>()
var list = mutableListOf("java", "kotlin", "c++")
var list : MutableList<String> = mutableListOf()
// 可同时接受不同的数据类型值
var list : MutableList<Any> = mutableListOf()
// Map
// HashMap是基于MutableMap接口的集合类。HashMap类使用Hash表实现MutableMap接口。它以键值对的形式存储数据。
// HashMap类的实现不保证健、值和集合数据项目的顺序。
var map : HashMap<String, String> = hashMapOf()
var map = HashMap<String, String()
var map = hashMapOf<String, String>()
var map = mutableMapOf<String, String>()
var map : MutableMap<String, String>() = mutableMapOf()
// Set
// HashSet是一个集合类，它扩展了AbstractMutableSet类并实现了Set接口。
// HashSet类使用散列机制存储元素，支持读写功能，不支持重复值，也不保证元素的顺序。
var set : HashSet<String> = hashSetOf()
var set = HashSet<String>()
var set = hashSetOf<String>()
var set = mutableSetOf<String>()
var set = mutableSetOf("kotlin", "java", "c++")
// MutableSet接口是一个通用的无序元素集合，不支持重复元素。
var set : MutableSet<String>() = mutableSetOf()

函数

// 所有函数默认是public
// 所有函数默认是final(抽象函数和接口函数除外)(不能被重写)，需要被重写要加上关键字'open'
// 使用'fun'关键字声明方法
// '()'后面接': Boolean'表示该方法有返回值，是Boolean类型
// 参数格式为'name: type'
fun eat(food: String) : Boolean {
    return true
}

// Unit即void，表示无返回值，也可以不写
fun eat(food: String) : Unit {}
fun eat(food: String) {}
// 参数可以有默认值
fun eat(food: String = "水饺") {}
// 调用的时候还可以省略有默认值的参数
eat()
// 当有多个参数时，调用的时候需要指定哪个参数
fun eat(food: String = "水饺", quantity: Int) {}
eat(quantity = 20)
// 可变长度的参数--'vararg'
fun eat(vararg quantity: Int) {}
eat(10, 20, 30)

// 范型
fun<T> eat(food: T): List<T>? {
    return null
}

// 局部函数，在函数中定义函数
fun eat(food: String) {
    fun delicious(delicious: Boolean): Boolean {
        return delicious
    }
    delicious(true)
}

// 单表达式函数
fun eat(delicious: Boolean): Boolean = delicious
fun eat(quantity: Int): Int = quantity * 2
//可以直接省略返回类型
fun eat(quantity: Int) = quantity * 2

类

// 所有类都继承于'Any'，相当于java中都Object
// 类和函数一样都是默认'public final'的
// ':'表示继承，接口的实现直接接在后面用','分割
class KotlinActivity : Activity(), View.OnClickListener{
}

// 类的声明
class Person {}
// 不需要new关键字直接声明
val person = Person()

构造函数

// 一个类中只有一个主构造函数和一个或多个次构造函数
// 主构造函数
// 可省略constructor
class Person(name: String) {}
class Person constructor(name: String) {}
// 有修饰符的情况下不能省去constructor
class Person private constructor(name: String) {}
// 可设默认值
class Person constructor(name: String = "名字") {}
// 参数前面加'var'，等同于下面的形式
class Person constructor(var name: String = "名字") {}
class Person constructor(name: String = "名字") {
    var name = name
}

// 初始化
class Person(var name: String = "名字") {
    // 可在'init {}‘代码块中进行初始化操作
    init {
        name = "name"
    }
}

// 次构造函数
// 次构造函数必须通过'this'调用主构造函数
class Person(var name: String = "name") {
    var age: Int = 0
   
    // 次构造函数要显示的指向主构造函数': this(name)'
    constructor(name: String, age: Int): this(name) {
        this.age = age
    }
}

class Person(){
    constructor(name: String, age: Int){}
}

继承

// kotlin中类和方法默认不可继承的，要继承就需要添加关键字'open'
open class Person() {
    // 属性也可以被重载，需要加上关键字'open'
    open var name = ""
    open fun eat() {}
}

class Man : Person() {
    override var name = "name"
    override fun eat() {
        super.eat()
    }
}

抽象类

// 和java一样使用'abstract'
// 抽象类默认是open的，所以可以忽略
abstract class Person {} 

object

// object用来声明一些特殊对象或类。
// 匿名内部类
button.setOnClickListener(object : View.OnClickListener {
    override fun onClick(v: View) {
    }
})

// 单例
object ActivityManager {
    fun addActivity() {}
}
ActivityManager.addActivity()

// 伴生对象
// 用来替换java中的静态变量
companion object {
    fun jump(context: Context) : Intent {
        return Intent(context, Activity::class.java)
    }
}

接口

// interface
// kotlin中的接口可以有方法体，可以有属性
interface Eat {
    var food: String
    fun drink() {}
    fun eat()
}

导入包

import android.view.View
// 可以使用'as'来重命名
import android.view.WindowManager as manager

可见修饰符

// 只有类的内部可见
private
// 类和子类中可见
protected
// 模块内都可见internal成员
internal
// 公共可见的，默认的，可以省略不写
public

空安全

// kotlin是空安全的，对象默认是不能为null的，如果想要赋值为null，在声明对象时需要加上'?'
// kotlin提供'?'和'!!'两种空安全操作符
//当person为null的时候，不会执行此行代码
person?.eat()
//当person为null的时候，执行到此行代码时，程序会抛出异常
person!!.eat()

for循环

for (i in 1..10) {}
val list = mutablelist<String>()
for (i in list) {}
for ((index, value) in list.withIndex()) {
    // 可以取到index和value的值
    print("index:$index, value:$value")
}

kotlin中的switch--when

// kotlin中去掉来switch
when(index) {
    1 ->{ "hello" }
    2 ->{ "world" }
    else -> { "hello kotlin" }
}
// 也可以直接赋值
var name = when(index) {
    1 ->{ "hello" }
    2 ->{ "world" }
    else -> { "hello kotlin" }
}

kotlin中的三元运算符

// kotlin中没有三元运算符
// 可以用'if() else'代替
var name = if (true) "kotlin" else "java"

字符串模版

// 用'$'来获取变量值
val name = "kotlin"
print("name:$kotlin")
print("length:${name.length}")
// 打印符号'$'
print("${'$'}")

高阶函数

// 函数可以作为参数传入另一个函数中
fun getIndex(i : Int)  = i
fun getName(index: Int): String = index.toString()
getName(getIndex(1))

内部类

// 使用关键字'inner'修饰
class Out {
    inner class Inner {
    }
}
val innerClass = Out().Inner()

注解

注解用于在编译时将元数据附加到类、参数、接口等。编译器可以在运行时反射注解，可以根据注解值更改数据或程序的含义。

元注解（Meta-annotations）

• @Target 它针对可以使用注解进行注解的所有可能类型的元素。
• @Retention 它指定注解是否存储在已编译的类文件中，或者是否在运行时通过反射显示。
• @Repeatable 此元注解确定注解在单个代码元素上适用两次或更多次。
• @MustBeDocumented 此元文档指定注解是公共API的一部分，应包含在类或方法中。