Kotlin
package com.example.test02
import kotlin.math.max
fun main(args: Array<String>) {
val a = 10 // 常量Int
var aa = 10L // 变量Long
var b = "string" // 变量string
// if 语句有返回值
b = if (a > 5) {
println(">")
">"
} else {
println("<")
"<"
}
b = when(a) {
1 -> "1"
2 -> {
print("")
"2"
}
else -> "3"
}
b = when {
a > 0 -> "1"
a > 10 && a % 2==0 -> "2"
else -> "3"
}
// 循环 while 和java中相同
var range = 0..10 // IntRange 变量
for (i in 1..10) {
println(i)
}
for (i in 1 until 10 step 2) { // 左闭右开区间，每次递增2
println(i)
}
// for (i in 10 downTo 1 step 2) [10, 1]每次递增2
println("Hello")
}
// 可使用默认参数，使用时可省略靠后的参数，也可指定传参
fun function(param1:Int = 0, param2: String = " ") {
return
}
fun getMax(num1: Int, num2:Int) : Int = max(num1, num2)
fun getMax2(num1: Int, num2: Int) = if (num1 > num2) num1 else num2
fun checkNumber(num: Number) {
when (num) {
is Int -> println("Int")
is Double -> {
println("Double")
}
else -> println("else")
}
}
/************************** 面向对象（注意，类似java，每个类一个文件） *****************************/
/*
* Kotlin 中有 主构造函数 和 次构造函数
* + 主构造函数
* 类名后的圆括号，其中的字段名用于赋值。默认为空
* 在创建下方Student时必须传入参数 `val stu = Student("a123", 5)`
* 继承时必须通过 () 指定调用的构造方法
* + 次构造函数
* 类内部的 init 代码块
* 当一个类既有主构造函数又有次构造函数时，所有的次构造函数都必须调用主构造函数（包括间接调用）
*/
open class Clazz {
var param1 = ""
var param2 = 0
fun info() {
println("$param1 $param2")
}
}
// 加上open后这个类才可以基础，默认不可以
open class Person(val name: String, val age: Int) {
fun info() {
println(name + " is " + age + "years old.")
}
}
// Student 不可以被继承
// 构造时传入父类参数，再用于构造父类
// 主构造中传给父类的参数不能使用 var val，使用了就是自己的，不能传给父类
// 3种构造方法：
// val stu1 = Student()
// val stu2 = Student("123", 10)
// val stu3 = Student("123", 1, "123", 19)
class Student(val sno:String, val grade: Int, name: String, age: Int) : Person(name, age), Study {
// 主构造函数的的函数体
init {
println("this is init function.")
}
// 次构造函数，必须调用主构造函数
constructor(name: String, age: Int) : this("", 0, name, age) {
}
constructor() : this("", 0) {
}
override fun readBooks() {
}
}
// 只有次构造函数，没有主构造函数
class Student2 : Person {
constructor(name: String, age: Int) : super(name, age) {}
}
// 接口与java种几乎相同，类实现时使用 : 和继承一样
interface Study {
fun readBooks()
fun doHomework() {
println("接口的默认实现")
}
}
// 可见性修饰符有4种：public（默认）、private（当前类可见）、protected（当前类、子类可见）、internal（只对同一模块可见）
// 数据类，自动实现 equals() hashcode() toString() 等方法
data class Cellphone(val brand: String, val price: Double)
// 单例类
object Singleton {
fun singletonTest() {
println("singletonTest is called.")
}
}
/****************************** Lambda ********************************/
// {参数名1: 参数类型, 参数名2: 参数类型 -> 函数体}
fun f() {
val list = ArrayList<String>()
list.add("Apple")
list.add("Banana")
list.add("Orange")
val list2 = listOf("Apple", "Banana", "Orange", "Pear", "Grape")
val list3 = mutableListOf("Apple", "Banana", "Orange", "Pear", "Grape")
val set = setOf("Apple", "Banana", "Orange", "Pear", "Grape")
val map1 = HashMap<String, Int>()
map1["Apple"] = 1
map1["Banana"] = 2
map1["Orange"] = 3
map1["Pear"] = 4
map1["Grape"] = 5
val map2 = mapOf("Apple" to 1, "Banana" to 2, "Orange" to 3, "Pear" to 4, "Grape" to 5)
for ((fruit, number) in map2) {
println("fruit is $fruit, number is $number")
}
val maxLengthFruit1 = list.maxBy({ fruit: String -> fruit.length })
val maxLengthFruit2 = list.maxBy() { fruit: String -> fruit.length }
val maxLengthFruit3 = list.maxBy { fruit: String -> fruit.length }
val maxLengthFruit4 = list.maxBy { it.length }
val newList5 = list.map { it.uppercase() }
val newList6 = list.filter { it.length <= 5 }.map { it.uppercase() }
val anyResult : Boolean = list.any { it.length <= 5 } // 是否有长度大于5的
val allResult : Boolean = list.all { it.length <= 5 } // 是否全部长度大于5
}
/*************************** 空指针 **************************/
// 可以直接用 == 比较类和string，不需要equal方法
// 利用编译时判空检查的机制几乎杜绝了空指针异常
// 空指针异常的检查提前到了编译时期，如果我们的程序存在空指针异常的风险，那么在编译的时候会直接报错，
// 修正之后才能成功运行，这样就可以保证程序在运行时期 不会出现空指针异常了。
fun f2() {
doStudy(null) // 报错，无法编译
doStudy2(null) // 正确
}
fun doStudy(study: Study) { // 此时无法传入 null
study.readBooks()
study.doHomework()
}
fun doStudy2(study: Study?) {
if (study != null) {
study.doHomework()
study.readBooks()
}
study?.readBooks() // 省略了 if-null 判断
var c = study ?: " " // val c = if (study != null) {study} else {" "}
}
fun getTextLength(text: String) = text?.length ?: 0
/****************************** 标准函数 let with run apply*********************************/
/*
let 主要配合 ?. 使用
obj.let { obj2 ->
// 编写具体的业务逻辑
}
obj 作为lambda的参数传入
*/
fun doStudy3(study: Study?) {
study?.let {
it.readBooks()
it.doHomework()
}
}
/*
val result = with(obj : 任意类型) { // lambda表达式
// 这里是obj的上下文
"value" // with函数的返回值
}
*/
val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")
val result = with(StringBuilder()) {
// 整个Lambda表达式的上下文就会是这个StringBuilder对象
append("Start eating fruits.\n")
for (fruit in list) {
append(fruit).append("\n")
}
append("Ate all fruits.")
toString()
}
println(result)
/*
与with类似
val result = obj.run {
// 这里是obj的上下文
"value" // run函数的返回值
}
*/
val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")
val result = StringBuilder().run {
append("Start eating fruits.\n")
for (fruit in list) {
append(fruit).append("\n")
}
append("Ate all fruits.")
toString()
}
println(result)
/*
与run类似apply函数无法指定返回值，而是会自动返回调用对象本身
val result = obj.apply {
// 这里是obj的上下文
}
// result == obj
*/
val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")
val result = StringBuilder().apply {
append("Start eating fruits.\n")
for (fruit in list) {
append(fruit).append("\n")
}
append("Ate all fruits.")
}
println(result.toString())
/******************************* 定义静态方法 ****************************/
/*
1. @JvmStatic 注解
2. 顶层方法：那些没有定义在任何类中的方法，比如 main() 方法。
顶层方法在kotlin中直接调用即可，无需包名、路径
java调用时要使用 文件名.顶层方法() 调用，编译器自动生成一个与文件名同名的类
*/
class Util {
fun doAction1() {
println("do action1")
}
companion object {
@JvmStatic // 只能加在单例类或companion object中的方法上
fun doAction2() {
println("do action2")
}
}
}
// Util.doAction2() 调用延迟初始化
class MainActivity : AppCompatActivity(), View.OnClickListener {
private lateinit var adapter: MsgAdapter // lateinit 延迟初始化：声明时不用赋值null，使用前赋值即可
override fun onCreate(savedInstanceState: Bundle?) {
...
if (!::adapter.isInitialized) { // ::adapter.isInitialized 返回是否已经初始化
adapter = MsgAdapter(msgList)
}
...
}
}密封类
fun getResultMsg(result: Result) = when (result) {
is Success -> result.msg
is Failure -> "Error is ${result.error.message}"
// 如果使用 interface 定义Result，这里不得不再加一个else语句
// 密封类及其所有子类只能定义在同一个文件的顶层位置，不能嵌套在其他类中，这是被密封类底层的实现机制所限制的。
}拓展函数
在不修改源码的情况下给类添加方法：
fun ClassName.methodName(param1: Int, param2: Int): Int {
return 0
}
// 给 String 多添加了一个方法
fun String.lettersCount(): Int {
var count = 0
for (char in this) {
if (char.isLetter()) {
count++
}
}
return count
}操作符重置
class Obj {
operator fun plus(obj: Obj): Obj {
// 处理相加的逻辑
}
}
class Money(val value: Int) {
operator fun plus(money: Money): Money {
val sum = value + money.value
return Money(sum)
}
operator fun plus(newValue: Int): Money {
val sum = value + newValue
return Money(sum)
}
}
高阶函数
如果一个函数接收另一个函数作为参数，或者返回值的类型是另一个函数，那么该函数就称为高阶函数
fun num1AndNum2(num1: Int, num2: Int, operation: (Int, Int) -> Int): Int {
val result = operation(num1, num2)
return result
}
fun plus(num1: Int, num2: Int): Int {
return num1 + num2
}
fun main() {
val num1 = 100
val num2 = 80
val result1 = num1AndNum2(num1, num2, ::plus)
val result2 = num1AndNum2(num1, num2) { n1, n2 ->
n1 - n2
}
println("result1 is $result1")
println("result2 is $result2")
}对应的java代码如下：
public static int num1AndNum2(int num1, int num2, Function operation) {
int result = (int) operation.invoke(num1, num2);
return result;
}
public static void main() {
int num1 = 100;
int num2 = 80;
int result = num1AndNum2(num1, num2, new Function() {
@Override
public Integer invoke(Integer n1, Integer n2) {
return n1 + n2;
}
});
}内联函数
使用lambda都会创建一个匿名类，带来性能开销。使用内联减小开销，在编译时将字节码放到必要的地方。使用 inline 关键字即可。
inline fun num1AndNum2(num1: Int, num2: Int, operation: (Int, Int) -> Int): Int {
val result = operation(num1, num2)
return result
}noinline与crossinline
// 只内联block1，不内联block2
inline fun inlineTest(block1: () -> Unit, noinline block2: () -> Unit) {
}内联函数所引用的Lambda表达式中是可以使用return关键字来进行函数返回的，而非内联函数只能进行局部返回。
保证在内联函数的Lambda表达式中一定不会使用return关键字
委托
/**
* 类委托，MySet 的函数实现全部委托由辅助对象实现
*/
class MySet<T>(val helperSet: HashSet<T>) : Set<T> {
override val size: Int
get() = helperSet.size
override fun contains(element: T) = helperSet.contains(element)
override fun containsAll(elements: Collection<T>) = helperSet.containsAll(elements)
override fun isEmpty() = helperSet.isEmpty()
override fun iterator() = helperSet.iterator()
}
// 类委托的简写方式，等于上面
class MySet<T>(val helperSet: HashSet<T>) : Set<T> by helperSet {
fun helloWorld() = println("Hello World")
override fun isEmpty() = false // 可只单独重写某个方法
}
/**
* 属性 p 由 Delegate 对象委托实现，
* 调用p属性的时候会自动调用Delegate类的getValue()方法，
* 当给p属性赋值的时候会自动调用Delegate类的setValue()方法
*/
class MyClass {
var p by Delegate()
}
class Delegate {
var propValue: Any? = null
// 必须用 operator 声明
operator fun getValue(myClass: MyClass, prop: KProperty<*>): Any? {
return propValue
}
operator fun setValue(myClass: MyClass, prop: KProperty<*>, value: Any?) {
propValue = value
}
}infix
A to B 等价于 A.to(B)
if ("Hello Kotlin".startsWith("Hello")) {
}
// 上面通过 infix 可简写，没有infix这就是一个String类的拓展函数
infix fun String.beginsWith(prefix: String) = startsWith(prefix)
if ("Hello Kotlin" beginsWith "Hello") {
}
if (list.contains("Banana")) {
}
// 等价于
infix fun <T> Collection<T>.has(element: T) = contains(element)
if (list has "Banana") {
}
