kotlin类

一、内部类和嵌套类

嵌套类：不持有外部类的引用，对应Java的静态内部类

内部类：嵌套类加上inner，持有外部类引用，对应Java的非静态内部类

class Outer {
    val outerA = 1
    class Inner{
        fun printA(){
            //嵌套类无法获取outerA
            println(outerA)
        }
    }
}

class Outer {
    val outerA = 1
    inner class Inner{
        fun printA(){
            //内部类可以获取outerA
            println(outerA)
        }
    }
}

二、数据类

1、构造函数至少要有一个参数，且所有参数必须有val或var修饰

2、不能够被继承也不能继承其他类，但可以实现接口

3、不可以声明为abstract、open、sealed和inner

4、提供了componentN()方法，方便解构

data class Test (val a: Int, val b: Int)

fun main(){
    val test = Test(1, 2)
    val (a, b) = test
}

5、提供copy()方法，只需对需要更改的参数修改即可完成创建新对象

val test = Test(1, 2)
val testCopy = test.copy(a = 3)

6、重新了hashCode和equals方法：全部参数值相等，则对象相等（注：不是同一个对象，===仍为false）

三、object

1、匿名内部类

open class Test {
}

fun main(){
    val test = object: Test() {

    }
}

2、单例（饿汉式）

object class Test{
}

3、伴随对象（同Java静态方法）

class Test {
    companion object{
        const val a = "a"
        fun testA(){
            println(a)
        }
    }
}

四、枚举类

1、可以定义抽象方法

enum class Test {
    ONE {
        override fun getValue(): Int {
            return 1
        }
    },
    TWO {
        override fun getValue(): Int {
            return 2
        }
    },
    THREE {
        override fun getValue(): Int {
            return 3
        }
    };

    abstract fun getValue(): Int
}

2、可以实现接口

interface A{
    fun getValue(): Int
}

//每个枚举实现接口方法
enum class Test: A{
    ONE {
        override fun getValue(): Int {
            return 1
        }
    },
    TWO {
        override fun getValue(): Int {
            return 2
        }
    },
    THREE {
        override fun getValue(): Int {
            return 3
        }
    };
}

//可以统一实现接口方法
enum class Test: A{
    ONE, TWO , THREE;

    override fun getValue(): Int {
        return 0
    }
}

五、密封类

1、不能直接实例，不能修饰interface和abstract class，允许有抽象方法

2、子类必须与密封类在同一个文件中，而子类的派生类可以在其他文件中

3、需要返回值的when，全部列出子类则无需定义else（如果直接使用when而不使用其返回值，即使未全部罗列也没有定义else也不会有异常提示）

sealed class Test{
    class A: Test()

    class B: Test()
}

fun mian(){
    var test: Test? = null
    val result = when(test){
        is Test.A -> 1
        is Test.B -> 2
        null -> 3
    }
}