随笔分类

随笔档案

阅读排行榜

作者做的思维导图

变量

val和var区别

val value 不可变变量
var variable 可变变量

变量的自动类型推导（弱）

  val a=10;
  print("a=" + a);

变量的显式声明(强)

val a:Int = 10;

数据类型

注意和java不同，这些都是对象数据类型，大写开头：

Int	Short	Long	Float	Double	Boolean	Char	Byte

函数 function

基本形式

param，parameter，参数

fun+名+（参数1，参数2）：返回类型

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

语法糖

fun largerNumber(num1:Int,num2:int)：Int{return max(num1,num2)}
//当返回值只有一行时（应该是说，一个表达式？这个表达式有返回值）
fun largerNumber(num1:Int,num2:int)：Int = max(num1,num2)
//进一步缩写，自动推导机制，因为返回值也是Int类型
fun largerNumber(num1:Int,num2:int) = max(num1,num2)

程序逻辑控制 if when

if else if else

基本书写

if(a>b){return a}
else if(a<b){return b}
else{return a+b}

省略return

if(a>b){ a}
else if(a<b){ b}
else{ a+b}

再省略{}

var result=if(a>b) a else if(a<b) b else a+b

结合函数

fun fun1(a:Int,b:Int) =if(a>b) a else if(a<b) b else a+b

when

相当于switch （）case ：
匹配值->

when(day){
  1->print("星期一")
  2->print("星期二")
  else->{print("输入错误");print("请重新输入")}
}

返回语法糖

fun getScore(name:String)=when(name){
  "Tom"->86
  "Jim"->77
  "Jack"->95
  else->0
}

when 判断数据类型，

fun checkNumbers(num:Number)=when(num){
    is Int-> print("num is Int")
    is Double-> print("num is Double")
    else-> print("else")}

无参数的when，更像if了

fun getScore(name:String)=when{
  name.startsWitch("T")->86
  name=="Jim"->77
  name=="Jack"->95
else->0
}

循环

while

while(){}

for in

val range=0..2

0..5	[0,5]	0,1,2,3,4,5
0 until 5	[0,5)	0,1,2,3,4
5 downTo 0	[5,0]	5,4,3,2,1,0	降序
0 .. 5 step 2		0,2,4	步长

for(i in 1..10){print(i)}
for(i in 0 until 10){print(i)}
for(i in 0 until 10 step 2){print(i)}
for(i in 10 downTo 0){print(i)}

类，对象

最简单的无构造参数的类

class Person {
    var name=""
    var age=0
    fun eat(){
        println(name+"is eating.He is "+age+"years old");
    }
}
fun main(){
    val p=Person()
    p.name="Jack"
    p.age=18
    p.eat()
}

构造函数

主构造函

,每个类都默认有一个不带参数的主构造函数

//class Person(){}==class Person{}
class Student(var sno:String ,var grade:Int){}

val student=Student("a123",86)

构造函数无函数体,只是括号（），用来传参数
要想同时进行其他初始化操作，可以用init结构体

class Student(var sno: String, var grade: Int) : Person() {
    init {
        println("sno is:" + sno)
        println("grade is" + grade)
    }
}

次构造函数

可以有多个，直接或间接调用主构造函数

class Student(var sno: String, var grade: Int, name: String,age: Int):Person(name,age){
    constructor(name: String,age: Int):this("",0,name,age){}
    constructor():this("" ,0)
}

只次构造函数，无主构造函数

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

继承

Kotlin的非抽象类默认都是不可继承的，类似java中final声明
非抽象类，抽象类，抽象类的意义就是为了继承用的？
所以首先声明此类可继承,open

open class Person {
    var name=""
    var age=0
}

改java中继承extends为:

class Student:Person(){}

父类构造的继承

子类的构造函数必须调用父类的构造函数
class Student():Person(){}

open class Person(val name:String,val age:Int) {}
class Student(val sno: String, val grade:Int,name: String,age: Int):
Person(name,age){ init{}}
or
names: String,age: Int):Person(names,age){ init{}}
传参作用
注意，这里子类Student构造体里增加的父类参数不需要声明val、var

