Kotlin基础语法篇

• Kotlin 是 JetBrains 在 2010 年推出的基于 JVM 的新编程语言，是一种新的静态类型编程语言。开发者称，设计它的目的是避免 Java 语言编程中的一些难题。比如：在 Kotlin 中类型系统控制了空指针引用，可以有效避免 Java 中常见的NullPointException。
  

• 相比于 Java，Kotlin 有着更好的语法结构，安全性和开发工具支持。
  Kotlin 中没有基础类型，数组是定长的，泛型是安全的，即便运行时也是安全的。此外，该语言支持闭包，还可通过内联进行优化。不过，它不支持检查异常（Checked Exceptions），许多语言设计者认为这是它的瑕疵。不论如何，重要的是 Java 和 Kotlin 之间的互操作性：Kotlin 可以调用 Java，反之亦可。
• Kotlin基于JVM的字节码结构（与java同属静态语言），Kotlin 应用程序的运行速度与 Java 类似。，但随着 Kotlin 对内联函数的支持，使用 lambda 表达式的代码通常比用 Java 写的代码运行得更快。
• Kotlin 可与 Java 进行 100％ 的互操作，允许在 Kotlin 应用程序中使用所有现有的 Android 库 ，这包括注解处理，Google官方也说过未来Android支持库优先支持Kotlin语言；
• Kotlin属于跨平台编译语言，除了可以进行原声开发外很好的支持Java服务端程序开发、Android应用程序开发以及JavaScript开发；

fun main(args: Array<String>) {
    //[1,2,3]
    val a = arrayOf(1, 2, 3)

    //读取数组内容
    println(a[0])    // 输出结果：1
    println(b[1])    // 输出结果：2
}


