kotlin 中的 java static

kotlin 中的 java static

lucas Lv4
  2025-04-08 08:57:54 2025-04-08 08:57:54 Created   2025-04-24 21:27:02 2025-04-24 21:27:02 Updated    

java static 的用法

  1. 静态变量（类变量）
    特点：可以不初始化实例就直接调用；所有实例共享同一内存空间，类加载时初始化，生命周期持续到程序结束。
    示例：统计类实例数量时，可通过静态变量实现全局共享。

    1
    2
    3
    4
    class Counter {
        static int count = 0; // 所有实例共享的计数器
        Counter() { count++; }
    }

  2. 静态方法
    特点：可以不初始化实例就直接调用；但不能访问非静态成员 （需通过对象引用）。
    典型场景：工具类方法（如数学计算、字符串处理）。

    1
    2
    3
    class MathUtils {
        static int add(int a, int b) { return a + b; } // 工具方法
    }

  3. 静态代码块
    作用：类加载时执行一次，相当于在类加载的时候执行的方法体，常用于初始化静态变量或加载资源。
    执行顺序：按代码顺序执行，优先于构造方法。

    1
    2
    3
    4
    5
    6
    class Database {
        static Connection conn;
        static {
            conn = DriverManager.getConnection(...); // 初始化数据库连接
        }
    }

  4. 静态内部类
    特点：独立于外部类实例，可直接创建，但仅能访问外部类的静态成员。
    示例：实现嵌套工具类或特定设计模式（如 Builder 模式）。

    1
    2
    3
    4
    5
    class Outer {
        static class Inner { // 静态内部类
            void display() { System.out.println("独立于外部类实例"); }
        }
    }

  5. 静态导包
    语法：import static java.lang.Math.*;，允许直接调用静态成员而无需类名前缀。
    注意：过度使用可能降低代码可读性。

kotlin 中与 static 有关的语法

包级函数(顶层函数)

kotlin 允许将函数直接定义到文件中，而不是在 class 内部

1
2
3
4
5
6
// GlobalFile.kt
val hello = "Hello"

fun printHello() {
    println(hello)
}

反编译成 java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Metadata(
   // 省略
)
public final class GlobalFileKt {
   @NotNull
   private static final String hello = "Hello";

   @NotNull
   public static final String getHello() {
      return hello;
   }

   public static final void printHello() {
      System.out.println(hello);
   }
}

用 java 调用，代码如下：

1
2
GlobalFileKt.getHello();
GlobalFileKt.printHello();

修改生成的类名

GlobalFileKt 这个名字是由编译器给我生成的，如果想改，可以使用 @file:JvmName("AAA")

1
2
3
4
5
6
7
8
@file:JvmName("AAA")
package org.czb

val hello = "Hello"

fun printHello() {
    println(hello)
}

反编译成 java

1
2
3
4
5
6
7
8
9
10
11
12
13
public final class AAA {
   @NotNull
   private static final String hello = "Hello";

   @NotNull
   public static final String getHello() {
      return hello;
   }

   public static final void printHello() {
      System.out.println(hello);
   }
}

object class

object class 本身就是声明成单例类，我看看写法

1
2
3
4
5
6
object SingleClass {
    val hello = "Hello"
    fun printHello() {
        println(hello)
    }
}

反编译成 java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Metadata(
   // 省略
)
public final class SingleClass {
   @NotNull
   public static final SingleClass INSTANCE = new SingleClass();
   @NotNull
   private static final String hello = "Hello";

   private SingleClass() {
   }

   @NotNull
   public final String getHello() {
      return hello;
   }

   public final void printHello() {
      System.out.println(hello);
   }
}

用 java 调用，代码如下：

1
2
SingleClass.INSTANCE.getHello();
SingleClass.INSTANCE.printHello();

companion object

1
2
3
4
5
6
7
8
9
class TestCompanion {
    companion object {
        var hello = "Hello"

        fun printHello() {
            println(hello)
        }
    }
}

反编译成 java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
@Metadata(
   // 省略
)
public final class TestCompanion {
   @NotNull
   public static final Companion Companion = new Companion((DefaultConstructorMarker)null);
   @NotNull
   private static String hello = "Hello";

   @Metadata(
      // 省略
   )
   public static final class Companion {
      private Companion() {
      }

      @NotNull
      public final String getHello() {
         return TestCompanion.hello;
      }

      public final void setHello(@NotNull String var1) {
         Intrinsics.checkNotNullParameter(var1, "<set-?>");
         TestCompanion.hello = var1;
      }

      public final void printHello() {
         System.out.println(this.getHello());
      }

      // $FF: synthetic method
      public Companion(DefaultConstructorMarker $constructor_marker) {
         this();
      }
   }
}

用 java 调用，代码如下：

1
2
TestCompanion.Companion.getHello();
TestCompanion.Companion.printHello();

这个 Companion 其实是一个用内部类实现的单例类

@JvmStatic

在半生对象（companion object）或者 object class 里的方法，在声明函数的时候，也只会生成 final 函数，如果我们想生成 static 函数就可以使用 @JvmStatic 了

1
2
3
4
5
6
7
8
9
10
class TestCompanion {
    companion object {
        var hello = "Hello"

        @JvmStatic
        fun printHello() {
            println(hello)
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public final class TestCompanion {
   @NotNull
   public static final Companion Companion = new Companion((DefaultConstructorMarker)null);
   @NotNull
   private static String hello = "Hello";

   @JvmStatic
   public static final void printHello() {
      Companion.printHello();
   }

   @Metadata(
      // 省略
   )
   public static final class Companion {
      private Companion() {
      }

      @NotNull
      public final String getHello() {
         return TestCompanion.hello;
      }

      public final void setHello(@NotNull String var1) {
         Intrinsics.checkNotNullParameter(var1, "<set-?>");
         TestCompanion.hello = var1;
      }

      @JvmStatic
      public final void printHello() {
         System.out.println(this.getHello());
      }

      // $FF: synthetic method
      public Companion(DefaultConstructorMarker $constructor_marker) {
         this();
      }
   }
}
  • Title: kotlin 中的 java static
  • Author: lucas
  • Created at : 2025-04-08 08:57:54
  • Updated at : 2025-04-24 21:27:02
  • Link: https://darkflamemasterdev.github.io/2025/04/08/java-static-和-kotlin-的-object/
  • License: This work is licensed under CC BY-NC-SA 4.0.
其他文章
kotlin 内部类 kotlin 内部类 阅读 Retrofit 源码 阅读 Retrofit 源码 Kotlin data class 被 gson 解析遇到的坑 Kotlin data class 被 gson 解析遇到的坑
其他文章
kotlin 内部类 kotlin 内部类 阅读 Retrofit 源码 阅读 Retrofit 源码
Comments
On this page
kotlin 中的 java static
  1. java static 的用法
  2. kotlin 中与 static 有关的语法
    1. 包级函数(顶层函数)
      1. 修改生成的类名
    2. object class
    3. companion object
    4. @JvmStatic