在Kotlin中没有静态关键字。
在Kotlin中表示静态Java方法的最佳方法是什么?
当前回答
静态属性的顶级/伴生对象
顶级
当属性与类有些关联时，在类声明之前将它们定义为顶级属性:
const val MAX_ATTEMPTS = 3
private const val DEFAULT_NAME = "Guest"
private const val MIN_AGE = 16
data class User(val id: String, val name: String = DEFAULT_NAME)
这类似于Java中的静态属性。
当属性完全独立于任何类时，可以将它们定义为不包含类的单独文件中的顶级属性。
伴星
当属性与类密切相关并且只会在该类中使用时，在伴随对象中定义它们:
data class User(val id: String, val name: String = DEFAULT_NAME) {
companion object {
const val DEFAULT_NAME = "Guest"
const val MIN_AGE = 16
}
}
用于静态方法的顶级/伴生对象
顶级
类似于上面的属性，当函数与类有点关联时，将它们定义在类的上方:
fun getAllUsers() { }
fun getProfileFor(userId: String) { }
data class User(val id: String, val name: String)
用法:
val userList = getAllUsers()
伴星
当函数与类密切相关时，在伴随对象中定义它们:
data class User(val id: String, val name: String) {
companion object {
fun getAll() { }
fun profileFor(userId: String) { }
}
}
用法:
val userProfile = User.profileFor("34")
这类似于Java中的静态方法。
顶级函数对于Kotlin来说通常更习惯。在伴生对象中定义函数的一个更好的原因是当您使用接口扩展伴生对象时。在单例部分中展示了一个示例。
静态类的嵌套类
当具有相关功能的类属于一起时，可以通过嵌套将它们分组在一起:
class User(val id: String, val name: String) {
class UserAccess : UserDao {
override fun add(user: User) { }
override fun remove(id: String) { }
}
}
这相当于Java中的静态嵌套类。这里的UserAccess类实现了一个接口UserDao。
用法:
fun main() {
val john = User("34", "John")
val userAccess = User.UserAccess()
userAccess.add(john)
}
用于静态INSTANCE的单例对象
顶级
当您只想要类的单个对象时，您不再需要像在Java中那样在类中创建静态INSTANCE。简单地使用顶级对象声明:
object UserAccess : UserDao {
override fun add(user: User) { }
override fun remove(id: String) { }
}
还要注意在单例中扩展接口或类是多么容易。
上面的代码，在底层，在Java中产生以下静态INSTANCE单例模式(简化):
public final class UserAccess implements UserDao {
public static final UserAccess INSTANCE;
public void add(User user) { }
public void remove(String id) { }
private UserAccess() { }
static { INSTANCE = new UserAccess();}
}
伴星
当单例对象与类密切相关时，使用companion对象:
data class User(val id: String, val name: String) {
companion object : UserDao {
override fun add(user: User) { }
override fun remove(id: String) { }
}
}
这样可以获得更优雅的命名:User.add(john)。另外，您要明确这个单例只用作User类的实用程序。如果需要多个单例对象或函数/属性组，也可以在类中使用不带companion关键字的对象。
静态工厂的伴生对象
Koltin中的工厂函数是使用伴生对象创建的。当您希望提供多种方法来创建对象，而对象构造过程很复杂，或者多个构造函数表达能力不够时，工厂函数非常有用。
例如，下面代码段中的newInstance()工厂函数通过自动生成id来创建一个用户:
class User private constructor(val id: Long, val name: String) {
companion object {
private var currentId = 0L;
fun newInstance(name: String) = User(currentId++, name)
}
}
这相当于Java中的静态工厂方法。
构造函数是私有的，但是伴生对象可以访问构造函数。
在上面的代码中，下一个id生成的一致性得到了保证，因为伴生对象是一个单例对象，只有一个对象会跟踪id，不会有任何重复的id。
还要注意，伴生对象可以具有表示状态的属性(在本例中为currentId)。
用法:
val john = User.newInstance("John")
@JvmStatic用于Java互操作性
Java的静态概念在Kotlin中并不存在。同伴对象是一个称为companion的真实类的实例。因此，当您从Java调用Kotlin代码时，Companion类的对象首先在后台实例化。你需要在Java中使用Companion对象调用该函数:
Profile userProfile = User.Companion.profileFor("34");
为了获得惯用的Java命名和更少的冗长，可以在函数或属性上使用@JvmStatic注释:
companion object {
@JvmStatic
fun profileFor(userId: String): Profile { }
}
@JvmStatic注释创建getProfileFor()函数的一个单独的纯静态副本。现在你可以在Java中使用常规语法:
Profile userProfile = User.profileFor("34");
就是这样!希望这些例子对你的项目有用。
其他回答
将它们直接写入文件。
在Java中(丑陋):
package xxx;
class XxxUtils {
public static final Yyy xxx(Xxx xxx) { return xxx.xxx(); }
}
在芬兰湾的科特林:
@file:JvmName("XxxUtils")
package xxx
fun xxx(xxx: Xxx): Yyy = xxx.xxx()
这两段代码在编译后是相等的(甚至编译后的文件名file:JvmName用于控制编译后的文件名，该文件名应该放在包名声明之前)。
静态属性的顶级/伴生对象
顶级
当属性与类有些关联时，在类声明之前将它们定义为顶级属性:
const val MAX_ATTEMPTS = 3
private const val DEFAULT_NAME = "Guest"
private const val MIN_AGE = 16
data class User(val id: String, val name: String = DEFAULT_NAME)
这类似于Java中的静态属性。
当属性完全独立于任何类时，可以将它们定义为不包含类的单独文件中的顶级属性。
伴星
当属性与类密切相关并且只会在该类中使用时，在伴随对象中定义它们:
data class User(val id: String, val name: String = DEFAULT_NAME) {
companion object {
const val DEFAULT_NAME = "Guest"
const val MIN_AGE = 16
}
}
用于静态方法的顶级/伴生对象
顶级
类似于上面的属性，当函数与类有点关联时，将它们定义在类的上方:
fun getAllUsers() { }
fun getProfileFor(userId: String) { }
data class User(val id: String, val name: String)
用法:
val userList = getAllUsers()
伴星
当函数与类密切相关时，在伴随对象中定义它们:
data class User(val id: String, val name: String) {
companion object {
fun getAll() { }
fun profileFor(userId: String) { }
}
}
用法:
val userProfile = User.profileFor("34")
这类似于Java中的静态方法。
顶级函数对于Kotlin来说通常更习惯。在伴生对象中定义函数的一个更好的原因是当您使用接口扩展伴生对象时。在单例部分中展示了一个示例。
静态类的嵌套类
当具有相关功能的类属于一起时，可以通过嵌套将它们分组在一起:
class User(val id: String, val name: String) {
class UserAccess : UserDao {
override fun add(user: User) { }
override fun remove(id: String) { }
}
}
这相当于Java中的静态嵌套类。这里的UserAccess类实现了一个接口UserDao。
用法:
fun main() {
val john = User("34", "John")
val userAccess = User.UserAccess()
userAccess.add(john)
}
用于静态INSTANCE的单例对象
顶级
当您只想要类的单个对象时，您不再需要像在Java中那样在类中创建静态INSTANCE。简单地使用顶级对象声明:
object UserAccess : UserDao {
override fun add(user: User) { }
override fun remove(id: String) { }
}
还要注意在单例中扩展接口或类是多么容易。
上面的代码，在底层，在Java中产生以下静态INSTANCE单例模式(简化):
public final class UserAccess implements UserDao {
public static final UserAccess INSTANCE;
public void add(User user) { }
public void remove(String id) { }
private UserAccess() { }
static { INSTANCE = new UserAccess();}
}
伴星
当单例对象与类密切相关时，使用companion对象:
data class User(val id: String, val name: String) {
companion object : UserDao {
override fun add(user: User) { }
override fun remove(id: String) { }
}
}
这样可以获得更优雅的命名:User.add(john)。另外，您要明确这个单例只用作User类的实用程序。如果需要多个单例对象或函数/属性组，也可以在类中使用不带companion关键字的对象。
静态工厂的伴生对象
Koltin中的工厂函数是使用伴生对象创建的。当您希望提供多种方法来创建对象，而对象构造过程很复杂，或者多个构造函数表达能力不够时，工厂函数非常有用。
例如，下面代码段中的newInstance()工厂函数通过自动生成id来创建一个用户:
class User private constructor(val id: Long, val name: String) {
companion object {
private var currentId = 0L;
fun newInstance(name: String) = User(currentId++, name)
}
}
这相当于Java中的静态工厂方法。
构造函数是私有的，但是伴生对象可以访问构造函数。
在上面的代码中，下一个id生成的一致性得到了保证，因为伴生对象是一个单例对象，只有一个对象会跟踪id，不会有任何重复的id。
还要注意，伴生对象可以具有表示状态的属性(在本例中为currentId)。
用法:
val john = User.newInstance("John")
@JvmStatic用于Java互操作性
Java的静态概念在Kotlin中并不存在。同伴对象是一个称为companion的真实类的实例。因此，当您从Java调用Kotlin代码时，Companion类的对象首先在后台实例化。你需要在Java中使用Companion对象调用该函数:
Profile userProfile = User.Companion.profileFor("34");
为了获得惯用的Java命名和更少的冗长，可以在函数或属性上使用@JvmStatic注释:
companion object {
@JvmStatic
fun profileFor(userId: String): Profile { }
}
@JvmStatic注释创建getProfileFor()函数的一个单独的纯静态副本。现在你可以在Java中使用常规语法:
Profile userProfile = User.profileFor("34");
就是这样!希望这些例子对你的项目有用。
Docs建议使用包级函数来解决静态函数的大部分需求。它们只是在源代码文件中的类之外声明的。文件的包可以在文件的开头用关键字package指定。
宣言
package foo
fun bar() = {}
使用
import foo.bar
另外
import foo.*
你现在可以调用函数:
bar()
或者不使用import关键字:
foo.bar()
如果不指定包，则可以从根目录访问该函数。
如果您只有java经验，这可能看起来有点奇怪。原因是kotlin不是严格的面向对象语言。你可以说它支持类之外的方法。
编辑: 他们编辑了文档，不再包含关于推荐包级函数的句子。这是上面提到的原稿。
您可以使用Companion Objects - kotlinlang
它可以通过首先创建该接口来显示
interface I<T> {
}
然后我们必须在该接口内部创建一个函数:
fun SomeFunc(): T
然后，我们需要一节课:
class SomeClass {}
在该类中，我们需要一个伴生对象:
companion object : I<SomeClass> {}
在那个同伴对象中，我们需要旧的SomeFunc函数，但是我们需要重写它:
override fun SomeFunc(): SomeClass = SomeClass()
最后，在所有这些工作下面，我们需要一些东西来支持静态函数，我们需要一个变量:
var e:I<SomeClass> = SomeClass()
对于Android使用从单个活动到所有必要活动的字符串。 就像java中的静态
public final static String TEA_NAME = "TEA_NAME";
Kotlin中的等效方法:
class MainActivity : AppCompatActivity() {
companion object {
const val TEA_NAME = "TEA_NAME"
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
}
}
另一个需要价值的活动是:
val teaName = MainActivity.TEA_NAME
推荐文章
- 禁用IntelliJ星(包)导入?
- 面试问题:检查一个字符串是否是另一个字符串的旋转
- 将文件加载为InputStream的不同方法
- Swift 'if let'语句等价于Kotlin
- 到底是什么导致了堆栈溢出错误?
- 为什么Android工作室说“等待调试器”如果我不调试?
- Java:路径vs文件
- ExecutorService，如何等待所有任务完成
- Maven依赖Servlet 3.0 API?
- 如何在IntelliJ IDEA中添加目录到应用程序运行概要文件中的类路径?
- getter和setter是糟糕的设计吗?相互矛盾的建议
- Android room persistent: AppDatabase_Impl不存在
- Java的String[]在Kotlin中等价于什么?
- 错误:执行失败的任务':app:compileDebugKotlin'。>编译错误。详细信息请参见日志
- Intellij IDEA上的System.out.println()快捷方式
