kotlin的方言（语法糖）

概述

之前介绍了kotlin的快速入门，http://www.cnblogs.com/lizo/p/7231167.html 大多数还是参照java。kotlin中提供了更多更方便的语言特性

这个方言其实是针对java而言，因为很多用法其实在其他语言里面是已经存在的。使用kotlin的这些方言能够在一定程度上提高你的开发效率

POJO类

在kotlin中定义class时候加上关键字data即可创建

//注意声明对象的成员变量的是加上val关键字
data class Persion(val name: String, val age: Int)

这种对象包含的方法有

• getter和setter方法
• equals()
• hashCode()
• toString()
• copy()
• 组成方法

组成方法

组成方法就是可以快速获取data对象方法，例如

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

fun main(args: Array<String>) {
    var p = Person("lizo",18);
    println(p.component1()) //获取第一个成员变量
    println(p.component2()) //获取第二个成立变量

    var (name,age) = p;  //把第一个和第二个变量分别赋值给 name 和age ，注意是根据顺序，而不是名字
    println("name : $name ,age : $age")
}

输出

lizo
18
name : lizo ,age : 18

应用场景

例如使用一个方法返回多个参数的时候，就可以使用这个方法

data class Persion(val name: String, val age: Int)
fun someCall():Person{
    ...
    return Person("lizo",18)
}

val (name,age) = someCall()

方法默认值

在调用某些方法的时候，我们需要可以设置一些默认值

fun someCall(var1: String, var2: Int, var3: String = "default"){
    print("$var1,$var2,$var3")
}

fun main(args: Array<String>) {
    someCall("lizo",18)
}

在一个方法阿尤多个默认值的时候，可以选择性的赋值（但没有默认值的参数必须传递）

fun someCall(var1: String = "default1", var2: Int, var3: String = "default2") {
    print("$var1,$var2,$var3")
}

fun main(args: Array<String>) {
    someCall(var2 = 18,var3 = "lizo123")
}

类型判断

利用when的语法，进行实例类型判断

when(a){
    is String -> print(a.length)
    is Int -> print(a)
    ...
    else -> throw RuntimeException();
}

遍历list/map

for (l in list) {
    println("$l")
}

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

使用数字区间

for (i in 1..100) { ... }  // 闭区间：包含100
for (i in 1 until 100) { ... } // 不包含100
for (x in 2..10 step 2) { ... } // 按照步长为2增长
for (x in 10 downTo 1) { ... } // 
if (x in 1..10) { ... } //判断x是否在1到10这个区间内

只读map和list

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

访问map元素

println(map["key"]) //get
map["key"] = value //set

延迟加载

有些属性我们希望可以延迟加载，可以是用 by lazy属性(必须是val修饰的变量)

class Clazz() {
    val p: String by lazy {
        println("lazy!")
        "haha"
    }
}

fun main(args: Array<String>) {
    var clazz = Clazz()
    println(clazz.p)
    println(clazz.p)
}

输出

lazy!
haha
haha

类扩展方法

kotlin中支持对一个类的方法进行扩展

fun String.myToLowerCase(): String {
    return this.toLowerCase()
}

fun main(args: Array<String>) {
    println("tHIs iS TeST".myToLowerCase())
}

输出

this is test

这样做的好处就是在我们需要扩展某个类的方法时候，不用定义一个新的类去扩展，不好的地方一个类的扩展类也许或分布在多个地方。

null处理

在编码过程中很多地方都用到了对null处理,kotlin中提供了便捷操作方法去处理

    //如果a为null，则整个a?.length都是null
    print(a?.length);

如果需要在为null的情况下赋值

//当a为null的时候，b的值为default
    var b = a?:"default"

如果需要判断当a不为null 到时候进行一些处理

a?.let{
    //do some thing a != null
}

根据条件判断语句赋值

赋值（=）的时候，可以直接在后面放入条件语句

var a = if(b > 0){1}else{-1}

val c = when (d){
        "red" -> 1
        "blue" -> 2
        else -> throw IllegalArgumentException("Invalid color param value")
    }
}

//函数返回
fun someCall(a:Int) = if(a>0){1}else if(){-1}

当用到一个对象的多个方法时候

通过使用with关键字，可以在范围内直接调用该方法

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

val myTurtle = Turtle()
with(myTurtle) { //draw a 100 pix square
    penDown()
    for(i in 1..4) {
        forward(100.0)
        turn(90.0)
    }
    penUp()
}

来源：https://www.cnblogs.com/lizo/p/7244220.html