常见的类

1. 嵌套类
2. 内部类
3. 枚举类
4. 密封类
5. 数据类
6. 单例模式
7. 伴生对象

嵌套类

嵌套类是嵌套在其它类中的类 不能访问外部类的成员 因为嵌套类是static的 和外部类没有什么环境依赖

• 如果嵌套类想要访问外部类成员 可以把外部类成员修饰为静态的 一般不会这么干
• 另外就是 如果想访问外部类成员 可以使用内部类

class Student {
    val name = "小杨杨"
    var age = 20

    // 静态成员
    /*companion object {
        @JvmStatic
        val name = "小杨杨"
        var age = 20
    }*/

    class Tony {
        fun sayHello() {
            println("嵌套类 函数")
            /*println("嵌套类 函数 外部类变量名字 $name")*/
        }
    }
}

内部类

嵌套在其它类中的类 能访问外部类成员 并用inner修饰符修饰

class Anim {
    var type = "小猪"
    var num = 1

    // inner关键字修饰的是内部类 可以直接访问外部类的成员
    inner class Pig {
        fun printInfo() {
            println(" 内部类访问外部类成员 物种名：$type 编号：$num ")
        }
    }
}

• 区别于Java 在Java中 将一个类定义在另一个类的内部 称为成员内部类 成员内部类用static修饰 称为静态内部类
• 成员内部类才可以访问外部类的所有成员 静态内部类也是嵌套内部类
• 在KT中 将一个类定义在另一个类的内部 不加任何修饰 称为嵌套类 添加inner修饰的才是内部类
• 在KT中 嵌套类是不能直接访问外部类的成员 内部类可以直接访问外部类的所有成员

枚举类

顾名思义一一列举 每个枚举常量都是一个对象 常量之间逗号隔开 使用enum关键字修饰

enum class Week1 {
    // 每个都是枚举类的实例 这些实例也可以初始化
    周一,
    周二,
    周三,
    周四,
    周五,
    周六,
    周日
}

// 枚举类支持构造函数 可以使用构造函数来初始化
enum class Week2(val what: String, val doSomeThing: String) {
    // 常量一般都是大写 下面已经把所有的枚举类型初始化完毕 可以直接使用
    MONDAY("周一", "看电影"),
    TUESDAY("周二", "看电影"),
    WEDNESDAY("周三", "看电影"),
    THURSDAY("周四", "看电影"),
    FRIDAY("周五", "看电影"),
    SATURDAY("周六", "看电影"),
    SUNDAY("周日", "看电影")
}

• 上述代码中 每个枚举都通过构造函数进行了初始化
• 如果需要对枚举进行初始化 则枚举后面的括号中必须传递每个枚举需要初始化的参数

数据类

数据类一般用于保存数据或者对象状态 习惯上称 bean 或 entity 再或者 model类
构建密封类的条件：
(1). 必须用sealed关键字修饰
(2). 由于密封类的构造函数是私有的 因此密封类的子类只能定义在密封类内部或者同一个文件中

• 每一个枚举常量只存在一个实例 而密封类的一个子类可以包含状态的多个实例

sealed class Mimi {
    class XiaoZhi : Mimi() {}
    class XiaoLi : Mimi() {}
}

class XiaoDai : Mimi() {}

单利模式

通过object来修饰 在程序中有且只有一个实例

object Singleton {
    var name: String = "单利"
    fun hello() {
        println(" 单利模式 姓名：$name ")
    }
}

伴生对象

在KT中是没有静态变量的（没有static关键字） 因此使用伴生对象来替代Java中的静态变量的作用
伴生对象是在类加载时初始化 生命周期与该类的声明周期一致
companion 关键字标识
一个类中有且只有一个伴生对象 因此也可以不指定伴生对象的名称 而且其它对象也可以共享伴生对象

class BanS {
    /*companion object {
        var name: String = "小黄"
    }*/
    companion object A {
        var name: String = "小黄"
    }
}

fun main() {
    // 外部类
    val student = Student()
    println(student.name)
    //println(Student.name)
    // 嵌套类
    val tony = Student.Tony()
    tony.sayHello()

    // 内部类
    val pig = Anim().Pig()
    pig.printInfo()

    // 枚举类
    println(Week1.周一)

    println(Week2.FRIDAY.what)
    println(Week2.FRIDAY.doSomeThing)

    // 获取枚举里面所有的数据
    val values = Week1.values()
    values.forEach {
        println(it)
    }

    // 密封类
    val childLiMi = Mimi.XiaoLi()
    val childDaiMi = XiaoDai()

    // 数据类 必须至少有一个参数
    val weekDay1 = WeekDay1("糖果")
    println(weekDay1.name)
    weekDay1.name = "苹果"
    println(weekDay1.name)
    println(weekDay1.toString())
    // 所有参数设置默认值 构造无参
    val weekDay2 = WeekDay2()
    println(weekDay2)

    // 单利模式
    println(Singleton.name)
    Singleton.hello()

    // 伴生对象
    // 没有指定伴生对象名称
    /*println(BanS.Companion.name)*/
    // 指定伴生对象名称
    /*println(BanS.A.name)*/
    // 无论有无伴生对象名称 都可以简写以下方式
    println(BanS.name)

}