Android 让一个类实现多个观察者

我实现了一个片段，它最初实现了android.arch.lifecycle.Observer，我想开始观察其他一些实时数据，但不能。我从这个开始：

class MyFragment : BaseFragment(), Observer<FragmentData> {
  lateinit var viewModel: MyViewModel

  override fun onActivityCreated(savedInstanceState: Bundle?) {
    viewModel.fragmentData.observe(this, this)
  }

  override fun onChanged(data: FragmentData?) {
    activity?.title = getTitleFromData(data)
  }
}

类MyFragment:BaseFragment（），观察者{
lateinit var viewModel:MyViewModel
覆盖活动创建的乐趣（savedInstanceState:Bundle？）{
viewModel.fragmentData.observe（这个，这个）
}
覆盖更改后的乐趣（数据：碎片数据？）{
活动？.title=getTitleFromData（数据）
}
}

如果我更新类以包含其他可观察数据，如下所示：

class MyFragment : BaseFragment(), Observer<FragmentData>, Observer<OtherData> {
  lateinit var viewModel: MyViewModel

  override fun onActivityCreated(savedInstanceState: Bundle?) {
    viewModel.fragmentData.observe(this, this)
  }

  override fun onChanged(otherData: OtherData) {
    // update UI from otherData
  }

  override fun onChanged(data: FragmentData?) {
    activity?.title = getTitleFromData(data)
  }
}

class MyFragment : BaseFragment(), Observer<Any> {...} 

类MyFragment:BaseFragment（），观察者，观察者{
lateinit var viewModel:MyViewModel
覆盖活动创建的乐趣（savedInstanceState:Bundle？）{
viewModel.fragmentData.observe（这个，这个）
}
更改后覆盖乐趣（其他数据：其他数据）{
//从其他数据更新UI
}
覆盖更改后的乐趣（数据：碎片数据？）{
活动？.title=getTitleFromData（数据）
}
}

我得到一个错误：

“Observer”的类型参数T的值不一致： 碎片数据，其他数据 超类型出现两次

我想要一些帮助来理解为什么编译器不能区分类型之间的差异，并想知道最佳的替代模式

像这样的

viewModel.fragmentData.observe(this, fragmentDataObserver)

private val fragmentDataObserver = Observer<Fragmentdata> {
   activity?.title = getTitleFromData(it)
}

viewModel.fragmentData.observe（这是fragmentDataObserver）
私有val fragmentDataObserver=观察者{
活动？.title=getTitleFromData（it）
}

由于类型擦除，编译器无法识别类型之间的差异。当您的程序编译时，几乎所有的通用信息都会从类中剥离出来。不再有

观察者

和

观察者

，只有一个

观察者

类。现在，如果没有类型擦除，像这样的事情是可能的

class MyFragment : BaseFragment(), Observer<FragmentData>, Observer<OtherData> {
   override fun onChanged(otherData: OtherData) {
      // update UI from otherData
    }

    override fun onChanged(data: FragmentData?) {
      activity?.title = getTitleFromData(data)
    }
}

类MyFragment:BaseFragment（），观察者，观察者{
更改后覆盖乐趣（其他数据：其他数据）{
//从其他数据更新UI
}
覆盖更改后的乐趣（数据：碎片数据？）{
活动？.title=getTitleFromData（数据）
}
}

但是一旦你应用了类型擦除，那么你基本上是在尝试两次扩展同一个类，并为同一个基方法提供两个不同的重写方法，这是不允许的。这就是为什么编译器不让你这么做。这是我用有限的知识所能给出的最准确的描述

至于另一种选择，如注释所建议的，尝试使用lambda，而不是尝试使片段本身成为双观察者

class MyFragment : BaseFragment(), Observer<OtherData> {
    lateinit var viewModel: MyViewModel

    override fun onActivityCreated(savedInstanceState: Bundle?) {
        super.onActivityCreated(savedInstanceState)
        viewModel.fragmentData.observe(this, Observer { onChanged(it) })
    }

    override fun onChanged(otherData: OtherData?) {
        // update UI from otherData
    }

    private fun onChanged(data: FragmentData?) {
        activity?.title = getTitleFromData(data)
    }
}

类MyFragment:BaseFragment（），观察者{
lateinit var viewModel:MyViewModel
覆盖活动创建的乐趣（savedInstanceState:Bundle？）{
super.onActivityCreated（savedInstanceState）
viewModel.fragmentData.observe（this，observator{onChanged（it）}）
}
更改后覆盖乐趣（其他数据：其他数据？）{
//从其他数据更新UI
}
更改了私人娱乐（数据：碎片数据？）{
活动？.title=getTitleFromData（数据）
}
}

您可以尝试实现如下通用观察者界面：

class MyFragment : BaseFragment(), Observer<FragmentData>, Observer<OtherData> {
  lateinit var viewModel: MyViewModel

  override fun onActivityCreated(savedInstanceState: Bundle?) {
    viewModel.fragmentData.observe(this, this)
  }

  override fun onChanged(otherData: OtherData) {
    // update UI from otherData
  }

  override fun onChanged(data: FragmentData?) {
    activity?.title = getTitleFromData(data)
  }
}

class MyFragment : BaseFragment(), Observer<Any> {...} 

第二种解决方法是创建OtherData和FragmentData的父类，FatherInterface只是一个在主体中没有任何内容的接口：

interface OtherData: FatherInterface{}...
interface FragmentData : FatherInterface{}...

那你就可以了

class MyFragment : BaseFragment(), Observer<FatherInterface>{}...

override fun onChanged(fatherInterface: FatherInterface?) {
    when{
        fatherInterface is OtherData -> ...
        fatherInterface is FragmentData -> ...
    }
    // update UI from otherData
}

类MyFragment:BaseFragment（），观察者{}。。。
更改后覆盖乐趣（父接口：父接口？）{
什么时候{
父界面是其他数据->。。。
父界面是碎片数据->。。。
}
//从其他数据更新UI
}

您应该能够只为您的

观察者使用lambda

。当我想要划分的这两个观察值的数据发生变化时，需要做大量的工作。我不喜欢将所有内容都塞进onActivityCreated（）中的想法，因此，让lambda调用另一个完成大部分工作的函数。或使用函数引用：。您尝试使用单独的泛型实现两次接口在Java中也失败了：

public class Scrap implements Observer，Observer

导致“duplicate class”语法错误。