[Android Studio] Kotlin - Drastically reduce the amount of boilerplate code 2

From: http://www.runoob.com/kotlin/kotlin-tutorial.html

Run online: http://www.runoob.com/try/runcode.php?filename=hello&type=kotlin

 

package com.unsw.www.myapplication

import android.support.v7.app.AppCompatActivity
import android.os.Bundle

class MainActivity : AppCompatActivity() {　　　　　　　　　　// 冒号表示“是”，这里就是“继承”的意思

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
}

Kotlin --> Java，不是人能读的，哈哈

package com.unsw.www.myapplication;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import java.util.HashMap;
import kotlin.Metadata;
import org.jetbrains.annotations.Nullable;

@Metadata(
   mv = {1, 1, 7},
   bv = {1, 0, 2},
   k = 1,
   d1 = {"\u0000\u0018\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0002\b\u0002\n\u0002\u0010\u0002\n\u0000\n\u0002\u0018\u0002\n\u0000\u0018\u00002\u00020\u0001B\u0005¢\u0006\u0002\u0010\u0002J\u0012\u0010\u0003\u001a\u00020\u00042\b\u0010\u0005\u001a\u0004\u0018\u00010\u0006H\u0014¨\u0006\u0007"},
   d2 = {"Lcom/unsw/www/myapplication/MainActivity;", "Landroid/support/v7/app/AppCompatActivity;", "()V", "onCreate", "", "savedInstanceState", "Landroid/os/Bundle;", "production sources for module app"}
)

public final class MainActivity extends AppCompatActivity {
   private HashMap _$_findViewCache;

   protected void onCreate(@Nullable Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      this.setContentView(2131296283);
   }

   public View _$_findCachedViewById(int var1) {
      if(this._$_findViewCache == null) {
         this._$_findViewCache = new HashMap();
      }

      View var2 = (View)this._$_findViewCache.get(Integer.valueOf(var1));
      if(var2 == null) {
         var2 = this.findViewById(var1);
         this._$_findViewCache.put(Integer.valueOf(var1), var2);
      }

      return var2;
   }

   public void _$_clearFindViewByIdCache() {
      if(this._$_findViewCache != null) {
         this._$_findViewCache.clear();
      }

   }
}

 

 

 

Kotlin 基础语法

 

默认导入

有多个包会默认导入到每个 Kotlin 文件中：

kotlin.*
kotlin.annotation.*
kotlin.collections.*
kotlin.comparisons.*
kotlin.io.*
kotlin.ranges.*
kotlin.sequences.*
kotlin.text.*
View Code

 

函数定义

fun sum(a: Int, b: Int) = a + b

public fun sum(a: Int, b: Int): Int = a + b   // public 方法则必须明确写出返回类型

 

可变长参数函数

fun vars(vararg v:Int){
    for(vt in v){
        print(vt)
    }
}

// 测试
fun main(args: Array<String>) {
    vars(1,2,3,4,5)  // 输出12345
}

 

lambda(匿名函数)

// 测试
fun main(args: Array<String>) {
    val sumLambda: (Int, Int) -> Int = {x,y -> x+y}　　　　// 等号　代表　形式的等价
    println(sumLambda(1,2))  // 输出 3
}

 

定义常量与变量

val a: Int = 1
val b = 1       // 系统自动推断变量类型为Int
val c: Int      // 如果不在声明时初始化则必须提供变量类型
c = 1           // 明确赋值

var x = 5        // 系统自动推断变量类型为Int
x += 1           // 变量可修改

 

字符串模板

fun main(args: Array<String>) {
    var a = 1
    // 模板中的简单名称：
    val s1 = "a is $a" 　　//　这里的$a已经赋值，之后改变a不影响这里

    a = 2
    // 模板中的任意表达式：
    val s2 = "${s1.replace("is", "was")}, but now is $a"
    print(s2)
}

 

NULL检查机制

//类型后面加?表示可为空
var age: String? = "23" 
//抛出空指针异常
val ages = age!!.toInt()
//不做处理返回 null
val ages1 = age?.toInt()
//age为空返回-1
val ages2 = age?.toInt() ?: -1　　// "?:" 空判断处理

? 可以为空；

?: 为空则使用后面的默认值；

 

