待续
一、Kotlin友好的语法
Kotlin不是诞生于学术界的一些不可思议难以理解的语法，它的语法类似于很多面向对象的语法，并且非常易于理解。
但是它又与传统的面向对象的Java有些区别，例如kotlin的val、var变量的声明。
例如：

二、相似友好的语法

/**
 * @author:wangdong
 * @description:Foo demo
 */
class Foo {

    //val 声明的变量是不可以改变的
    val b: String = "b"
    //var 声明是可以改变的
    var i: Int = 0

    //可以根据等号右边的类型，自动判断赋予左边变量的类型
    fun hello(){
        val str = "hello"
        print("$str world")
    }

    //根据传入的变量，求和
    fun sum(x: Int,y: Int): Int{
        return x + y;
    }

    //根据传人的变量，求最大值
    //如果a大于b,则返回a,否则返回b
    fun maxOf(a: Float, b: Float) = if(a > b) a else b

}

三、字符串的插入和计算
在字符串的插入和计算方面，类似于Java的String.format()。
例如：

fun stringDemo(){
        val x = 4;
        val y = 7;
        print("sum of $x and $y is ${x + y}")
        //会输出"sum of 4 and 7 is 11"
    }

四、
Kotlin will infer your types wherever you feel it will improve readability:
如果没有指定变量的类型的话，Kotlin可以根据改善阅读，自动赋予变量的类型

fun inferenceDemo() {
        val a = "abc"  //会自动推测为String类型
        var b = 4      //会自动推测为String类型

        val c: Double = 0.7  //明确的c的类型为Double
        val d: List<String> = ArrayList() //明确d的类型为List<String>
    }

五、
更灵活的类型转化

/**
 * @author:wangdong
 * @description:第一个kotlin项目
 */
fun main(args: Array<String>) {

    var obj = "Hello";
    //会将小写字母转化成大写输出
    if (obj is String) {
        print(obj.toUpperCase())     // obj is now known to be a String
    }
}

输出结果

六、更直观的相等比较

//因为两个对象属性完全一样
val john1 = Person("John")
val john2 = Person("John")
//判断结构相等用==
john1 == john2    // true  (structural equality)
//判断引用相等用===
john1 === john2   // false (referential equality)

七、灵活变化的参数和方法运用
可以通过类，调用方法传入指定类型的参数

fun build(title: String, width: Int = 800, height: Int = 600) {
    Frame(title, width, height)
}

八、更多样化的方法调用方式
下面来模拟调用第七步中的build方法，三种方式都是一样的

build("PacMan", 400, 300)                           // equivalent
build(title = "PacMan", width = 400, height = 300)  // equivalent
//参数顺序如果颠倒了，则需要指定前缀
build(width = 400, height = 300, title = "PacMan")  // equivalent

九、更灵活的表达在When判断语句

/**
 * @author:wangdong
 * @description:第一个kotlin项目
 */
fun main(args: Array<String>) {

    var x = 2
    //根据x的值走对应的一行，下面走x is 2
    when (x) {
        1 -> print("x is 1")
        2 -> print("x is 2")
        3, 4 -> print("x is 3 or 4")
        in 5..10 -> print("x is 5, 6, 7, 8, 9, or 10")
        else -> print("x is out of range")
    }
}

它在一个表达式或者一个声明中都是有用的
例如：

fun main(args: Array<String>) {

    var obj = "20"
    val res: Boolean = when {
        obj == null -> false
        //走这一层
        obj is String -> true
        else -> throw IllegalStateException()
    }
    print(res)
}

最终输出的结构true

十、更灵活的Bean实体类中的set和get方法

class Frame {
    var width: Int = 800
    var height: Int = 600

    val pixels: Int
        get() = width * height
}

调用类Frame中的get方法，得到的结果就是480000

十一、更灵活的对象创建和复制
It’s a POJO complete with toString(), equals(), hashCode(), and copy(), and unlike in Java it won’t take up 100 lines of code:
比Java的创建和赋值方便太多了

/**
 * @author:wangdong
 * @description:第一个kotlin项目
 */
fun main(args: Array<String>) {

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

    val john = Person("John","John@gmail.com",121)

    print(john)
}

输出结果：

Person(name=John, email=John@gmail.com, age=121)

十二、更灵活的预先重载的方法
A predefined set of operators can be overloaded to improve readability:
例如：

/**
 * @author:wangdong
 * @description:第一个kotlin项目
 */
fun main(args: Array<String>) {

    data class Vec(val x: Float,val y: Float){

        operator fun plus(v: Vec) = Vec(x + v.x, y + v.y)
    }

    val v = Vec(2.5f,3f) + Vec(4f, 1f)

    print(v)
}

输出的结果是Vec(x=6.5, y=4.0)
具体咱们来debug看一下

可以简单理解为x+x，y+y

本次暂时分享到这里了。