kotlin类的学习（对象表达式、伴生、接口）

对象表达式object

通过object可以快速声明一个对象

fun printAddress() {
    //相当于是声明了一个Address的子类，并重写其print方法
    Shop().addAddress(object : Address(21){
        override fun print() {
            print("new address = $id")
        }
    })
    //快速声明一个匿名的含有x和y的对象
    val newObj = object {
        var x : Int = 0
        var y: Int = 0
    }
    println("newObj = ${newObj}")
}

object关键字还可以用来声明一些工具类的方法

object DataUtil{
    //相当于声明一个static方法
    fun <T> isEmpty(list: ArrayList<T>?): Boolean {
        return list?.isEmpty() ?: false
    }
}

fun testDataUtil() {
    val list = arrayListOf<Int>()
    println(DataUtil.isEmpty(list))//返回true
}

在调用时其实是

//在调用时等价于
DataUtil.INSTANCE.isEmpty(list);

反编译之后可以看出isEmpty不是一个static方法，但是DataUtil自带Instance对象

public final class DataUtil {
   public static final DataUtil INSTANCE;

   public final boolean isEmpty(@Nullable ArrayList list) {
      return list != null ? list.isEmpty() : false;
   }

   private DataUtil() {
   }

   static {
        //直接在static代码块中初始化
      DataUtil var0 = new DataUtil();
      INSTANCE = var0;
   }
}

伴生对象Companion object

class Student(name : String) {
    companion object {
        val student = Student("wms")
        fun study() {
            println("print Student")
        }
    }
}

fun testCompanion() {
    Student.study()//反编译即java的Student.Companion.study();
    println(Student.student)//相当于java的Student.Companion.getStudent()
}

反编译后

public final class Student {
    //伴生类中声明的对象被转变成了static对象
    @NotNull
    private static final Student student = new Student("wms");
    //伴生类的真实面目是一个静态内部类Companion
    public static final Student.Companion Companion = new Student.Companion((DefaultConstructorMarker)null);
   
    public static final class Companion {
      @NotNull
      public final Student getStudent() {
        //直接访问伴生类的对象即访问外部Student的static对象
         return Student.student;
      }
      
      public final void study() {
         String var1 = "print Student";
         boolean var2 = false;
         System.out.println(var1);
      }
    }
}

接口interface

kotlin中的接口与java最大的区别就是可以有属性与方法体，属性其实就是写在接口中的set与get方法，而实现的方法则是接口中的静态内部类

interface Study {
    var num: Int
    fun discuss()
    fun learn() {
        println("Study learn")
    }
}

interface Play{
    fun learn(){
        println("Play learn")
    }
}

//若含有属性，则需要在构造方法中override
class StudyImpl(override var num: Int) : Study,Play {
    override fun discuss() {
        println("start discuss")
    }

    override fun learn() {
        //由于Study与Play都实现了learn方法，此处指定是调用Play的learn方法
        super<Play>.learn()
    }
}

反编译Study之后可以看到

public interface Study {
    //接口中的num属性其实就是get与set方法而已
   int getNum();

   void setNum(int var1);

   void discuss();

   void learn();

   //...省略
   
   //若是在interface中有实现方法，其实是interface中的一个静态内部类
   public static final class DefaultImpls {
      public static void learn(Study $this) {
         String var1 = "Study learn";
         boolean var2 = false;
         System.out.println(var1);
      }
   }
}