数据类（Data Classes）
data class User(val name: String, val age: Int)
编译器自动生成的有：
- equals()/hashCode()
- toString() 形式为 "User(name=John, age=42)"
- componentN() 函数
- copy() 函数
数据类必须符合以下条件。
- 主体构造器必须至少有一个参数。
- 所有主体构造器的参数都必须被标注为var或val。
- 数据类不可以是 abstract, open, sealed 或 inner。
// 缺省参数的例子。
data class User(val name: String = "", val age: Int = 0)
// 自动生成的copy函数。
// fun copy(name: String = this.name, age: Int = this.age) = User(name, age)
// 实际应用copy函数的代码
val jack = User(name = "Jack", age = 1)
val olderJack = jack.copy(age = 2)
// 数据类与解构
val jane = User("Jane", 35)
val (name, age) = jane
println("$name, $age years of age") // prints "Jane, 35 years of age"
标准数据类包括Pair和Triple。
密封类（Sealed Classes）
密封类对继承有所限制。
密封类可以有子类，但是必须在同一文件中。
sealed class Expr
data class Const(val number: Double) : Expr()
data class Sum(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()
密封类的子类的子类不必在同一文件中。
使用密封类的好处在于在when表达式中可以处理所有情况，不必用else。
fun eval(expr: Expr): Double = when(expr) {
is Const -> expr.number
is Sum -> eval(expr.e1) + eval(expr.e2)
NotANumber -> Double.NaN
// the `else` clause is not required because we've covered all the cases
}
嵌套类（Nested Classes）
// 嵌套类
class Outer {
private val bar: Int = 1
class Nested {
fun foo() = 2
}
}
val demo = Outer.Nested().foo() // == 2
// 内部类（Inner Classes）
class Outer {
private val bar: Int = 1
inner class Inner {
fun foo() = bar
}
}
val demo = Outer().Inner().foo() // == 1
// 匿名内部类（Anonymous Inner Classes）
window.addMouseListener(object: MouseAdapter() {
override fun mouseClicked(e: MouseEvent) {
// ...
}
override fun mouseEntered(e: MouseEvent) {
// ...
}
})
// 函数型接口的对象生成
val listener = ActionListener { println("clicked") }
枚举类（Enum Classes）
每个枚举常量都是一个对象。
enum class Direction {
NORTH, SOUTH, WEST, EAST
}
// 初始化
enum class Color(val rgb: Int) {
RED(0xFF0000),
GREEN(0x00FF00),
BLUE(0x0000FF)
}
// 枚举类内部的匿名类
// 在枚举类你内定义抽象方法
// 然后使用枚举对象的匿名类来实现抽象方法
// 这里需要使用分号隔开枚举对象的定义和抽象方法的定义
enum class ProtocolState {
WAITING {
override fun signal() = TALKING
},
TALKING {
override fun signal() = WAITING
};
abstract fun signal(): ProtocolState
}
// 使用枚举常量
// EnumClass.valueOf(value: String): EnumClass
// EnumClass.values(): Array<EnumClass>
// enumValues<T>()
// enumValueOf<T>()
enum class RGB { RED, GREEN, BLUE }
inline fun <reified T : Enum<T>> printAllValues() {
print(enumValues<T>().joinToString { it.name })
}
printAllValues<RGB>() // prints RED, GREEN, BLUE
// 每个枚举常量都有如下属性
val name: String
val ordinal: Int
// 枚举类都实现了Comparable接口
对象表达式（Object Expressions）
对象表达式扩展了Java中的匿名内部类。
window.addMouseListener(object : MouseAdapter() {
override fun mouseClicked(e: MouseEvent) {
// ...
}
override fun mouseEntered(e: MouseEvent) {
// ...
}
})
// 构造器带参数的类也能使用对象表达式
open class A(x: Int) {
public open val y: Int = x
}
interface B {...}
val ab: A = object : A(1), B {
override val y = 15
}
// 使用对象表达式可以达成匿名类（对象）的效果
fun foo() {
val adHoc = object {
var x: Int = 0
var y: Int = 0
}
print(adHoc.x + adHoc.y)
}
// 匿名对象只能用于local和private声明
// 如果用于public声明，则成员不可访问
class C {
// Private function, so the return type is the anonymous object type
private fun foo() = object {
val x: String = "x"
}
// Public function, so the return type is Any
fun publicFoo() = object {
val x: String = "x"
}
fun bar() {
val x1 = foo().x // Works
val x2 = publicFoo().x // ERROR: Unresolved reference 'x'
}
}
// 对象表达式中的方法可以访问外层变量（不仅限于final变量）
fun countClicks(window: JComponent) {
var clickCount = 0
var enterCount = 0
window.addMouseListener(object : MouseAdapter() {
override fun mouseClicked(e: MouseEvent) {
clickCount++
}
override fun mouseEntered(e: MouseEvent) {
enterCount++
}
})
// ...
}
对象声明（Object declarations）
使用对象声明可以方便的声明单件（Singleton）。
在类中使用对象声明可以声明类的伴生对象（Companion object）。
伴生对象中声明的方法相当于其他语言的静态方法。
object DataProviderManager {
fun registerDataProvider(provider: DataProvider) {
// ...
}
val allDataProviders: Collection<DataProvider>
get() = // ...
}
// 使用单件
DataProviderManager.registerDataProvider(...)
// 有基类的情况
object DefaultListener : MouseAdapter() {
override fun mouseClicked(e: MouseEvent) {
// ...
}
override fun mouseEntered(e: MouseEvent) {
// ...
}
}
// 类的伴生对象，用于实现静态方法
class MyClass {
companion object Factory {
fun create(): MyClass = MyClass()
}
}
// 使用伴生对象的方法（相当于静态方法）
val instance = MyClass.create()
// 使用伴生对象自身
class MyClass {
companion object {
}
}
val x = MyClass.Companion
// 伴生对象可以实现接口
interface Factory<T> {
fun create(): T
}
class MyClass {
companion object : Factory<MyClass> {
override fun create(): MyClass = MyClass()
}
}
对象表达式和对象声明的语义
- 对象表达式是贪婪的（使用时即刻生成）。
- 对象声明是懒惰的 （第一次访问时生成）。
- 伴生对象在相应的类被生成时生成。