类型检测及自动类型转换

fun getStringLength(obj: Any): Int? {

  if (obj is String) {
    // 做过类型判断以后，obj会被系统自动转换为String类型
    return obj.length 
  }

  //在这里还有一种方法，与Java中instanceof不同，使用!is
  // if (obj !is String){
  //   // XXX
  // }

  // 这里的obj仍然是Any类型的引用
  return null
}

 

区间

for (i in 1..4 step 2) print(i) // 输出“13”

for (i in 4 downTo 1 step 2) print(i) // 输出“42”


// 使用 until 函数排除结束元素
for (i in 1 until 10) {   // i in [1, 10) 排除了 10
     println(i)
}

 

 

 

Kotlin 基本数据类型

 

支持了下划线！

val oneMillion           = 1_000_000
val creditCardNumber     = 1234_5678_9012_3456L
val socialSecurityNumber = 999_99_9999L
val hexBytes             = 0xFF_EC_DE_5E
val bytes                = 0b11010010_01101001_10010100_10010010

 

变量常量初始化

var allByDefault: Int? // 错误: 需要一个初始化语句, 默认实现了 getter 和 setter 方法
var initialized = 1    // 类型为 Int, 默认实现了 getter 和 setter
val simple: Int?       // 类型为 Int ，默认实现 getter ，但必须在构造函数中初始化
val inferredType = 1   // 类型为 Int 类型,默认实现 getter

 

比较两个数字

三等号，表示：地址and值完全相等！

 

类型转换

注意：Byte-->int有问题，不能这么搞，只能toInt()，且toXXX()的标配：

toByte(): Byte
toShort(): Short
toInt(): Int
toLong(): Long
toFloat(): Float
toDouble(): Double
toChar(): Char
View Code

 

位操作符

shl(bits)    – 左移位 (Java’s <<)
shr(bits)    – 右移位 (Java’s >>)
ushr(bits)   – 无符号右移位 (Java’s >>>)
and(bits)    – 与
or(bits)     – 或
xor(bits)    – 异或
inv()        – 反向

 

数组

fun main(args: Array<String>) {
    //[1,2,3]
    val a = arrayOf(1, 2, 3)
    //[0,2,4]
    val b = Array(3, { i -> (i * 2) })

    //读取数组内容
    println(a[0])    // 输出结果：1
    println(b[1])    // 输出结果：2
}

注意: 与 Java 不同的是，Kotlin 中数组是不型变的（invariant）。

除了类Array，还有ByteArray, ShortArray, IntArray，用来表示各个类型的数组，省去了装箱操作，因此效率更高，其用法同Array一样：

Goto: 深入剖析Java中的装箱和拆箱

 

数组之遍历：forEach{...}，以及默认迭代器it。

package hello                      //  可选的包头
 
fun main(args: Array<String>) {    // 包级可见的函数，接受一个字符串数组作为参数
    val ints = intArrayOf(1, 2, 3, 0, 4, 5, 6)
    ints.forEach {
        if (it == 0) return　　　　 // it是默认迭代器
        print(it)
    }
}

 

字符串

fun main(args: Array<String>) {
    val text = """
    |多行字符串
    |菜鸟教程
    |多行字符串
    |Runoob
    """.trimMargin()
    println(text)    　　// 删除多余的空白
}

val s = "i = $i" // 求值结果为 "i = 10"
val str = "$s.length is ${s.length}" // 求值结果为 "runoob.length is 6"

 

IF 表达式

我们也可以把 IF 表达式的结果赋值给一个变量。

val max = if (a > b) {
    　　print("Choose a")
    　　a
　　} else {
    　　print("Choose b")
    　　b
　　}

 

When 表达式

(1) when类似其他语言的switch操作符。

when (x) {
    0, 1 -> print("x == 0 or x == 1")
    else -> print("otherwise")
}

(2) 可以检测一个值在（in）或者不在（!in）一个区间或者集合中

when (x) {
    in 1..10        -> print("x is in the range")
    in validNumbers -> print("x is valid")
    !in 10..20      -> print("x is outside the range")
    else            -> print("none of the above")
}

(3) 检测一个值是（is）或者不是（!is）一个特定类型的值。

fun hasPrefix(x: Any) = when(x) {
    is String -> x.startsWith("prefix")
    else -> false
}

