目录
1.嵌套类
如果一个类只对另外一个类有作用，那么可以将其嵌入到该类中，使两个类在一起。和Java中定义的内部类很像。
class Computer {
class Mouse(val name:String){
fun showDescribe(){
println("mouse name is $name")
}
}
}
fun main() {
val mouse = Computer.Mouse("Logitech")
//可以通过嵌套类的实例，访问其定义的属性和函数
mouse.showDescribe()
println(mouse.name)
}
2.数据类
顾名思义，数据类是专门用来存储数据的。
1）数据类的声明，通过在class前加data修饰，就可以将一个普通类定义为一个数据类。
2）数据类提供了toString，equals和hashCode的自定义实现。
3）==默认比较的是对象的引用。但是==用来比较数据类，比较的是他们的内容。
4）数据类默认支持解构。因为kotlin编译器实现了解构声明。
//用data关键字修饰class，就可以定义一个数据类
data class MotionEvent(var x: Int, var y: Int) {
}
fun main() {
//打印数据类对象，默认会调用toString方法。
val e1 = MotionEvent(10, 10)
val e2 = MotionEvent(10, 10)
println(e1)
println(e1.toString())
//数据类的==是判断的equals方法，比较的是内容，而不是对象引用。
println(e1 == e2)
//数据类支持解构
val (x, y) = e1
println("$x,$y")
}
打印结果:
10
MotionEvent(x=10, y=10)
MotionEvent(x=10, y=10)
true
10,10
通过反编，看下kotlin对数据类的默认实现。
public final class MotionEvent {
private int x;
private int y;
public final int getX() {
return this.x;
}
public final void setX(int var1) {
this.x = var1;
}
public final int getY() {
return this.y;
}
public final void setY(int var1) {
this.y = var1;
}
public MotionEvent(int x, int y) {
this.x = x;
this.y = y;
}
//解构声明
public final int component1() {
return this.x;
}
//解构声明
public final int component2() {
return this.y;
}
//默认实现了toString
public String toString() {
return "MotionEvent(x=" + this.x + ", y=" + this.y + ")";
}
//默认实现了hashCode
public int hashCode() {
return Integer.hashCode(this.x) * 31 + Integer.hashCode(this.y);
}
//默认实现了equals方法，比较的是两个对象数据的值。
public boolean equals(@Nullable Object var1) {
if (this != var1) {
if (var1 instanceof MotionEvent) {
MotionEvent var2 = (MotionEvent)var1;
if (this.x == var2.x && this.y == var2.y) {
return true;
}
}
return false;
} else {
return true;
}
}
}
3.定义数据类的必须满足的条件
1）数据类必须至少有一个参数的主构造函数。
2）数据类的主构造函数定义的参数必须是val或var修饰。
3）数据类用data关键字修饰，但是不能使用abstract、open、sealed、inner修饰。
4.解构声明
解构声明的实现原理，就是声明Component1、Component2等若干个组件函数，让每个函数返回一个熟悉数据。如果定义的是一个数据类，kotlin编译器会自动为每个属性声明Component函数。
自定义解构声明：
通过operator fun component1() 。从定义可以看出来解构声明，是一种特殊的函数。
class Student(val name: String,val age:Int){
operator fun component1() = name
operator fun component2() = age
}
fun main() {
val student = Student("HanMei",18)
val (name: String, age: kotlin.Int) = student
println("$name,$age")
}
5.枚举类enum class
其实枚举就是一个类，kotlin定义的枚举用enum class，来强调枚举也是一个类。而java中只用enum修饰，就可以定义一个类。所以，在java中，枚举是一个类的概念就不太深入。
enum class Week() {
SUNDAY,
MONDAY,
TUESDAY,
WEDNESDAY,
THURSDAY,
FRIDAY,
SATURDAY;
fun getDay(): String {
return when (this) {
SUNDAY -> "星期天"
MONDAY -> "星期一"
TUESDAY -> "星期二"
WEDNESDAY -> "星期三"
THURSDAY -> "星期四"
FRIDAY -> "星期五"
SATURDAY -> "星期六"
}
}
}
fun main() {
println(Week.SUNDAY)
println(Week.SUNDAY.getDay())
}
6.运算符重载
可以通过operator fun plus 对“+”运算符进行重载。
data class MotionEvent(var x: Int, var y: Int) {
operator fun plus(e1: MotionEvent) = MotionEvent(x + e1.x, y + e1.y)
}
fun main() {
val e1 = MotionEvent(10, 10)
val e2 = MotionEvent(10, 10)
println(e1+e2)
}
打印结果：
MotionEvent(x=20, y=20)