问题
var names: String,age: Int):Person(names,age){ init{}}
这样可同时print(s.name)和print(s.names)
var name: String,age: Int):Person(name,age){ init{}}
这个报错,不知道为什么

接口

interface
接口的定义，其中的函数，分有函数体和无函数体

interface Study{
  fun readBooks()
  fun doHomework(){println("先写数学作业")}
}

接口的继承

java中使用implements，kotlin还是使用：

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

类似实现多继承，用“，”分隔
但是注意，若此接口中的函数无函数体，需要补上，重写，不写会报错
如override fun readBooks()
而有函数体的doHomework(){println("先写数学作业")}可以保持默认，或是重写（覆盖）

class Student(name:String,age:Int):Person(name,age),Study{
    override fun readBooks(){
        println(name+"is reading")
    }}

修饰符

修饰符	Kotlin	Java
public	所有类可见（默认） * 1. 1.
private	当前类可见
protected	当前类，子类可见	当前类子类，同一包路径下的类可见
default	无	同一包路径下的类可见（默认）
internal	同一模块中类可见	无

数据类

自动帮你重写，equals(),hashCode(),toString(),
使用data关键字，大括号{}还可以省略

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

fun main(){
    val cellphone1=Cellphone("huawei",3999.99)
    val cellphone2=Cellphone("huawei",3999.99)
    println(cellphone1)
    println(cellphone1==cellphone2)
}

单例类，工具类

我们只希望这个类只有一个对象来用
把class 改为 object
调用时无需创建对象，类似静态调用

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

Singleton.singletonTest()

数据结构

集合List

基本

val list=ArrayList<String>()
   list.add("apple")
   list.add("banana")

不可变

val list=listOf("apple","Orange","banana","Pear")

可变

 val list2= mutableListOf("apple","Orange","banana","Pear")
    list2.add("hello")

遍历集合for in

for(i in list){
       println(i)
   }

集合Set

同list，分可变和不可变
setOf()
mutableSetOf()

Map

    val map=HashMap<String,Int>()
    map.put("Apple",1)
    map["Banana"]=2
    println(map["Apple"])
    val map2=mapOf("Apple" to 2,"Banana" to 2)
    for((key,value)in map2){
        println(key+value)
    }

Lambda编程

   val list=listOf("apple","banana","pear","Watermelon")

//    val lambda={fruit:String->fruit.length}
//    val maxLengthFruit=list.maxBy(lambda)
//    val maxLengthFruit=list.maxBy({fruit:String->fruit.length})
//    val maxLengthFruit=list.maxBy(){fruit:String->fruit.length}
//    val maxLengthFruit=list.maxBy{fruit:String->fruit.length}
//    val maxLengthFruit=list.maxBy{fruit->fruit.length}
    val maxLengthFruit=list.maxBy{it.length}
    val newlist=list.filter { it.length<5 }.map{it.uppercase()}
    for(i in newlist){
        print(i)
    }
    val anyResult=list.any{it.length<=5}
    val allResult=list.all{it.length<=5}
    println(anyResult )
    print(allResult)

空指针检查

>kotlin默认所有参数和变量都不可为空

fun doStudy(study:Study){
    study.readBooks()
    study.doHomework()
}
//等价
public void doStudy(Study study){
  if(study!=null){
    study.readBooks()
    study.doHomework()}
}

>允许可传入空

用?号

val a:Int?=null
fun doStudy(study:Study?){}

但是，外层函数允许空参，里面的函数就未知了，也可能造成空指针
fun doStudy(study:Study?){
study~~.readBooks()~~
}
如：readBook（）{~~this.name~~}

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

简化非空判断

?.

当对象不为空的时候正常，为空的时候不执行

    val s=Study()
    s?.doHomework()

fun doStudy(study: Study?) {
        study?.readBooks()
        study?.doHomework()   
}

拓展let
study?.readBooks()
study?.doHomework()
原本一次if判断,变为两次if判断

study?.let{stu->stu.readBooks();stu.readBooks()}
study?.let{it.readBooks();
          it.readBooks()}

?:

类似三目运算符a>b?a:b
a!=null? a : b
左面不为空，返回左侧结果，左边为空，返回右侧结果

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

结合可空传入返回

