1、抽象类
2、接口类
3、内部类（嵌套类）
4、数据类
5、密封类
6、枚举类

关键字：冒号(:)
在Kotlin中冒号 : 使用的地方很多：
　用于变量的定义
　用于继承
　用于接口
　方法的返回类型声明

抽象类

1、关键字为：abstract
2、定义格式

abstract class  抽象类名{
    ...
}

3、使用格式

class 类名 ： 抽象类名{
    // 重写的抽象类函数、属性等
    ...
}

注意事项
　1、抽象可以分为抽象类、抽象函数、抽象属性。而一个抽象类和普通类的区别在于抽象类除了可以有其自己的属性、构造函数、方法等组成部分，还包含了抽象函数以及抽象属性。
　2、抽象类不能直接被实例化，需要依靠子类采用向上转型的方式实例化。
　3、子类必须全部重写带abstract修饰的属性和方法。
　4、抽象类是为其子类定义了一个模板，同是类实现不同的功能。
　5、抽象类可以继承自一个继承类，即抽象类可以作为子类。不过，抽象类建议不用open修饰符修饰，因为可以覆写抽象类的父类的函数。

fun main(args: Array<String>) {
    var student = Student()
    student.name = "kotlin"
    println(student.name)
    student.eat()
}

class Student : Person() {
    override fun initAn() {

    }

    override var name: String = ""
    override fun eat() {
        println("实现抽象方法")
    }

}

abstract class Person : Animal() {
    var sex: String = ""//自身属性
    fun showMesg() {//自身方法
    }

    abstract var name: String           // 抽象属性
    abstract fun eat()                  // 抽象方法

    abstract override fun initAn()       //父类抽象方法

}

open class Animal {
    open fun initAn() {}
}

结果图：

结果图

接口类

1、关键字：interface
2、定义格式

interface 接口名{
    ...
}

3、使用格式

class 类名 ： 接口名{
    // 重写的接口函数、属性等
    ...
}

注意事项
　1、不带结构体的函数可以省略大括号。
　2、带结构体的函数，可以不重写，直接可以调用。

fun main(args: Array<String>) {
    var student = Student()
    student.fun1()
    student.fun2(12)
    student.fun3(13)
    student.fun4()
    student.fun5()
}

class Student : Person {
    override fun fun1() {
        println("我是fun1")
    }

    override fun fun2(num: Int) {
        println("我是fun2")
    }

    override fun fun3(num: Int): Int {
        println("我是fun3")
        return num
    }
    
}

interface Person {
    // 定义一个无参数无返回值的方法
    fun fun1()

    //定义一个有参数的方法
    fun fun2(num: Int)

    //定义一个有参数有返回值的方法
    fun fun3(num: Int): Int

    // 下面的两个方法是有结构体， 故可以不重写

    //定义一个无参数有返回值的方法
    fun fun4(): String {
        println("我是fun4")
        return "fun4"
    }

    //定义一个无结构体函数，大括号是可以省略的
    fun fun5() {
        // 如果函数中不存在表达式，大括号可以省略。
        // 如fun1一样
        println("我是fun5")
    }
}

结果图：

结果图

嵌套类

1、即指一个类可以嵌套在其他类中
2、调用嵌套类的属性或方法的格式为：外部类.嵌套类().嵌套类方法/属性。在调用的时候嵌套类是需要实例化的。
3、嵌套类不能使用外部类的属性和成员。

fun main(args: Array<String>) {
    var xiaoMing = Student.XiaoMing()  // 调用格式为：外部类().内部类().内部类方法/属性
    xiaoMing.eat()

}
class Student {//外部类

    var name: String = ""

    class XiaoMing { //嵌套类
        fun eat() {
            println("小明吃苹果")
        }
    }

}

内部类

1、关键字：inner
2、声明格式：

inner class 类名(参数){}

3、调用内部类的属性或方法的格式为：外部类().内部类().内部类方法/属性。在调用的时候嵌套类是需要实例化的。
4、内部类不能使用外部类的属性和成员。

