android巩固-kotlin第二篇

类和对象

/* -------------- 类和对象 -------------- */
/**
Kotlin 类可以包含：构造函数和初始化代码块、函数、属性、内部类、对象声明。
class Runoob {  // 类名为 Runoob
// 大括号内是类体构成
}

声明空类
class Empty

成员函数
class Runoob {
fun foo(){}
}

类的属性
class Runoob {
var name:String
var url:String
var city:String
}

实例的创建
val site = Runoob()
属性的引用
site.name="zzz"
site.url="action.call"

构造方法
class Person constructor(firstName:String){}
如果主构造器没有任何注解，也没有任何可见度修饰符，那么constructor关键字可以省略。
class Person(firstName:String){}

getter 和 setter

var [: ] [= ]
[]
[]

getter 和 setter 都是可选

如果属性类型可以从初始化语句或者类的成员函数中推断出来，那就可以省去类型，val不允许设置setter函数，因为它是只读的。

var allByDefault: Int? // 错误: 需要一个初始化语句, 默认实现了 getter 和 setter 方法
var initialized = 1    // 类型为 Int, 默认实现了 getter 和 setter
val simple: Int?       // 类型为 Int ，默认实现 getter ，但必须在构造函数中初始化
val inferredType = 1   // 类型为 Int 类型,默认实现 getter
 */

class Person {
    var lastName: String = "zhang"
        get() = field.toUpperCase()
        set

    /*Kotlin 中类不能有字段。提供了 Backing Fields(后端变量) 机制,备用字段使用field关键字声明,field 关键词只能用于属性的访问器*/
    var no: Int = 100
        get() = field
        set(value) {
            if (value < 10) {
                field = value
            } else {
                field = -1
            }
        }

    var height: Float = 145.4f
        private set
}

fun t_obj_person() {
    val person = Person()
    person.lastName = "ratel"
    println("lastName = ${person.lastName}")
    person.no = 9
    println("no = ${person.no}")
    person.no = 21
    println("no = ${person.no}")
}


public class MyTest {
    // 非空属性必须在定义的时候初始化,kotlin提供了一种可以延迟初始化的方案,使用 lateinit 关键字描述属性
    lateinit var subject: TestSubject

    @SetUp
    fun setup() {
        subject = TestSubject()
    }

    @Test
    fun test() {
        subject.method()
    }
}

annotation class SetUp
annotation class Test

class TestSubject {
    fun method() {
    }

}

/**主构造器
 *  主构造器中不能包含任何代码，初始化代码可以放在初始化代码段中，初始化代码使用init关键字
 */
class BookBean constructor(name: String) {
    init {
        println("book name $name")
    }
}

/**
 * 注意：主构造器的参数可以在初始化代码段中使用，也可以在类主体n定义的属性初始化代码中使用。 一种简洁语法，可以通过主构造器来定义属性并初始化属性值（可以是var或val）：
 *  val 定义的常量是不可以修改的
 *  如果构造器有注解，或者有可见度修饰符，这时constructor关键字是必须的，注解和修饰符要放在它之前。
 */
class People(val firstName: String, val lastName: String) {
    init {
        println("firstName $firstName , lastName $lastName")
    }
}

fun t_consutrctor() {
    BookBean("三国")
    People("kagle", "ai")
}


class Runoob constructor(name: String) {
    var url = "http://www.runoob.com"
    var contry: String = "CN"
    var siteName = name

    init {
        println("初始化网站名: $name")
    }

    fun printTest() {
        println("我是类的函数")
    }
}

fun t_runoob() {
    val runoob = Runoob("菜鸟教程")
    println(runoob.siteName)
    println(runoob.url)
    println(runoob.contry)
    runoob.printTest()
}

/**
 * 次构造函数
类也可以有二级构造函数，需要加前缀 constructor:
 */
class NewPerson {
    private val children: Children = Children()

    constructor(parent: NewPerson) {
        parent.children.add(this)
    }
}

/**
 * 如果类有主构造函数，每个次构造函数都要，或直接或间接通过另一个次构造函数代理主构造函数。
 * 在同一个类中代理另一个构造函数使用 this 关键字：
 */
class NewPerson2 constructor(val name: String) {
    var age: Int = 0

    init {
        println("NewPerson2 init name : $name")
    }


    constructor(name: String, _age: Int) : this(name) {
        age = _age
        // 初始化
        println("NewPerson2 次构造 : name : $name , age : $age")
    }
}

