Kotlin 中 object 关键字的使用场景主要有三种:
对象声明(object declaration):定义单例的一种方式
伴生对象(companion object):创建类的静态成员
对象表达式(object expression):替代 Java 的匿名内部类
一、对象声明
Kotlin 中对象声明将 类声明 与 该类的单一实例声明 结合到了一起。不同于普通类的实例,对象声明在定义的时候就创建了实例
对象声明中不允许包含构造方法(主构造方法 & 从构造方法)
对象声明同样可以继承自类和接口
对象声明的例子:
object UserManager {
fun saveUser(){}
}
// 反编译出的Java代码
public final class UserManager {
public static final UserManager INSTANCE;
public final void saveUser() {
}
private UserManager() {
}
static {
UserManager var0 = new UserManager();
INSTANCE = var0;
}
}
在kotlin和java代码中,它们的调用方式有点差别:
kotlin代码调用:UserManager.saveUser()
java代码调用:UserManager.INSTANCE.saveUser();
Java实现单例模式 与 Kotlin实现单例模式 的对比:
(1)饿汉模式
//java 饿汉模式
public class Singleton{
private final static Singleton INSTANCE = new Singleton();
private Singleton(){}
public static Singleton getInstance(){
return INSTANCE;
}
}
//Kotlin 饿汉模式
//关键字 “object” 定义单例,类加载时实例化对象,Singleton既是类名也是对象名,是饿汉模式的单例实现
object Singleton
(2)懒汉模式
//java 定义一个使用private的构造方法,并且用静态字段来持有这个类仅有的实例 懒汉模式
public class Singleton{
private static Singleton instance;
private Singleton(){}
public static synchronized Singleton getInstance(){
if(instance == null){
instance = new Singleton();
}
return instance;
}
}
//Kotlin 懒汉模式
class Singleton private constructor(){ //主构造方法
companion object{ //伴生对象
private var instance:Singleton ?= null
get(){
if(field == null){
field = Singleton()
}
return field
}
fun get():Singleton{
return instance!!
}
}
}
二、伴生对象
Kotlin 中的类不能拥有静态成员,即在 Kotlin 中是没有 static 关键字的,所以 Kotlin 中没有静态方法和静态成员。在kotlin中想要表达这种概念,可使用 包级别函数(顶层函数) 和 伴生对象
大多数情况下,推荐使用顶层函数来替代 Java 的静态方法,但是顶层函数不能访问类的 private 成员(包括 private 构造方法),这时使用伴生对象
companion object 关键字定义的伴生对象,可以直接通过容器类名称来访问这个对象的方法和属性,不需要显式地指明对象的名称。类似于Java中的静态方法调用。
伴生对象可以有名称(命名伴生对象),可以实现一个接口,可以有扩展函数或属性
(1)伴生对象语法形式:
class ClassName {
// 伴生对象名可以省略,默认为Companion
companion object 伴生对象名 {
// define field and method
}
}
伴生对象实例解析以及在kotlin和java代码中的调用:
class App {
companion object {
fun getAppContext() {}
}
}
// 反编译出的Java代码
public final class App {
public static final App.Companion Companion = new App.Companion((DefaultConstructorMarker)null);
public static final class Companion {
public final void getAppContext() {
}
private Companion() {
}
// $FF: synthetic method
public Companion(DefaultConstructorMarker $constructor_marker) {
this();
}
}
}
与对象声明类似,它们在kotlin和java代码中的调用方式也有点差别:
kotlin代码调用:App.getAppContext()
java代码调用:App.Companion.getAppContext();
(2)命名伴生对象
class A{
companion object B{ //命名伴生对象
fun bar(){
println("Compainon object called")
}
}
}
fun main(args:Array<String>){
A.bar() //通过包含伴生对象的类的名字来引用伴生对象
A.B.bar()
}
如果省略伴生对象的名字,默认的名字将会分配为 Companion,会在伴生对象扩展中使用。
class A{
companion object{
fun bar(){
println("Compainon object called")
}
}
}
fun main(args:Array<String>){
A.bar() //通过包含伴生对象的类的名字来引用伴生对象
A.Companion.bar() //未命名时,可通过Companion引用伴生对象
}
(3)在伴生对象中实现接口
interface F{
fun price()
}
class A{
companion object: F{
override fun price() {
println("A:::F:::price")
}
}
}
fun fun22(f:F){
f.price()
}
fun main(args:Array<String>){
fun22(A) //可将包含伴生对象的类的名字当作实现了该接口的对象实例
}
(4)伴生对象扩展
class A{
companion object{
}
}
fun A.Companion.bar(){
println("Compainon object called")
}
fun main(args:Array<String>){
A.bar() //通过包含伴生对象的类的名字来引用伴生对象
A.Companion.bar() //未命名时,可通过Companion引用伴生对象
}
三、对象表达式
对象表达式常用来作为匿名内部类的实现
与对象声明不同,匿名对象不是单例的,每次对象表达式被执行都会创建一个新的对象实例
Java 和 Kotlin 匿名内部类的区别:
//Java 使用匿名对象来实现事件监听器
button.setOnClickListener(new OnClickListener(){ //相当于实现了一个接口的匿名类
@Override
public void onClick(View v){
... ...
}
})
//Kotlin
button.setOnClickListener(object:OnClickListener{
override fun onClick(v:View){
... ...
}
}
)
与Java匿名内部类只能扩展一个类 或 实现一个接口 不同,Kotlin的匿名对象可以实现多个接口或者不实现接口
与Java的匿名类一样,在对象表达式中的代码可以访问创建它的函数中的变量,Java的访问被限制在 final 变量,Kotlin的匿名类访问并没有被限制在 final 变量。
四、扩展
有这样一个疑问,在对象声明和伴生对象中,java代码调用总会跟上INSTANCE或者Companion,直观上感觉不太友好,能不能像kotlin代码那样可以直接调用?
答案肯定是可以的。需要使用kotlin自带的注解: @JvmStatic 或者 @JvmField ,这样就可以和kotlin调用保持一致。
@JvmStatic既可以修饰属性,也可以修饰方法;而@JvmField只能修饰属性
————————————————
版权声明:本文为CSDN博主「浅唱整个春天」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/qq_32677531/article/details/126090224