android 从0开始重构项目 kotlin教程

/*

一直在独立开发，也没时间调整自己的知识系统，虽然写代码速度变快了，项目经验很丰富了，但是快2年了。还是

用以前的开发方式。打算从0开始，开始重新架构我最近刚写完的护林系统。后面也打算开源出去。在此自勉吧。

这个项目就是使用kotlin，我就花了几天就入门。比较简单，但是就是写java 习惯了。之前还坚信 koltin不可能

取代java,因为android 底层，还有大量的库类和 思想都是适用于 java的，koltin只是让写代码变得方便了，但是

没有实质改变。但是像 很多android 程序员 都是独立开发项目的，大量的业务逻辑需要去写，真正只写核心代码

的人比较少吧。所以抱着试一试的态度尝试下。

 

*/

 

kotlin教程： http://www.runoob.com/kotlin/kotlin-basic-syntax.html

根据这个教程大致讲解下:

1.不需要分号结尾，有也没事

2.导包可以把导入一个文件夹，在导入的包比较多的时候，让代码界面看着舒服。

• kotlin.annotation.*

3.函数定义，给人感觉像人类文字， 直观翻译就是： 方法 sum 传入 （ a （int类型）, b(int类型)） 返回 int类型结果

fun sum(a: Int, b: Int): Int {   // Int 参数，返回值 Int
    return a + b
}

4. 表达式作为函数体，实际用处不大 。 在 代码太多了，需要简化代码时候可以使用下

表达式作为函数体，返回类型自动推断：

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

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

 

5.可变长参数函数 ，java也有但是麻烦， 使用场景很多，比如接口传递参数时候

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

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

6.lambda表达式   ， 核心了 

// 这里举例一个Android中最常见的按钮点击事件的例子 
mBtn.setOnClickListener(object : View.OnClickListener{ 
override fun onClick(v: View?) { 
Toast.makeText(this,"onClick",Toast.LENGTH_SHORT).show() 
} 
})

//java 代码为： ，感觉没有变少很多，但是看下面lambda。

et_mima.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        Toast.makeText(this,"onClick",Toast.LENGTH_SHORT).show();
    }
});

使用lambda 变为：

mBtn.setOnClickListener {

Toast.makeText(this,"onClick",Toast.LENGTH_SHORT).show()

}

 

7. 一个是 var ,一个val . 一般写代码的时候都会初始化值的。所以基本都不用生命类型

可变变量定义：var 关键字

var <标识符> : <类型> = <初始化值>

不可变变量定义：val 关键字，只能赋值一次的变量(类似Java中final修饰的变量)

val <标识符> : <类型> = <初始化值>

常量与变量都可以没有初始化值,但是在引用前必须初始化

编译器支持自动类型判断,即声明时可以不指定类型,由编译器判断。

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


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

 

 

 

8. 取代自己去拼写

$ 表示一个变量名或者变量值

$varName 表示变量值

${varName.fun()} 表示变量的方法返回值:

var a = 1
// 模板中的简单名称：
val s1 = "a is $a" 

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

 

9.  核心

NULL检查机制

Kotlin的空安全设计对于声明可为空的参数，在使用时要进行空判断处理，有两种处理方式，字段后加!!像Java一样抛出空异常，另一种字段后加?可不做处理返回值为 null或配合?:做空判断处理

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

10.

我们可以使用 is 运算符检测一个表达式是否某类型的一个实例(类似于Java中的instanceof关键字)。

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
}

 

11. 简单的循环判断方便的多  step 每几位取值  downTo 去返方向   until排除最后一位

区间表达式由具有操作符形式 .. 的 rangeTo 函数辅以 in 和 !in 形成。

区间是为任何可比较类型定义的，但对于整型原生类型，它有一个优化的实现。以下是使用区间的一些示例:

print("循环输出：")
    for (i in 1..4) print(i) // 输出“1234”
    println("\n----------------")
    print("设置步长：")
    for (i in 1..4 step 2) print(i) // 输出“13”
    println("\n----------------")
    print("使用 downTo：")
    for (i in 4 downTo 1 step 2) print(i) // 输出“42”
    println("\n----------------")
    print("使用 until：")
    // 使用 until 函数排除结束元素
    for (i in 1 until 4) {   // i in [1, 4) 排除了 4
        print(i)
    }
    println("\n----------------")

 

12.类型强制转换

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

13.

字符

和 Java 不一样，Kotlin 中的 Char 不能直接和数字操作，Char 必需是单引号 ' 包含起来的。比如普通字符 '0'，'a'。

fun check(c: Char) {
    if (c == 1) { // 错误：类型不兼容
        // ……
    }
}

字符字面值用单引号括起来: '1'。 特殊字符可以用反斜杠转义。 支持这几个转义序列：\t、 \b、\n、\r、\'、\"、\\ 和 \$。 编码其他字符要用 Unicode 转义序列语法：'\uFF00'。

我们可以显式把字符转换为 Int 数字：

fun decimalDigitValue(c: Char): Int {
    if (c !in '0'..'9')
        throw IllegalArgumentException("Out of range")
    return c.toInt() - '0'.toInt() // 显式转换为数字
}

当需要可空引用时，像数字、字符会被装箱。装箱操作不会保留同一性。

 

14.

数组

数组用类 Array 实现，并且还有一个 size 属性及 get 和 set 方法，由于使用 [] 重载了 get 和 set 方法，所以我们可以通过下标很方便的获取或者设置数组对应位置的值。

数组的创建两种方式：一种是使用函数arrayOf()；另外一种是使用工厂函数。如下所示，我们分别是两种方式创建了两个数组：

   //[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

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