fun t_new_person2() {
    val newPerson2 = NewPerson2("zzg", 32)
    println("user name ${newPerson2.name} , age ${newPerson2.age}")
}

class Children {
    var pList = ArrayList()

    fun add(person: NewPerson) {
        if (!pList.contains(person)) {
            pList.add(person)
        }
    }
}

/**
 *如果一个非抽象类没有声明构造函数(主构造函数或次构造函数)，它会产生一个没有参数的构造函数。构造函数是 public 。如果你不想你的类有
 * 公共的构造函数，你就得声明一个空的主构造函数
 */
class DontCreateMe private constructor() {

}

/**
 * 注意：在 JVM 虚拟机中，如果主构造函数的所有参数都有默认值，编译器会生成一个附加的无参的构造函数，这个构造函数会直接使用默认值。这使得 Kotlin 可以更简单的使用像 Jackson 或者 JPA 这样使用无参构造函数来创建类实例的库。
class Customer(val customerName: String = "")
 */
/* -------------- 类和对象 -------------- */


/* -------------- 抽象类 -------------- */
/**
 * 抽象是面向对象编程的特征之一，类本身，或类中的部分成员，都可以声明为abstract的。抽象成员在类中不存在具体的实现。
注意：无需对抽象类或抽象成员标注open注解。
 */
open class BaseHandler {
    open fun f() {}
}

// 抽象类
abstract class BaseDefaultHanlder : BaseHandler() {
    // 抽象方法
    override abstract fun f()

}
/* -------------- 抽象类 -------------- */

/* -------------- 嵌套类(静态内部类) -------------- */
class Outer {
    private val bar: Int = 1

    class Nested {

        var ot: Outer = Outer()

        fun test() {
            // 嵌套类可以引用外部类私有变量，但要先创建外部类的实例，不能直接引用
            println(ot.bar)
        }

        fun foo() = 2
    }
}

// 调用格式:外部类.嵌套类.嵌套类方法/属性
fun t_nest_cls() {
    // 嵌套类，Outter后边没有括号
    val foo = Outer.Nested().foo()
    println("foo = $foo")
}
/* -------------- 嵌套类(静态内部类) -------------- */

/* -------------- 内部类 -------------- */
/**
 * 内部类使用 inner 关键字来表示。
内部类会带有一个对外部类的对象的引用，所以内部类可以访问外部类成员属性和成员函数。
 */
class Outer2 {
    private val bar: Int = 2
    var v = "成员属性"

    /*嵌套内部类*/
    inner class Inner2 {
        // 访问外部类成员
        fun foo() = bar

        fun innterTest() {
            // 获取外部类的成员变量
            // 相当于Outer.this
            /*
            为了消除歧义，要访问来自外部作用域的 this，我们使用this@label，
            其中 @label 是一个 代指 this 来源的标签。
            */
            var o = this@Outer2
            println("Outer2 内部类可以引用外部类的成员: v " + o.v)
        }
    }
}

fun t_inner_cls() {
    // 内部类，Outter后边有括号
    //
    val foo = Outer2().Inner2().foo()
    println("t_inner_cls foo = $foo")

    val d = Outer2().Inner2().innterTest()
    println("t_inner_cls d = $d")
}
/* -------------- 内部类 -------------- */

/* -------------- 匿名内部类 -------------- */
/*使用对象表达式来创建匿名内部类*/

class Test2 {
    var v = "成员属性"

    fun setInterFace(test: ITest) {
        println("Test2 setInterFace v = $v ")
        test.test()
    }
}

// 定义接口
interface ITest {
    fun test()
}

fun t_anonymous() {
    val test2 = Test2()
    /**
     * 采用对象表达式来创建接口对象，即匿名内部类的实例
     */
    test2.setInterFace(object : ITest {
        override fun test() {
            println("接口回调,对象表达式创建匿名内部类的实例")
        }
    })
}
/* -------------- 匿名内部类 -------------- */

/* -------------- 类的修饰符 -------------- */
/**
 * 类的修饰符包括 classModifier 和_accessModifier_:
 * classModifier: 类属性修饰符，标示类本身特性。

abstract    // 抽象类
final       // 类不可继承，默认属性
enum        // 枚举类
open        // 类可继承，类默认是final的
annotation  // 注解类

accessModifier: 访问权限修饰符

private    // 仅在同一个文件中可见
protected  // 同一个文件中或子类可见
public     // 所有调用的地方都可见
internal   // 同一个模块中可见
 */
