Kotlin修仙之旅：类成员，运算符，语句，表达式

上一篇文章着重介绍了Kotlin中的常量与变量，函数和Lambda表达式（点我补课），这一篇文章专注于类成员，运算符，各种语句和表达式。

类成员

包括属性和方法。

属性：也就是成员变量，是指类范围内的变量

方法：也就是成员函数，类范围内的函数

成员函数的写法与普通函数完全一致。

fun main(args: Array<String>) {
    猫咪("10kg","橘色","橘云遮天").跳舞("海草舞")
}class 猫咪(体重:String,颜色:String,花纹:String){
    fun 跳舞(name:String){
        println("喵咪跳起了$name")
    }
}

在构造方法参数中，val和var修饰的都是数学，而类的内部也可以定义属性，就是成员变量

class 猫咪(体重:String,颜色:String,花纹:String){
    var catName:String = "胖胖"  //这就是成员变量
    fun 跳舞(name:String){
        println("喵咪跳起了$name")
    }
}

属性访问控制：

属性可以定义getter、setter,比如:

class 猫咪(体重:String,颜色:String,花纹:String){
    var catName:String = "胖胖"
        get() = field   //get方法
        set(value){field = value} //set方法
    fun 跳舞(name:String){
        println("喵咪跳起了$name")
    }
}
fun main(args: Array<String>) {
var 胖胖:猫咪 = 猫咪("10kg","橘色","橘云遮天")
    胖胖.catName = "大胖" //相当于 setCatName}

属性的初始化应该尽量在构造方法，若无法再构造方法中初始化，尝试降级为局部变量

在类中定义了var 类型的成员变量时候需要初始化，否则编译器报错，或者使用 lateinit 关键字，告诉编译器我们需要延迟初始化。

class ABC{
    lateinit var b:String}

而val类型的，需要使用 by lazy，使得该实例在用到的时候才初始化

class Dclass ABC{
    lateinit var b:String
    val d:D by lazy { 
        D()
    }
}

类ABC初始化的时候并不会初始化变量d，只有使用到d的时候才会初始化并返回一个D类的实例

运算符

Kotlin中运算符与Java基本没有太大差别，但Kotlin中运算符支持重载。

比如我们来重载一个 " + " 作为复数运算符

fun main(args: Array<String>) {
    val c1 = Complex(1.0,2.0)
    val c2 = Complex(4.0,5.0)
    println(c1 + c2)
}class Complex(var real:Double,var imaginary:Double){
    operator fun plus(other:Complex):Complex{ //关键字 operator        return Complex(real + other.real,imaginary + other.imaginary)
    }

    override fun toString(): String {        return "$real + ${imaginary}i"
    }
}

结果：

5.0 + 7.0i

在Kotlin中，任何类都可以定义或者重载父类的基本运算符，通过运算符对应的具名函数来定义（比如“ + ”的 “plus”）

对参数个数作要求，对参数和返回值类型不做要求（上文 plus 的返回值类型可以多样）

当然，Kotlin中，并不能像 Scala一样定义任意运算符

表达式

中缀表达式

是指只有一个参数，且用infix修饰的函数，有点类似自定义运算符

比如我们有 in 运算符，可以判断 某个元素是否在一个集合内 比如:

if (3 in 1..10)  表示判断是否3是否在【3，10】的区间内

那我们自定义一个表达式，来判断 一本书是否在书架上：

fun main(args: Array<String>) {    if (Book() on Desk()){

    }
}class Book{    infix fun on(any:Any):Boolean{        return false
    }
}class Desk

分支表达式

if ..else..表达式跟java大同小异

无非就是 if(a == b) ..else if (a == c) ..else..

之类的表达式，但Kotlin更灵活的是，表达式可以返回每个分支的最后一句话，例如：

var a:Int
    a = if (3 in 1..10){
        println("true")        1
    }else{
        println("false")        2
    }

但这种情况下，表达式需要具有完备性，

像 val x = if(a < 0) 0   这样就是错误的，少了一个else分支

when表达式

相当于加强版switch，支持任意类型，支持纯表达式的条件分支（这点类似if）

看几个例子，就知道怎么用了：

 val state:Int = 3
    when(state){        1 -> println("1")        2 -> println("2")        else -> println("3")
    }    when(state){
        is Int -> println("is Int")        in 1..100 -> println(" in [1,100]")
        !in 1..100 -> println("not in [1,100]")        1 -> println(" == 1")
    }

    val status = when{        2 == 3 -> 1
        1 in 2..100 -> 3
        else -> 4
    }

循环语句

Kotlin中的循环语句没有太多特别的地方，无非就是for ()，while()，do..while()这些。

只是for语句比Java简洁许多，比如

for(i in IntList){ //输出一个list中所有的元素println(i)
}

少了去根据list尺寸去判断循环次数的麻烦。

这里再说一点比Java优越之处。

在Java 中，要跳出多层循环是比较麻烦的，在Kotlin中，可以为for循环命名，精确指定要跳出哪个循环：

Outter@for(i in 1..100){
        Inner@for (j in 100..1000){            break@Outter
        }

其他一些小知识点

具名参数：

其实就是给函数的实参附上形参

fun plus(arg1:Int,arg2:Int):Int{    return arg1 + arg2
}fun main(args: Array<String>) {
    plus(arg2 = 1,arg1 = 3) //指定第一个参数和第二个参数的值}

变长参数：

某个参数可以接收多个值，且可以不为最后一个参数，此时可能传参有歧义，需要使用具名参数

fun hello(vararg ints:Int,name:String){
    ints.forEach { println(name + it) }
}

fun main(args: Array<String>) {
hello(1,2,3,5,name = "wo")
}

默认参数：

可以为任意位置的参数指定默认值，在传参时，若有歧义，再使用具名参数

fun hello(vararg ints:Int,name:String = "小猪"){
    ints.forEach { println(name + it) }
}

fun main(args: Array<String>) {

    hello(1,2,3,5)
}

这一篇文章主要还是说明了一些程序结构上的问题，包括表达式，语句，运算符，类成员等，下一篇文章可能介绍面向对象的内容，包括继承，重载，扩展成员，属性代理等，或者看情况介绍高阶函数的内容。

作者：请抱抱陈先生
链接：https://www.jianshu.com/p/2e0abb6ad9e8