Kotlin中如何用类似Java static的方式定义静态成员？

本文共计1623个文字，预计阅读时间需要7分钟。

静态修饰符在Java中非常常用，用法也很多。然而，在Kotlin中，并没有直接的静态概念。以下是一些Java中静态修饰符的常见用法及其在Kotlin中的替代方式：

1. 静态变量：在Java中，静态变量属于类而非实例。在Kotlin中，可以使用`object`关键字来创建一个单例对象，并在其中定义变量。

kotlin object Singleton { var staticVar=0 }

2. 静态方法：在Java中，静态方法属于类，可以直接通过类名调用。在Kotlin中，可以通过单例对象或伴生对象来实现。

kotlin object Helper { fun staticMethod() { // ... } }

// 或者使用伴生对象 class MyClass { companion object { fun staticMethod() { // ... } } }

3. 静态初始化块：在Java中，静态初始化块用于初始化静态变量。在Kotlin中，可以在伴生对象中定义初始化代码。

kotlin class MyClass { companion object { init { // 初始化代码 } } }

4. 静态内部类：在Java中，静态内部类可以访问外部类的静态成员。在Kotlin中，可以通过定义一个没有访问修饰符的内部类来实现。

kotlin class OuterClass { class InnerClass { // 可以访问OuterClass的静态成员 } }

通过以上方式，可以在Kotlin中实现Java中静态修饰符的许多功能。

static修饰符是java里面非常常用的一个东西，用法也非常多。然而，在kotlin里竟然没有这个东西！那该如何替代呢？本文就总结了下java里面static的几种常见用法在kotlin里的替代方式。

static在java里面的用法总结

static在java里面的用法有很多，最常用的有下面几种：

• 静态变量及方法
• 静态初始化
• 静态内部类

下面我们就看看这几种场景在kotlin是如何实现的。

场景一：静态变量及方法

静态变量及方法可能是我们平时用到static最多的地方，我们先看看java里面是如何做的。

java静态变量及方法介绍：

首先，是静态变量和方法的定义：

public class StaticTest { public static int STATIC_VAR = 0; public static void staticMethod(String str){ System.out.println(str); } }

然后是静态变量和方法的使用：

StaticTest.STATIC_VAR = 10; StaticTest.staticMethod("hello");

java的实现方式大家都非常熟悉了，下面着重说说kotlin是如何实现的。

kotlin替代静态变量及方法的方案

kotlin通过引入“伴生对象”的概念来替代java里的静态变量及方法。

“伴生对象”这个名词听上去很古怪，其实非常简单：在类的内容使用companion来标记一个对象。所有需要“静态化”的变量和方法都放在这个对象里。

下面是定义伴生对象的代码：

class StaticTest { companion object{//伴生对象是可以指定名字的，不过一般都省略掉。 var STATIC_VAR = 0 fun staticMethod(str: String?) { println(str) } } }

接下来看看如何使用伴生对象，伴生对象只能通过类名来访问，使用方法和java差不多：

StaticTest.STATIC_VAR = 100 StaticTest.staticMethod("hello")

kotlin的伴生对象解决了什么问题？

大家可能会好奇，为什么kotlin要用这么一个奇怪的方式来解决这个问题呢？

我的理解是有两个原因：

第一，使用伴生对象体现了kotlin一贯的设计理念：一切都是对象！伴生对象也是对象！而java的static，显然和对象没有关系。

第二，伴生对象解决了java静态变量及方法的一个常见的反模式：静态方法及变量可以通过对象的引用来访问。

还是拿上面的例子，java的静态变量及方法可以通过类引用和对象引用两种方法访问：

//通过类引用访问 StaticTest.STATIC_VAR = 10; StaticTest.staticMethod("hello"); //通过对象引用访问 StaticTest obj = new StaticTest(); obj.STATIC_VAR = 10; obj.staticMethod("hello");

而通过对象引用访问静态变量及方法，显然是不合适的。但是在java里却没有办法从语法层面避免这个问题。

而kotlin的伴生对象只能通过类引用访问，从语法的层面解决了这个问题：

//使用类引用访问 StaticTest.STATIC_VAR = 100 StaticTest.staticMethod("hello") //不能使用对象引用访问 val obj = StaticTest() obj.STATIC_VAR = 100 //编译错误 obj.staticMethod("hello") //编译错误

总之，kotlin里每个新的语言特性，都是为了填补java的某一个坑。

场景二：静态初始化

java里的静态初始化可以在类加载的时候初始化一些静态变量，比如：

public class StaticTest { public static int STATIC_VAR = 0; static { STATIC_VAR = 100; System.out.println("in static init"); } public static void main(String[] args) { System.out.println(StaticTest.STATIC_VAR); } }

上面的代码执行结果如下：

in static init
100

在kotlin里，因为java的静态变量及方法都是放在伴生对象里实现的，而伴生对象也是一个普通对象，所以可以通过伴生对象的init方法来实现变量的初始化，代码如下：

class StaticTest { companion object{//伴生对象是可以指定名字的，不过一般都省略掉。 var STATIC_VAR = 0 init { STATIC_VAR = 100 println("in companion object init") } } }

执行代码：

println(StaticTest.STATIC_VAR)

结果如下：

in companion object init
100

可以看到，kotlin的实现方式要比java的更加一致，既然大家都是对象，所以都是通过init来初始化的。而java里，非静态变量是通过构造函数来初始化的，而静态变量是通过static代码块来初始化的，两者很不一致。

场景三：静态内部类

java的内部类有两种，普通内部类和静态内部类。二者的区别是前者可以访问外部类的变量，而后者不可以。同时普通内部类会持有外部类的一个引用，静态内部类则没有。

public class StaticTest { private int out = 0; class InnerClass{ public void InnerClassMethod(){ out = 100; //可以访问外部类的变量 } } static class StaticInnerClass{ public void StaticInnerClassMethod(){ out = 100; //编译错误，不可以访问外部类的变量 } } }

而kotlin的内部类也有两种：内部类和嵌套类。从语法上说，二值的差别就是前者多一个inner修饰符。

下面是和java的比较：

• kotlin的内部类（使用inner修饰符）相当于java的普通内部类，可以访问外部变量，同时持有外部对象的引用。
• kotlin的嵌套类（没有inner修饰符）相当于java的静态内部类，不可以访问外部变量

kotlin嵌套类的例子：

class StaticTest { var out = 0 inner class InnerClass{ fun InnerClassMethod(){ out = 100 //内部类可以访问外部变量 } } }

kotlin内部类的例子：

class StaticTest { var out = 0 class InnerClass{ fun InnerClassMethod(){ out = 100 //编译错误，嵌套类不可以访问外部变量 } } }

通过对比，大家应该很容易的搞清楚kotlin里内部类和嵌套类的区别了。

总结：

本文的知识点总结如下：

• java的静态变量和方法，在kotlin中使用伴生对象替代
• java的静态初始化，在kotlin中使用伴生对象的init替代
• java的静态内部类，在kotlin中使用嵌套类来替代

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持易盾网络。