目录
kotlin的基本原理：kottlin文件 编译成字节码文件（.class），将其交给java虚拟机处理
Kotlin的基本语法
变量
- val:常量 不可变
- var:变量 可变
*kotlin的语句是没有结束符号的！！！
Kotlin的自动推导机制
它可以自动根据数值推导出数据类型，如果一个变量延迟赋值的话，它就无法自动推导了
解决方案：显示声明类型
val a:Int=10Kotlin的类型全是类对象一共8种分别对应java的八种基本类型
函数
main函数：入口函数、可以启动程序
自定义函数
fun largNum(a:Int,b:Int):Int{
return max(a,b)
}- fun关键字：声明函数
- 形参的格式： 参数名称：参数类型
- 返回类型（在参数列表后面的:Int）:如果没有返回值可以不用写
简写：
fun largNum1(a:Int,b:Int)= max(a,b)- 省去了返回类型
- 省去了返回值
- 直接将语句的返回值进行返回
控制流程
分为：顺序结构、判断结构、循环结构
判断结构
if语句
和Java中if的区别：if语句可以返回数据
fun Max_Num(num1:Int,num2: Int)=if (num1>num2){
num1
}else{
num2
}分析代码：当num1>num2时，返回num1;当num1<=num2时，返回num2
if语句的返回值直接作为函数的返回值进行返回
when语句
类似于java的switch,但是要比它强大的多，没有数据类型的约束，每一次业务逻辑不需要添加break
fun t_1(name:String)=when(name){
"A"->12
"B"->23
"C"->45
else->0
}格式：匹配值->{执行逻辑}
when的无参格式（不常见）
fun t_2(name:String)=when{
name=="A"->12
name=="B"->23
name=="C"->45
else->0
}格式：判断条件->{执行逻辑}
关键字：is
类似于java中的instanconf 用于判断数据类型
fun t_3(num:Number)=when(num){
is Int -> "int"
is Double-> "double"
else->"No"
}代码分析：根据数据类型不同，输出返回不同的结果
循环语句
when语句与java的用法一致，就不再这里赘述了
for语句
区间的概念
升序区间
- .. : 1..10==>[1,10]
- until: 1 until 10 ==>[1,10)
降序区间
- downTo : 10 downTo 1 ==>[10,1]
关键字：step 步长
// 正序
for(i in 0 until 10){
println(i)
}
println("==========")
// 倒序 步长为2
for(i in 10 downTo 0 step 2){
println(i)
}面向对象编程
类的常用格式
类的定义格式
class Person {
var name:String=""
var age:Int=123
fun displayInformation(){
println("显示信息："+name+age)
}
}- 将属性、行为封装成一个类
创建一个类对象、使用其方法
val person = Person()
person.displayInformation()- 创建对象不需要使用new关键字
构造函数
构造函数分为：主构造函数、次构造函数
主构造函数?
每一个类只能有一个主构造函数
设置主构造函数：在类后面添加即可
class Person(var name:String,var age:Int) {
fun displayInformation(){
println("显示信息："+name+age)
}
}添加主构造函数的业务逻辑 需要使用init关键字
class Person(var name:String,var age:Int) {
init {
println("主构造函数被调用")
}
fun displayInformation(){
println("显示信息："+name+age)
}
}次构造函数
一个类可以拥有多个次构造函数，可以实现java构造函数重载的效果
需要使用constructor关键字，使用次构造函数的时候必须调用主构造函数
constructor():this("张三",123){
displayInformation()
}当没有主构造函数的时候，使用次构造函数
class Person {
constructor(name:String,age:Int){
displayInformation(name,age)
}
fun displayInformation(name:String,age:Int){
println("显示信息："+name+age)
}
}如果存在继承关系，子类没有主构造函数可以调用父类构造函数，使用super关键字
次构造函数可以被函数默认值这一方法所取代。
继承
步骤
- 使该类可以被继承 使用关键字open，kotlin默认不可继承
- 设置继承，使用冒号
定义父类
open class Person {...}设置继承: 继承时调用的时父类的构造方法
class stu:Person("tom",123) {...}子类继承父类的所有属性及其函数
当子类没有设置主构造函数时：父类的构造方法在设置次构造方法时使用，所以就不需要在设置继承时显式调用了
class stu:Person {
constructor():super("ttt",123){getstu()}
...
}接口
接口的定义
interface Dog {
fun t_1()
fun t_2(a:String)
fun t_3(){
println("预定义")
}
}接口中的方法可以提前定义，如果方法提前被定义，那么该方法可以不用重写、
实现接口类
class andom:Dog {
override fun t_1() {
println("第一个方法")
}
override fun t_2(a: String) {
println("第二个方法")
}
}- 实现接口的关键字是冒号":"，与继承相同，但是没有后面的括号
- 重写的关键字是override
实例：多态的体现??
andom是Dog接口的实现类
多态： 接口变量=实现类对象
fun t_8(dog:Dog){
println("hello")
}
fun main(){
val andom = andom()
t_8(andom)
}
数据类
数据类：根据属性，重写equals、toString、hashCode...
使用data关键字即可
创建数据类
data class Cat (var a:String)创建对象 查看是否是数据类
?通过创建相同数据的对象，也可以进行验证
单例类
单例类：避免创建重复的对象
使用关键字object
object Padad {
fun t_1(){}
}权限修饰符
?集合
集合的基本操作
List
创建list的方法
- listOf:创建的是不可变集合，只能读取
- mutableListOf:创建的是可变集合
// 创建list
val list = listOf("A", "B", "C", "D")
// 遍历list
for (l in list) {
println(l)
}Set:不可重复、无序
创建set的方法
- setOf:创建的是不可变集合，只能读取
- mutableSetOf:创建的是可变集合
val setOf = mutableSetOf("A", "B", "C")
for (s in setOf) {
println(s)
}Map
创建map的方法
- mapOf:创建的是不可变集合，只能读取
- mutableMapOf:创建的是可变集合
使用时需要关联词 to
val map = mutableMapOf("A" to 12, "B" to 3)
for ((grade,score) in map) {
println(grade+" "+score)
}Lambda表达式
Lambda的格式：{参数1：参数类型，...->函数体}
功能就是将简短的代码段封装起来，像变量一样反复使用
集合函数式编程
实例一：求最长的单词
val list = mutableListOf("a", "aa", "aaa", "aaaa")
//maxBy:该方法根据传入条件来遍历集合，取出最大值
val maxBy = list.maxBy { it.length }
println(maxBy)当参数列表只有一个参数时，可以不用定义参数名称，使用it即可
实例二：将单词变为大写?
val list = mutableListOf("a", "aa", "aaa", "aaaa")
// map方法：根据传入的条件，遍历，生成新的集合
val map = list.map { it.toUpperCase() }
for (m in map) {
println(m)
}实例三：将字母个数小于3的单词变为大写
val list = mutableListOf("a", "aa", "aaa", "aaaa")
// filter方法：过滤器
val map = list.filter { it.length<3 }.map { it.toUpperCase() }
for (m in map) {
println(m)
}any、all函数
- any函数：有一个符合条件就会返回true
- all函数：全部符合条件才返回true
fun main(){
val list = mutableListOf("a", "aa", "aaa", "aaaa")
val any = list.any { it.length > 3 }
println(any)//true
val all = list.all { it.length > 3 }
println(all)//false
}Java函数式编程
条件：单抽象方法接口
以Thread作为例子
kotlin正常编写方式
Thread(object :Runnable{
override fun run() {
println("开启线程")
}
}).start()使用lambda表达式方式（重点）
Thread{
print("开启线程")
}.start()- 省去了重写方法的过程，直接书写方法体即可，是不是一下子方便多了
空指针异常处理
kotlin默认所有参数、变量均不为空，所以它将空指针异常提前到了编译时期处理
java是运行时期处理空指针异常
如果需要null变量，可以使用可为空变量
- Int：不可为空整型
- Int?:可为空整型
判空的辅助工具
- ？.? ?:a?.xxxx 当a不为空时执行语句
- ？：? ：a=b?:c 左面不为空时，返回左面值；否则，返回右面值
实例：返回字符串的长度
//先判断字符串是否为空，不为空返回其长度，为空返回0
fun t_3(name:String?)= name?.length?:0辅助工具let
let既不是操作符，也不是什么关键字，而是一个函数。这个函数提供了函数式API的编程接口，并将原始调用对象作为参数传递到Lambda表达式中。
格式：
val list = listOf("q", "qq", "qqq")
list.let { list1-> ...}- let中，list1与list是同一个对象
- 如果只有一个参数，可以直接使用it
实例：
以前只使用?.完成判空,缺点：每次都需要进行一次判空
fun t_6(s: stu){
s?.getstu()
s?.getstu()
}现在，使用？.和let搭配使用? 只需要进行一次判空，更加高效
fun t_5(s: stu){
s?.let {
it.getstu()
it.toString()
}
}- let可以解决全局变量的判空问题，而if语句不可以
字符串内嵌表达式
使用格式${},类似于el表达式
fun displayInformation(name:String,age:Int){
println("显示信息：${name},${age}")
// 表达式变量名称唯一 花括号可以省去
println("显示信息：$name,$age")
}函数参数默认值
这个方法可以省去次构造函数
方法中，参数有了默认值，在调用方法中，该参数可传可不传
fun t_7(s:String="hello"){
println(s)
}调用方法时，传入参数的格式可以是键值对
t_7(s="word")构造函数
class Person1(var name:String="",var age:Int=0) {
fun show(){
println("姓名：$name 年龄:$age")
}
}创建对象
fun main(){
// 无参
val person1 = Person1()
// 一个参数
val person11 = Person1(name = "tom")
// 全参
val person12 = Person1(name = "tom", age = 456)
}