val x: IntArray = intArrayOf(1, 2, 3)
x[0] = x[1] + x[2]

 

15.  """ 规则比较死板，但是用习惯了就方便了

字符串

和 Java 一样，String 是不可变的。方括号 [] 语法可以很方便的获取字符串中的某个字符，也可以通过 for 循环来遍历：

for (c in str) {
    println(c)
}

Kotlin 支持三个引号 """ 扩起来的字符串，支持多行字符串，比如：

fun main(args: Array<String>) {
    val text = """
    多行字符串
    多行字符串
    """
    println(text)   // 输出有一些前置空格
}

String 可以通过 trimMargin() 方法来删除多余的空白。

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

默认 | 用作边界前缀，但你可以选择其他字符并作为参数传入，比如 trimMargin(">")。

 

16. 优化了下 if与 3元表达式吧

IF 表达式

一个 if 语句包含一个布尔表达式和一条或多条语句。

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

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

这也说明我也不需要像Java那种有一个三元操作符，因为我们可以使用它来简单实现：

val c = if (condition) a else b

 

 

17.

When 表达式

when 将它的参数和所有的分支条件顺序比较，直到某个分支满足条件。

when 既可以被当做表达式使用也可以被当做语句使用。如果它被当做表达式，符合条件的分支的值就是整个表达式的值，如果当做语句使用， 则忽略个别分支的值。

when 类似其他语言的 switch 操作符。其最简单的形式如下：

when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    else -> { // 注意这个块
        print("x 不是 1 ，也不是 2")
    }
}

在 when 中，else 同 switch 的 default。如果其他分支都不满足条件将会求值 else 分支。

如果很多分支需要用相同的方式处理，则可以把多个分支条件放在一起，用逗号分隔：

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

when 中使用 in 运算符来判断集合内是否包含某实例：

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")
    }
}

输出结果：

apple is fine too

 

 

18. for 循环，不像java那么死板，固定格式，简化了下。最后一条注意看下，不然有点绕

For 循环

fun main(args: Array<String>) {
    val items = listOf("apple", "banana", "kiwi")
    for (item in items) {
        println(item)
    }

    for (index in items.indices) {
        println("item at $index is ${items[index]}")
    }
}

for 循环可以对任何提供迭代器（iterator）的对象进行遍历，语法如下:

for (item in collection) print(item)

 

for (i in 1..4) print(i) // 打印结果为: "1234"

 

19. 成员变量注意 需要声明类型

类的属性

属性定义

类的属性可以用关键字 var 声明为可变的，否则使用只读关键字 val 声明为不可变。

class Runoob {
    var name: String = ……
    var url: String = ……
    var city: String = ……
}

 

20. 调用java get/set 方法 直接用 点  。   但是这里也有一个问题，就是有些set方法 不一样是赋值，

就需要 你取看下 它的代码逻辑，重写了

我们可以像使用普通函数那样使用构造函数创建类实例：

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

要使用一个属性，只要用名称引用它即可

site.name           // 使用 . 号来引用
site.url

Koltin 中的类可以有一个 主构造器，以及一个或多个次构造器，主构造器是类头部的一部分，位于类名称之后:

class Person constructor(firstName: String) {}

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

class Person(firstName: String) {
}

getter 和 setter

属性声明的完整语法：

var <propertyName>[: <PropertyType>] [= <property_initializer>]
    [<getter>]
    [<setter>]
 

getter 和 setter 都是可选

如果属性类型可以从初始化语句或者类的成员函数中推断出来，那就可以省去类型，val不允许设置setter函数，因为它是只读的。

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

 

 

 

21. 对上面的解析下，不然很难理解

1、field 关键字

其中最关键的一句：Remember in kotlin whenever you write foo.bar = value it will be translated into a setter call instead of a PUTFIELD.

也就是说，在 Kotlin 中，任何时候当你写出“一个变量后边加等于号”这种形式的时候，比如我们定义 var no: Int 变量，当你写出 no = ... 这种形式的时候，这个等于号都会被编译器翻译成调用 setter 方法；而同样，在任何位置引用变量时，只要出现 no 变量的地方都会被编译器翻译成 getter 方法。那么问题就来了，当你在 setter 方法内部写出 no = ... 时，相当于在 setter 方法中调用 setter 方法，形成递归，进而形成死循环，例如文中的例子：

var no: Int = 100
    get() = field                // 后端变量
    set(value) {
        if (value < 10) {       // 如果传入的值小于 10 返回该值
            field = value
        } else {
            field = -1         // 如果传入的值大于等于 10 返回 -1
        }
    }

这段代码按以上这种写法是正确的，因为使用了 field 关键字，但是如果不用 field 关键字会怎么样呢？例如：

var no: Int = 100
    get() = no
    set(value) {
        if (value < 10) {       // 如果传入的值小于 10 返回该值
            no = value
        } else {
            no = -1         // 如果传入的值大于等于 10 返回 -1
        }
    }

注意这里我们使用的 Java 的思维写了 getter 和 setter 方法，那么这时，如果将这段代码翻译成 Java 代码会是怎么样呢？如下：

int no = 100;
public int getNo() {
    return getNo();// Kotlin中的get() = no语句中出来了变量no，直接被编译器理解成“调用getter方法”
}

public void setNo(int value) {
    if (value < 10) {
        setNo(value);// Kotlin中出现“no =”这样的字样，直接被编译器理解成“这里要调用setter方法”
    } else {
        setNo(-1);// 在setter方法中调用setter方法，这是不正确的
    }
}

翻译成 Java 代码之后就很直观了，在 getter 方法和 setter 方法中都形成了递归调用，显然是不正确的，最终程序会出现内存溢出而异常终止。