Kotlin实战开发总结

2018-09-29 本文已影响0人丁小胖fly

本文的demo地址（https://github.com/dingjinwen/kotlin_tips）

Tip1-Kotlin和Java相互查看

1. Kotlin转化为Java代码查看

kotlin文件是不能直接转化为Java文件的，但是可以将Kotlin代码转化成Java语言去理解，步骤如下：在Android Studio中选择Tools ---> Kotlin ---> Show Kotlin Bytecode 这样就把Kotlin转化为Class字节码了,Class字节码阅读不太友好，点击左上角的Decompile就转化为Java

2. Java文件直接转化为Kotlin文件

再介绍一个小窍门，在前期对Kotlin语法不熟悉的时候，可以先用Java写好代码，再利用AndroidStudio工具将Java代码转化为Kotlin代码，步骤如下：在Android Studio中选中要转换的Java代码 ---> 选择Code ---> Convert Java File to Kotlin File

Tip2-属性

1. 什么时候属性类型不能省略？

a. 属性的修饰符，和方法类似的，属性也有多种修饰符(public,protected,private)。
如果可以根据属性的值推断出属性类型，则可省略类型,比如：
var aa: String = ""

b. 不能根据属性的值推断出属性类型，则不可省略类型,比如：
abstract修饰的属性,自身不能初始化，要在子类进行初始化，不能省略类型
lateinit延迟初始化的，在使用之前再初始化的，不能省略类型

2. 属性的组成部分

对属性的访问，并不是像Java里面一样，直接访问属性的本身，而是默认调用了 get 和 set 方法，保证了属性的闭合性. 一般属性包含三个部分，set , get 和 backing filed.

var aa: String = "" 
    set(value) {
         field = value //field是（Backing field）幕后字段
    }
    get() {
        return field
    }

3. 自定义set 和 get 方法

var,val修饰的变量默认是 public 的，编译器会自动生成 set 和 get 方法,也可以手动重写他的 set 和 get 方法,val只有 get 方法

var aa: String = "ding jin wen " 
    set(value) {
        field = value + "  123  "
    }
    get() {
        return field + "大地零一"
    }

    Log.d("text", "aa : $aa")
    aa = "zhang san"
    Log.d("text", "aa : $aa")

    //输出
    aa:ding jin wen 大地零一
    aa:zhang san 123 大地零一

4. 幕后字段(Backing Field)

kotlin的 get和 set 是不允许访问本身的局部变量的，因为属性的调用也是对get的调用，因此会产生递归，造成内存溢出。

属性1.jpg

5. 延迟初始化lateinit 和懒初始化by lazy

lateinit var aa:String 

a.lateinit只能用于var声明的类变量，并且属性没有自定义get或set方法。

b.属性的类型必须是非空的

val aa:String by lazy { }

a.lazy只能作用在val属性,应用于单例模式,当且仅当属性被第一次调用的时候,委托方法才会执行。

b.lazy()是接受一个 lambda 并返回一个 Lazy <T> 实例的函数,返回的实例可以作为实现延迟属性的委托, 第一次调用 get() 会执行已传递给 lazy() 的 lambda 表达式并记录结果,后续调用 get() 只是返回记录的结果。

属性2.jpg

6. 编译器常数值

如果在编译期间，属性值就能被确定，该类属性值使用const 修饰符，类似Java里面的静态常量用法。这类属性必须满足以下条件：
a. 必须是顶级属性，或者是一个object的成员
b. 值被初始化为 String 类型，或基本类型(primitive type)
c. 只能修饰val常量
d. 不存在自定义的取值方法

const val key = "key"
object Config {
    const val name="name"
}

7. 委托属性

有一种属性，在使用的时候每次都要手动实现它，但是可以做到只实现一次，并且放到库中，一直使用，这种属性称为委托属性。

委托属性包括：
a. 延迟属性(lazy properties)：上面第5点中已经提到了。
b. 可观察属性(observable properties)：监听得到属性变化通知。

//看下面例子，快速双击退出页面
var mBackPressedTime by Delegates.observable(0L) {
    prop, old, new ->//三个参数，分别是：被赋值的属性，旧值和新值。
        if (new - old > 1000) {
            Toast("再按一次返回就退出")
        }
        if (new - old in 1..1000) {
            finish()
        }
    }

