不同于Java中相对中规中矩的通用简一的类定义方式，在Kotlin中有了较多的关键字类定义一些特别的类，比如单例类、伴生、内部类、密封类、数据类等，对比于Java我们来分析一下这些特别的类，会不会让你学的特别累！
一、简化的数据类
数据类(data class)，用于保存元数据的封装类，Java中的POJO（Plain Ordinary Java Object）所有都是继承自Object，并自然而然的有其toString()、hashcode()、equals()等函数。一般都需要有getter/setter，复杂的Java Bean的话，手写getter/setter实在是挺繁琐的，即使有些快捷框架，也未必能尽如人意。
public class Student {
private String name;
private int age;
private String desc;
public Student() {
//无参构造函数
}
/**
* 多参数构造函数
* @param name
* @param age
* @param desc
*/
public Student(String name, int age, String desc) {
this.name = name;
this.age = age;
this.desc = desc;
}
//getter/setter
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
//...其他setter getter
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", desc='" + desc + '\'' +
'}';
}
}
而Kotlin中对应数据类data class
data class Student(val name:String,var age:Int,var desc:String)
查看kotlin转java的代码，就会感觉的kt的甜甜蜜蜜
在AS中Tools--Kotlin--ShowKotlinBytecode得到Kotlin字节码，点击Decompile得到对应的Java代码形式
数据类的知识点：
Kotlin中nullable可空类型是区别的，String和String?不一样。图中可见，反编译后对应Java写法就是@NotNull的注解；data class是专用的数据封装类，它的构造函数至少有一个主构造函数及至少一个入参，主构造函数的入参必须有val/var的修饰（这么才算做是类的属性而非简单的构造入参）；component123之类的，便于读取，自然也根据权限修饰符来确定属性的getter/setter，val的是没有setter的；data class AA(val name:String="")data class不复写toString()、equals()、hashcode()，那么默认判定对象特征值只是用到构造函数内的属性参数，也就会出现即使类内属性值不一致而认定为相等，记住是相等而不是同一对象。
//name是构造属性
data class People(val name:String){
var age:Int = 18//类内属性
}
//构造参数只有name，如果一致，即使age不一致
val p1 = People("张三")
val p2 = People("张三")
p1.age = 20
p2.age = 30
//若没有复写equals、hashcode，就会会判定为两个对象相等，
p1== p2 就是true
//切记！！ 相等的原因是没有override equals和hashcode，但是对象本身并不是同一个，
p1===p2 是false
数据类有copy函数，不同于Java中clone，Kotlin中的copy就是便捷的帮你new了对象并赋值了原有对象的参数（根据你的修改与否）
@Test
fun testKt(){
val a1 = AA("张三")
val a2 = AA("张三")
val a1Copy = a1.copy()
val a2Copy = a2.copy(name = "李四")
a1.age = 19
a2.age = 29
println("a1===a2 ${a1 === a2}")
println("a1==a2 ${a1 == a2}")
println("a1==aCopy ${a1 == a1Copy}")
println("a1===a1Copy ${a1 === a1Copy}")
println("a1==a2Copy ${a2 == a2Copy}")
println("a1===a2Copy ${a2 === a2Copy}")
}
//输出结果
a1===a2 false
a1==a2 true
a1==aCopy true
a1===a1Copy false
a1==a2Copy false
a1===a2Copy false
看一下对应java代码,可以看出copy就是甜甜的语法糖，帮你new
数据类的解构声明
可能不好理解这个词，看代码就清晰了
data class AA(val name:String,var age:Int,var desc:String)
//定义一个函数，返回AA对象
fun getAA():AA{
return AA("zhangsan",39,"a worker")
}
//调用处，就可感觉到解构声明的魅力
val aaa = getAA()//普通的方式
val (name,age,desc) = getAAA()//解构声明的方式，便于直接使用某些参数，而不需要aaa.name
- 系统标准库提供了
Pair和Triple数据类，分别是两个参数和三个参数的。
封装性的数据类，可使用泛型方式定义参数类型
//这样数据类可以使用泛型确定内部参数类型，也有其特定使用场景
data class BBB(val t:T,var r:R,var q:Q,val s:S)
二、不是?甜似?的密封类
密封类用以表示受限的类继承结构
快速理解，类似于大号的枚举,用于特定类型限定。与枚举异同
- 枚举，一种特定类型，可有多个枚举常量。每个枚举值只是一个实例。
- 密封类，可有很多子类，每个子类都可有多个实例。
sealed关键字，其所有子类都必须在同一kt文件内，且最好是top level的；- 若在其他类内声明，则其子类就只能在自身内部声明了；
- 密封类是抽象的，可有抽象成员，但不能实例化；
- 密封类构造函数私有；
class ExampleUnitTest {
//在其它类内声明，则其子类也就只能在其内部了，根源在于sealed class的私有化构造函数
sealed class HHH() {
object mmm : HHH()
}
object hhhhhhh : HHH()//无法在其它类内继承 密封类
data class eeeeee(val name: String) : AAAA() {
class eee(val age: Int) : AAAA()
}
}
//在外也不能继承 其他类内 看似不报错的密封类
object ggg : ExampleUnitTest.HHH()
//这才是合规的
sealed class AAAA {
fun aa() {}
val bbb: String = ""
open fun ad() {}
abstract class ccc() {}
//在它自身内部可以
object jjj : AAAA()
}
data class ccc(val name: String) : AAAA() {
}
class ddd(val age: Int) : AAAA()
object fff : AAAA()
三、Object类
Object类可以快速创建Kotlin版本的单例类,也可以是companion object的伴生类，其特性差不多。
object单例类，也是kotlin的类的一种，比较特殊而已。
open/abstract，内部也不能有open的函数Java代码，也就是静态饿汉式的单例类写法，线程安全的。四、枚举类
Kotlin中的枚举类，类比于Java的枚举，更为灵活一些
enum class Direction{
NORTH,SOUTH,WEST,EAST//枚举对象用,符号分隔
}
enum class Color(val colorName:String){//这里添加val/var为的是可以称为成员属性参数
YELLOW("#f0f0f0"), GREEN("#00f0f0"), BLUE("#000ff0");
}
Java枚举，Kotlin的枚举可以有参数构造函数Java枚举，Kotlin枚举可以有抽象函数，这样每个实例都要override改函数
enum class ColorHHH(val cn: String) {
//每个实例，都要override
YELLOW("#f0f0f0"){
override fun info() {
TODO("Not yet implemented")
}
}, GREEN("#00f0f0"){
override fun info() {
TODO("Not yet implemented")
}
}, BLUE("#000ff0"){
override fun info() {
TODO("Not yet implemented")
}
};
//定义枚举类的抽象函数，其内部实例，就要override
abstract fun info()
open fun foo(){}
fun boo(){}
}
EnumClass.valueOf(value:String)这个函数，入参是String就是对应枚举实例对象的名字。
val co = ColorHHH.valueOf("YELLOW")//这样才能获取到
co.name//就是实例的名字，co.ordinal，就是实例在枚举类中定义的索引编号。
open/abstract。同2，如果实现接口，所以实例都要实现，或者枚举类通用实现。
interface Color9{
fun fillColor()
}
interface Shape{
fun defineShape()
}
//实现上面两个接口
enum class Car:Color9,Shape{
//1、每个实例都实现接口函数的方式
BIZ{
override fun fillColor() {
TODO("Not yet implemented")
}
},BW{
override fun fillColor() {
TODO("Not yet implemented")
}
};
//2，或者就是枚举类自身直接实现接口的函数
override fun defineShape() {
}
}
五、内部类、嵌套类
- 嵌套类，顾名思义，嵌套在其它类中的定义类。
Kotlin的特别之处，接口和类可以互相嵌套，也就是类中可定义接口，接口中可定义类。interface OuterInterface { class InnerClass interface InnerInterface } class OuterClass { class InnerClass interface InnerInterface inner class RealInnerClass//这才是对应与Java的内部类，会引用外部类的对象 } //匿名内部类，如果java的new XXX直接用一样 window.addMouseListener(object:MouseAdapter(){ override fun mouseClicked(e: MouseEvent){ //... } override fun mouseEntered(e: MouseEvent){ //... } })注意，
kotlin中这么写是嵌套类，在Java中这么写就是内部类了。 - 内部类，不同于
Java中的写法，这里需要一个标记inner - 匿名内部类，
Kotlin中object的另一作用
