Java kotlin在同伴对象中抽象静态乐趣

我从一个名为UserViewHolder的官方示例学习ViewHolder的用法

public class UserViewHolder extends RecyclerView.ViewHolder {

static UserViewHolder create(LayoutInflater inflater, ViewGroup parent) {
    UserItemBinding binding = UserItemBinding
        .inflate(inflater, parent, false);
    return new UserViewHolder(binding);
  } 

  private UserItemBinding mBinding;

  private UserViewHolder(UserItemBinding binding) {
    super(binding.getRoot());
    mBinding = binding;
  }

  public void bindTo(User user) {
    mBinding.setUser(user);
    mBinding.executePendingBindings();
  }

}

我将要编写许多

ViewHolder

类，因此我希望能够编写一个抽象类。在Java中，它看起来像：

public abstract  static class BaseViewHolder {

abstract static BaseViewHolder create()

abstract void bindTo()

}

我尝试使用Kotlin编写它，但最后我发现它没有Java中那么简单

abstract class BaseViewHolder(itemView: View):RecyclerView.ViewHolder(itemView) {

abstract fun bindTo(viewModel: BaseViewModel)

}

在Kotlin中，如果我想要一个静态函数，我需要在“companion objects”中编写该函数。但它不能是“抽象的”

在Java中，带有抽象类的抽象类很常见

但是我怎么能用Kotlin写呢

更新：

我已经写了我自己的SleepViewHolder。我将要写很多的ViewHolder，比如AppleViewHolder，BananaViewHolder等等。因此，我想构建一个BaseViewHolder作为一个模式。我的问题是，在这种情况下，编写模式BaseViewHolder的最佳方法是什么？我应该更改它的构造，还是将创建函数公开

open class SleepViewHolder private constructor(private val binding: ItemSleepBinding)
: RecyclerView.ViewHolder(binding.root) {

companion object {
    @JvmStatic
    fun create(inflater: LayoutInflater, parent: ViewGroup): SleepViewHolder {

        val binding: ItemSleepBinding
                = DataBindingUtil.inflate(inflater, R.layout.fragment_base, parent, false)

        return SleepViewHolder(binding)
    }
}

open fun bindTo(viewmodel: SleepViewModel) {
    binding.vm = viewmodel
    binding.executePendingBindings()
}

---

}在

Kotlin

中，与

Java或C#不同，

类没有静态方法。在大多数情况下，建议只使用包级函数

如果您需要编写一个可以在没有类实例的情况下调用的函数，但需要访问类的内部（例如，工厂方法），则可以将其作为该类内对象声明的成员来编写

更具体地说，如果在类中声明一个伴生对象，则可以使用与在

Java/C

中调用静态方法相同的语法调用其成员，只使用类名作为限定符

这就是如何编写同伴类的方法

class MyClass {
   companion object { } // will be called "Companion"
}
fun MyClass.Companion.foo() { // ...
}

这就是调用foo（）函数的方式

MyClass.foo()

---

默认情况下，嵌套类在Kotlin中是静态的。因此，您不必在类名之前添加任何修饰符。您可以参考下面我给出的示例作为起点

注意：

ItemFruit

是

ItemApple

和

ItemBanana

class ExampleAdapter: RecyclerView.Adapter<ExampleAdapter.BaseViewHolder<ItemFruit>>(){

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): DynamicSpinnerAdapter.ViewHolder {
        when(viewType){
            VIEW_TYPE_BANANA -> BananaViewHolder(....)  // Inflate your view Banana layout here
            VIEW_TYPE_APPLE  -> AppleViewHolder(....)   // Inflate your view Banana layout here
            else             ->                         // Do something for default case
        }
    }

    override fun onBindViewHolder(holder: BaseViewHolder<ItemFruit>, position: Int){
        holder.bind(itemAppleOrBanana)      // binds your item to corresponding view
    }

    override fun getItemViewType(position: Int): Int {
        return when (position){
            condition_banana -> VIEW_TYPE_BANANA
            condition_apple  -> VIEW_TYPE_BANANA
            else             -> VIEW_TYPE_NONE
        }
    }

    inner class BananaViewHolder(itemView: View): BaseViewHolder<ItemBanana>(itemView) {
        override fun bind(item: ItemBanana) {
            // Implement your logic
        }

    }
    inner class AppleViewHolder(itemView: View): BaseViewHolder<ItemApple>(itemView) {
        override fun bind(item: ItemApple) {
            // Implement your logic
        }

    }
    inner abstract class BaseViewHolder<T>(itemView: View) : RecyclerView.ViewHolder(itemView){

        internal abstract fun bind(item: T)
    }

    internal abstract inner class GenericViewHolder<T>(itemView: View) :
        RecyclerView.ViewHolder(itemView) {

        internal abstract fun bind(item: T, position: Int)
    }
}

class-ExampleAdapter:RecyclerView.Adapter（）{
重写CreateViewHolder（父级：ViewGroup，viewType:Int）：DynamicsInnerAdapter.ViewHolder{
何时（视图类型）{
查看\u类型\u香蕉->BananaViewHolder（..）//在此处展开视图香蕉布局
查看\u TYPE\u APPLE->AppleViewHolder（..）//在此处展开视图布局
else->//为默认情况做一些事情
}
}
覆盖BindViewHolder（holder:BaseViewHolder，位置：Int）{
bind（itemappleorbana）//将项目绑定到相应的视图
}
覆盖getItemViewType（位置：Int）：Int{
返回时（位置）{
条件\u香蕉->查看\u类型\u香蕉
条件\u苹果->视图\u类型\u香蕉
其他->查看\类型\无
}
}
内部类BananaViewHolder（itemView:View）：BaseViewHolder（itemView）{
覆盖趣味绑定（项目：ItemBanana）{
//实现你的逻辑
}
}
内部类AppleViewHolder（itemView:View）：BaseViewHolder（itemView）{
覆盖趣味绑定（项目：ItemApple）{
//实现你的逻辑
}
}
内部抽象类BaseViewHolder（itemView:View）：RecyclerView.ViewHolder（itemView）{
内部抽象趣味绑定（项目：T）
}
内部抽象内部类GenericViewHolder（itemView:View）：
RecyclerView.ViewHolder（itemView）{
内部抽象趣味绑定（项目：T，位置：Int）
}
}

，首先我们不能使用抽象的静态方法。因此，即使在科特林，这也是不可能的。您也可以参考此链接：

静态

函数不能是

抽象的

，无论是在kotlin还是在java@Lovis谢谢，我找错地方了。@Lovis但是静态类可以。仅供参考