private fun foo() {} // 在包类可见，包级函数

public var bar: Int = 5 // 该属性随处可见

internal val baz = 6 // 相同模块内可见

/* -------------- 类的修饰符 -------------- */

fun main(args: Array) {
    t_obj_person()
    t_consutrctor()
    t_runoob()
    t_new_person2()
    t_nest_cls()
    t_inner_cls()
    t_anonymous()
}

继承

/* -------------- 继承 -------------- */
/**
kotlin中所有的类都继承Any,它是所有类的超父，对于没有超类型声明的类默认继承超类
class Exemaple // 从Any隐式继承
Any默认提供三个函数:equals,hashCode,toString

Any不是java.lang.Object
如果一个类要被继承，可以使用open关键字进行修饰
 */

open class Base(p: Int) // 定义基类

class Dervied(p: Int) : Base(p)
/* -------------- 继承 -------------- */

/* -------------- 构造函数 -------------- */
/**
 *子类有主构造函数
如果子类有主构造函数， 则基类必须在主构造函数中立即初始化
 */
open class New_EPerson(var name: String, var age: Int) { // 基类

}

class Student(name: String, age: Int, var no: String, var score: Int) : New_EPerson(name, age) {

}

fun t_ext_obj() {
    val student = Student("runnob", 18, "S0035", 89)
    println("姓名: ${student.name}")
    println("年龄: ${student.age}")
    println("学生号: ${student.no}")
    println("学分: ${student.score}")
}


/**
 *子类没有主构造函数
如果子类没有主构造函数，则必须在每一个二级构造函数中用 super 关键字初始化基类，
或者在代理另一个构造函数。初始化基类时，可以调用基类的不同构造方法。
 */

open class Animal constructor(ctx: Context) {
    // 次构造
    constructor(ctx: Context, attrs: AttributeSet) : this(ctx)
}

class Cat : Animal {
    constructor(ctx: Context) : super(ctx)

    constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
}

//实例

open class User(name: String) {
    // 次级构造函数
    constructor(name: String, age: Int) : this(name) {
        println("---------- 基类次级构造函数 ----------")
    }
}

class Worker : User {
    constructor(name: String, age: Int, no: String, score: Int) : super(name, age) {
        println("---------- 继承类次级构造函数 ----------")
        println("Worker 姓名: $name")
        println("Worker 年龄: $age")
        println("Worker 学生号: $no")
        println("Worker 学分: $score")
    }
}

fun t_ext_user() {
    Worker("test01", 23, "S1174", 135)
}


/**
 *重写
在基类中，使用fun声明函数时，此函数默认为final修饰，不能被子类重写。如果允许子类重写该函数，
那么就要手动添加 open 修饰它, 子类重写方法使用 override 关键词
 */
// 用户基类
open class NewUser {
    open fun study() { // 允许子类重写
        println("我毕业了")
    }
}

/*子类继承NewUser类*/
class NewStudent : NewUser() {
    override fun study() { // 重写方法
        println("我在读大学")
    }
}

fun t_ode() {
    val student = NewStudent()
    student.study()
}

// 如果有多个相同的方法（继承或者实现自其他类，如A、B类），则必须要重写该方法，使用super范型去选择性地调用父类的实现。
open class A {
    open fun f() {
        println("A")
    }

    fun a() {
        println("a")
    }
}

interface B {
    //  //接口的成员变量默认是 open 的
    fun f() {
        println("B")
    }

    fun b() {
        println("b")
    }
}

class C() : A(), B {
    override fun f() {
        println("C run f ... ")
        // 选择性的去调用父类的实现
        super.f()
        super.f()
    }
}

fun t_oc() {
    val c = C()
    c.f()
}

/**
 * 属性重写
属性重写使用 override 关键字，属性必须具有兼容类型，每一个声明的属性都可以通过初始化程序或者getter方法被重写：
 */
open class Foo {
    open val x: Int
        get() = 10
}

class Bar1 : Foo() {
    override val x: Int
        get() = super.x
}

/**
 *
你可以用一个var属性重写一个val属性，但是反过来不行。因为val属性本身定义了getter方法，重写为var属性会在衍生类中额外声明一个setter方法
你可以在主构造函数中使用 override 关键字作为属性声明的一部分:
 */
