Kotlin入坑（三）基本识点

从这篇开始捋一遍kotlin的知识点

基本语法

定义包和导入包

跟java一样

package com.chs.kotlintext
import android.support.v7.app.AppCompatActivity

定义方法

这个跟java不一样了

 fun plus(a:Int,b:Int):Int{
        return a+b
    }

上面的函数，括号里面的是参数，参数的声明跟java是反过来的，先写参数名在写参数的类型，最后的冒号后面是返回类型。返回类型如果没有的话可以省略也可以写Unit

定义变量

定义变量跟java完全不一样了 val 定义常量 var定义变量

val a: Int = 1  // 立即赋值
var x = 5 // 自动推断出 `Int` 类型

条件表达式

if 语句跟java基本一样

 fun check(a: Int,b: Int) : Int{
        if(a > b)return a
        else return  b
    }

switch选择器跟java不一样 这里使用 when来代替 比switch更加强大，我们知道java中switch只能判断Int类型和String类型。这里的when可判断的类型就多了，而且还可以写条件 比如下面的 !is String，obj.isOdd()

fun describe(obj: Any): String =
when (obj) {
    1          -> "One"
    "Hello"    -> "Greeting"
    is Long    -> "Long"
    !is String -> "Not a string"
    obj.isOdd() -> print("x is odd")
    else       -> "Unknown"
}

返回为null的判断

fun parseInt(str: String): Int? {
}

如果返回值可以为null 必须在返回类型后面加？ ，？代表可以为空

类型的检测
java中我们判断类型使用 instanceof
kotlin 中使用 is

fun getStringLength(obj: Any): Int? {
    if (obj is String) {
        // `obj` 在该条件分支内自动转换成 `String`
        return obj.length
    }
    // 在离开类型检测分支后，`obj` 仍然是 `Any` 类型
    return null
}

for循环

这个比java中的简单很多。跟前端框架VUE中的差不多 也挺好理解

val items = listOf("apple", "banana", "kiwi")//声明一个数组
for (item in items) {
    println(item)
}

while循环

这个跟java中的基本一样

val items = listOf("apple", "banana", "kiwi")
var index = 0
while (index < items.size) {
    println("item at $index is ${items[index]}")
    index++
}

区间range

使用 .. 来表示区间 比如

if (i in 1..10) { // 等同于 1 <= i && i <= 10
    println(i)
}
//循环打印
for (i in 1..4) print(i) // 输出“1234”
//可以隔一个打印
for (i in 1..4 step 2) print(i) // 输出“13”  

集合
创建一个集合可以使用listOf，mapOf

 val items = listOf(
            "今天",
            "明天",
            "后天",
            "大后天",
            "大大后天",
            "大大大后天",
            "哈哈哈哈"
    )

 val map = mapOf("a" to 1, "b" to 2, "c" to 3)

循环集合

for (item in items) {
    println(item)
}

listOf创建的集合是不能修改的如果要对集合进行操作使用 mutableListOf
mapOf创建的也是只读的集合 如果要操作 使用mutableMapOf

var mList = mutableListOf<String>()
val map = mutableMapOf<Int,String>()
        map.put(1,"aa")

习惯用法

创建实体类，项目中实体类是肯定会创建的

data class Person(val name: String, val email: String)

上面的一句话相当于java中的 下面的写法。其实比下面的写法还全面，还包括toString()方法，hashCode()方法，equals()方法等

public class Person {
    String name;
    String email;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

方法的默认参数可以直接在参数类型后面声明

fun foo(a: Int = 0, b: String = "") { …… }

过滤list

比如上面创建的那个集合

var res = items.filter {
            item -> item.length > 5
        }

字符串内插

出入name的值可以直接代替下面的$name

println("Name： $name")

遍历集合map

k,v 可以改成任意名字 当然是用k,v 更容易理解

for ((k, v) in map) {
    println("$k -> $v")
}

创建单例

单例使用 object关键词

object Singleton{
    val name = "Name"
}

如果想调用的时候才创建 实现懒加载

class Singleton private constructor(){
    companion object {
        val instance:Singleton by lazy { Singleton() }
    }
}

线程安全的单例

class SingleTon private constructor() {
    companion object {
        val instance by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
            SingleTon()
        }
    }
}

使用静态内部类的方式实现单例

class SingleTon private constructor() {
    companion object {
       fun getInstance() = Holder.instance
    }
    private object Holder{
        val instance = SingleTon()
    }
}

空判断

if not null 执行代码

val value = ……

value?.let {
    …… // 代码会执行到此处, 假如data不为null
}

上面的代码，我们可以使用 ？ 来代替以前的if判断。如果value不为null则执行let里面的代码块。null 的那个会被忽略掉，而不会引起空指针异常。

?: 表达式就相当于一个简写的 if 语句。如果 ?: 左边的表达式不是 null，则返回左边的结果，否则返回 ?: 右边的表达式。比如下面：

val l = b?.length ?: -1

!! 操作符

!!操作符可以抛出空指针异常

val l = b!!.length

上面的代码 当 b 是一个 null 的时候，代码执行在这里会抛出一个 NullPointerException

对一个对象实例调用多个方法 （with） 这个用起来还是挺方便的 可以使代码简单易懂

class Turtle {
    fun penDown()
    fun penUp()
    fun turn(degrees: Double)
    fun forward(pixels: Double)
}

val myTurtle = Turtle()
with(myTurtle) { // 画一个 100 像素的正方形
    penDown()
    for(i in 1..4) {
        forward(100.0)
        turn(90.0)
    }
    penUp()
}

kotlin中的编码规范按照Java中的编码规范来就可以啦