Kotlin学习之路(2)——Kotlin的基础

Kotlin基础

函数

函数用关键字fun来声明，fun后面包括了函数名称，函数参数列表，函数返回值，举例如下：

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

在kotlin中也可以用表达式来代替返回值，比如下面：

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

这里虽然少了返回类型，但是kotlin自带类型推导，它会根据表达式类型自动推导出返回结果，只是隐式的拥有一个返回值。

变量

java中定义变量是 变量类型：变量名 ，例如 String s

kotlin中定义变量是 关键字 变量名：变量名， 例如 var s：String

可用变量与不可变变量

val——不可变引用。使用val修饰的变量不能在初始化后再次赋值，对应的是java中的final变量。

var——可变引用。这种变量的值可以被修改，对应的是非final类型变量。

我们应尽可能的使用不可变引用来保证尽可能的接近函数式编程，

val 修饰的变量自身不可以变，但是它所指向的对象是可以改变的，例如：

val list = arrayListOf("Java")
list.add("Kotlin")

var 所修饰的变量可以改变，但是并不可以修改他的变量类型，例如

var answer = 42
answer = “Kotlin”     //这样写是错误的，因为answer已经默认为Int类型

打印模板

Java中假如需要打印某个变量名，需要使用System.out.println("Hello, “+ name + " !”);

kotlin中使用了在变量名前使用字符$，就表示该处打印该变量，上述打印就可以转换为println(“Hello, $name !”)

当然也可以在$后使用表达式来表示采用哪一个变量，比如println(“Hello, ${if(list.size > 0) list[0] else “Kotlin”} !”)

类和属性

定义类

用 val 修饰属性，表示该属性仅是可读的，只拥有getter。

class Person(val name: String)

用 var 修饰属性，表示该属性可变，即该属性拥有getter和setter。

class Person(var name: String)

若不加任何修饰，就相当于只是自定义构造器中的一个参数，编译器并不能帮我们将其自动转换为属性，所以在对象中无法访问这个变量。

class Person(name: String)

自定义访问器

class Rectangle(val height: Int, val width: Int){
 
	val isSquare: Boolean

		get(){

			return height == weight

		}

}

这里的isSquare属性就不需要我们定义类时来传递给它值，他只有自定义的getter方法，即它的值是访问它时才计算出来的

目录和包

kotlin文件中顶层一般都用 package 声明文件所在包目录。

• 所在同一包下的所有文件可以互相访问
• 访问其他包下的文件就需要import导入（import可以导入函数，类）

枚举和”When“

枚举

enum class 两个关键字结合起来就可以表示一个枚举类，例如

enum class Color(
    var r: Int,
    var g: Int,
    var b: Int) {
    RED(255,0,0),ORANGE(255,165,0),
    YELLOW(255,255,0),GREEN(0,255,0);

    fun rgb() = (r * 256 + g) * 256 + b
}

这里就定义了一个颜色类，里面枚举了红橙黄绿四个颜色实体类。

”When“

Java中我们使用Switch和case的组合来解决多种选择，而Kotlin中我们使用的是When。

fun getColorName(color: Color) = 
    when(color){
        RED -> "RED"
        ORANGE -> "ORANGE"
        YELLOW -> "YELLOW"
        BLUE -> "BLUE"
    }

在Kotlin中，和if相似，when也是一个有返回值的表达式，所以上述的表达式时成立的。、

当然，我们的when关键字后也可以不带任何参数，例如：

fun getColorName(color: Color)=
    when{
        color == RED -> "RED"
        color == ORANGE -> "ORANGE"
        color == YELLOW -> "YELLOW"
        color == BLUE -> "BLUE"
    }

智能转换

下列函数我们用于计算几个数字的和，但是可能会出现(1+2)+4这种简单的算术表达式，所以我们需要判断表达式中的子元素是数字还是子表达式。

interface Expr
class Num(val value: Int) : Expr
class Sum(val left : Expr, val right: Expr) : Expr

fun eval(e: Expr) : Int {
    //is用来判断一个变量是否是某种类型，和java的instanceOf()相似，is判断后，会自动转换类型
    if (e is Num) {
        return e.value
    }
    if (e is Sum) {
        return eval(e.left) + eval(e.right)
    }
    throw IllegalAccessException("Unknown expression")
}

我们再用"When"代替if：

fun eval(e: Expr) : Int =
    when(e){
        //is如果判断成功，就会智能转换
            //代码块最后是返回值，相当于return
        is Num -> e.value
        is Sum -> eval(e.left) + eval(e.right)
        else -> throw IllegalAccessException("unknown expression")
    }

迭代循环

while循环

while 和 do-while 两个循环机制和Java类似，这里就不与阐述。

for…in循环

kotlin中常用的还有for…in循环。

kotlin中使用…运算符来表示区间，且两端的数值都是包含的或者闭合的。

for (i in 1..10) {
    println(i)
}	//打印结果就是1，2，3，...,10

那么倒序的数列该如何打印呢？

使用downTo运算符就可以表示倒叙区间，同样，它也是包含两端数值的。

for(i in 100 downTo 0){
    println(i)
}

如何定义步长呢？例如，我们想打印含100以内的正偶数，就可以使用step运算符来表示步长。

for (i in 2..100 step 2) {
    println(i)
}

集合的迭代

学习Java时学习过Foreach循环，kotilin也类似，想遍历集合时也可以运用for…in 循环

var lists = arrayListOf<String>("RED","GREEN")
for (list in lists){	//这里我们默认将lists集合内的单值赋给了list变量
    println(list)		//打印结果为RED，GREEN
}

我们再看一下Map类的迭代：

val binaryReps = TreeMap<Char, String>()

for(c in 'A'..'F'){
    val binary = Integer.toBinaryString(c.toInt())
    binaryReps[c] = binary    //等价binaryReps.put(c,binary)，kotlin是map[key] = value,不需要调用get 和 put
}

for ((letter,binary) in binaryReps){
    println("$letter = $binary")
}

我们从上述代码可以看出kotlin对map也进行了优化，可以使用map[key] = value 来设置对应的值，而不再需要调用get和put。

“in“检查集合和区间的成员

in不仅仅可以和for搭配起来来进行迭代遍历，它还可以检查某个值是否属于某个区间或者某个集合！

fun isLetter(c: Char) = c in 'a'..'z' || c in 'A'..'Z'
fun isNotDigit(c: Char) = c !in '0'..'9'

就比如上述两个函数可以分别检验某字符是否为字母和是否为数字。

println("Kotlin" in setOf("Java","Scala"))		//打印false

上述代码就可以判断"Kotlin"是否在由”Java“和”Scala“组成的集合里，显然不在。

Kotlin中的异常

Kotlin的异常处理和Java以及其他许多语言的处理方式相似，不过Kotlin不需要你声明函数可以抛出的异常，即不用在方法上使用throws声明异常信息。