interface IFoo {
    val count: Int
}

class Bar_1(override val count: Int) : IFoo

class Bar_2 : IFoo {
    override var count: Int = 0
}

/* -------------- 构造函数 -------------- */
fun main(args: Array) {
    t_ext_obj()

    t_ext_user()

    t_ode()

    t_oc()
}

接口

/* -------------- 接口 -------------- */
//接口与java8类似，使用interface定义，允许方法有默认实现
interface IMe {
    fun bar()

    fun foo() {
        // 默认实现
        println("foo")
    }
}

/**
 * 实现接口
 *  一个类或者对象可以实现一个或多个接口
 */
class MyChild : IMe {
    override fun bar() {
        println("bar")
    }
}

fun t_mychild() {
    val myChild = MyChild()
    myChild.bar()
    myChild.foo()
}

/**
 * 接口中的属性
 * 接口中的属性只能是抽象的，不允许初始化值，接口不会保存属性值，实现接口时，必须重写属性
 */
interface INewMe {
    // 抽象属性
    var name: String
}

class NewMeImpl : INewMe {
    // 重写属性
    override var name: String = "runoob"
}

fun t_new_me() {
    val meImpl = NewMeImpl()
    println("name = ${meImpl.name}")
}

/**
 * 函数的重写
 * 实现多个接口时，可能会遇到同一方法继承多个实现的问题
 */
interface A_1 {
    fun foo() {
        println("A_1")
    }

    fun bar()
}

interface B_1 {
    fun foo() {
        println("B_1")
    }

    fun bar() {
        println("B_1 bar")
    }
}

class C_1 : A_1 {
    override fun bar() {
        println("C_1 bar")
    }

}

class D_1 : A_1, B_1 {
    override fun bar() {
        println("D_1 bar")
        super.bar()
    }

    override fun foo() {
        println("D_1 foo")
        super.foo()
        super.foo()
    }
}

fun t_o_method() {
    val d_1 = D_1()
    d_1.foo()
    d_1.bar()
}

/**
 * 实例中接口 A 和 B 都定义了方法 foo() 和 bar()， 两者都实现了 foo(), B 实现了 bar()。因为 C 是一个实现了 A 的具体类，
 * 所以必须要重写 bar() 并实现这个抽象方法。

  然而，如果我们从 A 和 B 派生 D，我们需要实现多个接口继承的所有方法，并指明 D 应该如何实现它们。
  这一规则 既适用于继承单个实现（bar()）的方法也适用于继承多个实现（foo()）的方法。
 */
/* -------------- 接口 -------------- */
fun main(args: Array) {
    t_mychild()
    t_new_me()
    t_o_method()
}

扩展

package com.example.ext

/* -------------- 扩展 -------------- */
/**
 * kotlin可以对一个类的属性和方法进行扩展，且不需要使继承或使用Decorator模式
 * 扩展是一种静态行为，对于被扩展的类代码本身不会造成任何影响
 */

/**
 * 扩展函数
 * 扩展函数可以在已有的类中添加新的方法，不会对原类做修改
 * fun receiverType.functionName(params){
 *   body
 * }
 *
 * receiverType 要扩展的类
 * functionName 方法名称
 */

class New_User(var name: String)

// 扩展函数
fun New_User.Print() {
    println("User .. $name")
}

fun t_user_print() {
    val user = New_User("zz")
    user.Print()
}

/**
 * 为MutableList添加一个swap函数,交换不同位置的值
 */
fun MutableList.swap(_i: Int, _j: Int) {
    var tmp = this[_i]
    this[_i] = this[_j]
    this[_j] = tmp

    // this关键字指代接收者对象(receiver object)(也就是调用扩展函数时, 在点号之前指定的对象实例)。
}

fun t_change_item() {
    val l = mutableListOf(1, 2, 3)
    l.swap(0, 2)
    println(l.toString())
}


/**
 * 扩展函数是静态解析的
扩展函数是静态解析的，并不是接收者类型的虚拟成员，在调用扩展函数时，具体被调用的的是哪一个函数，由调用函数的的对象表达式来决定的，
而不是动态的类型决定的:
 */

open class EC

class ED : EC()

fun EC.foo() = "c" // 扩展函数foo

fun ED.foo() = "d" // 扩展函数foo

/**
 * 无论方法传递的是哪个实例，最终只会调用EC的扩展函数
 */
