Android Kotlin：网络状态监听场景下接口变量初始化与调用问题

我有一个监听网络连接状态变化的BaseActivity，代码如下：

class BaseActivity : AppCompatActivity() {
    private val connectivityLiveStatus: ConnectionLiveStatus = ConnectionLiveStatus(this)

    init {
        observeConnectivity()
    }

    private fun observeConnectivity(){
        connectivityLiveStatus.observe(this , Observer {status ->
             handleConnectivityStatus()  
        })
    }
    private fun handleConnectivityStatus(){}
}

我希望MainActivity继承该BaseActivity来实现自定义的网络状态变化处理，但MainActivity已经继承了AppCompatActivity，而Kotlin不支持多继承。因此我创建了BaseActivityListener接口：

interface BaseActivityListener {
    fun handleNetworkConnectivityChange(status : Boolean)
}

并让MainActivity实现该接口：

class MainActivity : AppCompatActivity() , BaseActivityListener {

lateinit var movieViewModel : MoviesViewModel
lateinit var moviesAdapter : MoviesAdapter
lateinit var movieRecyclerView: RecyclerView
lateinit var connectivityLiveStatus: ConnectionLiveStatus
private var pageAlreadyLoaded = false

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    init()
}

override fun handleNetworkConnectivityChange(status: Boolean) {
    TODO("handle network connectivity change")
}

现在的问题是：网络状态变化的逻辑仅在BaseActivity中，我想从BaseActivity调用接口的handleNetworkConnectivityChange方法，但不知道在Kotlin中如何初始化该接口对象（Java中可以用new操作符实现）。另外，我知道用接口会造成紧耦合，这种场景还有其他实现方式吗？

一、Kotlin中初始化接口对象的方式 #

在Kotlin中，你可以通过对象表达式创建接口的匿名实现类实例，语法无需new关键字，和Java匿名内部类逻辑一致：

方式1：直接创建匿名实现类 #

如果需要临时调用接口方法，可以直接创建匿名实例：

// 示例：创建接口匿名实现类并调用方法
val tempListener = object : BaseActivityListener {
    override fun handleNetworkConnectivityChange(status: Boolean) {
        // 临时处理逻辑
    }
}
tempListener.handleNetworkConnectivityChange(true)

方式2：让BaseActivity持有接口引用（更合理的业务场景用法） #

核心修正：你之前的误区是让MainActivity直接继承AppCompatActivity——Kotlin单继承规则下，MainActivity应该继承BaseActivity（而BaseActivity已经继承了AppCompatActivity），这样就不存在多继承冲突。然后让BaseActivity持有接口引用，就能调用实现类的方法：

1. 修改BaseActivity，添加接口引用变量：

class BaseActivity : AppCompatActivity() {
    private val connectivityLiveStatus: ConnectionLiveStatus = ConnectionLiveStatus(this)
    // 声明可空的接口引用
    var connectivityListener: BaseActivityListener? = null

    init {
        observeConnectivity()
    }

    private fun observeConnectivity(){
        connectivityLiveStatus.observe(this , Observer {status ->
             // 调用接口方法，用?.避免空指针
             connectivityListener?.handleNetworkConnectivityChange(status)
        })
    }
}

2. 修正MainActivity的继承关系，并将自身设置为接口实现：

// 改为继承BaseActivity，而非直接继承AppCompatActivity
class MainActivity : BaseActivity() , BaseActivityListener {

    // ... 原有成员变量

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        init()
        // 将当前Activity实例赋值给BaseActivity的接口引用
        connectivityListener = this
    }

    override fun handleNetworkConnectivityChange(status: Boolean) {
        // 这里编写MainActivity自定义的网络状态处理逻辑
        if (status) {
            if (!pageAlreadyLoaded) {
                // 网络恢复时加载数据
            }
        } else {
            // 网络断开时显示提示
        }
    }
}

二、避免紧耦合的替代实现方案 #

方案1：使用高阶函数（推荐，Kotlin风格） #

无需定义接口，直接将网络状态处理逻辑作为函数参数传递给BaseActivity，耦合度更低：

1. 修改BaseActivity：

class BaseActivity : AppCompatActivity() {
    private val connectivityLiveStatus: ConnectionLiveStatus = ConnectionLiveStatus(this)
    // 声明高阶函数变量，接收Boolean类型的状态参数
    var onConnectivityChanged: ((Boolean) -> Unit)? = null

    init {
        observeConnectivity()
    }

    private fun observeConnectivity(){
        connectivityLiveStatus.observe(this , Observer {status ->
             // 调用高阶函数
             onConnectivityChanged?.invoke(status)
        })
    }
}

2. 在MainActivity中直接赋值处理逻辑：

class MainActivity : BaseActivity() {

    // ... 原有成员变量

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        init()
        
        // 直接定义网络状态变化的处理逻辑
        onConnectivityChanged = { status ->
            if (status) {
                // 网络恢复的处理逻辑
            } else {
                // 网络断开的处理逻辑
            }
        }
    }
}

方案2：全局LiveData监听 #

把网络状态封装成全局单例LiveData，任何需要监听的组件都可以直接观察，完全解耦BaseActivity和业务页面：

1. 创建单例网络管理类：

object NetworkManager {
    private lateinit var connectivityLiveStatus: ConnectionLiveStatus

    fun init(context: Context) {
        connectivityLiveStatus = ConnectionLiveStatus(context)
    }

    fun getConnectivityLiveData(): LiveData<Boolean> {
        return connectivityLiveStatus
    }
}

2. 在Application中初始化：

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        NetworkManager.init(this)
    }
}

3. 在MainActivity中直接观察：

class MainActivity : AppCompatActivity() {

    // ... 原有成员变量

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        init()
        
        // 监听网络状态变化
        NetworkManager.getConnectivityLiveData().observe(this) { status ->
            // 自定义处理逻辑
        }
    }
}

方案3：EventBus事件传递（适合复杂跨组件场景，不推荐轻量场景） #

如果项目已使用EventBus，可以通过发送事件传递网络状态：

1. 在BaseActivity中发送事件：

private fun observeConnectivity(){
    connectivityLiveStatus.observe(this , Observer {status ->
         EventBus.getDefault().post(NetworkStatusEvent(status))
    })
}

2. 创建事件数据类：

data class NetworkStatusEvent(val isConnected: Boolean)

3. 在MainActivity中注册并接收事件：

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        EventBus.getDefault().register(this)
    }

    @Subscribe(threadMode = ThreadMode.MAIN)
    fun onNetworkStatusChanged(event: NetworkStatusEvent) {
        // 处理网络状态变化逻辑
    }

    override fun onDestroy() {
        super.onDestroy()
        EventBus.getDefault().unregister(this)
    }
}

内容的提问来源于stack exchange，提问作者Saneen K P