fun main(args: Array<String>) {
    val items = setOf("apple", "banana", "kiwi")
    when {
        "orange" in items -> println("juicy")
        "apple"  in items -> println("apple is fine too")
    }
}

 

For 循环

for (i in array.indices) {
    print(array[i])
}

有点Python中的 for idx, val in enumerate(arr) 的意思是：

var array = intArrayOf(1, 2, 3) 
    
for ((index, value) in array.withIndex()) {
　　println("the element at $index is $value")
}

如果是List：

val items = listOf("apple", "banana", "kiwi")
    for (item in items) {
        println(item)
}

 

Break 和 Continue 标签

标签限制的break跳转到刚好位于该标签指定的循环后面的执行点。

continue继续标签指定的循环的下一次迭代。

loop@ for (i in 1..100) {
    for (j in 1..100) {
        if (……) break@loop
    }
}

实例：

package hello                      //  可选的包头
 
fun main(args: Array<String>) {
    test2()
}

fun test2() {
    loop@ for (j in 0..10) {
        for (i in j..10) {
            if (i==5 && j == 5) {
                println("当外层值为 $j 内层值为$i， 使用break标签 跳出循环")
                break@loop　　// 制定跳出这个循环
            } else {
                println("当外层值为 $j 内层值为$i，使用continue标签继续下一次循环")
                continue@loop　　// 指定继续这个循环
            }
        }
    }
}

 

标签处返回

fun foo() {
    ints.forEach lit@ {
        if (it == 0) return@lit　　　　 // 不想跳出foo(),只是跳出ints.forEach
        

        print(it)
    }
}

或者，我们用一个匿名函数替代 lambda 表达式。

fun foo() {
    ints.forEach(fun(value: Int) {
        if (value == 0) return　　　　// 匿名函数内部的 return 语句将从该匿名函数自身返回
        print(value)　　　　　　　　　　// value从哪里来的？
    })
}

这里，ints.forEach自动加入仅仅一个参数值，赋值给了value，看上去是默认的。

package hello                      //  可选的包头
 
fun main(args: Array<String>) {
    val ints = intArrayOf(1, 2, 3, 0, 4, 5, 6)
    
    ints.forEach( fun(value: Int) {
        if (value == 0) return;
        print(value)
    } )
}

注意：解析器优先选用标签限制的 return。

return@a 1　　　　// 意为："从标签 @a 返回 1"

 

 

 

Kotlin 类和对象 基础

 

类的构造

对象创建不需要关键字new。

val site = Runoob()　　//Kotlin 中没有new关键字

如果主构造器没有任何注解，也没有任何可见度修饰符，那么constructor关键字可以省略。

class Person(firstName:String){...}
class Person constructor(firstName:String){...}

 

getter 和 setter

class Person {

    var lastName: String = "zhang"
        get() = field.toUpperCase()   // 将变量赋值后转换为大写
        set
------------------------------------------------------------------
    var no: Int = 100
        get() = field                // 后端变量
        set(value) {
            if (value < 10) {       // 如果传入的值小于 10 返回该值
                field = value
            } else {
                field = -1         // 如果传入的值大于等于 10 返回 -1
            }
        }
------------------------------------------------------------------
    var heiht: Float = 145.4f
        private set
}

// 测试
fun main(args: Array<String>) {
    var person: Person = Person()

    person.lastName = "wang"

    println("lastName:${person.lastName}")

    person.no = 9
    println("no:${person.no}")

    person.no = 20
    println("no:${person.no}")
}

  

后端变量(Backing Fields)

ref: [Kotlin]深入理解backing field

 

  • backing field的意图

在Kotlin语言中，如果在类中定义一个成员变量，Kotlin将自动生成默认setter/getter方法。而Kotlin提供了一种非常特殊的方式声明setter/getter方法：

var name: String? = null
　　set(value) {
　　　　name = value　　　　// <----- 出现了递归调用，自己不断给自己赋值，进入无限梦境空间
　　}
　　get() = name


var name: String? = null
　　set(value) {
　　　　field = value
　　}
　　get() = field
  • 扩展属性
var Dog.color: String = "#ff0000"
        set(value) field = value
        get()            = field 