override fun onBackPressed() {
    mBackPressedTime = System.currentTimeMillis()
}

c. Map委托属性(Storing Properties in a Map)：将所有属性存在Map中。

class Person2(private val maps: Map<String, String>) {
        val name: String by  maps
        val company: String by  maps
        val address: String by  maps
        val email: String by  maps
    }

    fun main(args: Array<String>) {
        val data = mapOf("name" to "Jack", "company" to "JetBrains")
        val p = Person2(data)
        println(p.name) // Jack
    }

Tip3-函数

1. 变参函数

//在Java中，我们这么表示一个变长函数
public boolean hasEmpty(String... strArray){
    for (String str : strArray){
        if ("".equals(str) || str == null)
            return true;
    }
    return false;
}

//在Kotlin中，使用关键字vararg来表示
fun hasEmpty(vararg strArray: String?): Boolean{
    for (str in strArray){
        if (str.isNullOrEmpty())
            return true
    }
    return false
}

2. 扩展函数

声明一个扩展函数，我们需要在函数的名称前加上一个接收者类型并且加上.符号,在扩展函数中的this关键字表示接收者对象

fun Activity.toast(message: CharSequence, duration: Int = Toast.LENGTH_SHORT) {
    Toast.makeText(this, message, duration).show()
}

扩展是静态解析

open class Animal

class Dog : Animal()

fun Animal.bark() = "animal"

fun Dog.bark() = "dog"

fun printBark(animal: Animal) {
    println(animal.bark())
}

printBark(Animal()) 和 printBark(Dog())打印的都是 animal ,因为在定义扩展函数的时候接收对象类型是Animal类，而Kotlin的扩展是静态解析的，所以即使调用的时候是传了Animal类的子类Dog类进去，还是会执行定义的时候的类型的函数。

3. 构造函数

kotlin里面的构造函数，分为主构造函数和次构造函数,主构造函数写在类头中,跟在类名后面,次构造函数写在类体中，关键字是constructor,次构造函数必须直接或者间接地委托到主构造函数

class Student(private var name: String) {
    private var age: Int? = null
    private var classId: Int? = null

    constructor(name: String, age: Int) : this(name) {
        this.age = age
        this.name = name
    }

    constructor(classId: Int, name: String, age: Int) : this(name, age) {
        this.classId = classId
        this.age = age
        this.name = name
    }

    fun sayHello() {
        Log.e("test", "hello $name")
        Log.e("test", "hello $classId")
        Log.e("test", "hello $age")
    }
}

btn.setOnClickListener {
    Student(1, "zhang san", 20).sayHello()
    // 打印test: hello zhang san
    // 打印test: hello 1
    // 打印test: hello 20
}

4. 单例怎么写？

不带参数(两种写法)

伴生对象更多的用途是用来创建一个单例类。只是简单的写，直接用伴生对象返回一个val修饰的外部类对象就可以了

class Single private constructor() {
    companion object {
        val instance = Single()
    }
}

但是更多的时候我们希望在类被调用的时候才去初始化他的对象。以下代码将线程安全问题交给虚拟机在静态内部类加载时处理，是一种推荐的写法：

class Single private constructor() {
    companion object {
        val instance: Single by lazy { Holder.INSTANCE }
    }

    private object Holder {
        val INSTANCE = Single()
    }
}

带参数

/**
* 简单写法
*/
class Single private constructor(name:String) {
    companion object {
        @Volatile
        private val instance:Single?=null
        fun getInstance(c:String):Single{
            if (instance == null) {
                synchronized(Single::class) {
                    if (instance == null) {
                        instance = Singleton(c)
                    }
                }
            }
            return instance!!
        }
    }
}

/**
 * 带参数的单例，去掉断言，google推荐的写法
 */
class SingleInstance private constructor(name: String) {
    companion object {
        @Volatile
        private var instance: SingleInstance? = null

        fun getInstance(name: String): SingleInstance {
            return instance ?: synchronized(this) {
                instance ?: SingleInstance(name).also {
                    instance = it
                }
            }
        }
    }
}

5. 静态方法

Kotlin 没有静态方法,在项目中常用的两种方法：

用@jvmStatic注解,和Java的static类似

object StringUtils {
    @JvmStatic fun isEmpty(str: String): Boolean {
        return "" == str
    }
}