fun printFoo(c: EC) {
    // 类型是c类型
    // c
    println(c.foo())
}

fun t_ext_method_2() {
    // 这里会走EC的扩展函数
    printFoo(ED())

    // 这里才会走ED的扩展函数
    println(ED().foo())
}

/**
 * 若扩展函数和成员函数一致，则使用该函数时，会优先使用成员函数。
 */
class NC {
    fun foo() {
        println("成员函数")
    }
}

fun NC.foo() {
    println("扩展函数")
}

fun t_ext_method_3() {
    val nc = NC()
    nc.foo()
}

/**
 * 扩展一个空对象
在扩展函数内， 可以通过 this 来判断接收者是否为 NULL,这样，即使接收者为 NULL,也可以调用扩展函数
 */
fun Any?.toString(): String {
    if (this == null)
        return "null"
    // 空检测之后，this自动转换为非空类型，所以下面的toString
    // 解析为Any类的成员函数
    return toString()
}

fun t_ext_nul_obj() {
    var t = null
    println(t.toString())
}

/**
 * 扩展属性
除了函数，Kotlin 也支持属性对属性进行扩展:

扩展属性允许定义在类或者kotlin文件中，不允许定义在函数中。初始化属性因为属性没有后端字段（backing field），所以不允许被初始化，只能由显式提供的 getter/setter 定义。

val Foo.bar = 1 // 错误：扩展属性不能有初始化器
扩展属性只能被声明为 val。
 */
val  List.lastIndex: Int
    get() = size - 1


/**
 *
伴生对象的扩展
如果一个类定义有一个伴生对象 ，你也可以为伴生对象定义扩展函数和属性。

伴生对象通过"类名."形式调用伴生对象，伴生对象声明的扩展函数，通过用类名限定符来调用
 */
class MyCls {
    companion object {
        // 将称为Companion
    }
}

// 扩展函数
fun MyCls.Companion.foo() {
    println("伴随对象的扩展函数")
}

// 扩展字段
val MyCls.Companion.no: Int
    get() = 10

fun t_ext_companion() {
    println("no: ${MyCls.no}")
    MyCls.foo()
}


/**
 * 扩展的作用域
 * 通常扩展函数或属性定义在顶级包下:

package foo.bar

fun Baz.goo() { …… }

要使用所定义包之外的一个扩展, 通过import导入扩展的函数名进行使用:

package com.example.usage

import foo.bar.goo // 导入所有名为 goo 的扩展
// 或者
import foo.bar.*   // 从 foo.bar 导入一切

fun usage(baz: Baz) {
baz.goo()
}
 */

/**
 * 扩展声明为成员
在一个类内部你可以为另一个类声明扩展。

在这个扩展中，有个多个隐含的接受者，其中扩展方法定义所在类的实例称为分发接受者，而扩展方法的目标类型的实例称为扩展接受者。
 */
// 扩展接受者
class EN_D {
    fun bar() {
        println("EN_D bar")
    }
}

// 分发接受者
class EN_C {
    fun baz() {
        println("EN_C baz")
    }

    fun EN_D.foo() {
        println("EN_C ext foo")
        bar()
        baz()
    }

    fun caller(d: EN_D) {
        println("EN_C caller")
        // 调用扩展函数
        d.foo()
    }
}

fun t_ext_mem() {
    println("t_ext_mem")
    val c: EN_C = EN_C()
    val d: EN_D = EN_D()
    c.caller(d)
}

/**
 * 假如在调用某一个函数，而该函数在分发接受者和扩展接受者均存在，则以扩展接收者优先，
 * 要引用分发接收者的成员你可以使用限定的 this 语法。
 */
class END {
    fun bar() {
        println("END bar")
    }
}

class ENC() {
    fun bar() {
        println("ENC bar")
    }

    fun END.foo() {
        println("ENC foo")
        // 调用END.bar(),扩展接收者优先
        bar()
        [email protected]() // 调用ENC.bar
    }

    fun caller(d: END) {
        println("ENC caller")
        // 调用扩展函数
        d.foo()
    }
}

fun t_ext_mem_2() {
    println("t_ext_mem_2")
    val enc = ENC()
    val end = END()
    enc.caller(end)
}

// 调用 ->> 分发接收者 ->> 扩展接收者

