Kotlin学习笔记

• 写在前面
• 变量
• 常量
• 构造函数
• 单例？！
• 高阶函数，Lambda，匿名函数，闭包？...
• 扩展函数
• 协程的装逼玩意
• 设计模式

写在前面

变量

lateinit var test1:Int
var test1:Int? = null

//
var test1: Int
    set(value) {
    }
    get() {
        return 1;
    }

//
val test2: Int by lazy {
    val a = 10
    val b = 10
    a + b 
}

常量

你认为下面的写法是常量么？不是，我之前也认为是(只要加了val都是常量)，每次访问currentTimeMillis得到的值是变化的，因而不是常量！！！是不是蒙蔽了.
因为var的变量会 生成(字节码) get,set的方法，val会 生成(字节码) get的方法；

val currentTimeMillis: Long
    get() {return System.currentTimeMillis()}

每次输出我使用 Thread.sleep，看最终打印：

那如何才能写真正的常量呢？一种是使用 const，另一种使用 @JvmField注解
正确的写法：

const val TRANSLATION_ZERO_VALUE = 0f
private const val ROTATION_Y_PROPERTY = "rotationY"
@JvmField val FIELD_CONST_TEST = 250

构造函数

Kotlin 自定义 View 的构造函数 的几种 写法

class TestView : View {
  constructor(context: Context):this(context, null){
  }
  constructor(context: Context, attributeSet: AttributeSet?):this(context, attributeSet, 0){
  }
  constructor(context: Context, attributeSet: AttributeSet?, defStyleAttr: Int):super(context, attributeSet, defStyleAttr) {
  }
}

这种方式类似以前的Java写法

public class TestView extends View {
    public TestView(Context context) {
        this(context, null);
    }
    public TestView(Context context, AttributeSet attrs) {
        this(context, attrs, R.attr.TVUIRoundButtonStyle);
    }
    public TestView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }
}

另一种方式

open class TestView2 constructor(context: Context?, attrs: AttributeSet? = null, defStyleAttr: Int = 0) :
    View(context, attrs, defStyleAttr) {

    val rootRelativeLayout: RelativeLayout by lazy { RelativeLayout(context) }

    init {
        setupRootRelativeLayout()
    }

    private fun setupRootRelativeLayout() {
        rootRelativeLayout.apply {
            id = ViewCompat.generateViewId()
            layoutParams = ViewGroup.LayoutParams(
                LayoutParams.MATCH_PARENT,
                LayoutParams.MATCH_PARENT
            )
        }
    }
}

单例？！

高阶函数，Lambda，匿名函数，闭包？…

如果你学过C/C++，你会发现 高阶函数 和 函数指针 有异曲同工之妙；

高阶函数 就是 以另外一个函数 作为 参数 或者 返回值 的函数
任何以 lambda 或 函数引用 作为 参数 或 返回值 的都是高阶函数

// 高阶函数：函数作为 参数
private fun initArgvFun(result:(Int, Int)->Int):Int {
    return result(1,2)
}
// 看懂了么？函数作为参数，显示写法
val result: (Int, Int) -> Int = { x: Int, y: Int -> x + y }
initArgvFun(result)
// 变化下，缩减下 类型推导，隐示写法
val result = { x: Int, y: Int -> x + y }
initArgvFun(result)
// 再转换下
initArgvFun({ x: Int, y: Int -> x + y })
initArgvFun({ x, y -> x + y })

// 高阶函数：函数作为 返回值
private fun initResultFunCal(): (Int, Int)->Int {
    return { a, b ->
        a + b
    }
}
// 调用方式
val callFunResult = initResultFunCal()
val s = callFunResult(3, 4)
println("callFunResult 返回值: $s")

扩展函数

目录命名 extensions

internal fun View.testFunction():String {
    return "testFunction"
}

协程的装逼玩意

设计模式