第一行代码第三版笔记（第二章kotlin）

Java基本数据类型	Kotlin对象数据类型	数据类型说明
int	Int	整型
long	Long	长整型
short	Short	短整型
float	Float	单精度浮点型
double	Double	双精度浮点型
boolean	Boolean	布尔型
char	Char	字符型
byte	Byte	字节型

变量和函数

val声明不可变变量
var声明可变变量

package com.apep.kotlinlearn

import kotlin.math.max

fun main() {
    test1()
    test2()
    val value = largerNumber(32,43)
    println(value)
    val value2 = largerNumber2(12,44)
}
fun test1() {
    val a = 10
    println("a=" + a)
}

fun test2() {
    var a: Int = 10
    a = a * 10
    println("a=" + a)
}

fun largerNumber(num1:Int,num2:Int):Int {
    return max(num1,num2)
}
//largerNumber可简化为largerNumber2
fun largerNumber2(num1: Int,num2: Int)= max(num1,num2)

逻辑控制

if

fun largerNumber3(num1: Int, num2: Int): Int {
    var value = 0
    if (num1 > num2) {
        value = num1
    } else {
        value = num2
    }
    return value
}

//可简化为
fun largerNumber4(num1: Int, num2: Int) = if (num1 > num2) num1 else num2

when

fun getScore(name: String) = when (name) {
    "tom" -> 33
    "jim" -> 32
    else -> 0
}

fun checkNumber(num: Number) {
    when (num) {
        is Int -> println("int")
        is Double -> println("double")
        else -> println("support")
    }
}

fun getScore2(name: String) = when {
    name == "jim" -> 22
    name.startsWith("tom") -> 76
    else -> 12
}

循环语句

fun main() {
    for (i in 0..3) {
        println(i)//0 1 2 3
    }
}

fun main() {
    for (i in 0 until 3) {
        println(i)//0 1 2 
    }
}

fun main() {
    for (i in 0 until 6 step 2) {
        println(i)//0 2 4
    }
}

fun main() {
    for (i in 3 downTo  1) {
        println(i)//3 2 1
    }
}

继承

fun main() {
    val student = Student("a123", 4, "23", 5)
    val student2 = Student2("222", 4)
}

//父类
open class Person(val name: String, val age: Int)

//子类  设置默认值方法（ val grade: Int = 5）
class Student(val sno: String, val grade: Int = 5, name: String, age: Int) : Person(name, age){
    //主构造函数中如需编写逻辑，使用init结构体
    init {
        println("sno is " + sno)
        println("grade is " + grade)
    }
}

//子类没有主构造函数，只有次构造函数（少见）
class Student2 : Person {
    constructor(name: String, age: Int) : super(name, age)
}

接口

fun main() {
    val student3 = Student3("qqq", 2)
    student3.readBooks()
    student3.doHomeWork()
}

interface Study {
    fun readBooks()
    fun doHomeWork() {//默认实现
        println("doHomeWork")
    }
}

class Student3(name: String, age: Int) : Person(name, age), Study {
    override fun readBooks() {
        println(name + "--readBooks" + "--age" + age)
    }
}

数据类和单例类

data class Cellphone(val brand: String, val price: Double)

object Singleton {
    fun singletonTest() {
        println("singletonTest")
    }
}

Lambda

 val list2 = listOf("Apple", "Banana", "Orange", "Pear")

 val list3 = mutableListOf("Apple", "Banana", "Orange", "Pear")
 list3.add("WaterMelon")

 val map = mapOf("Apple" to 1, "Banana" to 2, "Pear" to 3)

val maxLengthFruit = list.maxBy { it.length }  
val newList = list.map { it.toUpperCase() }
val newList = list.filter { it.length <= 5 }.map { it.toUpperCase() }

val list = listOf("Apple", "Banana", "Orange", "Pear", "WaterMelon", "Grape")
val anyResult = list.any { it.length <= 5 }//Any判断集合中是否至少存在一个元素满足此条件。
val allResult = list.all { it.length <= 5 }//all函数用于判断集合中是否所有元素都满足此条件。
println("anyResult " + anyResult + ",all Result " + allResult)

   Thread({
        println("Thread is running")
   }).start()

button.setOnClickListener{}

空指针

fun doStudy(study: Study?) {//?表示Study可为空
    study?.readBooks()//if(study!=null){study.readBooks()}
    study?.doHomeWork()
}

学习?:操作符,其是左右两边都接受一个表达式，如果左边表达式的结果不为空就返回左边表达式的值，否则返回右边表达式的值。

 val c = if (a != null) {
        a
    else{
        b
    }
}
//简化后为：
val c = a ?: b

let函数

 obj.let{obj2 -> //具体逻辑}

obj对象的let函数会立即执行Lambda表达式的代码，并且obj对象本身会作为参数传入，为了防止重名，我们将参数改为obj2，但实际是同一对象。

fun doStudy(study: Study?) {
    //?.表示对象不为空时调用let函数
    //let函数会将study本身作为参数传递至Lambda表达式中，此时对象不为空，可以放心调用。
    study?.let { stu ->
        stu.readBooks()
        stu.doHomeWork()
    }
}
即
fun doStudy(study: Study?) {
    study?.let { 
        it.readBooks()
        it.doHomeWork()
    }
}

    val str = "hello,${obj.name}.nice to meet u"
当仅有一个变量时，甚至可以将两边大括号缩写。以下代码示例最后两句是完全等价的：
    val brand = "Samsung"
    val price = 1299.99
    println("Cellphone(brand=" + brand + ",price=" + price + ")")
    println("Cellphone(brand=$brand,price=$price)")