Kotlin开始学习之基本语法

基本语法

1.1 包名的定义

包名需要放在文件的开头部分。
但是不需要匹配目录和包：源文件可以放在任意目录中。

package my.demo

import java.util.*

// ...

1.2 函数的定义

标准语法：

fun 方法名 （参数名1 : 参数类型1，参数名2 : 参数类型2，...）: 返回值类型 {

                 方法体
}

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

方便起见，我们也可以直接在方法后面直接加 = 表达式， 返回值的类型会自动推算出来：

fun sum(a: Int, b: Int) = a + b

当函数返回无意义值时，可以使用Unit类型（相当于Java中的void），也可以省略不写：

fun printSum(a: Int, b: Int): Unit {
    println("sum of $a and $b is ${a + b}")
}

fun printSum(a: Int, b: Int) {
    println("sum of $a and $b is ${a + b}")
}

函数的具体讲解，请参考输入链接说明。

1.3、变量

Kotlin 中，变量分为** 可变变量** 和 不可变变量。

• 可变变量使用 var 声明。
• 不可变变量使用 val 声明。一旦声明，不可修改。(const val 相当于 java 中的 final)。

举例说明：

val a: Int = 1  // 显示指定常量的类型

val b = 2   // 自动推断类型为‘Int’

val c: Int  //  声明一个不初始化的常量，必须显示指定类型

c = 3     // 赋值后，值不可再更改 

// 变量的声明方式同常量，唯一不同的是赋值后，值可改变

var x = 5 // 自动推断类型为‘Int’

x += 1

1.4、注释

kotlin的注释同Java/JavaScript:

// This is an end-of-line comment

/* This is a block comment                                                                   
on multiple lines. */

1.5、字符串模板的使用

模板表达式以美元符$ 开头，由一个简单的名字构成( $a ) 或者 用花括号括起来的任意表达式（${s1.replace(“is”, “was”)}）。

var a = 1
// simple name in template:
val s1 = "a is $a" 

a = 2
// arbitrary expression in template:
val s2 = "${s1.replace("is", "was")}, but now is $a"

// a was 1, but now is 2

原生字符串和转义字符串内部都支持模板。
如果你需要在原生字符串中表示字面值 $ 字符（它不支持反斜杠转义），你可以用下列语法：

val price = """ 
        ${'$'}9.99
    """
// 求值结果为$9.99

1.6 条件表达式的使用

常规写法：

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

使用表达式的写法:

// 返回值类型自动推断
fun maxOf(a: Int, b: Int) = if (a > b) a else b

1.7、空值的使用和 空指针检查

1.7.1、 空安全特性：

        空安全 是 Kotlin 的语言特性之一，很好地避免了在Android开发时的 空指针异常 。
        Kotlin的空安全设计 对于 声明可为空的参数，在使用时要进行空判断处理（即空指针检查：处理方式使用空安全操作符）。

1.7.2、 空安全操作符

1.7.2.1、? （可空变量修饰符）

通常情况下，声明的变量 默认是不可空变量，不能赋值为空。例如：

val s:String = null 
// 提示 空值不能赋值给 不可空变量

正确的写法是：

val s:String? = null

1.7.2.2、?. (空安全调用符)

当用一个可空变量进行逻辑处理时，需要进行 空判断处理。例如：

val s:String? = null
// 当s 不为空时，转换成Int型
 if( s != null ){
     s.toInt()
 }

上面的写法比较繁琐，更简单的使用方式使用空安全调用符（?.）:

val s:String? = null
// 当s 不为空时，执行toInt；否则不执行，返回null
s?.toInt()

1.7.2.3、!! （非空断言）

除了可以使用空安全调用符外，还可以使用非空断言。非空断言，告诉编译器 当前变量一定不为空，如果为空，还是会像Java一样报 空指针异常。不建议使用该操作符。

val s:String? = null
// 当s 不为空时，执行toInt；否则不执行，抛出空指针异常
s!!.toInt()

1.7.2.4、?: （Elvis操作符）

如果 可空变量不为空 执行该操作符前面的逻辑，如果为空，执行该操作符后面的逻辑。

    val s: String? = null
   // 当s 不为空时，执行toInt；否则返回 -1
    val  a :Int = s?.toInt()?:-1

1.7.3 当引用一个可空的变量

当一个变量可能为 null 时，引用必须被明确地标记为空。

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

fun printProduct(arg1: String, arg2: String) {
    val x = parseInt(arg1)
    val y = parseInt(arg2)

    // Using `x * y` yields error because they may hold nulls.
    if (x != null && y != null) {
        // x and y are automatically cast to non-nullable after null check
        println(x * y)
    }
    else {
        println("either '$arg1' or '$arg2' is not a number")
    }    
}

or

// ...
if (x == null) {
    println("Wrong number format in arg1: '$arg1'")
    return
}
if (y == null) {
    println("Wrong number format in arg2: '$arg2'")
    return
}

// x and y are automatically cast to non-nullable after null check
println(x * y)

1.8、使用类型检查和自动类型转换

1.8.1、类型检查及类型自动转换

        Kotlin 中 类型检查 使用关键字 is，作用相当于Java 中的 instanceOf。
        Kotlin中的Any，相当于Java中的Object。所有的类型都继承于它。

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

  // 在这里还有一种方法，与Java中instanceof不同，使用!is
  // if (obj !is String){
  //   // XXX
  // }

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

or:

fun getStringLength(obj: Any): Int? {
    if (obj !is String) return null

    // 在这个分支中, `obj` 的类型会被自动转换为 `String`
    return obj.length
}

or even:

fun getStringLength(obj: Any): Int? {
    // 在 `&&` 运算符的右侧, `obj` 的类型会被自动转换为 `String`
    if (obj is String && obj.length > 0) {
        return obj.length
    }
    return null
}

1.8.2 补充：自动类型推断

在 java 中，要明确告诉编译器变量或者表达式的类型；
在Kotlin 中，编译器可以自动推断出类型。如：

// 自动推断出 a 的类型是Int
var a = 10
// 自动推断出 函数表达式值的类型 为Int
fun sum(a: Int, b: Int) = a + b

1.8.3 补充：类型转换（需要显示转换，直接隐式转换不支持）

val b: Byte = 1 // OK, literals are checked statically

// 隐式转换报错
val i: Int = b // ERROR

// 显示转换没问题
val i: Int  = b.toInt() 

数字类型支持以下显示转换：

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

隐式转换可以通过算术操作进行适合的转换。因为类型是可以从上下文中推断出来的：

//  Long + Int => Long
val a = 1L + 3

字符串 和 字符 转换成Int时，需要是有意义的转换。如果 s = "hello",转换成Int会报错的。

    var b = 10
    var s = "10"
    b = s.toInt()

    b.toLong()
    
    var c = 'c'
    c.toInt()

以下内容参考后续章节一一讲解：

1.9 使用 for 循环

1.10 使用 while 循环

1.11 使用 when 表达式

1.12 使用区间（ranges）

1.13 使用集合（collections）

以上内容参考后续章节一一讲解：

1.14 创建基本的类和它的实例

val rectangle = Rectangle(5.0, 2.0) //no 'new' keyword required
val triangle = Triangle(3.0, 4.0, 5.0)

具体用法参考 “对象 ”章节。