kotlin--嵌套类、枚举、对象

主要内容

---

• 嵌套类
• 内部类
• 枚举
• 对象表达式
• 单例

嵌套类(Nested Class)

---

类中嵌套其他类：

class Outer{
    private val name:String = "jason"

    /**嵌套类**/
    class Nested{
        fun doSomething() = 18
    }
}

若嵌套类需要访问外部类成员，则需要使用inner关键词进行修饰：

class Outer{
    private val name:String = "jason"

    /**嵌套内部类**/
    inner class Inner{
        fun doSomething() = name //访问外部类成员
    }
}

若需要实例化内部类，需要首先获取到外部类对象，然后再进行实例化：

var name = Outer().Inner().doSomething() // jason

枚举

---

定义与java中类似，存放一些常量。定义如下：

enum class Color{
    RED,BLACK,BLUE,GREEN,WHITE
}

fun displayColor(){
    var color:Color=Color.RED

    println(color.name())
    println(color.ordinal())
}

输出结果为：

RED
0

默认名称为枚举字符名，值从0开始。若需要指定值，则可以使用其构造函数：

enum class Shape(value:Int){
    ovel(100),
    rectangle(200)
}

同时，枚举还支持自定义方法，如：

enum class ProtocolState {
  WAITING {
    override fun signal() = TALKING
  },

  TALKING {
    override fun signal() = WAITING
  };

  abstract fun signal(): ProtocolState
}

其他值转换成枚举值

枚举类提供两个方法：

valueof(value:String)  // 转换指定name为枚举值，若未匹配成功，会抛出IllegalArgumentException

values() //已数组的形式，返回枚举值

获取枚举相关信息：

name():String //获取枚举名称
ordinal():Int //获取枚举值在所有枚举数组中定义的顺序

对象表达式(Object Expressions)

---

正常情况下，当需要使用一个类，同时需要对其某些属性或方法做调整时，使用继承；当不使用继承的情况下，java允许使用匿名内部类;kotlin也有类似的概念，称为对象表达式-object expressions。

用在单独定义中：

open class KeyBord{
    open fun onKeyEvent(code:Int):Unit = Unit
}

/**匿名内部类**/
var key=object :KeyBord(){
    override open fun onKeyEvent(code:Int):Unit = Unit
};

用作参数，使用 object 关键字进行定义：

fun onClick(key:KeyBord){
    //do nothing
}

fun print(){
    /**匿名内部类用作函数参数**/
    onClick(object :KeyBord(){
        override open fun onKeyEvent(code:Int):Unit = Unit
    });
}

当仅需要对象时，可以不继承类，直接使用object进行定义：

var value=object {
    var x=1
    var y=2
}

与java匿名内部类的区别：当匿名内部类需要访问外部成员时，需要将该成员定义成final；kotlin允许不定义成final直接访问。

单例

---

使用object定义类，该类的实例即为单例，访问单例直接使用类名，不能通过构造函数进行访问，不允许有构造函数：

object Place{
    fun showDetail(){

    }
}

Place.showDetail() // 访问单例对象

当在类内部使用 object 关键词定义对象时，允许直接通过外部类的类名访问内部对象进而访问其相关属性和方法，相当于静态变量：

class MyClass{
   object Place{
        fun showDetail(){

        }
   }
}

MyClass.Place.showDetail() // 访问内部单例对象方法

可以使用companion修饰单例，则访问其属性或方法时，允许省略单例名：
class MyClass{
companion object Place{
fun showDetail(){

        }
   }
}

MyClass.showDetail() // 访问内部单例对象方法

匿名内部类和单例总结：

实例化的时候，单例是懒加载，当使用的时候才去加载；而对象表达式是在初始化的地方去加载。