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 , 欢迎关注