Kotlin實戰指南二：變量、常量、靜態常量

轉載請標明出處：https://blog.csdn.net/zhaoyanjun6/article/details/87811333
本文出自【趙彥軍的博客】

---

變量

Java中的變量

public class App {
    private String name;  //定義一個變量  
}

Kotlin中的變量，用 var 修飾

class App {
    var name = "abc"
}

這樣寫，相當於

public final class App {
   @NotNull
   private String name = "abc";

   @NotNull
   public final String getName() {
      return this.name;
   }

   public final void setName(@NotNull String var1) {
      Intrinsics.checkParameterIsNotNull(var1, "<set-?>");
      this.name = var1;
   }
}

Kotlin定義的變量，默認有 getXXX 、 setXXX 方法

常量

Java定義一個常量，用 final 修飾

public class App {
    final String NAME = "zhaoyanjun";  //定義一個常量
}

Kotlin定義一個常量，用 val 修飾

class App {
    val NAME = "zhaoyanjun"
}

這樣寫，相當於

public final class App {
   @NotNull
   private final String NAME = "zhaoyanjun";

   @NotNull
   public final String getNAME() {
      return this.NAME;
   }
}

Kotlin定義的常量，默認有 getXXX 方法，沒有 setXXX 方法

靜態常量

Java中的靜態常量, 用 final 、static 修飾

public class App {
    final static String NAME = "zhaoyanjun";  //定義一個靜態常量
}

Kotlin定義一個靜態常量，用 object、val 修飾
用object 修飾的類爲靜態類，裏面的方法和變量都爲靜態的。

object App {

    val NAME = "zhaoyanjun"

    fun add(a: Int, b: Int): Int {
        return a + b;
    }
}

這樣寫，相當於

public final class App {
   @NotNull
   private static final String NAME = "zhaoyanjun";
   public static final App INSTANCE;

   @NotNull
   public final String getNAME() {
      return NAME;
   }

   public final int add(int a, int b) {
      return a + b;
   }

   static {
      App var0 = new App();
      INSTANCE = var0;
      NAME = "zhaoyanjun";
   }
}

Kotlin 代碼調用

App.NAME  //調用靜態常量
App.add(3,5)  //調用靜態方法

綜上，我就完美的解決了靜態常量，靜態方法的問題。但是等等，我們發現一個問題，用 object 修飾的類中所有的方法都成了靜態了，這不是我們希望看到的結果，我們希望能夠在一個普通類中，可以有靜態方法，也可以有非靜態方法。有什麼解決方案嗎？

答案當然是有的，就是下面我們要講的伴生。

伴生

Kotlin中實現伴生對象用 companion object 來實現

class App {

    companion object {

        //靜態常量
        val NAME = "zhaoyanjun"

        //靜態方法
        fun add(a: Int, b: Int): Int {
            return a + b
        }
    }

   //非靜態常量
    val age = 20
    
    //非靜態方法
    fun remove(a: Int, b: Int): Int {
        return a - b
    }

}

這樣寫，就相當於

public final class App {
   private final int age = 20;
   @NotNull
   private static final String NAME = "zhaoyanjun";
   public static final App.Companion Companion = new App.Companion((DefaultConstructorMarker)null);

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

   public final int remove(int a, int b) {
      return a - b;
   }

   public static final class Companion {
      @NotNull
      public final String getNAME() {
         return App.NAME;
      }

      public final int add(int a, int b) {
         return a + b;
      }

      private Companion() {
      }
   }
}

調用

//調用靜態常量，靜態方法
App.NAME
App.add(3, 4)

//調用非靜態常量、非靜態方法
App().age
App().remove(4, 3)

實戰演練

在Android開發中，我們通常需要在 Application 類中提供一個 Application 實例和 ApplicationContext 實例

Java 代碼實現方式

public class App extends Application {

    public static Application mInst;
    public static Context mContext;
    
    @Override
    public void onCreate() {
        super.onCreate();

        mInst = this;
        mContext = getApplicationContext();
    }
}

Kotlin實現方式

class App : Application() {

    override fun onCreate() {
        super.onCreate()

        mInst = this
        mContext = applicationContext
    }

    companion object {
        var mInst: Application? = null
        var mContext: Context? = null
    }
}

調用

 App.mInst
 App.mContext

---

個人微信號：zhaoyanjun125 , 歡迎關注