Kotlin 从零单排之小 tips

object

object xxx {
	fun test() {
		// todo
	}
}

这种类型的 kotlin 类是一种单例模式，在转成 java 字节码的时候，会变成如下：

public final class xxx {
	public static final xxx INSTANCE;
	
	private xxx() {
	}
	
	public final void test() {
		// todo
	}
}

所以这是一种”恶汉“类型的单例模式。

abstract

Kotlin 支持抽象属性和非抽象函数。但是抽象属性被子类继承时，必须赋值。

abstract class A {
    abstract val name: String
    abstract var age: Int

    fun getInfo(): String {
        return "name: $name -- age$age"
    }
}

// 方式一
class B : A() {
    override val name: String
        get() = "coding"
    override var age: Int
        get() = 18
        set(value) {}
}

// 方式二
class C(override val name: String, override var age: Int) : A() {

}

Decompile Kotlin bytecode 出来的代码如下：

public abstract class A {
   @NotNull
   public abstract String getName(); // val声明的变量只有get函数。不能被 set 赋值

   public abstract int getAge();

   public abstract void setAge(int var1);

   @NotNull
   public final String getInfo() { // 非抽象函数被定义成了 final
      return "name: " + this.getName() + " -- age" + this.getAge();
   }
}

public final class B extends A {
   @NotNull
   public String getName() {
      return "coding";
   }

   public int getAge() {
      return 18;
   }

   public void setAge(int value) {
   }
}

public final class C extends A {
   @NotNull
   private final String name; // 声明私有 “父类的抽象属性” 
   private int age; // 声明私有 “父类的抽象属性” 

   @NotNull
   public String getName() { // name 依然只有 get 函数
      return this.name;
   }

   public int getAge() {
      return this.age;
   }

   public void setAge(int var1) {
      this.age = var1;
   }

   public C(@NotNull String name, int age) { // 构造函数中对两个 “抽象属性” 进行赋值。没有默认构造，所以只能通过这个来进行赋值。
      Intrinsics.checkParameterIsNotNull(name, "name");
      super();
      this.name = name;
      this.age = age;
   }
}

internal

internal 用来修改一个类或者一个函数、变量。用 internal 来修饰之后，这个类、函数或者变量只能在当前的 model 中使用。不能跨 model 来进行调用。