Kotlin基础知识三
Kotlin 数据类与密封类
数据类
Kotlin 可以创建一个只包含数据的类，关键字为 data：
data class User(val name: String, val age: Int)
编译器会自动的从主构造函数中根据所有声明的属性提取以下函数：
- equals() / hashCode()
- toString() 格式如 “User(name=John, age=42)”
- componentN() functions 对应于属性，按声明顺序排列
- copy() 函数
如果这些函数在类中已经被明确定义了，或者从超类中继承而来，就不再会生成。
为了保证生成代码的一致性以及有意义，数据类需要满足以下条件：
- 主构造函数至少包含一个参数。
- 所有的主构造函数的参数必须标识为val 或者 var ;
- 数据类不可以声明为 abstract, open, sealed 或者 inner;
- 数据类不能继承其他类 (但是可以实现接口)。
复制copy()
复制使用 copy() 函数，我们可以使用该函数复制对象并修改部分属性, 对于上文的 User 类，其实现会类似下面这样：
fun copy(name: String = this.name, age: Int = this.age) = User(name, age)
实例
使用 copy 类复制 User 数据类，并修改 age 属性:
data class User(val name: String, val age: Int)
fun main(args: Array) {
val jack = User(name = "Jack", age = 1)
val olderJack = jack.copy(age = 2)
println(jack)
println(olderJack)
}
输出结果为：
User(name=Jack, age=1)
User(name=Jack, 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 修饰类，密封类可以有子类，但是所有的子类都必须要内嵌在密封类中。
sealed 不能修饰 interface ,abstract class(会报 warning,但是不会出现编译错误)
sealed class Expr
data class Const(val number: Double) : Expr()
data class Sum(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()
fun eval(expr: Expr): Double = when (expr) {
is Const -> expr.number
is Sum -> eval(expr.e1) + eval(expr.e2)
NotANumber -> Double.NaN
}
使用密封类的关键好处在于使用 when 表达式 的时候，如果能够 验证语句覆盖了所有情况，就不需要为该语句再添加一个 else 子句了。
fun eval(expr: Expr): Double = when(expr) {
is Expr.Const -> expr.number
is Expr.Sum -> eval(expr.e1) + eval(expr.e2)
Expr.NotANumber -> Double.NaN
// 不再需要 `else` 子句，因为我们已经覆盖了所有的情况
}
Kotlin 泛型
泛型，即 “参数化类型”，将类型参数化，可以用在类，接口，方法上。
与 Java 一样，Kotlin 也提供泛型，为类型安全提供保证，消除类型强转的烦恼。
声明一个泛型类：
class Box(t: T) {
var value = t
}
创建类的实例时我们需要指定类型参数：
val box: Box = Box(1)
// 或者
val box = Box(1) // 编译器会进行类型推断，1 类型 Int，所以编译器知道我们说的是 Box。
以下实例向泛型类 Box 传入整型数据和字符串：
class Box(t : T) {
var value = t
}
fun main(args: Array) {
var boxInt = Box(10)
var boxString = Box("Kotlin")
println(boxInt.value)
println(boxString.value)
}
输出结果为：
10
Kotlin
定义泛型类型变量，可以完整地写明类型参数，如果编译器可以自动推定类型参数，也可以省略类型参数。
Kotlin 泛型函数的声明与 Java 相同，类型参数要放在函数名的前面：
fun boxIn(value: T) = Box(value)
// 以下都是合法语句
val box4 = boxIn(1)
val box5 = boxIn(1) // 编译器会进行类型推断
在调用泛型函数时，如果可以推断出类型参数，可以省略泛型参数。
以下实例创建了泛型函数 doPrintln，函数根据传入的不同类型做相应处理：
fun main(args: Array) {
val age = 23
val name = "luobo"
val bool = true
doPrintln(age) // 整型
doPrintln(name) // 字符串
doPrintln(bool) // 布尔型
}
fun doPrintln(content: T) {
when (content) {
is Int -> println("整型数字为 $content")
is String -> println("字符串转换为大写：${content.toUpperCase()}")
else -> println("T 不是整型，也不是字符串")
}
}
输出结果为：
整型数字为 23
字符串转换为大写：LUOBO
T 不是整型，也不是字符串
泛型约束
我们可以使用泛型约束来设定一个给定参数允许使用的类型。
Kotlin 中使用 : 对泛型的的类型上限进行约束。
最常见的约束是上界(upper bound)：
fun > sort(list: List) {
// ……
}
Comparable 的子类型可以替代 T。 例如：
sort(listOf(1, 2, 3)) // OK。Int 是 Comparable 的子类型
sort(listOf(HashMap())) // 错误：HashMap 不是 Comparable> 的子类型
默认的上界是 Any?。
对于多个上界约束条件，可以用 where 子句：
fun cloneWhenGreater(list: List, threshold: T): List
where T : Comparable, Cloneable {
return list.filter(it > threshold).map(it.clone())
}
型变
Kotlin 中没有通配符类型，它有两个其他的东西：声明处型变（declaration-site variance）与类型投影（type projections）。
声明处型变
声明处的类型变异使用协变注解修饰符：in、out，消费者 in, 生产者 out。
使用 out 使得一个类型参数协变，协变类型参数只能用作输出，可以作为返回值类型但是无法作为入参的类型：
// 定义一个支持协变的类
class Test(val a: A) {
fun foo(): A {
return a
}
}
fun main(args: Array) {
var strCo: Test = Test("a")
var anyCo: Test = Test("b")
anyCo = strCo
println(anyCo.foo()) // 输出 a
}
in 使得一个类型参数逆变，逆变类型参数只能用作输入，可以作为入参的类型但是无法作为返回值的类型：
// 定义一个支持逆变的类
class Test(a: A) {
fun foo(a: A) { }
}
fun main(args: Array) {
var strDCo = Test("a")
var anyDCo = Test("b")
strDCo = anyDCo
}
星号投射
有些时候, 你可能想表示你并不知道类型参数的任何信息, 但是仍然希望能够安全地使用它. 这里所谓”安全地使用”是指, 对泛型类型定义一个类型投射, 要求这个泛型类型的所有的实体实例, 都是这个投射的子类型。
对于这个问题, Kotlin 提供了一种语法, 称为 星号投射(star-projection)：
- 假如类型定义为 Foo< out T> , 其中 T 是一个协变的类型参数, 上界(upper bound)为 TUpper ,Foo<> 等价于 Foo< out TUpper> . 它表示, 当 T 未知时, 你可以安全地从 Foo<> 中 读取TUpper 类型的值.
- 假如类型定义为 Foo< in T> , 其中 T 是一个反向协变的类型参数, Foo<> 等价于 Foo< in Nothing> . 它表示, 当 T 未知时, 你不能安全地向 Foo<> 写入 任何东西.
- 假如类型定义为 Foo< T > , 其中 T 是一个协变的类型参数, 上界(upper bound)为 TUpper , 对于读取值的场合, Foo<*> 等价于 Foo< out TUpper> , 对于写入值的场合, 等价于 Foo< in Nothing> .
如果一个泛型类型中存在多个类型参数, 那么每个类型参数都可以单独的投射. 比如, 如果类型定义为interface Function< in T, out U> , 那么可以出现以下几种星号投射：
- Function<*, String> , 代表 Function< in Nothing, String> ;
- Function< Int, *> , 代表 Function< Int, out Any?> ;
- Function<, > , 代表 Function< in Nothing, out Any?>
注意: 星号投射与 Java 的原生类型(raw type)非常类似, 但可以安全使用。
Kotlin 枚举类
枚举类最基本的用法是实现一个类型安全的枚举。
枚举常量用逗号分隔,每个枚举常量都是一个对象。
enum class Color{
RED,BLACK,BLUE,GREEN,WHITE
}
枚举初始化
每一个枚举都是枚举类的实例，它们可以被初始化：
enum class Color(val rgb: Int) {
RED(0xFF0000),
GREEN(0x00FF00),
BLUE(0x0000FF)
}
默认名称为枚举字符名，值从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
}
如果枚举类定义任何成员，要使用分号将成员定义中的枚举常量定义分隔开。
使用枚举常量
Kotlin 中的枚举类具有合成方法，允许遍历定义的枚举常量，并通过其名称获取枚举常数。
EnumClass.valueOf(value: String): EnumClass // 转换指定 name 为枚举值，若未匹配成功，会抛出IllegalArgumentException
EnumClass.values(): Array // 以数组的形式，返回枚举值
获取枚举相关信息：
val name: String //获取枚举名称
val ordinal: Int //获取枚举值在所有枚举数组中定义的顺序
实例
enum class Color{
RED,BLACK,BLUE,GREEN,WHITE
}
fun main(args: Array) {
var color:Color=Color.BLUE
println(Color.values())
println(Color.valueOf("RED"))
println(color.name)
println(color.ordinal)
}
输出：
[LColor;@65b54208 //堆地址
RED
BLUE
2
自 Kotlin 1.1 起，可以使用 enumValues< T >() 和 enumValueOf< T >() 函数以泛型的方式访问枚举类中的常量 ：
enum class RGB { RED, GREEN, BLUE }
inline fun > printAllValues() {
print(enumValues().joinToString { it.name })
}
fun main(args: Array) {
printAllValues() // 输出 RED, GREEN, BLUE
}
Kotlin 对象表达式和对象声明
Kotlin 用对象表达式和对象声明来实现创建一个对某个类做了轻微改动的类的对象，且不需要去声明一个新的子类。
对象表达式
通过对象表达式实现一个匿名内部类的对象用于方法的参数中：
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 main(args: Array) {
val site = object {
var name: String = "百度"
var url: String = "www.baidu.com"
}
println(site.name)
println(site.url)
}
请注意，匿名对象可以用作只在本地和私有作用域中声明的类型。
如果你使用匿名对象作为公有函数的 返回类型或者用作公有属性的类型，那么该函数或属性的实际类型 会是匿名对象声明的超类型，如果你没有声明任何超类型，就会是 Any。在匿名对象 中添加的成员将无法访问。
class C {
// 私有函数，所以其返回类型是匿名对象类型
private fun foo() = object {
val x: String = "x"
}
// 公有函数，所以其返回类型是 Any
fun publicFoo() = object {
val x: String = "x"
}
fun bar() {
val x1 = foo().x // 没问题
val x2 = publicFoo().x // 错误：未能解析的引用“x”
}
}
在对象表达中可以方便的访问到作用域中的其他变量：
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++
}
})
// ……
}
对象声明
Kotlin 使用 object 关键字来声明一个对象。
Kotlin 中我们可以方便的通过对象声明来获得一个单例。
object DataProviderManager {
fun registerDataProvider(provider: DataProvider) {
// ……
}
val allDataProviders: Collection
get() = // ……
}
引用该对象，我们直接使用其名称即可：
DataProviderManager.registerDataProvider(……)
当然你也可以定义一个变量来获取获取这个对象，当你定义两个不同的变量来获取这个对象时，你会发现你并不能得到两个不同的变量。也就是说通过这种方式，我们获得一个单例。
var data1 = DataProviderManager
var data2 = DataProviderManager
data1.name = "test"
print("data1 name = ${data2.name}")
实例
以下实例中，两个对象都输出了同一个 url 地址：
object Site {
var url:String = ""
val name: String = "百度百科"
}
fun main(args: Array) {
var s1 = Site
var s2 = Site
s1.url = "www.baidu.com"
println(s1.url)
println(s2.url)
}
输出结果为:
www.baidu.com
www.baidu.com
对象可以有超类型：
object DefaultListener : MouseAdapter() {
override fun mouseClicked(e: MouseEvent) {
// ……
}
override fun mouseEntered(e: MouseEvent) {
// ……
}
}
与对象表达式不同，当对象声明在另一个类的内部时，这个对象并不能通过外部类的实例访问到该对象，而只能通过类名来访问，同样该对象也不能直接访问到外部类的方法和变量。
class Site {
var name = "百度"
object DeskTop{
var url = "www.baidu.com"
fun showName(){
print{"desk legs $name"} // 错误，不能访问到外部类的方法和变量
}
}
}
fun main(args: Array) {
var site = Site()
site.DeskTop.url // 错误，不能通过外部类的实例访问到该对象
Site.DeskTop.url // 正确
}
伴生对象
类内部的对象声明可以用 companion 关键字标记，这样它就与外部类关联在一起，我们就可以直接通过外部类访问到对象的内部元素。
class MyClass {
companion object Factory {
fun create(): MyClass = MyClass()
}
}
val instance = MyClass.create() // 访问到对象的内部元素
我们可以省略掉该对象的对象名，然后使用 Companion 替代需要声明的对象名：
class MyClass {
companion object { }
}
val x = MyClass.Companion
注意：一个类里面只能声明一个内部关联对象，即关键字 companion 只能使用一次。
伴生对象的成员看起来像其他语言的静态成员，但在运行时他们仍然是真实对象的实例成员。例如还可以实现接口：
interface Factory {
fun create(): T
}
class MyClass {
companion object : Factory {
override fun create(): MyClass = MyClass()
}
}
对象表达式和对象声明之间的语义差异
对象表达式和对象声明之间有一个重要的语义差别：
- 对象表达式是在使用他们的地方立即执行的
- 对象声明是在第一次被访问到时延迟初始化的
- 伴生对象的初始化是在相应的类被加载（解析）时，与 Java 静态初始化器的语义相匹配
kotlin 委托
委托模式是软件设计模式中的一项基本技巧。在委托模式中，有两个对象参与处理同一个请求，接受请求的对象将请求委托给另一个对象来处理。
Kotlin 直接支持委托模式，更加优雅，简洁。Kotlin 通过关键字 by 实现委托。
类委托
类的委托即一个类中定义的方法实际是调用另一个类的对象的方法来实现的。
以下实例中派生类 Derived 继承了接口 Base 所有方法，并且委托一个传入的 Base 类的对象来执行这些方法。
// 创建接口
interface Base {
fun print()
}
// 实现此接口的被委托的类
class BaseImpl(val x: Int) : Base {
override fun print() { print(x) }
}
// 通过关键字 by 建立委托类
class Derived(b: Base) : Base by b
fun main(args: Array) {
val b = BaseImpl(10)
Derived(b).print() // 输出 10
}
在 Derived 声明中，by 子句表示，将 b 保存在 Derived 的对象实例内部，而且编译器将会生成继承自 Base 接口的所有方法, 并将调用转发给 b。
属性委托
属性委托指的是一个类的某个属性值不是在类中直接进行定义，而是将其托付给一个代理类，从而实现对该类的属性统一管理。
属性委托语法格式：
val/var <属性名>: <类型> by <表达式>
- var/val：属性类型(可变/只读)
- 属性名：属性名称
- 类型：属性的数据类型
- 表达式：委托代理类
by 关键字之后的表达式就是委托, 属性的 get() 方法(以及set() 方法)将被委托给这个对象的 getValue() 和 setValue() 方法。属性委托不必实现任何接口, 但必须提供 getValue() 函数(对于 var属性,还需要 setValue() 函数)。
定义一个被委托的类
该类需要包含 getValue() 方法和 setValue() 方法，且参数 thisRef 为进行委托的类的对象，prop 为进行委托的属性的对象。
import kotlin.reflect.KProperty
// 定义包含属性委托的类
class Example {
var p: String by Delegate()
}
// 委托的类
class Delegate {
operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
return "$thisRef, 这里委托了 ${property.name} 属性"
}
operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
println("$thisRef 的 ${property.name} 属性赋值为 $value")
}
}
fun main(args: Array) {
val e = Example()
println(e.p) // 访问该属性，调用 getValue() 函数
e.p = "Luobo" // 调用 setValue() 函数
println(e.p)
}
输出结果为：
Example@433c675d, 这里委托了 p 属性
Example@433c675d 的 p 属性赋值为 Luobo
Example@433c675d, 这里委托了 p 属性
标准委托
Kotlin 的标准库中已经内置了很多工厂方法来实现属性的委托。
延迟属性 Lazy
lazy() 是一个函数, 接受一个 Lambda 表达式作为参数, 返回一个 Lazy < T > 实例的函数，返回的实例可以作为实现延迟属性的委托： 第一次调用 get() 会执行已传递给 lazy() 的 lamda 表达式并记录结果， 后续调用 get() 只是返回记录的结果。
val lazyValue: String by lazy {
println("computed!") // 第一次调用输出，第二次调用不执行
"Hello"
}
fun main(args: Array) {
println(lazyValue) // 第一次执行，执行两次输出表达式
println(lazyValue) // 第二次执行，只输出返回值
}
执行输出结果：
computed!
Hello
Hello
Kotlin在线编辑学习：https://try.kotlinlang.org/#/Examples/Hello,%20world!/Simplest%20version/Simplest%20version.kt
菜鸟教程：http://www.runoob.com/kotlin/kotlin-tutorial.html