一、类的定义

• java中定义类

  public class SimpleClass {
      // 定义成员变量
      public int x;
  
      // 定义构造方法
      public SimpleClass(int x) {
          this.x = x;
      }
  
      // 定义方法
      public void y() {
      }
  }
  

• kotlin中定义类

  • 副构造器写法

    class SimpleClass {// Kotlin中的类默认都是public
        // 定义成员变量，Kotlin中必须初始化
        var x: Int = 0
    
        // 定义构造方法，对应Kotlin中的副构造器
        constructor(x: Int) {
            this.x = x
        }
    
        // 定义方法
        fun y() {
        }
    }
    

  • 主构造器写法

    // 对应Kotlin中的主构造器的概念，主构造器要求其它所有的构造器都要调用它
    class SimpleClass
            constructor(x: Int){
                var x: Int = x
    }
    
    // 精简写法
    class SimpleClass(x: Int){
                var x: Int = x
    }
    
    // 精简写法2
    class SimpleClass(var x: Int){
    }
    

二、类的实例化

• Java中类的实例化

  SimpleClass simpleClass = new SimpleClass(1)
  System.out.println(simpleClass.x);
  simpleClass.y();
  

• Kotlin中类的实例化

  val simpleClass = SimpleClass(2)
  println(simpleClass.x)
  simpleClass.y()
  

三、接口的定义

• Java中接口的定义

  public interface SimpleInterface {
      void simpleMethod();
  }
  

• Kotlin中接口的定义

  interface SimpleInterface {
      fun simpleMethod()
  }
  

四、接口的实现

• Java中接口的实现

  public class SimpleClass
          implements SimpleInterface {
              ...
              @Override
              public void simpleMethod(){
              }
  }
  

• Kotlin中接口的实现

  class SimpleClass(var x: Int)
      : SimpleInterface {
          ...
          override fun simpleMethod() {
          }
  }
  

注：Java中的Override是jdk 1.5以后引入的一个注解，在Java中它不是强制必须要添加的，在Kotlin中你必须要添加override关键字；
Override表示覆盖，它是一个比较危险的行为——有可能会覆写到别人的方法。

五、抽象类的定义

• Java中抽象类的定义

  public abstract class AbsClass {
      // 抽象方法，它是一定用来被覆写的
      public abstract void absMethod();
      // 未添加final关键字的方法默认也是可以被覆写的
      protected void overrideable() { }
      // 添加final关键字的方法不能被覆写
      public final void nonOverrideable() { }
  }
  

• Kotlin中抽象类的定义

  abstract class AbsClass {
      // 抽象方法，它是一定用来被覆写的
      abstract fun absMethod()
      // Kotlin抽象类中的方法默认不可以被覆写，你必须添加open关键字才能够对它进行覆写
      open fun overrideable() { }
      fun nonOverrideable() { }
  }
  

注意：
1.Java和Kotlin抽象类中的抽象方法都可以被覆写；
2.Java抽象类中的其它方法默认是可以被覆写的，而Kotlin中则默认不可以被覆写；
3.Java抽象类中在方法前添加final关键字可以保证该方法不能被覆写；
4.Kotlin抽象类中在方法前添加open关键字可以允许该方法能被覆写。

六、类的继承

• Java中类的继承

  public class SimpleClass
      extends AbsClass implements SimpleInterface {
          ...
  }
  

• Kotlin中类的继承

  // kotlin在继承类的时候相对实现接口会在类名后多一个()，因为它调用了父类的构造方法
  class SimpleClass(var x: Int)
      : AbsClass(), SimpleInterface {
          ...
  }
  

七、属性Property

Java中没有属性这个概念，而是通过语法约定的形式来实现

public class Person {
    private int age;// field-领域
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

Kotlin中的属性Property

class Person(age: Int) {
    var age: Int = age // Property，它等于Java中的filed+get+set
        get() {
            return filed
        }
        set(value) {
            filed = value
        }
}

八、属性引用

Kotlin中的属性引用类似于函数引用

// 未绑定Receiver
val ageRef = Person::age
val person = Person(18)
ageRef.set(person, 22)

// 绑定Receiver
val ageRef2 = person::age
ageRef2.set(33)