Kotlin系列之data、open、object、sealed、class、inner类的种类

数据类：data

用于声明数据类。

data class Result(var code:Int,val msg:String)

编译器会自动的从主构造函数中根据所有声明的属性提取以下函数(大家可以解释成Java看一下)
1、equals() / hashCode()
2、toString() 格式如 “User(name=John, age=42)”
3、componentN() functions 对应于属性，按声明顺序排列
4、copy() 函数
使用 copy 类复制 User 数据类，并修改 age 属性:

data class User(val name: String, val age: Int)

fun main(args: Array<String>) {
    val jack = User(name = "Jack", age = 1)
    val olderJack = jack.copy(age = 2)
    println(jack)
    println(olderJack)
}

公开类：open

用于修饰公开类，表示该类可派生子类；或者用于修饰成员，表示该成员可以被重写。
在kotlin中它所有的类默认都是final的，那么就意味着不能被继承，而且在类中所有的方法也是默认是final的，那么就是kotlin的方法默认也不能被重写。
open的作用在于 让类和方法可以被继承和重写
对比一下编译后的的代码就清楚了
Kotlin默认创建的Class类

class Person(val name: String) {
    
    fun showName() = "姓名:$name"
    
}

解释后Java的代码

public final class Person {
   @NotNull
   private final String name;

   @NotNull
   public final String showName() {
      return "姓名:" + this.name;
   }
}
open修饰后的Kotlin类
open class Person(val name: String) {

   open fun showName() = "姓名:$name"

}

解释后的Java的代码

public class Person {
   @NotNull
   private final String name;

   @NotNull
   public String showName() {
      return "姓名:" + this.name;
   }
}

静态类：object

以object关键字修饰的类， 其成员变量都是静态的， 编译时当前类会生成静态实例INSTANCE。(所以Java引用的时候需要手动生成INSTANCE) kotlin可以直接用
Kotlin代码

object Person {
    @JvmStatic
    fun checkLoginPermission(storeId: Long) {
        //
    }
}

解释后的Java代码

public final class Person {
   @NotNull
   public static final Person INSTANCE;    //自动生成了INSTANCE

   @JvmStatic 
   public static final void checkLoginPermission(long storeId) {
       //方法也默认了静态
   }

   private Person() {
   }

   static {
      Person var0 = new Person();    
      INSTANCE = var0;    
   }
}

kotlin直接调用

Person.checkLoginPermission(1)

Java通过INSTANCE调用

Person.INSTANCE.checkLoginPermission(1) 
//也可以直接进行调用（因为我们上面的方法加了@JvmStatic进行兼容）

密封类：sealed

用于声明一个密封类。
Enum Class：每个枚举都是枚举类的实例，可以直接使用
Sealed Class：密封类约束的子类只是一个类型，你可以为不同子类定义方法和属性，并对齐动态实例化
密封类，顾名思义就是密封的，定义的子类也必须在密封类中，之所以是枚举类的扩展，是因为除了使用常量定义有限值，还可以用子类灵活定义有限值，比如object定义的单例类，class定义的内部类
密封类通常与表达时一起使用。 由于密封类的子类将自身类型作为一种情况。 因此，密封类中的when表达式涵盖所有情况，从而避免使用else子句。

sealed class MyColor {
    class Yellow : MyColor()  //这每一个类，你可以看成相当于枚举类的一个常量

    class Red : MyColor()

    class Black : MyColor()
}

fun evals(color: MyColor) = when (color) {  //我们具体需要哪一种
    is MyColor.Yellow -> println("yellow")
    is MyColor.Red -> println("red")
    is MyColor.Black -> println("black")
}

fun main(args: Array<String>) {
    evals(MyColor.Black()) 
}

嵌套类：class

kotlin中的嵌套类指的是在某个类中再创建一个类，但是这个内部的类，不会持有外部类的引用，它其实相当与java中的静态内部类。如以下例子。创建Test这个嵌套类的实例，直接通过 InnerClassess.Test()即可。

class InnerClassess {
    class Test {
        fun test(){ println("test.....") }
     }
}
fun main() {
    InnerClassess.Test().test()
}

它其实等同与java中一下代码

public class MyTest {

    public void myTest(){}
    
    public static class Test {}
    
    public static void main(String[] args) {
        new MyTest.Test();
    }
}  

我们知道再java中，非静态的内部类持有外部类的引用，可以直接调用外部类的属性，方法。而静态的内部类不持有外部类的引用，不能直接访问外部类的属性，方法。再Kotlin中的嵌套类，其实就等同与java中静态的内部类。所以是不持有外部的引用的。

内部类：inner

用于声明内部类，内部类可以访问外部类的实例
kotlin内部类与嵌套类的区别是： 1.内部类会带有一个外部类的对象的引用，嵌套类则没有。 2.内部类需要使用 inner class 定义，而嵌套类则使用 class 定义。

class OutClass {

    var name ="哒哒1"

    //inner表示内部类
    inner class innerClass{
        var name = "哒哒2"
        fun hello(){
            println("你好$name")
            //内部类使用this,访问外部类的变
            println("你好${this@OutClass.name}")
        }
    }
}

相当于Java中的内部类

public class OutClass {
    public class innerClass {
       @NotNull
       private String name = "哒哒2";

       public void hello() {
          String var1 = "你好" + this.name;
          System.out.println(var1);
          var1 = "你好" + OutClass.this.getName();
          System.out.println(var1);
       }
    }
}