kotlin进阶语法

1. 构造方法

class Child : Parent {
    constructor(name:String) : super(name) {
    }  
}


class Child constructor(name:String) : Parent(name) {
    var name:String? = null
    init {
        //对象初始化的时候可以访问到构造方法参数
        this.name = name;
    }   
}

class Child constructor(name:String) : Parent(name) {
    //成员变量初始化的时候可以访问到构造方法参数
    var name:String? = name
}



class Child constructor(var name:String) : Parent(name) {
    //var name:String或  val name:String 代表声明构造器方法的参数同时声明一个成员变量name
    
    //声明在类名后面的为主构造函数，其他构造函数需要调用主构造函数
    constructor():this(null) {
    }
}

2. data class

data class 
hashCode
equals
toString 
copy
结构声明的component函数

3. ==

java中 == 对比的是对象的地址
kotlin中 == 对比的是equals函数
kotlin中 === 对比的是对象的地址

var name:String  = user.name?: "张三"
相当于
var name:String = user.name
if(name == null) {
  name = "张三"
}

5. 遍历

list.forEach {
  user:User->
  println(user)
}

list.forEach {
  user->
  println(user)
}

list.forEach {
  println(it)
}

6.循环

repeat(100) {
  println(it)
}

for (i in 0..100){
}

for ( i in 0..(list.size-1) ){
}

//until不包含右边界
for (i in 0 until (list.size)){
}

//until其实是一个函数的调用 
for (i in 0.until(list.size)){
}

infix关键字

7. 函数嵌套

 1、防止方法被其他地方调用
 2、内部方法可以访问外部方法的变量
 3、函数嵌套会在每次调用这个函数时生成一个额外的临时对象，循环里面不要用，非必须不用

class KotlinDemoApplication() : Application() {

    override fun onCreate() {
        super.onCreate()
        sApplication = this
    }

    companion object {
         //这两行注解的意思是生成Java可以直接调用的方法，KotlinDemoApplication.sApplication();
        @JvmStatic
        @get:JvmName("sApplication")
        lateinit var sApplication: Application
            private set //将set方法设置为私有的，防止外部赋值
    }

}

//以下两种写法等价
fun get(key:String) {
  SP.getString(key,null)
}


fun get(key:String) = SP.getString(key,null)

10. 函数参数默认值

//这样就可以使用单参数调用，也可以双参数调用了
fun toast(string:String,duration:Int = Toast.LENGTH_LONG)

//构造方法参数也可以有默认值

//但是在Java中只能看到一个双参数构造方法，这时候就要使用@JvmOverloads，这样在Java中调用时可以看到两个重载方法
@JvmOverloads
fun toast(string:String,duration:Int = Toast.LENGTH_LONG)

11. 扩展

//扩展可以给任何一个类加上对应的成员属性和成员方法
//如果扩展函数跟原类的方法相同，则只会使用原类的方法
//扩展函数是静态解析的，扩展函数的调用在编译时已经确定了

//扩展函数：代码中可以使用  1f.dp2px()调用
fun Float.dp2px(): Float {
    return TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, this, Resources.getSystem().displayMetrics)
}

//扩展属性：代码中可以使用 1f.dp调用
val Float.dp: Float
    get() = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, this, Resources.getSystem().displayMetrics)

12. 内联函数

内联函数：将内联函数的代码直接放到调用方函数里面
可以少一层调用栈，可以提高一点点性能(很小)，被调用较多的工具类方法则会复制很多份到调用方代码里面

不要企图利用inline来提升性能，只有在传入参数类型是函数类型时，使用才比较好。因为这种函数在调用时每次都会生成一个对象

inline fun log(string:String){
  Log.e("TAG",string)
}

13. 函数类型参数

class View {
    interface OnClickListener {
        fun onClick(view: View)
    }

    //声明一个接收函数类型参数的方法
    fun setOnClickListener(listener: (view: View) -> Unit) {

    }
}

fun main() {
    val view = View()
    view.setOnClickListener {
        view.toString()
    }

    //传递函数
    view.setOnClickListener(::onClick)

    //传递匿名函数
    view.setOnClickListener(fun(view: View) {
        println(view.toString())
    })
}

fun onClick(view: View) {

}

interface API {

    @GET("lessons")
    fun lessons(): Call<Any>
}

val RETROFIT: Retrofit = Retrofit.Builder()
        .baseUrl("https://www.xxx.xx/")
        .build()

//原方式
fun <T> create(clazz: Class<T>): T {
    return RETROFIT.create(clazz)
}

fun main1() {
    println(create(API::class.java))
}

//内联方式，因为内联函数的存在，我们可以通过配合 inline + reified 达到「真泛型」的效
inline fun <reified T> create(): T {
    return RETROFIT.create(T::class.java)
}

fun main() {
    println(create<API>())
}

14. by lazy

//lazy：只会初始化一次，在第一次访问时初始化
val p : xxPresenter by lazy {
    return@lazy XXPresenter()
    //简写 XXPresenter()
}

//by 委托
//以后再给token赋值或者取值时会执行对应的方法
var token: String by Saver("token")
var token2: String by Saver("token2")

class Saver(var key: String) {
    operator fun getValue(nothing: Nothing?, property: KProperty<*>): String {
        return get(key)!!
    }

    operator fun setValue(nothing: Nothing?, property: KProperty<*>, value: String) {
        save(key, value)
    }
}

15. Kotlin 标准函数

//选择合适的作用域的操作符，是否需要返回自身(apply、also)、不需要返回自身(run、let)
//增强代码可读写
返回⾃身 -> 从 apply 和 also 中选
    作⽤域中使⽤ this 作为参数 ----> 选择 apply
    作⽤域中使⽤ it 作为参数 ----> 选择 also
不需要返回⾃身 -> 从 run 和 let 中选择
    作⽤域中使⽤ this 作为参数 ----> 选择 run
    作⽤域中使⽤ it 作为参数 ----> 选择 let

apply 适合对⼀个对象做附加操作的时候
let 适合配合空判断的时候 (最好是成员变量，⽽不是局部变量，局部变量更适合⽤ if )
with 适合对同⼀个对象进⾏多次操作的时候

16. 注解使⽤处⽬标

@file: 、 @get: 、 @set:

class KotlinDemoApplication() : Application() {

    override fun onCreate() {
        super.onCreate()
        sApplication = this
    }

    companion object {
        @JvmStatic
        @get:JvmName("xxApplication")  //这样就可以在Java中调用get方法
        @set:JvmName("xxxx")
        lateinit var sApplication: Application
    }

}



public class JavaDemo {
    public void demo() {
        KotlinDemoApplication.xxApplication();
        KotlinDemoApplication.xxxx(null);
    }
}