field是当前属性的影子。而当前属性是与某个实例一一对应的。这就是为什么官方文档说，没有一个有效的办法使扩展属性拥有field字段。结果就尴尬了！

声明扩展属性的时候我们就have to实现setter/getter方法。

  @Nullable
  private String name;
  
  @Nullable
  public final String getName() {
    return this.name;
  }
  
 // 这里的value对应你在set方法中自定义的参数名称
  public final void setName(@Nullable String value) {
    this.name = value;
  }
  • 非空属性

必须在定义的时候初始化，kotlin提供了一种可以延迟初始化的方案，使用 lateinit 关键字描述属性：

public class MyTest {
    lateinit var subject: TestSubject

    @SetUp fun setup() {
        subject = TestSubject()
    }

    @Test fun test() {
        subject.method()  // dereference directly
    }
}

必要性： 

在类内声明的属性必须初始化，
如果设置非NULL的属性，应该将此属性在构造器内进行初始化。
假如想在类内声明一个NULL属性，在需要时再进行初始化（最典型的就是懒汉式单例模式），这看上去与Kotlin的规则是相背的，此时，我们可以声明一个属性并延迟其初始化，此属性用lateinit修饰符修饰。
 

主构造器

实例：

class Runoob  constructor(name: String) {
    var url: String     = "http://www.runoob.com"　　 // step 3
    var country: String = "CN"　　　　　　　　　　　　　　// step 4
    var siteName        = name　　　　　　　　　　　　　　// step 2

    init {
        println("初始化网站名: ${name}")　　　　　　　　　// step 1
    }

    fun printTest() {
        println("我是类的函数")　　　　　　　　　　　　　　// step 5
    }
}

fun main(args: Array<String>) {
    val runoob =  Runoob("菜鸟教程")
    println(runoob.siteName)
    println(runoob.url)
    println(runoob.country)
    runoob.printTest()
}

 

次构造函数

次构造函数 代理 主构造函数 使用 this 关键字：

class Person { 
    constructor(parent: Person) {
        parent.children.add(this) 
    }
}

实例：

class Runoob  constructor(name: String) {  // 类名为 Runoob
    // 大括号内是类体构成
    var url: String      = "http://www.runoob.com"
    var country: String  = "CN"
    var siteName         = name

    init {
        println("初始化网站名: ${name}")
    }

    // 次构造函数
    constructor (name: String, alexa: Int) : this(name) {
        println("Alexa 排名 $alexa")
    }

    fun printTest() {
        println("我是类的函数")
    }
}

fun main(args: Array<String>) {
    val runoob =  Runoob("菜鸟教程", 10000)
    println(runoob.siteName)
    println(runoob.url)
    println(runoob.country)
    runoob.printTest()
}

 

抽象类

open class Base {　　　　　　// open　表示可以继承
    open fun f() {}
}

abstract class Derived : Base() {
    override abstract fun f()
}

 

嵌套类

class Outer {                  // 外部类
    private val bar: Int = 1
    class Nested {             // 嵌套类
        fun foo() = 2
    }
}

fun main(args: Array<String>) {
    val demo = Outer.Nested().foo() // 调用格式：外部类.嵌套类.嵌套类方法/属性
    println(demo)    // == 2
}

 

内部类

class Outer {
    private val bar: Int = 1
    var v = "成员属性"

    /**嵌套内部类**/
    inner class Inner {
        fun foo() = bar  // 访问外部类成员

        fun innerTest() {
            var o = this@Outer //获取外部类的成员变量
            println("内部类可以引用外部类的成员，例如：" + o.v)
        }
    }
}

fun main(args: Array<String>) {
    val demo = Outer().Inner().foo()
    println(demo) //   1
    val demo2 = Outer().Inner().innerTest()   
    println(demo2)   // 内部类可以引用外部类的成员，例如：成员属性
}

 

匿名内部类

既然是匿名类，所以你无法在别的地方使用这个类（实例化，调用它的静态方法之类的）

(1) 在其他包下想调用这个protected方法是不行的。

(2) 在TestClass中搞一个函数callParentTest，如此以匿名的方式调用super.test()。

 

再回到现实当中：

class Test {
    var v = "成员属性"

    fun setInterFace(test: TestInterFace) {
        test.test()
    }
}

