数据类：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;
@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)
密封类：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 class innerClass{
var name = "哒哒2"
fun hello(){
println("你好$name")
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);
}
}
}
|