使用伴生对象

class StringUtils {
    companion object {
    fun isEmpty(str: String): Boolean {
            return "" == str
        }
    }
}

6. let,apply,with,run,also的用法和区别

先看下面这个例子，打印字母表函数

/*
*打印字母表函数，在函数内result变量在好几处有使用到
*/
fun alphabet(): String {
    val result = StringBuilder()
    result.append("START\n")
    for (letter in 'A'..'Z') {
        result.append(letter)
    }
    result.append("\nEND")
    return result.toString()
}

在上面的函数中，result变量出现了5次，下面分别用apply,with,let来简化这个函数，可以将这5次都不用再出现了

apply用法：

/**
* 打印字母表函数，apply函数，调用某对象的apply函数，在函数范围内，可以任意调用该对象的任意方法，并返回该对象
*/
private fun alphabetApply(): String {
    // fun <T> T.apply(f: T.() -> Unit): T { f(); return this }
    return StringBuilder().apply {
        append("START\n")
        for (letter in 'A'..'Z') {
            append(letter)
        }
        append("\nEND")
    }.toString()
}

btn.setOnClickListener {   
    Log.d("test", StringUtils.alphabetApply())
}
//打印 
//START
//ABCDEFGHIJKLMNOPQRSTUVWXYZ
//END

with用法：

/**
* 打印字母表函数，with函数是一个单独的函数，并不是Kotlin中的extension，所以调用方式有点不一样，返回是最后一行
*/
private fun alphabetWith(): String {
    // fun <T, R> with(receiver: T, f: T.() -> R): R = receiver.f()
    return with(StringBuilder()) {
        append("START\n")
        for (letter in 'A'..'Z') {
            append(letter)
        }
        append("\nEND")
        toString()
    }
}

btn.setOnClickListener {   
    Log.d("test", StringUtils.alphabetWith())
}
//打印 
//START
//ABCDEFGHIJKLMNOPQRSTUVWXYZ
//END

let用法：

/**
 * 打印字母表函数，let函数，默认当前这个对象作为闭包的it参数，返回值是函数里面最后一行，或者指定return
 * XX?.let{}这种写法在代码中，比较常见
 * XX?:let{}
 */
private fun alphabetLet(): String {
    // fun <T, R> T.let(f: (T) -> R): R { f(this)}
    return StringBuilder().let {
        it.append("START\n")
        for (letter in 'A'..'Z') {
            it.append(letter)
        }
        it.append("\nEND")
        it.toString()
        //  return it.toString()
    }
}
btn.setOnClickListener {   
    Log.d("test", StringUtils.alphabetLet())
}
//打印 
//START
//ABCDEFGHIJKLMNOPQRSTUVWXYZ
//END

also用法：

/**
* also()函数和let()函数很像，但是返回值为该对象自己
* 字面理解：做。。。的同时也做。。。
*/
fun testAlso() {
    // fun <T> T.also(block: (T) -> Unit): T { block(this); return this }
    "testAlso".apply {
        println("this = " + this)
    }.also { println(it) }
}

btn.setOnClickListener {   
    Log.d("test", StringUtils.testAlso())
}
//打印 
//System.out: this = testAlso
//System.out: testAlso

run用法：

/**
* run函数和apply函数很像，只不过run函数是使用最后一行的返回，apply返回当前自己的对象。
*/
fun testRun() {
    // fun <T, R> T.run(f: T.() -> R): R = f()
    "testRun".run {
        println("this = " + this)
    }.let { println(it) }
}
btn.setOnClickListener {   
    Log.d("test", StringUtils.testRun())
}
//打印 
//System.out: this = testRun
//System.out: kotlin.Unit

8.中缀函数

中缀表达式是操作符以中缀形式处于操作数的中间（例：3 + 4），先来看一下Kotlin中的中缀函数：

在mapOf()方法中的to就是个中缀函数

// public infix fun <A,B> A.to(that:B):Pair<A,B> = Pair(this,that)
val map: Map<Int,Int> = mapOf(1 to 1,2 to 2)

Range里面的downTo也是个中缀函数：

（10 downTo 1）.forEach{print(it)}

使用中缀符号infix修饰函数，但必须符合一些条件：