/**
 * 定义接口
 */
interface TestInterFace {
    fun test()
}

fun main(args: Array<String>) {
    var test = Test()

    /**
     * 采用对象表达式来创建接口对象，即匿名内部类的实例。
     */
    test.setInterFace(object : TestInterFace {
        override fun test() {
            println("对象表达式创建匿名内部类的实例")
        }
    })
}

 

类的修饰符

类的修饰符包括 classModifier 和_accessModifier_:

  • classModifier: 类属性修饰符，标示类本身特性。

    abstract    // 抽象类  
final       // 类不可继承，默认属性
enum        // 枚举类
open        // 类可继承，类默认是final的
annotation  // 注解类

  • accessModifier: 访问权限修饰符

    private    // 仅在同一个文件中可见
protected  // 同一个文件中或子类可见
public     // 所有调用的地方都可见
internal   // 同一个模块中可见

 

 

 

Kotlin 继承

 

Any类 

Kotlin 中所有类都继承该 Any 类，Any 默认提供了三个函数：

equals()
hashCode()
toString()

如果一个类要被继承，可以使用 open 关键字进行修饰。 

open class Base(p: Int)           // 定义基类
class Derived(p: Int) : Base(p)

 

构造函数

  • 子类有 "主构造函数"
open class Person(var name : String, var age : Int){　　　　// 基类

}

class Student(name : String, age : Int, var no : String, var score : Int) : Person(name, age) {

}

// 测试
fun main(args: Array<String>) {
    val s =  Student("Runoob", 18, "S12346", 89)
    println("学生名： ${s.name}")
    println("年龄： ${s.age}")
    println("学生号： ${s.no}")
    println("成绩： ${s.score}")
}
  • 子类没有 "主构造函数"

必须在每一个二级构造函数中用 super 关键字初始化基类，

或者，再代理另一个构造函数。

/**用户基类**/
open class Person(name:String){
    /**次级构造函数**/
    constructor(name:String,age:Int):this(name){
        //初始化
        println("-------基类次级构造函数---------")　　　　// step 1
    }
}

/**子类继承 Person 类**/
class Student: Person{

    /**次级构造函数**/
    constructor(name:String,age:Int,no:String,score:Int):super(name,age){

        println("-------继承类次级构造函数---------")　　// step 2
        println("学生名： ${name}")　　　　　　　　　　　　// step 3
        println("年龄： ${age}")　　　　　　　　　　　　　// step 4
        println("学生号： ${no}")　　　　　　　　　　　　　// step 5
        println("成绩： ${score}")　　　　　　　　　　　　// step 6
    }
}

fun main(args: Array<String>) {
    var s =  Student("Runoob", 18, "S12345", 89)
}

 

重写

  • 方法重写

在基类中，使用fun声明函数时，此函数默认为final修饰，不能被子类重写。

如果允许子类重写该函数：

    1. 那么就要手动添加 open 修饰它,
    2. 子类重写方法使用 override 关键词
/**用户基类**/
open class Person{
    open fun study(){       // <---- 允许子类重写
        println("我毕业了")
    }
}

/**子类继承 Person 类**/
class Student : Person() {
    override fun study(){    // <---- 重写这个方法
        println("我在读大学")
    }
}

fun main(args: Array<String>) {
    val s =  Student()
    s.study();
}

如果有多个相同的方法（继承或者实现自其他类，如A、B类），则必须要重写该方法，使用super范型去选择性地调用父类的实现。

open class A {
    open fun f () { print("A") }
    fun a() { print("a") }
}

interface B {
    fun f() { print("B") } //接口的成员变量默认是 open 的
    fun b() { print("b") }
}

class C() : A() , B {
    override fun f() {
        super<A>.f()　　//调用 A.f()
        super<B>.f()　　//调用 B.f()
    }
}

fun main(args: Array<String>) {
    val c =  C()
    c.f();
}
  • 属性重写
open class Foo {
    open val x: Int get { …… }
}

class Bar1 : Foo() {
    override val x: Int = ……
}

 

Kotlin 接口

  • 接口方法

使用 interface 关键字定义接口，允许方法有默认实现

interface MyInterface {
    fun bar()    // 未实现
    fun foo() {  //已实现
      println("foo")
    }
}

