上一篇文章着重介绍了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 D
class 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)
}
这一篇文章主要还是说明了一些程序结构上的问题，包括表达式，语句，运算符，类成员等，下一篇文章可能介绍面向对象的内容，包括继承，重载，扩展成员，属性代理等，或者看情况介绍高阶函数的内容。
喜欢请点赞关注哦😝