使用infix关键字表示
必须是成员方法或者扩展函数
函数只有一个参数

下面来写个中缀函数：

// 定义扩展函数
infix fun Int.add(x: Int): Int  = this + x

fun main(args: Array<String>) {
    // 用中缀符号表示的扩展函数
    println("2 add 1:${2 add 1}") // 打印：2 add 1:3
    // 与下面是相同的
    println("2.add(1):${2.add(1)}") // 打印：2.iInfix(1):3
}

Tip4-自定义属性委托

1. 只读属性实现委托

只读属性（使用val定义）,委托类需实现getValue函数

interface ReadOnlyProperty<in R, out T> {
    operator fun getValue(thisRef: R, property: KProperty<*>): T
}

2. 可变属性实现委托

可变属性（使用var定义）,委托类需实现getValue函数和setValue函数

interface ReadWriteProperty<in R, T> {
    operator fun getValue(thisRef: R, property: KProperty<*>): T
    operator fun setValue(thisRef: R, property: KProperty<*>, value: T)
}

3. 一个委托实例

下面来看一个自定义的Delegate，用来访问SharedPreference，这段代码是Kotlin for Android Developer的示例：

class Preference<T>(val context: Context, val name: String, val default: T) : ReadWriteProperty<Any?, T> {

    val prefs by lazy { context.getSharedPreferences("default", Context.MODE_PRIVATE) }

    override fun getValue(thisRef: Any?, property: KProperty<*>): T {
        return findPreference(name, default)
    }

    override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
        putPreference(name, value)
    }

    private fun <U> findPreference(name: String, default: U): U = with(prefs) {
        val res: Any = when (default) {
            is Long -> getLong(name, default)
            is String -> getString(name, default)
            is Int -> getInt(name, default)
            is Boolean -> getBoolean(name, default)
            is Float -> getFloat(name, default)
            else -> throw IllegalArgumentException("This type can be saved into Preferences")
        }

        res as U
    }

    private fun <U> putPreference(name: String, value: U) = with(prefs.edit()) {
        when (value) {
            is Long -> putLong(name, value)
            is String -> putString(name, value)
            is Int -> putInt(name, value)
            is Boolean -> putBoolean(name, value)
            is Float -> putFloat(name, value)
            else -> throw IllegalArgumentException("This type can be saved into Preferences")
        }.apply()
    }
}

使用的时候：

class ExampleActivity : AppCompatActivity(){
    var a: Int by Preference(this, "a", 0)
    
    fun whatever(){
        println(a)//会从SharedPreference取这个数据
        aInt = 9 //会将这个数据写入SharedPreference
        println(a)//会从SharedPreference取这个数据
    }
}

Tip5-委托模式

Kotlin支持委托模式，与java的动态代理类似，有两个对象参与处理同一个请求，接受请求的对象将请求委托给另一个对象来处理。java里面动态代理是用反射来实现的，还要添加额外的很多代码，相比较kotlin的动态代理就简单很多了。

interface Animal{
    fun bark()
}

class Dog :Animal {
    override fun bark() {
        Log.e("test","Wang Wang")
    }
}

class Cat(animal: Animal) : Animal by animal {
}

fun main(args: Array<String>) {
   Cat(Dog()).bark()
}

//输出：wangwang
//这个实例中，用狗代理了猫,帮猫处理了叫声的操作

class CountingSet2<T>(val innerSet: MutableCollection<T> = HashSet<T>()) :MutableCollection<T> by innerSet{

    var objectAdded = 0

    init {
        objectAdded += innerSet.size
    }

    override fun add(element: T): Boolean {
        objectAdded++
        return innerSet.add(element)
    }

    override fun addAll(elements: Collection<T>): Boolean {
        objectAdded += elements.size
        return innerSet.addAll(elements)
    }
}

val hashSet = hashSetOf("1", "2", "3", "4")
val set = CountingSet2(hashSet)
set.addAll(listOf("5", "6", "7"))
Log.e("test", "set-----${set.size}----${set.objectAdded}")

//输出：set-----7----7
//这个实例中，用innerSet代理了CountingSet2,帮CountingSet2处理了add,addAll的操作

Tip6-Lambda表达式与高阶函数

1. Lambda 表达式的语法