实现接口方法：

class Child : MyInterface {
    override fun bar() {
        // 方法体
    }
}
  • 接口属性

接口中的属性只能是抽象的，不允许初始化值，接口不会保存属性值；

实现接口时，必须重写属性：

interface MyInterface {
    var name:String //name 属性, 抽象的
    fun bar()
    fun foo() {
        // 可选的方法体
        println("foo")
    }
}

class Child : MyInterface {
    override var name: String = "runoob" //重载属性
    override fun bar() {
        // 方法体
        println("bar")
    }
}

fun main(args: Array<String>) {
    val c =  Child()
    c.foo();
    c.bar();
    println(c.name)
}
  • 函数重写

实现多个接口时，可能会遇到同一方法继承多个实现的问题。例如：

interface A {
    fun foo() { print("A") }   // 已实现　　step 01
    fun bar()                  // 未实现，没有方法体，是抽象的
}
 
interface B {
    fun foo() { print("B") }   // 已实现　　step 02
    fun bar() { print("bar") } // 已实现　　step 03
}
 
class C : A {
    override fun bar() { print("bar") }   // 重写
}
 
class D : A, B {
    override fun foo() {
        super<A>.foo()
        super<B>.foo()
    }
 
    override fun bar() {
        super<B>.bar()
    }
}
 
fun main(args: Array<String>) {
    val d = D()
    d.foo();
    d.bar();
}

 

 

 

 

Kotlin 扩展

 

Kotlin 可以对一个类的属性和方法进行扩展，且不需要继承或使用 Decorator 模式。

扩展是一种静态行为，对被扩展的类代码本身不会造成任何影响。

 

扩展函数

在已有类中添加新的方法

class User(var name:String)

/**扩展函数**/
fun User.Print(){
    print("用户名 $name")
}

fun main(arg:Array<String>){
    var user = User("Runoob")
    user.Print()
}

系统函数添加个扩展函数。

// 扩展函数 swap,调换不同位置的值
fun MutableList<Int>.swap(index1: Int, index2: Int) {
    val tmp = this[index1]     //  this 对应该列表
    this[index1] = this[index2]
    this[index2] = tmp
}

fun main(args: Array<String>) {

    val l = mutableListOf(1, 2, 3)
    // 位置 0 和 2 的值做了互换
    l.swap(0, 2) // 'swap()' 函数内的 'this' 将指向 'l' 的值

    println(l.toString())
}

 

  • 扩展函数是静态解析的！

扩展函数是静态解析的，并不是接收者类型的虚拟成员，

在调用扩展函数时，具体被调用的的是哪一个函数，由调用函数的的对象表达式来决定的，而不是动态的类型决定的:

open class C

class D: C()

fun C.foo() = "c"   // 扩展函数 foo

fun D.foo() = "d"   // 扩展函数 foo

fun printFoo(c: C) {
    println(c.foo())  // 类型是 C 类
}

fun main(arg:Array<String>){
    printFoo(D())
}
  • 扩展函数与成员函数

若扩展函数和成员函数一致，则使用该函数时，会优先使用成员函数。

class C {
    fun foo() { println("成员函数") }　　　// 优先
}

fun C.foo() { println("扩展函数") }　　　　// 被覆盖

fun main(arg:Array<String>){
    var c = C()
    c.foo()
}
  • 扩展一个空对象

在扩展函数内， 可以通过 this 来判断接收者是否为 NULL,

这样，即使接收者为 NULL,也可以调用扩展函数。例如:

fun Any?.toString(): String {
    if (this == null) return "null"
    // 空检测之后，“this”会自动转换为非空类型，所以下面的 toString()
    // 解析为 Any 类的成员函数
    return toString()
}

fun main(arg:Array<String>){
    var t = null　　　　　　　　// 接受者为null,
    println(t.toString())　　 // 这里依然可以使用t.toString()
}
  • 扩展属性

/* implement */

 

伴生对象的扩展

/* implement */

扩展的作用域

/* implement */

扩展声明为成员

/* implement */

 

 

 

Kotlin 数据类与密封类

 

 

继续 。。。

 

posted @ 2017-10-29 13:01  郝壹贰叁  阅读(260)  评论(0)    收藏  举报