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()
}
