Kotlin笔记

前言

笔记主要是由自己使用，用于在书上博客上看到的相关知识整合，以防看完就没了

---

Kotlin

1.类型可变，后置，自动识别

var/val name
//方法用fun关键字
fun functin:Int / var name:String
//name类型自动识别
//kotlin中默认数据是非空类型,令空时特定设定
var name="abcdefg" 

• 表达式为函数体能够自动识别返回类型
  
• is
  相当于Java语言里的Instanceof
  

Kotlin的基本数据类型

2.data

//kotlin中函数默认是public final类型,不可继承，open解决此问题
open class hello{}
//相当于在类中√私有数据的get()set()方法
data class world{}

3.迭代

//i从1到100
for (i in 1..100)
//i从100降序输出到1 且只输出偶数
for (i in 100 downTo 1 step 2)
//1到100半区间输出
for(i in 1 until 100)

• step是正的

4.when

fun hello(color:Color)=
	when(color){
		Color.RED->"blue"
		//多个值合成一个分支
		//->前面相当于if中的条件
		Color.WHITE,Color.BLACK,Color.ORANGE->"blue"
		else->"else"
	}
// 匹配值 -> 执行逻辑

5.字符串模板

//简单些的"$"
val name="world"
println("hello"+"$name")

//复杂些的"${}"
println("hello"+"${max(1,2)}")

6.Unit类型

• 相当于void

fun f():Unit

7.Noting类型

当返回值没有意义或者发生异常时，常用Nothing来替代

fun f(message:String):Nothing{}

8.判断

8.1 in 和 ！in

fun isBetter(c:char)= c in 'a'...'z'&& c !in 'A'...'Z'

8.2 all any count find

val list=listOf(1,2,3,4,5,6,7,8)
val result={i:Int->i%2==0}
println(list.all(result))
/*
集合:
val set=hashSetOf(1,3,5)
val map=hashMapOf(3,5,7,9)
val list=arrayListOf(1,2,3,4,5)
*/

8.3 可空类型

• as?
  类型可为空

name as String
name as? Int

• !!
  一定不为空类型

• !!.
  抛出空指针异常

• ?.
  判空不做处理

A?.toUpperCase()

如果前面有过判空，代码将记住，后面默认为不为空类型

• ?:
  判空处理

A?.B  //当A为null时会返回B  
fun str(s:String?):Int{
   s ?. length ?: 0
}

• as
  类型转换
  as？安全类型转换

val url=URL("http://www.baidu.com");
connection=url.openConnection() as HttpURLConnection

• lateinit
  延迟初始化修饰符

private lateinit var hi:String

kotlin要求构造方法中初始化所有属性，否则必须用可空类型

• == 比较两个值大小 ===比较对象地址

8.4 继承，实现

• ：

//Kotlin默认非抽象类不可被继承，so父类需要用open修饰

MyThread：Thread
MyThread:Runnable

• ::
  将一个方法当做参数，传递到另一个方法中使用

val Intent=Intent(this,MyService::class.java)

9.函数

9.1 高阶函数

参数或返回类型是函数的函数称为高阶函数

fun operation（name:Int,age:Int,exam:(Int,Int)->Int）-> Int{
	return exam(name,age);
}
```　
　　　　　　　　　
- ->



#### 9.2 扩展函数
```kotlin
//格式：被扩展类.扩展方法
/*
  扩展函数特点：
  1.扩展方法不能访问被扩展类的 私有/保护的方法和属性
  2.扩展方法在函数外部，无法访问函数内部
*/
fun String.abc():char=...

9.3 伴生函数

//伴生相当于 static 作用
fun campaion.Sring.

9.4 顶层函数

//函数放入代码文件顶层
package Utils 
fun hi(a:Int,b:Int)=if(a>b) a else b

//调用
import package Utils.hi
fun main(args:Array<String>){
	hi(3,7)
}

9.5 密封类

• static = sealed + abstract
• sealed作用防止类多次派生，引起逻辑混乱，如A继承B，B继承C…
• sealed能被继承但是子类只能执行父类方法不能拓展，且为final,sealed或者unsealed

9.6 修饰符

java	Kotlin
protected 同包及不同包子类	protected子类
default同包	internal模块

9.7 构造函数

• 主构造只能有一个，次构造（constructor关键字）可以有多个
• 主构造没有方法体，用init初始化，不管什么结构体，init先执行

//主构造体--Parent后边可以没有constructor
class Parent constructor(name:String){
   //写逻辑
	init{
		println(name);
	}
}
//次构造体
constructor(name:String,age:Int){}

• 有主构造体，次构造体要执行主，没有就蒜了
• 可以直接/间接委托

//直接
class kotlin {
   class Person (name: String){
   // 初始化代码块本质就是主构造函数的方法体
   // 因为主构造函数在类名头部声明不能带有方法体
       init {
           println(name)
       }
       // 次构造器(通过this直接调用主构造器)
       constructor(age: Int): this("HAHA"){
           println(age)
       }
   }
}

fun main(arge: Array<String>) {
   kotlin.Person(25)
}


//间接
class Parent(name: String) {

   var age = 0;
   var sex = "man"
   
   //次级构造函数1
   constructor(name: String, age: Int) : this("Main name 1") {
       this.age = age;
       println("constructor 1 $name , $age , $sex")
   }

   //次级构造函数2
   constructor(nickName: String, sex: String) : this("nickName jj", 12) {

       this.sex = sex;
       println("constructor 2 $nickName , $age , $sex")
   }

   open fun learn() {
       println(" learn ")
   }
}

fun main() {
   Parent("lucy", "woman").learn()
}

9.8 内部类和嵌套类

类型	java	Kotlin
内部类	class A	inner class A
嵌套类	static class A	class A

9.9 open abstract override

open	abstract	override
不final	抽象，默认open
可以重写	在抽象类中使用，必须重写	重写父类或接口中的成员

abstract class hi{
	//抽象方法默认为open不需要用open显式表示
	//若是非抽象就需要用open
	abstract fun B() //抽象方法
    open  fun A{}  //非抽象方法
    
	/*接口和抽象类格式
	class C : D,E{}
	*/
}

java	kotlin
static	campion
get/set	data
void	Unit
内部类	拓展函数
===	==比较地址值
需要初始化控件	拿id即可使用

9.10 内联函数

• inline

9.11 泛型函数

9.12 单例

9.13集合

• listOf是只读，不可变的集合

val fruit=listOf{melon,apple,banana}
for(i in fruit){
	println(i);
}

9.14 Lambda表达式

runnable

• Java版
  
• Kotlin版