fun getTextLength(text String?)=text.length?:0

!!

非空断言，非常确定这里不可能为空
如此处
text?.uppercase()，不需要用？.

var text:String?="hello"


if(text!=null){
    doing()
}
fun doing(){
    text?.uppercase()
}

改为text!!.uppercase()

其他

${},文字模版，字符串内嵌表达式

print("hello, ${s.name} ")

默认参数

fun doHomework(work:Studing="数学")

键值对传参

次构造函数的替代，顺序无所谓

val stu1=Student(age=18,name="lihua")

111

11
11
1
1
1
1
1
1
1
1
1
1
------------恢复内容开始------------
作者做的思维导图

变量

val和var区别

val value 不可变变量
var variable 可变变量

变量的自动类型推导（弱）

  val a=10;
  print("a=" + a);

变量的显式声明(强)

val a:Int = 10;

数据类型

注意和java不同，这些都是对象数据类型，大写开头：

Int	Short	Long	Float	Double	Boolean	Char	Byte

函数 function

基本形式

param，parameter，参数

fun+名+（参数1，参数2）：返回类型

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

语法糖

fun largerNumber(num1:Int,num2:int)：Int{return max(num1,num2)}
//当返回值只有一行时（应该是说，一个表达式？这个表达式有返回值）
fun largerNumber(num1:Int,num2:int)：Int = max(num1,num2)
//进一步缩写，自动推导机制，因为返回值也是Int类型
fun largerNumber(num1:Int,num2:int) = max(num1,num2)

程序逻辑控制 if when

if else if else

基本书写

if(a>b){return a}
else if(a<b){return b}
else{return a+b}

省略return

if(a>b){ a}
else if(a<b){ b}
else{ a+b}

再省略{}

var result=if(a>b) a else if(a<b) b else a+b

结合函数

fun fun1(a:Int,b:Int) =if(a>b) a else if(a<b) b else a+b

when

相当于switch （）case ：
匹配值->

when(day){
  1->print("星期一")
  2->print("星期二")
  else->{print("输入错误");print("请重新输入")}
}

返回语法糖

fun getScore(name:String)=when(name){
  "Tom"->86
  "Jim"->77
  "Jack"->95
  else->0
}

when 判断数据类型，

fun checkNumbers(num:Number)=when(num){
    is Int-> print("num is Int")
    is Double-> print("num is Double")
    else-> print("else")}

无参数的when，更像if了

fun getScore(name:String)=when{
  name.startsWitch("T")->86
  name=="Jim"->77
  name=="Jack"->95
else->0
}

循环

while

while(){}

for in

val range=0..2

0..5	[0,5]	0,1,2,3,4,5
0 until 5	[0,5)	0,1,2,3,4
5 downTo 0	[5,0]	5,4,3,2,1,0	降序
0 .. 5 step 2		0,2,4	步长

for(i in 1..10){print(i)}
for(i in 0 until 10){print(i)}
for(i in 0 until 10 step 2){print(i)}
for(i in 10 downTo 0){print(i)}

类，对象

最简单的无构造参数的类

class Person {
    var name=""
    var age=0
    fun eat(){
        println(name+"is eating.He is "+age+"years old");
    }
}
fun main(){
    val p=Person()
    p.name="Jack"
    p.age=18
    p.eat()
}

构造函数

主构造函

,每个类都默认有一个不带参数的主构造函数

//class Person(){}==class Person{}
class Student(var sno:String ,var grade:Int){}

val student=Student("a123",86)

构造函数无函数体,只是括号（），用来传参数
要想同时进行其他初始化操作，可以用init结构体

class Student(var sno: String, var grade: Int) : Person() {
    init {
        println("sno is:" + sno)
        println("grade is" + grade)
    }
}

次构造函数

可以有多个，直接或间接调用主构造函数

class Student(var sno: String, var grade: Int, name: String,age: Int):Person(name,age){
    constructor(name: String,age: Int):this("",0,name,age){}
    constructor():this("" ,0)
}

只次构造函数，无主构造函数

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

继承

Kotlin的非抽象类默认都是不可继承的，类似java中final声明
非抽象类，抽象类，抽象类的意义就是为了继承用的？
所以首先声明此类可继承,open

