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:Stringval 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{ //关键字 operatorreturn 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:Inta = 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 = 3when(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 -> 11 in 2..100 -> 3else -> 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)
}

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

喜欢请点赞关注哦