一个Lambda表达式通常使用{ }包围，参数是定义在()内，可以添加类型注解，实体部分跟在“->”后面；如果Lambda的推断返回类型不是Unit，那么Lambda主体中的最后一个（或单个）表达式将被视为返回值。
先来看下面的例子：

val sum: (Int, Int) -> Int = { x, y -> x + y }  

// val printMsg: (String) -> Unit = { msg: String -> println(msg)}
val printMsg = { msg: String -> 
    println(msg) 
}

fun main(args: Array<String>) {
  sum(2，3)
  printMsg.invoke("hello")
}

//输出：hello

2. Lambda 表达式的约定

当参数只有一个的时候，声明中可以不用显示声明参数，在使用参数时可以用 it 来替代那个唯一的参数。

class Num {
    fun oneParams(one : (Int) -> Int){
        println("oneParams : ${one(5)}")
    }
}

fun main(args : Array<String>){
    val num = Num()
    // num.oneParams({ it -> it * 2 })
    num.oneParams{it * 2}
}

// 输出oneParams : 10

当有多个用不到的参数时，可以用下划线来替代参数名(1.1以后的特性)，但是如果已经用下划线来省略参数时，是不能使用 it 来替代当前参数的。

class Num {
    fun unusedParams(unused : (Int,Int) -> Int){
        println("unusedParams : ${unused(5,10)}")
    }
}

fun main(args : Array<String>){
    val num = Num()
    num.unusedParams { _, used -> used * 2 }
    // num.unusedParams { _, used -> it * 2 }  这种写法是编译不过的，不能使用 it 来替代当前参数的。
}

// 输出 unusedParams : 20

如果函数的最后一个参数是一个函数，那么我们在用Lambda表达最后一个函数参数的时候，可以把它放在括号()外面，所以下面的写法是等价的。

class Num {
    fun logic(a: Int, b: Int, calc: (Int, Int) -> Int){
        println("calc : ${calc(a,b)}")
    }
}

fun main(args : Array<String>){
    val num = Num()
    // num.logic(1, 2,{x,y -> x+y})
    num.logic(1, 2){x,y -> x+y}
}

Lambda 最后一条语句的执行结果表示这个 Lambda 的返回值。

// 写法2
num.unusedParams { _, used ->
    println("print first")
    used * 2
    // 下面这种写法是等价的
    // return@unusedParams used * 2
}

Lambda表达式来简化OnClickListener的写法：

interface OnClickListener {
    fun onClick()
}

class View {
    var listener: OnClickListener? = null;

    /*
    * 传统方式
    * 
    */
    fun setOnClickListener(listener: OnClickListener) {
        this.listener = listener
    }

    fun doSth() {
        // some case:
        listener?.onClick()
    }
    
    // 但是这种方式仅适用于有一个回调函数的情况

    /*
    * 声明lambda方式，listener: () -> Unit
    * 函数可以是一种类型,一个变量可以是函数类型的
    */
    var listener1:()->Unit

   
    fun setOnClickListener(listener: () -> Unit) {
        this.listener1=listener
    }

    fun doSth() {
        // some case:
        listener1?.invoke()
    }
}

3. 高阶函数

Lambda 表达式最大的特点是可以作为参数传递。当定义一个闭包作为参数的函数，称这个函数为高阶函数。（通常情况下，我们所说的闭包是 Lambda 表达式）

fun main(args: Array<String>) {
    log("world", printMsg)
}

val printMsg = { str: String ->
    println(str)
}

val log = { str: String, printLog: (String) -> Unit ->
    printLog(str)
}
//输出：world
//log 有两个参数，一个str:String，一个printLog: (String) -> Unit。

函数作为返回值
函数作为返回值也非常实用，例如我们的需求是根据不同的快递类型返回不同计价公式，普通快递和高级快递的计价规则不一样，这时候我们可以将计价规则函数作为返回值：

enum class Delivery {
    STANDARD, EXPEDITED
}

/*
* 根据不同的运输类型返回不同的快递方式
* */
fun getShippingCostCalculator(delivery: Delivery): (Int) -> Double {
    if (delivery == Delivery.EXPEDITED) {
        return { 6 + 2.1 * it }
    }
    return { 1.3 * it }
}

