Kotlin学习4.6：常见类

嵌套类

Kotlin中的嵌套类是指可以嵌套在其它类中的类，该类不能访问外部类的成员，内部类指的是可以用 inner 标记以便能够访问外部类的成员。

Kotlin中的内部类与嵌套类与Java相似，不同的是在没有任何修饰的情况下，定义在一个类内部的类被默认称为嵌套类，不持有外部类的引用，如果想将它声明为一个内部类，则需要加上 inner 修饰符。

示例代码如下：

class Outer{
    var name = "wanku"
    var age = 35
    class Nested{
        fun sayHello(){
            //无法访问外部类字段
            //println("name:${name}!age:${age}")
        }
    }
}

内部类

通过上一小节的学习，我们会发现在嵌套类中是无法访问外部类中成员的，这样定义的嵌套类在实际开发中没有任何意义，为此，Kotlin提供了内部类，内部类只需要在嵌套类的基础上添加一个 inner 关键字即可，将其标识为内部类。

示例代码如下：

class Outer{
    var name = "wanku"
    var age = 35
    inner  class Nested{
        fun sayHello(){
            //访问外部类字段
            println("name:${name}!age:${age}")
        }
    }
}
fun main() {
    Outer().Nested().sayHello()
}

枚举类

枚举顾名思义就是一一列举，每个枚举常量都是一个对象，枚举常量用逗号分隔，枚举类的前面用 enum 关键字来修饰。

enum class Weekl{
	星期一，星期二，星期三，星期四，星期五，星期六，星期日
}

由于每个枚举常量都是枚举类的实例，因此这些实例也可以初始化，同时枚举支持构造函数，因此可以使用构造函数来初始化。

enum class Week(val what:String, val data: Int){
    monday("monday",1),
    tuesday("tuesday",2),
    wednewsday("wednewsday",3),
    thursday("thursday",4),
    friday("friday",5),
    saturday("saturday",6),
    sunday("sunday",7)
}

密封类

密封类用于表示受限制的类层次结构，当一个值只能在一个集合中取值而不能取其他值时，此时可以使用密封类。

在某种意义上。密封类是枚举类的扩展，即枚举类型的值集合。
每个枚举常量只存在一个实例，而密封类的一个子类可以有可包含状态的多个实例。

如果想要创建一个密封类，必须满足以下两个条件：
（1）密封类必须用关键字 sealed 来修饰。
（2）由于密封类的构造函数是私有的，因此密封类的子类只能定义在密封类的内部或者同一个文件中。

示例代码如下。

sealed class Student{
    class Student1 : Student(){}
    class Student2 : Student(){}
    class Student3 : Student(){}
    class Student4 : Student(){}
}
class Student5 : Student(){}

需要注意的是，密封类的非直接继承子类可以声明在其他文件中。

数据类

在Java程序中，一般会用一些类来保存一些数据或者对象的状态，习惯上将这些类称为bean类或entity类或model类。

在Kotlin中，专门处理这些数据的类被称为数据类，用关键字 data 进行标记。

语法格式如下：

data class 类名([形参1，形参2···])

定义一个数据类时。需要注意以下几点。
（1）数据类的主构造函数至少有一个参数，如果需要一个无参的构造函数，可以将构造函数中的参数都设置为默认值。
（2）数据类中的主构造函数中传递的参数必须用 val 或 var 来修饰。
（3）数据类不可以用 abstract、open、sealed 或 inner 关键字来修饰。
（4）编译器可以自动生成一些常用方法，如 equal()、hashCode()、toString()、等， 这些方法也可以进行自定义。

在实际开发中，经常会用到数据类来存储一些数据信息，这些信息一般是通过该类的主构造函数来传递的。

示例代码如下：

data class Man(var name:String, var age:Int){}

fun main() {
    var man:Man = Man("wanuk", 20)
    println("man:$man")
}

单例模式

在编写程序时经常会遇到一些典型的问题或某些特定的需求，设计模式就是针对这些问题和需求的一种解决方式。

单例模式就是其中的一种。
所谓的单例模式就是在程序运行期间针对该类只存在一个实例。

就好比这个世界只有一个太阳一样，假设现在要设计一个太阳类，这该类就只能有一个实例对象，否则就违背了事实。

单例模式是通过 object 关键字来完成的，通过 object 修饰的类即为单例类，单例类在程序中有且仅有一个实例。

示例代码如下：

object Singletion{
    var name = "Singletion function"
    fun sayHello(){
        println("I am a ${name}")
    }
}

fun main() {
    Singletion.name = "single function"
    Singletion.sayHello()
}

伴生对象

由于在Kotlin中没有静态变量，因此它使用了半生对象来代替Java中的静态变量的作用。
伴生对象是在类加载时初始化，生命周期与该类的生命周期一致。

在Kotlin中，定义伴生对象是通过 companion 关键字标识的，由于每个类中有且仅有一个伴生对象，因此也可以不指定伴生对象的名称，并且其他对象也可以共享伴生对象。

语法格式如下：

companion object 伴生对象名称（也可以不写）{
	程序代码······
}

由于伴生对象可以指定名称，也可以不指定名称。因此在调用伴生对象时分两种情况。
（1）有名称：调用方式为 “类名.伴生对象名.成员名” 或 “类名.成员名”。
（2）无名称：调用方式为 “类名.Companion.成员名” 或 “类名.成员名”。

示例代码如下。

class Company{
    companion object Factory{
        fun sayHello(){
            println("the object of Company")
        }
    }
}

fun main() {
    Company.Factory.sayHello()
    Company.sayHello()
}

博客为个人收集学习，供大家交流学习。
参考书籍：《Kotlin从基础到实践》