/**
 * 以成员的形式定义的扩展函数, 可以声明为 open , 而且可以在子类中覆盖. 也就是说, 在这类扩展函数的派 发过程中,
 * 针对分发接受者是虚拟的(virtual), 但针对扩展接受者仍然是静态的。
 */
open class EN2D {

}

class N2D : EN2D() {

}

open class EN2C {
    open fun EN2D.foo() {
        println("EN2D.foo in EN2C")
    }

    open fun N2D.foo() {
        println("N2D.foo in EN2C")
    }

    fun caller(d: EN2D) {
        println("EN2C caller")
        // 调用扩展函数
        d.foo()
    }
}

class N2C : EN2C() {
    override fun EN2D.foo() {
        println("EN2D.foo in N2C")
    }

    override fun N2D.foo() {
        println("N2D.foo in N2C")
    }
}

fun t_ext_mem_3() {
    println(" t_ext_mem_3 ")
    println(" -------------- ")
    EN2C().caller(EN2D()) // EN2D.foo in EN2C
    println(" -------------- ")
    N2C().caller(EN2D()) // EN2D.foo in N2C
    println(" -------------- ")
    EN2C().caller(N2D()) // EN2D.foo in EN2C
}

class MyNewCls {
    companion object {
        val mFid1: Int = 1
        var mFid2 = "this is myCFid2"

        fun companionFun1() {
            println("MyNewCls this is 1st companion func")
            foo()
        }

        fun companionFun2() {
            println("MyNewCls this is 2st companion func")
            companionFun1()
        }
    }

    fun MyNewCls.Companion.foo() {
        println("MyNewCls 伴随对象的扩展函数 (内部) ")
    }

    fun test2() {
        println("MyNewCls test2 ")
        MyNewCls.foo()
    }

    init {
        println("MyNewCls init ")
        test2()
    }
}

val MyNewCls.Companion.no: Int
    get() = 10

fun MyNewCls.Companion.foo() {
    println("MyNewCls.Companion foo 伴随对象外部扩展函数")
}

fun t_ext_mem_4() {
    println("t_ext_mem_4")
    println("no: ${MyNewCls.no}")
    println("filed1:${MyNewCls.mFid1}")
    println("filed2:${MyNewCls.mFid2}")
    MyNewCls.foo()
    MyNewCls.companionFun2()
}

/* -------------- 扩展 -------------- */

fun main(args: Array) {
    t_user_print()
    t_change_item()
    t_ext_method_2()
    t_ext_method_3()
    t_ext_nul_obj()
    t_ext_companion()
    t_ext_mem()
    t_ext_mem_2()
    t_ext_mem_3()
    t_ext_mem_4()
}

数据类和密封类

/* -------------- 数据类 -------------- */
/**
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() 函数，我们可以使用该函数复制对象并修改部分属性
fun copy(name: String = this.name, age: Int = this.age) = User(name, age)
 */
data class Account(val name: String, val age: Int)

fun t_data() {
    var jack = Account(name = "Jack", age = 1)
    // 复制并修改部分属性
    val olderJack = jack.copy(age = 2)
    println(jack)
    println(olderJack)
}

/**
 * 数据类以及解构声明
 * 组件函数允许数据在解构声明中使用
 */
fun t_data_dec_con() {
    val jane = Account("jane", 35)
    val (name, age) = jane
    println("$name , $age years of age") // 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就实现了单例模式）

即将class关键字替换为object关键字，来声明一个类，与此同时也声明它的一个对象。只要编写这么多代码，这个类就已经是单例的了

 换句话说，object declaration的类最终被编译成：一个类拥有一个静态成员来持有对自己的引用，并且这个静态成员的名称为INSTANCE，当然这个INSTANCE是单例的，故这里可以这么去使用。如果用Java代码来声明这个RepositoryManager的话，可以有如下代码：

class RepositoryManager{
    private RepositoryManager(){}
    public static final RepositoryManager INSTANCE = new RepositoryManager();

}

*/
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
}

class ObjectOuter {
    object Inner {
        fun method() {
            println("I'm in inner class")
        }
    }
}

fun t_object_cls() {
    ObjectOuter.Inner.method()
}

/* -------------- 密封类 -------------- */
fun main(args: Array) {
    t_data()

    t_data_dec_con()

    println("eval_1 ${eval(Const(35.0))}")
    println("eval_2 ${eval(Sum(Const(35.0), Const(35.0)))}")
    println("eval_2 ${eval(NotANumber)}")
    t_object_cls()
}