open class Person {
    var name=""
    var age=0
}

改java中继承extends为:

class Student:Person(){}

父类构造的继承

子类的构造函数必须调用父类的构造函数
class Student():Person(){}

open class Person(val name:String,val age:Int) {}
class Student(val sno: String, val grade:Int,name: String,age: Int):
Person(name,age){ init{}}
or
names: String,age: Int):Person(names,age){ init{}}
传参作用
注意，这里子类Student构造体里增加的父类参数不需要声明val、var

问题
var names: String,age: Int):Person(names,age){ init{}}
这样可同时print(s.name)和print(s.names)
var name: String,age: Int):Person(name,age){ init{}}
这个报错,不知道为什么

接口

interface
接口的定义，其中的函数，分有函数体和无函数体

interface Study{
  fun readBooks()
  fun doHomework(){println("先写数学作业")}
}

接口的继承

java中使用implements，kotlin还是使用：

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

类似实现多继承，用“，”分隔
但是注意，若此接口中的函数无函数体，需要补上，重写，不写会报错
如override fun readBooks()
而有函数体的doHomework(){println("先写数学作业")}可以保持默认，或是重写（覆盖）

class Student(name:String,age:Int):Person(name,age),Study{
    override fun readBooks(){
        println(name+"is reading")
    }}

修饰符

修饰符	Kotlin	Java
public	所有类可见（默认） * 1. 1.
private	当前类可见
protected	当前类，子类可见	当前类子类，同一包路径下的类可见
default	无	同一包路径下的类可见（默认）
internal	同一模块中类可见	无

数据类

自动帮你重写，equals(),hashCode(),toString(),
使用data关键字，大括号{}还可以省略

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

fun main(){
    val cellphone1=Cellphone("huawei",3999.99)
    val cellphone2=Cellphone("huawei",3999.99)
    println(cellphone1)
    println(cellphone1==cellphone2)
}

单例类，工具类

我们只希望这个类只有一个对象来用
把class 改为 object
调用时无需创建对象，类似静态调用

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

Singleton.singletonTest()

数据结构

StringBuilder()

可变字符串？

val builder=StringBuilder()
builder.append("sth \n").append("\n")
//转为不可变字符串
val result=builder.toString()

集合List

基本

val list=ArrayList<String>()
   list.add("apple")
   list.add("banana")

不可变

val list=listOf("apple","Orange","banana","Pear")

可变

 val list2= mutableListOf("apple","Orange","banana","Pear")
    list2.add("hello")

遍历集合for in

for(i in list){
       println(i)
   }

集合Set

同list，分可变和不可变
setOf()
mutableSetOf()

Map

    val map=HashMap<String,Int>()
    map.put("Apple",1)
    map["Banana"]=2
    println(map["Apple"])
    val map2=mapOf("Apple" to 2,"Banana" to 2)
    for((key,value)in map2){
        println(key+value)
    }

Lambda编程

类似，参数是简单函数代码

filter过滤

map遍历

any/all

   val list=listOf("apple","banana","pear","Watermelon")

//    val lambda={fruit:String->fruit.length}
//    val maxLengthFruit=list.maxBy(lambda)
//    val maxLengthFruit=list.maxBy({fruit:String->fruit.length})
//    val maxLengthFruit=list.maxBy(){fruit:String->fruit.length}
//    val maxLengthFruit=list.maxBy{fruit:String->fruit.length}
//    val maxLengthFruit=list.maxBy{fruit->fruit.length}
    val maxLengthFruit=list.maxBy{it.length}
    val newlist=list.filter { it.length<5 }.map{it.uppercase()}
    for(i in newlist){
        print(i)
    }
    val anyResult=list.any{it.length<=5}
    val allResult=list.all{it.length<=5}
    println(anyResult )
    print(allResult)

let

    study?.readBooks()
    study?.doHomework()

原本一次if判断,变为两次if判断

study?.let{stu->stu.readBooks();stu.readBooks()}
study?.let{it.readBooks();
          it.readBooks()}

with（obj）

传入参数是个obj
代码块就相当于对象的内部，直接调用其函数
最后一行代码作为返回值

