Kotlin -＞ object声明和object表达式

核心区别总结

详细对比代码

1. 具名单例对象 - 全局声明

object ImmediateStart : StartStrategy {
    override operator fun invoke(block: suspend () -> Unit) {
        println("ImmediateStart: ${this.hashCode()}")
    }
}

2. 匿名对象表达式 - 局部创建

class TestClass {
    fun testDifference() {
        val anonymous1 = object : StartStrategy {
            override operator fun invoke(block: suspend () -> Unit) {
                println("Anonymous1: ${this.hashCode()}")
            }
        }
        
        val anonymous2 = object : StartStrategy {
            override operator fun invoke(block: suspend () -> Unit) {
                println("Anonymous2: ${this.hashCode()}")
            }
        }
        
        // 验证实例数量
        val singleton1 = ImmediateStart
        val singleton2 = ImmediateStart
        
        println("=== 单例对象测试 ===")
        println("singleton1 === singleton2: ${singleton1 === singleton2}")  // true
        singleton1 { }  // 输出相同hashCode
        singleton2 { }  // 输出相同hashCode
        
        println("\n=== 匿名对象测试 ===")
        println("anonymous1 === anonymous2: ${anonymous1 === anonymous2}")  // false
        anonymous1 { }  // 输出不同hashCode
        anonymous2 { }  // 输出不同hashCode
    }
}

字节码层面的区别

object声明编译后

public final class ImmediateStart implements StartStrategy {
    public static final ImmediateStart INSTANCE = new ImmediateStart();
    private ImmediateStart() {}  // 私有构造函数，确保单例
    // ...
}

object表达式编译后

// 每次调用都会生成类似这样的代码：
new StartStrategy() {  // 每次new一个新实例
    @Override
    public Object invoke(Function0 block) {
        // ...
    }
}

实际应用场景对比

class NetworkManager {
    
    // 场景1: 全局策略配置 - 使用object声明
    companion object {
        val DEFAULT_STRATEGY = ImmediateStart  // 全局共享同一个实例
    }
    
    // 场景2: 临时策略定制 - 使用object表达式
    fun createCustomStrategy(delay: Long): StartStrategy {
        return object : StartStrategy {  // 每次调用创建新实例
            override operator fun invoke(block: suspend () -> Unit) {
                GlobalScope.launch {
                    delay(delay)
                    block()
                }
            }
        }
    }
    
    fun demonstrateUsage() {
        // 单例使用
        val strategy1 = DEFAULT_STRATEGY
        val strategy2 = DEFAULT_STRATEGY
        println("Same instance: ${strategy1 === strategy2}")  // true
        
        // 匿名对象使用
        val custom1 = createCustomStrategy(1000)
        val custom2 = createCustomStrategy(1000)
        println("Different instances: ${custom1 === custom2}")  // false
    }
}

内存和性能影响

class PerformanceTest {
    
    fun testMemoryUsage() {
        // 单例对象 - 内存友好
        repeat(1000) {
            val strategy = ImmediateStart  // 始终引用同一个实例
            // 没有额外内存分配
        }
        
        // 匿名对象 - 可能造成内存压力
        repeat(1000) {
            val strategy = object : StartStrategy {  // 每次创建新对象
                override operator fun invoke(block: suspend () -> Unit) {}
            }
            // 创建了1000个不同的对象实例
        }
    }
}