fun test05() {
    val calculator1 = getShippingCostCalculator(Delivery.EXPEDITED)
    val calculator2 = getShippingCostCalculator(Delivery.STANDARD)
    println("Ex costs ${calculator1(5)}")
    println("St costs ${calculator2(5)}")
}

如果是普通快递，采用1.3 * it的规则计算价格，如果是高级快递按照6 + 2.1 * it计算价格，根据不同的类型返回不同的计价函数。

Tip7-数据类

1. 用法和重要方法介绍

data class User(var name: String, var age: Int)
会自动生成getter和setter方法，还有componentN()，对应按声明顺序出现的所有属性，如name就是component1()，age就是component2()。
当然还有 equals()、hashCode()、和 toString()（输出的格式为User(name=..., age=...)）
如果构造函数参数中没有声明是val或者var，这些函数就不会生成
主构造函数需要有至少一个参数
数据类不能有abstract、open、sealed和inner修饰
在1.1版本之前，数据类只能实现接口
在构造函数那里也说过，如果生成的类需要一个无参数的构造函数，则必须指定所有属性的默认值
data class User(var name: String = "lily", var age: Int = 0)
eg.比如适用fastjson解析json串为对象时，要求数据类必须有一个无参的构造函数，就要用到上面的写法了
复制(copy)
数据类在创建的时候，除了会生成上面的几个方法外，还会生成一个copy()函数，copy()能够复制一个对象改变它的一些属性情况下，又要保持其余的不变，如上面的User类，copy()函数的实现：

fun copy(name: String = this.name, age: Int = this.age) = User(name, age)

在使用copy()之后，就可以修改数据类的一些属性了：

val jack = User(name = "jack", age = 1)
val olderJack = jack.copy(age = 2)

2.Pair和Triple

Kotlin提供了Pair和Triple作为标准数据类，命名数据类是更好的设计选择。
两个参数的时候使用Pair数据类
三个参数的时候使用Triple数据类

/**
* 元组（Tuple），给多个变量同时赋值，分二元（Pair）和三元（Triple）
 */
val (year, month, day) = Triple(2017, "6月", "14号")
Log.e("test", "${year}年$month$day")

val date = Triple(2017, "6月", "14号")
Log.e("test", "${date.first}年${date.second}${date.third}")
//二元同上，把Triple换成Pair

3.解构声明

在Kotlin中创建变量的话是这样的

data class Person(var name: String, var age: Int)

fun main(args: Array<String>) {
    val person = Person("jowan", 1)
    var name = person.name
    var age = person.age
    println(name) // 打印jowan
    println(age) // 打印1
}

使用解构变量，同时创建多个变量

data class Person(var name: String, var age: Int)

fun main(args: Array<String>) {
    val (name, age) = Person("person", 1)
    println(name) // 打印person
    println(age) // 打印1
}

Anko

Anko是 JetBrains 公司开发的一个强大的库，主要的目的是用来替换之前用XML的方式，来使用代码生成UI布局

1. Anko四个组成部分内容

Anko Commons
轻量级的一些帮助类，比如 intent，dialog，logging 等等，其实就是对安卓一些类：Activity、Fragment、Intent 等添加扩展函数。
Anko Layouts
动态布局用的最主要的库，将许多 Android 的控件 View 转换成了 Anko 加载的形式。
由于 Android 还有其他的控件库，因此 Anko 也对那些库进行了拓展支持，可以选择添加对应的依赖库。
当然，还可以根据需要对自定义 View 进行改造，让它们也支持 Anko 加载的形式。
Anko SQLite
用于 Android SQLite 数据库的查询的库
Anko Coroutines
基于 kotlinx.coroutines 协程的一个工具库。

2. Anko用法示例

Anko Toast的简单用法

toast("大地零一")
longToast("大地零一")

Anko Dialog的简单用法

alert("确定删除吗?"){
yesButton { toast("确定") }
noButton { toast("取消") }
}.show()

Anko Intent的简单用法

startActivity(intentFor<MainActivity().singleTop())

Anko Coroutines
Anko还提供了协程的用来做一些耗时的操作，提供的操作为bg{},具体代码如下：

async(UI){//UI线程
    val data: Deferred<MyBean> = bg {//后台线程
        // Runs in background
        MyBean()
    }

    showData(data.await()) //await方法将一直等待bg返回的数据
}