val x: IntArray = intArrayOf(1, 2, 3

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

fun main(args: Array<String>) {
    val text = """多行字符串 多行字符串"""
    println(text)   // 输出
}

val b: Byte = 1 // OK, 字面值是静态检测的
val i: Int = b.toInt() // OK

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

val a: Int = 1  // 立即赋值 （非空属性必须在定义时候初始化，）
val b = 2   // 自动推断出 `Int` 类型  （非空属性必须在定义时候初始化，）

var x = 5 // 自动推断出 `Int` 类型 （非空属性必须在定义时候初始化，）
x += 1

var count:Int?=null //可空属性可以在后面赋值 
count=5

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

fun sum( a:Int, b:Int)=  a+b  // 自动类型推断或者 fun sum(a:Int,b:Int):Int=a+b  

fun printSum(a: Int, b: Int): Unit { 
    print(a + b)
}

可变长参数用vararg关键字进行修饰：

fun print(vararg v:Int){   
        for(a in v){   
            println("$a")
        }
} 

4. 字符串模板

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

$varName 表示变量值

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

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

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

// 运行结果：a was 1, but now is 2

5. 条件表达式

fun value(a:Int, b :Int):Int { 
  if(a>b) { 
    return a+b  
  }else{   
    return a-b     
  }
}

通过条件表达式可以：

fun value(a:Int,b:Int)=if(a>b) a+b else a-b


6. NULL检查机制

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

val listWithNulls: List<String?> = listOf("Kotlin", null)      
for (item in listWithNulls) {
           item?.let {   
           println(it) // 输出 Kotlin 并忽略 null  
    }
 }

person?.class?.mathTeacher = TeachManager.getTeacher()

val l: Int = if (b != null) b.length else -1

或者

fun value(a:Int,b:Int)=if(a>b) a+b else a-b
//条件表达式用法

val l = b?.length ?: -1

如果 ?: 左侧表达式非空，elvis 操作符就返回其左侧表达式，否则返回右侧表达式。 请注意，当且仅当左侧为空时，才会对右侧表达式求值。

这种Elvis用法类似java语言中三元操作符；

public int value(int a,int b){return a>b?a+b :a-b}
等同于：
fun value(a:Int,b:Int)=if(a>b) a+b else a-b

val l = b?.length ?: -1

等同于：

final int l= b!=null? b.length : -1 

8. 类型检测及类型转换

如果对象不是目标类型，那么常规类型转换可能会导致 ClassCastException，

val aInt: Int? = a as Int

为了避免类型转成异常，另一个选择是使用安全的类型转换，如果尝试转换不成功则返回 null：

val aInt: Int? = a as? Int
或者
val sInt :Int?= if(a is Int) a as Int else null
或者
val sInt :Int?= if(a is Int) a else null

is 运算符检测一个表达式是否某类型的一个实例(类似于Java中的instanceof关键字), 如果一个不可变的局部变量或属性已经判断出为某类型，那么检测后的分支中可以直接当作该类型使用，无需显式转换：

fun getStringLength(obj: Any): Int? {
  if (obj is String) {
    // 做过类型判断以后，obj会被系统自动转换为String类型
    return obj.length 
  }

  // 这里的obj仍然是Any类型的引用
  return null
}

或者

fun getStringLength(obj: Any): Int? {
  if (obj !is String)
    return null
  // 在这个分支中, `obj` 的类型会被自动转换为 `String`
  return obj.length
}

9. 可空类型的集合

如果你有一个可空类型元素的集合，并且想要过滤掉空元素，你可以使用 filterNotNull 来实现：

val listOf = listOf<Int?>(1, 2, null, 4)

val intList: List<Int> = listOf.filterNotNull()

10. 区间

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

使用 in 运算符来检测某个数字是否在指定区间内：

for (i in 1..4) print(i) // 输出“1234”

for (i in 4..1) print(i) // 什么都不输出

if (i in 1..10) { // 等同于 1 <= i && i <= 10
    println(i)
}

// 使用 step 指定步长
for (i in 1..4 step 2) print(i) // 输出“13”

for (i in 4 downTo 1 step 2) print(i) // 输出“42”

// 使用 until 函数排除结束元素
for (i in 1 until 10) {   // i in [1, 10) 排除了 10
     println(i)
}


val list = listOf("a", "b", "c")
if (-1 !in 0..list.lastIndex) {
    println("-1 is out of range")
}
if (list.size !in list.indices) {
    println("list size is out of valid list indices range, too")
}

11. 使用 for 循环

val items = listOf("dog", "cat", "pig")
for (item in items) { 
 println(item)
}

或者通过索引

val items = listOf("apple", "banana", "kiwifruit")

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

val array=arrayOf("a","b","c")
for (i in array.indices) {
    print(array[i])
}

12. 使用 when 表达式

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

在Kotlin中Any类是所有类的超类，类似java中的Object；

在 when 中，else 同 switch 的 default。如果其他分支都不满足条件将会求值 else 分支。如果很多分支需要用相同的方式处理，则可以把多个分支条件放在一起，用逗号分隔。

when 也可以用来取代 if-else if链。 如果不提供参数，所有的分支条件都是简单的布尔表达式，而当一个分支的条件为真时则执行该分支：

when {
    x.isOdd() -> print("x is odd")
    x.isEven() -> print("x is even")
    else -> print("x is funny")
}

13. 使用 lambda 表达式来过滤（filter）与映射（map）集合

val fruits = listOf("banana", "avocado", "apple", "kiwifruit")
fruits.filter { it.startsWith("a") } 
.sortedBy { it }
.map { it.toUpperCase() }
.forEach { println(it) }

结果：APPLE AVOCADO

class Person constructor(firstName: String) {}

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

class Person(firstName: String) {
}

主构造器中不能包含任何代码，初始化代码可以放在初始化代码段中，初始化代码段使用 init 关键字作为前缀。

class Person constructor(firstName: String) {
    init {
       firstName="Scus"  //主构造器的参数可以在初始化代码段中使用
    }
}

另外可以通过主构造器来定义属性并初始化属性值（可以是var或val）：

class People(val firstName: String, val lastName: String) {
    //...
}

如果一个非抽象类没有声明构造函数(主构造函数或次构造函数)，它会产生一个没有参数的构造函数。构造函数是 public 。如果你不想你的类有公共的构造函数，你就得声明一个空的主构造函数：

class DontCreateMe private constructor () {
}

• 次构造函数

class Person(val name: String) {
    constructor (name: String, age:Int) : this(name) {
        // 初始化...
    }
}

open class Base {
    open fun f() {}
}

abstract class Derived : Base() {
    override abstract fun f()
}

class Outer {                  // 外部类
    private val bar: Int = 1
    class Nested {             // 嵌套类
        fun foo() = 2
    }
}

    test.setInterFace(object : TestInterFace {
        override fun test() {
            println("对象表达式创建匿名内部类的实例")
        }
    })

class Outer {
    private val bar: Int = 1
    var v = "成员属性"
    /**嵌套内部类**/
    inner class Inner {
        fun foo() = bar  // 访问外部类成员
        fun innerTest() {
            var o = this@Outer //获取外部类的成员变量
            println("内部类可以引用外部类的成员，例如：" + o.v)
        }
    }
}

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

sealed class Expr
data class Const(val number: Double) : Expr()
data class Sum(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()

fun eval(expr: Expr): Double = when (expr) {
    is Const -> expr.number
    is Sum -> eval(expr.e1) + eval(expr.e2)
    NotANumber -> Double.NaN
}

interface MyInterface {
     fun bar() // 未实现     
     fun foo() {//已实现       
        println("foo")  
    }
}

class Child : MyInterface {
    override fun bar() {
        // 方法体
    }
    override fun fool() {
        // 方法体
    }
}

interface MyInterface{
    var name:String //name 属性, 抽象的
}
 
class MyImpl:MyInterface{
    override var name: String = "runoob" //重写属性
}

16. Kotlin 继承

kotlin 中所有类都继承该 Any 类，它是所有类的超类，对于没有超类型声明的类是默认超类：

如果一个类要被继承，可以使用 open 关键字进行修饰。

open class Base(p: Int)           // 定义基类

class Derived(p: Int) : Base(p)

如果子类有主构造函数， 则基类必须在主构造函数中立即初始化。

open class Person(var name : String, var age : Int){// 基类

}

class Student(name : String, age : Int, var no : String, var score : Int) : Person(name, age) {

}

如果子类没有主构造函数，则必须在每一个二级构造函数中用 super 关键字初始化基类，或者在代理另一个构造函数。初始化基类时，可以调用基类的不同构造方法。

class Student : Person {

    constructor(ctx: Context) : super(ctx) {
    } 

    constructor(ctx: Context, attrs: AttributeSet) : super(ctx,attrs) {
    }
}

在基类中，使用fun声明函数时，此函数默认为final修饰，不能被子类重写。如果允许子类重写该函数，那么就要手动添加 open 修饰它,。

17.对象声明

object DataProviderManager {
    fun registerDataProvider(provider: DataProvider) {
        // ……
    }

    val allDataProviders: Collection<DataProvider>
        get() = // ……
}

引用该对象，我们直接使用其名称即可：

DataProviderManager.registerDataProvider(……)

类内部的对象声明可以用 companion 关键字标记，这样它就与外部类关联在一起，我们就可以直接通过外部类访问到对象的内部元素。