Android 如何将MediatorLiveData与抽象源一起使用

我有一个抽象类，里面有一个

MediatorLiveData

对象。此对象有多个源，其中一个源依赖于childs类，并且在父类中是

抽象的

。 在

init

块中添加源代码会在运行时导致NullPointerException，因为在init块添加源代码时，它仍然是抽象的（或者我一直认为是抽象的）

有没有一种方法可以使用

摘要
LiveData
作为
MediatorLiveData
的源，而不必在子类中设置该源？我只想
覆盖val
并完成它，因为将来某个时候我肯定会忘记调用
addSources（）
函数

（我知道这个例子不是做这件事最有用的方法，但我不想增加不必要的复杂性）

例如：

abstract class MyClass: ViewModel(){
    private val _myMediator = MediatorLiveData<String>()
    
    protected abstract val mySource: LiveData<String>
    
    val myObservable: LiveData<String>
        get() = _myMediator
    
    // This will cause a NullPointerException at runtime
    init{
        _myMediator.addSource(mySource){ _myMediator.value = it }
    }
    
    //This should work, but requires this to be called in child class
    protected fun addSources(){
        _myMediator.addSource(mySource){ _myMediator.value = it }
    }
}

class myChild: MyClass(){
    override val mySource = Transformations.map(myRepository.someData) { it.toString() }
    
    // This is where init { addSources() } would be called
}

抽象类MyClass:ViewModel（）{
private val_myMediator=MediatorLiveData（）
受保护的抽象val mySource:LiveData
val myObservable:LiveData
get（）=\u myMediator
//这将在运行时导致NullPointerException
初始化{
_myMediator.addSource（mySource）{u myMediator.value=it}
}
//这应该是可行的，但需要在子类中调用它
受保护的数据源（）{
_myMediator.addSource（mySource）{u myMediator.value=it}
}
}
类myChild:MyClass（）{
重写val mySource=Transformations.map（myRepository.someData）{it.toString（）}
//这是调用init{addSources（）}的地方
}

在读了Stachu的anwser之后，我决定采用这个，我没有测试，但我认为应该可行：

abstract class MyFixedClass: ViewModel(){
    private val _myMediator: MediatorLiveData<String> by lazy{
        MediatorLiveData<String>().apply{
            addSource(mySource){ this.value = it }
        }
    }

    protected abstract val mySource: LiveData<String>

    val myObservable: LiveData<String>
        get() = _myMediator
}

class MyChild: MyFixedClass(){
    override val mySource = Transformations.map(myRepository.someData) { it.toString() }
}

抽象类MyFixedClass:ViewModel（）{
private val_myMediator:MediatorLiveData by lazy{
MediatorLiveData（）.apply{
addSource（mySource）{this.value=it}
}
}
受保护的抽象val mySource:LiveData
val myObservable:LiveData
get（）=\u myMediator
}
类MyChild:MyFixedClass（）{
重写val mySource=Transformations.map（myRepository.someData）{it.toString（）}
}
如何使用惰性评估，例如这样的东西

abstract class MyClass : ViewModel() {
    private val _myMediator = MediatorLiveData<String>()
    private val _mySource: LiveData<String> by lazy { mySource() }
    protected abstract fun mySource(): LiveData<String>
    val myObservable: LiveData<String>
        get() = _myMediator
    init {
        _myMediator.addSource(_mySource) { _myMediator.value = it }
    }
}

class myChild : MyClass() {
    override fun mySource() = Transformations.map(myRepository.someData) { it.toString() }
}

抽象类MyClass:ViewModel（）{
private val_myMediator=MediatorLiveData（）
private val_mySource:LiveData by lazy{mySource（）}
受保护的抽象fun mySource（）：LiveData
val myObservable:LiveData
get（）=\u myMediator
初始化{
_myMediator.addSource（_mySource）{{u myMediator.value=it}
}
}
类myChild:MyClass（）{
重写fun mySource（）=Transformations.map（myRepository.someData）{it.toString（）}
}
如何使用惰性评估，例如这样的东西

abstract class MyClass : ViewModel() {
    private val _myMediator = MediatorLiveData<String>()
    private val _mySource: LiveData<String> by lazy { mySource() }
    protected abstract fun mySource(): LiveData<String>
    val myObservable: LiveData<String>
        get() = _myMediator
    init {
        _myMediator.addSource(_mySource) { _myMediator.value = it }
    }
}

class myChild : MyClass() {
    override fun mySource() = Transformations.map(myRepository.someData) { it.toString() }
}

抽象类MyClass:ViewModel（）{
private val_myMediator=MediatorLiveData（）
private val_mySource:LiveData by lazy{mySource（）}
受保护的抽象fun mySource（）：LiveData
val myObservable:LiveData
get（）=\u myMediator
初始化{
_myMediator.addSource（_mySource）{{u myMediator.value=it}
}
}
类myChild:MyClass（）{
重写fun mySource（）=Transformations.map（myRepository.someData）{it.toString（）}
}
最终导致MediatorLiveData变懒，因为我认为在您的示例中，
mySource（）
可能在被重写之前被调用。我会提出这个问题。谢谢由于我认为在您的示例中，
mySource（）
可能会在被重写之前被调用，因此最终导致MediatorLiveData变懒。我会提出这个问题。谢谢