为了防止内存泄漏我们常会使用弱引用，在Anko中使用弱引用方法如下

val ref: Ref<AnkoActivity05> = this.asReference()
    async(UI){
        //ref替代了this@AnkoActivity05
        ref().showData()
    }

Anko Layout

<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_height="match_parent"
    android:padding="30dp"
    android:layout_width="match_parent">

    <EditText
        android:id="@+id/todo_title"
        android:layout_width="match_parent"
        android:layout_heigh="wrap_content"
        android:hint="@string/title_hint" />

    <!-- Cannot directly add an inline click listener as onClick delegates implementation to the activity -->
    <Button
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@string/add_todo" />

</LinearLayout>

用 Anko 描述的同样的视图

verticalLayout {
    padding = dip(30)
    var title = editText {
        id = R.id.todo_title
        hintResource = R.string.title_hint
    }
    button {
        textResource = R.string.add_todo
        onClick { view -> {
                // do something here
                title.text = "Foo"
            }
        }
    }
}

3. 不足

Anko 好是好，但是依旧不够完美。
在 XML 中能够设置的控件属性更多，更精确的控制布局状态，而 Anko 在构建简单界面的时候才显得快速、便捷。
而且 Anko 支持的控件有限，加载自定义的控件还得添加额外的代码，在更复杂的应用中应该不太会广泛的使用。

总结

Kotlin是一门相对比较新的JVM语言，JetBrains自2011年以来一直在积极地开发。多年来，该语言在Android社区受到的关注度越来越高，并在Google IO 2017大会之后成为Android开发领域最热门的话题。这次大会宣布，Android正式支持Kotlin。Kotlin在Java以及多种语言的基础上，去掉了冗余代码，代码更加简洁，可读性更强，Kotlin还为已有的Java类提供一组好用的扩展,绝大部分Java能实现的功能kotlin也是可以实现的，以后开发中，推荐大家能使用Kotlin的地方尽量使用。

Kotlin实战开发总结

Tip1-Kotlin和Java相互查看

1. Kotlin转化为Java代码查看

2. Java文件直接转化为Kotlin文件

Tip2-属性

1. 什么时候属性类型不能省略？

2. 属性的组成部分

3. 自定义set 和 get 方法

4. 幕后字段(Backing Field)

5. 延迟初始化lateinit 和懒初始化by lazy

6. 编译器常数值

7. 委托属性

Tip3-函数

1. 变参函数

2. 扩展函数

3. 构造函数

4. 单例怎么写？

5. 静态方法

6. let,apply,with,run,also的用法和区别

8.中缀函数

Tip4-自定义属性委托

1. 只读属性实现委托

2. 可变属性实现委托

3. 一个委托实例

Tip5-委托模式

Tip6-Lambda表达式与高阶函数

1. Lambda 表达式的语法

2. Lambda 表达式的约定

3. 高阶函数

Tip7-数据类

1. 用法和重要方法介绍

2.Pair和Triple

3.解构声明

Anko

1. Anko四个组成部分内容

2. Anko用法示例

3. 不足

总结

猜你喜欢

热点阅读

Kotlin实战开发总结

Tip1-Kotlin和Java相互查看

1. Kotlin转化为Java代码查看

2. Java文件直接转化为Kotlin文件

Tip2-属性

1. 什么时候属性类型不能省略？

2. 属性的组成部分

3. 自定义set 和 get 方法

4. 幕后字段(Backing Field)

5. 延迟初始化lateinit 和 懒初始化by lazy

6. 编译器常数值

7. 委托属性

Tip3-函数

1. 变参函数

2. 扩展函数

3. 构造函数

4. 单例怎么写？

5. 静态方法

6. let,apply,with,run,also的用法和区别

8.中缀函数

Tip4-自定义属性委托

1. 只读属性实现委托

2. 可变属性实现委托

3. 一个委托实例

Tip5-委托模式

Tip6-Lambda表达式与高阶函数

1. Lambda 表达式的语法

2. Lambda 表达式的约定

3. 高阶函数

Tip7-数据类

1. 用法和重要方法介绍

2.Pair和Triple

3.解构声明

Anko

1. Anko四个组成部分内容

2. Anko用法示例

3. 不足

总结

猜你喜欢

热点阅读

5. 延迟初始化lateinit 和懒初始化by lazy