郭霖第一行代码第三版学习笔记（二）

二、Kotlin

变量和函数

main函数

fun main(){
    println("Hello kotlin")
}

变量

val（value）声明一个不可变的变量，初始赋值之后不能重新赋值，类似final

var（variable的简写）用来声明一个可变的变量

var a:Int =10

注：优先使用val来声明一个变量，而当val没有办法满足你的需求时再使用var。

自定义函数，语法规则如下

fun methodName(param1: Int, param2: Int): Int {
 return 0
}

函数使用fun来声明，函数名后面括号里声明该函数接收什么参数（可选），格式是“参数名: 参数类型”，后面用于声明该函数会返回什么类型的数据（可选）

fun main(){
    var a : Int=10
    var b : Int=11
    val sum : Int = add(a,b)
    val max : Int = largeNumber(a,b)
    println("和:"+sum+"，最大值："+max)
}
fun add(num1 : Int, num2 :Int) : Int{
    return num1+num2
}
fun largeNumber(num1:Int,num2:Int)= max(num1,num2)

数据类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wCzxDz2I-1690217221431)(/Users/apus/Library/Application Support/typora-user-images/image-20230131145906668.png)]

简写方式

fun largeNumber(num1:Int,num2:Int)= max(num1,num2)

逻辑控制

if：可以有返回值

    val ifMax=if(a>b){
        a
    }else{
        b
    }
    if(a>b) a else b

when:可以有返回值

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

循环

while

for

区间，双端闭

   val range=0..10  //[0,10]
   for ( i in 0..10)
        println(i)

区间单端闭

val range = 0 until 10 //[0,10)

step跳过

val range = 0 until 10 step 2
输出0,2,4,6,8

downto降序

val range = 10 downTo  1 step 2 //10,8,6

面向对象

类与对象

class Person {
    var name : String=""
    var age : Int=0
    fun toStrings(){
        print("名字："+name+"年龄"+age)
    }
}
fun main(){
    val p=Person()
    p.name="huahua"
    p.age=30
    p.toStrings()
}

继承和构造函数

kiotlin中非抽象类默认不可被继承

允许被继承，加open

open class Person{}

类继承方法，加：，父类后加()

class Student : Person(){
}

构造函数

主构造函数，没有函数体,可以写结构体

class Student(var sno:String,var grade : String){}
class Student(var sno:String,var grade : String){
    init {
        println("sno is" +sno )
        println("grade is" + grade)
    }
    }
fun main(){
    val Student=Student("s123","dsdjs")
}

继承

父类

open class Person(name: String, age: Int) {
    var name : String=""
    var age : Int=0
    class Person(var pname : String,var page : Int){}
    fun toStrings(){
        print("名字："+ name +"年龄"+ age)
    }
}
fun main(){
    val p=Person("jj", 9)
    p.name="huahua"
    p.age=30
    p.toStrings()
}

子类

class Student(var sno:String,var grade : Int, name : String,age : Int) : Person(name, age){
    init {
        println("sno is" +sno )
        println("grade is" + grade)
    }
    }
fun main(){
    val Student=Student("s123",5,"jack",6)
}

次构造函数。用constructor定义，当既有主构造函数又有次构造函数时，所有次构造函数必须调用主构造函数

    constructor(name: String,age: Int) : this("",0,name,age){}
    constructor() : this("", 0) //通过this调用主构造函数

接口

实现用,用override重写父类或实现接口中的函数

interface Study {
    fun readBooks()
    fun doHomework()
}

子类

class Student(name : String,age : Int) : Person(name, age), Study{
    var sname=name

    override fun readBooks(){
        println(sname + " is reading")
    }

    override fun doHomework() {
        println(sname + " is doingHomework ")
    }
}

//}
fun main(){
    val student=Student("s123",5)
    student.doHomework()
    doStudy(student)
}
fun doStudy(study: Study){
    study.readBooks()
    study.doHomework()
}

接口中的函数只有一个函数体时默认实现。

可见性修饰符

public，private，proctected和default定义在fun前面

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Wgq2tptc-1690217221435)(/Users/apus/Library/Application Support/typora-user-images/image-20230131173408331.png)]

数据类和单例类

重写equals时也要重写hashcode

数据类

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

//待处理
fun main(){
    val cellphone1= Cellphone("Samsung",1300)
    val cellphone2= Cellphone("Samsung",1300)
    println(cellphone1)
    println("cellphone1 equals cellphone2 "+(cellphone1 == cellphone2))
}
com.ku.kotlin1.Cellphone@34ce8af7
cellphone1 equals cellphone2 false

单例类,新建类时选择object类型

object Singleton {
    fun singletonTest(){
        println("singleton is called")
    }
}
fun main(){ 
    Singleton.singletonTest()
}

集合的创建与遍历

Lambda编程

List集合

listof，不可变集合

        val list= listOf("Apple", "Banana", "Orange")
        for (fruit in list){
            print(fruit)
        }

mutableListOf，可变集合

val list= mutableListOf("Apple", "Banana", "Orange")
list.add("watermelon")

Set集合：不存放重复元素

setof，不可变集合

mutableSetof，可变集合

val list= mutableListOf("Apple", "Banana", "Orange")
list.add("watermelon")

Map:键值对，存放多个用mapOf里用to

mapof

        map["Apple"] = 1
        val fruits1=map["Apple"]
        val maps = mapOf("Apple" to 1, "Banana" to 2)
        for ((fruit,number) in maps){

mutablemapof 可变

Lambda表达式

        val list= listOf("Apple", "Banana", "Orange")
        val lambda = {fruit: String -> fruit.length}
        val maxLengthFruit = list.maxBy(lambda)
        val maxLengthFruit = list.maxBy{fruit -> fruit.length}
        val maxLengthFruit=list.maxBy{it.length}

filter函数，进行过滤

        val list= listOf("Apple", "Banana", "Orange","Pear","WaterMelow")
        val newList = list.filter { it.length <= 8 } //过滤长度小于8的，并转换成大写
            .map { it.uppercase() }
        for (fruit in newList){
            println(fruit)
        }

        val anyResult = list.any{it.length <= 5} //至少存在一个
        val allResult = list.all { it.length<=6 } //所有都
        																				返回true或false

kiotlin匿名类

  Thread(object : Runnable{
        override for run(){
            println("Thread is running")
    }
    }).start

button.setOnClickListener{
}

避免空指针异常

fun doStudy(study: Study){
    if (study != null){
    study.readBooks()
    study.doHomework()}
}

判空辅助工具

?.

a?.doSomething()   <==
if (a != null){
		a.doSomething()
}

?:

val c=a ?:b <==
val c = if (a != null){
	a
} else{
	b
}

fun getTextLength(text: String?)= text?.length ?:0   <==
fun getTextLength(text: String?): Int{
	if (text != null){
			return text.length
	}
	return 0}

非空断言工具!!

content!!.toUpperCase

let函数可以全局变量的判空，if不行

obj.let{
obj ->
}

fun doStudy(study: Study?){
//    if (study != null){
    study?.let {  
    it.readBooks()
    it.doHomework()}}

字符串内嵌表达式

val brand="samsung"
println("Cellphone(brand=$brand)")

函数参数默认值

fun printParams(num: Int, str: String = "hello"){
	println("num is $num")
}

对于类型不匹配

printParams(str = "world")