val result=with(StringBuilder()){
    append("sth").append("/n")
    toString()
}

obj.run()

非常类似with(),但是

val result=StringBuilder().run{append("sth");"nothing"}

obj.apply{}

无返回

val intent=Intent().apply(putExtry())

空指针检查

>kotlin默认所有参数和变量都不可为空

fun doStudy(study:Study){
    study.readBooks()
    study.doHomework()
}
//等价
public void doStudy(Study study){
  if(study!=null){
    study.readBooks()
    study.doHomework()}
}

>允许可传入空

用?号

val a:Int?=null
fun doStudy(study:Study?){}

但是，外层函数允许空参，里面的函数就未知了，也可能造成空指针
fun doStudy(study:Study?){
study~~.readBooks()~~
}
如：readBook（）{~~this.name~~}

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

简化非空判断

?.

当对象不为空的时候正常，为空的时候不执行

    val s=Study()
    s?.doHomework()

fun doStudy(study: Study?) {
        study?.readBooks()
        study?.doHomework()   
}

?:

类似三目运算符a>b?a:b
a!=null? a : b
左面不为空，返回左侧结果，左边为空，返回右侧结果

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

结合可空传入返回

fun getTextLength(text String?)=text.length?:0

!!

非空断言，非常确定这里不可能为空
如此处
text?.uppercase()，不需要用？.

var text:String?="hello"


if(text!=null){
    doing()
}
fun doing(){
    text?.uppercase()
}

改为text!!.uppercase()

其他

${},文字模版，字符串内嵌表达式

print("hello, ${s.name} ")

默认参数

fun doHomework(work:Studing="数学")

键值对传参

次构造函数的替代，顺序无所谓

val stu1=Student(age=18,name="lihua")

静态方法

单例类

单例类，可以调用静态，但是都是静态

object f{fun func(){}}

普通类里的静态

此类的伴生类，虚假静态，java无法找到并调用

class f{
  fun func(){}
  cpmpanion object{
    fun func2(){}}
}
f.func2()

@JvmStatic注解

只能加在单例类和cpmpanion object中的方法前，能被java调用

cpmpanion object{
    @JvmStatic
    fun func2(){}}

顶层方法

可以单独创建一个文件Func，都是fun func()
java调用就文件名FuncKt.func()

111

11
11
1
1
1
1
1
1
1
1
1
1

------------恢复内容结束------------

posted on 2024-02-20 11:28 李ly 阅读(30) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· android开发，有关时间处理

· 清除缓存解决viewBinding不生效没提示，+ 新手，android stdio，kotlin，viewBinding笔记,2024

· Kotlin入门笔记(适合有JAVA最基本基础的）

· kotlin之基础001

· Kotlin 面向对象编程

阅读排行：
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型，支持深度思考和联网搜索！
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· ollama系列01：轻松3步本地部署deepseek，普通电脑可用
· 25岁的心里话
· 按钮权限的设计及实现

导航

搜索

常用链接

我的标签

随笔分类

随笔档案

阅读排行榜

变量

val和var区别

变量的自动类型推导（弱）

变量的显式声明(强)

数据类型

函数 function

基本形式

语法糖

程序逻辑控制 if when

if else if else

when

循环

while

for in

类，对象

最简单的无构造参数的类

构造函数

主构造函

次构造函数

只次构造函数，无主构造函数

继承

父类构造的继承

接口

接口的继承

修饰符

数据类

单例类，工具类

数据结构

集合List

基本

遍历集合for in

集合Set

Map

Lambda编程

空指针检查

>kotlin默认所有参数和变量都不可为空

>允许可传入空

简化非空判断

?.

?:

!!

其他

${},文字模版，字符串内嵌表达式

默认参数

键值对传参

变量

val和var区别

变量的自动类型推导（弱）

变量的显式声明(强)

数据类型

函数 function

基本形式

语法糖

程序逻辑控制 if when

if else if else

when

循环

while

for in

类，对象

最简单的无构造参数的类

构造函数

主构造函

次构造函数

只次构造函数，无主构造函数

继承

父类构造的继承

接口

接口的继承

修饰符

数据类

单例类，工具类

数据结构