fun main(args: Array<String>) {
    var xiaoMing = Student().XiaoMing()  // 调用格式为：外部类().内部类().内部类方法/属性
    xiaoMing.eat()

}

class Student {//外部类

    var name: String = ""

    inner class XiaoMing { //嵌套类
        fun eat() {
            println("小明吃苹果")
        }
    }

}

匿名内部类

1、在开发中，匿名内部类随处可见。比如说Button的OnClickListener，ListView的单击、长按事件等都用到了匿名内部类。

fun main(args: Array<String>) {
    var student = Student()

    student.setOnClickListener(object : OnClickListener {
        override fun onItemClick(positon: Int) {
            println("匿名内部类")
        }

    })
    student.testListener()
}

class Student {

    lateinit var listener: OnClickListener

    fun setOnClickListener(listener: OnClickListener) {
        this.listener = listener
    }

    fun testListener() {
        listener.onItemClick(0)
    }
}

interface OnClickListener {
    fun onItemClick(positon: Int)
}

数据类

在Java中，或者在我们平时的Android开发中，为了解析后台人员给我们提供的接口返回的Json字符串，我们会根据这个字符串去创建一个类或者实例对象，在这个类中，只包含了一些我们需要的数据，以及为了处理这些数据而所编写的方法。这样的类，在Kotlin中就被称为数据类。
1、关键字：data
2、声明格式：

data class 类名(var param1 ：数据类型,...){}

或者：

data class 类名 可见性修饰符 constructor(var param1 : 数据类型 = 默认值,...)

3、data为声明数据类的关键字，必须书写在class关键字之前。
4、在没有结构体的时候，大括号{}可省略。
5、构造函数中必须存在至少一个参数，并且必须使用val或var修饰。
6、参数的默认值可有可无。（若要实例一个无参数的数据类，则就要用到默认值）
数据类的特性：
　1、主构造函数需要至少有一个参数
　2、主构造函数的所有参数需要标记为 val 或 var；
　3、数据类不能是抽象、开放、密封或者内部的；
　4、数据类是可以实现接口的，如(序列化接口)，同时也是可以继承其他类的，如继承自一个密封类。

fun main(args: Array<String>) {
    var student = Student("kotlin",10,"nv")
    println(student.toString())

}

data class Student(var name:String,
                   var age:Int,
                   var sex:String) {

}

密封类

密封类用来表示受限的类继承结构：当一个值为有限几种的类型, 而不能有任何其他类型时。
1、关键字：sealed
2、用来表示受限的类继承结构。
3、密封类是不能被实例化的
4、密封类可以有子类，但是所有的子类要内嵌在密封类中。
5、子类可以定在密封类外部，但是必须在同一文件中 v1.1之前只能定义在密封类内部。

fun main(args: Array<String>) {
    var student = Person.Student("aaa")
    var student1 = Person.Student("bbb")
    println(student)
    println(student1)

}


sealed class Person {
    data class Student(var name: String) : Person()
    object Doctor : Person()//单例模式
}

object Worker : Person() {

}

枚举类

1、关键字：enum
2、声明格式：

enum class 类名{
      ...
}

3、访问格式：
　　枚举类名.枚举常量.属性
４、每一个枚举都是枚举类的实例，所以他们可以是初始化过的。
5、要实现枚举常量的匿名类，则必须提供一个抽象方法（必须重写的方法）。且该方法定义在枚举类内部。而且必须在枚举变量的后面。
6、枚举变量之间使用逗号（,）分割开。但是最后一个枚举变量必须使用分号结束。不然定义不了抽象方法。

fun main(args: Array<String>) {

    println(Person.BLACK.argb)
    Person.BLACK.print()
}

enum class Person(var argb: Int) {
    RED(0) {
        override fun print() {
            println("RED")
        }
    },
    WHITE(1) {
        override fun print() {
            println("WHITE")
        }
    },
    BLACK(2) {
        override fun print() {
            println("BLACK")
        }
    };

    abstract fun print()
}

----------------------------THE END-------------------------