给 Java 开发者的 Kotlin 快速上手教程（Kotlin for Java Developers）v0.1

package com.fooimport foo.Bar 
import foo.*

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

fun localVariables() {
    val a: Int = 1
    val b = 1   // 自动推导类型为Int
    val c: Int  // 没有初始值时需要显式制定变量类型
    c = 1       // 初始复制
    // c = 2 这个是错误的，val定义的只读变量不可重新赋值}

fun mutableVariables() {
    var x = 5 // 类型自动推导为Int
    x += 1}

fun strTemplate() {
    val name = "Miufox"
    val age = 6    print("I have a cat, name is $name age:$age")

    val a:Int = 2016
    val b = 40    print("sum($a+$b) = ${a+b}")

    var args = arrayOf("Cat", "Dog", "Rabbit")    print("Hello ${args[0]}")
}

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

fun max(a: Int, b: Int) = if (a > b) a else b

fun cases(obj: Any) {
    when (obj) {
        1 -> print("One")        "Hello" -> print("Greeting")
        is Long -> print("Long")
        !is String -> print("Not a string")        else -> print("Unknown")
    }
}

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

fun testInt(args: Array<String>) {    if (args.size < 2) {
        print("Two integers expected")        return
    }
    val x = parseInt(args[0]) // Int?
    val y = parseInt(args[1])//Int?
    if (x != null && y != null) {        // null检查之后，这里自动类型转换为非空值
        print(x * y)
    }
}

fun getStringLength(obj: Any): Int? {  if (obj is String) {    // `obj` 自动转换为 `String`
    return obj.length
  }  // 在类型检查的if分支外 obj依然是 `Any` 类型
  return null}

fun getStringLength(obj: Any): Int? {  if (obj !is String)    return null
  // `obj` 自动转换为 `String` 类型
  return obj.length
}

fun getStringLength(obj: Any): Int? {  // && 右边 obj 已经自动转换为 String 类型
  if (obj is String && obj.length > 0)    return obj.length  return null}

fun forLoop1(args: Array<String>) {    for (arg in args) {
        print(arg)
    }
}

fun forLoop2(args: Array<String>) {    for (i in args.indices) {
        print(args[i])
    }
}

fun whileLoop1(args: Array<String>) {    var i = 0
    while (i < args.size){
        print(args[i++])
    }
}

fun range1(x: Int, y: Int) {    if (x in 1..y - 1) {        print("OK")
    }
}

// 集合类型fun names1(names: Array<String>) {    for (name in  names) {
        println(name)
    }
}// 检查是否包含fun names2(text: String, names: Array<String>) {    if (text in names) {
        print("Yes")
    }
}// 使用lambda表达式fun names3(names: Collection<String>) {
    names.filter { it.startsWith("A") }
            .sortedBy { it }
            .map { it.toUpperCase() }
            .forEach { print(it) }
}

list.filter { it > 10 }.map { element -> element * 2 }

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

fun foo(a: Int = 0, b: String = "") {    // do something}

fun filters(list: Collection<Int>) {
    val positives1 = list.filter { x -> x > 0 }    // 也可以这样
    val positives2 = list.filter { it > 0 }
}

fun maps(map: Map<String, String>) {    for ((k, v) in map) {
        println("$k -> $v")
    }
}

fun readOnlyList() {
    val list = listOf("a", "b", "c")    // list.add("d") 错误：不能修改元素}

fun readOnlyMap() {
    val map1 = mapOf("a" to 1, "b" to 2, "c" to 3)
    println(map1["a"])    // map2["key"] = 123 错误：不能修改元素}

fun Int.biggerThanTen(): Boolean {    return this > 10}// 测试一下扩展函数fun extensions() {    100.biggerThanTen()    5.biggerThanTen()
}

object Singleton {
    val name = "Name"}

//nullable用法fun testNullable() {
    val files = File("Test").listFiles()
    println(files?.size)
    println(files?.size ?: "empty")
}

fun transform(color: String): Int {    return when (color) {        "Red" -> 0
        "Green" -> 1
        "Blue" -> 2
        else -> throw IllegalArgumentException("Invalid color param value")
    }
}

fun tryCatch() {
    val result = try {        // do something
    } catch (e: ArithmeticException) {        throw IllegalStateException(e)
    }    // Working with result}

fun ifExp(param: Int) {
    val result = if (param == 1) {        "one"
    } else if (param == 2) {        "two"
    } else {        "three"
    }
}

class Turtle {
    fun penDown() { }    fun penUp() {}    fun turn(degrees: Double) { }    fun forward(pixels: Double) { }
}// 如果你要调用某个对象的多个函数，可以这样用fun withExp() {
    val turtle = Turtle()
    with(turtle) { //draw a 100 pix square
        penDown()        for (i in 1..4) {
            forward(100.0)
            turn(90.0)
        }
        penUp()
    }
}

Type    BitWidth
Double  64
Float   32
Long    64
Int     32
Short   16
Byte    8

fun conversation1() {
    val a: Int? = 1 // Int 包装类型 (java.lang.Integer)
    // val b: Long? = a // Long 包装类型 (java.lang.Long)
    // print(a == b) // 结果是false，因为两者类型不一样
    val b: Byte = 1 // OK, literals are checked statically
    // val i: Int = b // ERROR
    val i: Int = b.toInt() // OK: 显式转换}

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

//数组的部分接口class Array<T> private constructor() {
val size: Int
fun get(index: Int): T
fun set(index: Int, value: T): Unit
fun iterator(): Iterator<T>// ...}

// 创建数组fun testArray1() {
    val asc = Array(5, { i -> (i * i).toString() })
}// Kotlin的数组是不可变的(Java 的数组可变；泛型的协变，逆变)// 不允许将Array<String>赋值给Array<Any>// Kotlin还有ByteArray, ShortArray, IntArray等类型fun testArray2() {
    val x: IntArray = intArrayOf(1, 2, 3)
    x[0] = x[1] + x[2]
}

fun testString1(str: String) {    for (c in str) {
        println(c)
    }
}

* 字符串字面量

fun testString2() {
    val s = "Hello, world!\n"
    // 或者三引号
    val text = """
    for (c in "foo")
        print(c)
    """}

    // 三引号
    val text = """
    for (c in "foo")
        print(c)
    """

fun stringTemplate() {
    val i = 10
    val s = "i = $i" // evaluates to "i = 10"
    val x = "abc"
    val str = "$x.length is ${x.length}" // "abc.length is 3"
    // 可以包含反义字符
    val price = "${'$'}9.99"}

var a :String? = "a"a.?length