Java中正确封装ViewDataBinding初始化代码的OOP实现方案

现有多个结构相似的类（如LoadElement、ErrorElement），它们都持有ViewDataBinding子类实例，初始化逻辑高度重复，包括绑定实例的创建、生命周期所有者的设置。尝试用抽象类封装时，出现了在父类构造器中调用非final/抽象方法的问题（违反Java规范，可能导致子类初始化未完成时方法被调用的风险）。

原重复代码示例：

public class LoadElement {

    LoadingElementBinding binding;

    public LoadElement(ViewGroup parent) {
        binding = LoadingElementBinding.inflate(
                       LayoutInflater.from(parent.getContext()),
                       parent,
                       false);
        binding.setLifecycleOwner(ViewTreeLifecycleOwner.get(parent));
    }

    public void doDomething() {
        // 操作binding的逻辑
    }
}

public class ErrorElement {

    ErrorElementBinding binding;

    public ErrorElement(ViewGroup parent) {
        binding = ErrorElementBinding.inflate(
                       LayoutInflater.from(parent.getContext()),
                       parent,
                       false);
        binding.setLifecycleOwner(ViewTreeLifecycleOwner.get(parent));
    }

    public void doDomething() {
        // 操作binding的逻辑
    }
}

最初的封装尝试（存在构造器调用非final方法的问题）：

public abstract class BindingElement <T extends ViewDataBinding>{

    T binding;

    public BindingElement (ViewGroup parent) {
        binding = createBinding(LayoutInflater.from(parent.getContext()), parent);
        binding.setLifecycleOwner(ViewTreeLifecycleOwner.get(parent));
    }

    abstract T createBinding(ViewGroup parent, LayoutInflater inflater);

    public void doDomething() {
        // 操作binding的逻辑
    }
}

public class LoadElement extends BindingElement<LoadingElementBinding>{

    public LoadElement(ViewGroup parent) {super(parent);}

    @Override 
    LoadingElementBinding createBinding(ViewGroup parent, LayoutInflater inflater){
       return LoadingElementBinding.inflate(
                       LayoutInflater.from(parent.getContext()),
                       parent,
                       false);
    }
}

针对构造器调用非final方法的问题，我们可以通过静态工厂方法或延迟初始化+显式初始化方法两种方式重构，既保证代码复用，又符合Java规范。

方法一：静态工厂方法（推荐） #

将子类的实例创建逻辑移到静态工厂中，父类通过构造器接收已创建的Binding实例，避免构造器调用子类方法。

重构后的抽象父类 #

public abstract class BindingElement<T extends ViewDataBinding> {
    protected final T binding;

    // 父类构造器仅接收已创建的Binding实例，完成通用初始化
    protected BindingElement(T binding, ViewGroup parent) {
        this.binding = binding;
        binding.setLifecycleOwner(ViewTreeLifecycleOwner.get(parent));
    }

    public void doDomething() {
        // 通用操作binding的逻辑
    }
}

子类实现（带静态工厂） #

public class LoadElement extends BindingElement<LoadingElementBinding> {
    // 私有构造器，仅允许工厂方法调用
    private LoadElement(LoadingElementBinding binding, ViewGroup parent) {
        super(binding, parent);
    }

    // 静态工厂方法，负责创建Binding并实例化子类
    public static LoadElement create(ViewGroup parent) {
        LoadingElementBinding binding = LoadingElementBinding.inflate(
                LayoutInflater.from(parent.getContext()),
                parent,
                false
        );
        return new LoadElement(binding, parent);
    }

    // 子类自定义逻辑
    @Override
    public void doDomething() {
        super.doDomething();
        // 子类特有的操作
    }
}

public class ErrorElement extends BindingElement<ErrorElementBinding> {
    private ErrorElement(ErrorElementBinding binding, ViewGroup parent) {
        super(binding, parent);
    }

    public static ErrorElement create(ViewGroup parent) {
        ErrorElementBinding binding = ErrorElementBinding.inflate(
                LayoutInflater.from(parent.getContext()),
                parent,
                false
        );
        return new ErrorElement(binding, parent);
    }
}

优点：

• 完全避免构造器调用子类方法的风险，所有初始化逻辑在工厂中完成，子类实例创建时状态完整
• 封装性更好，子类构造器私有，只能通过工厂方法创建，保证实例初始化的规范性
• 扩展灵活，工厂方法可以添加参数或做额外校验

方法二：显式初始化方法 #

父类提供初始化入口，子类实例创建后调用初始化方法，将原构造器中的逻辑移到初始化方法中，避免构造器阶段调用子类方法。

重构后的抽象父类 #

public abstract class BindingElement<T extends ViewDataBinding> {
    protected T binding;

    protected BindingElement() {
        // 空构造器，仅创建实例，不做初始化
    }

    // 通用初始化方法，设为final避免被子类重写，保证逻辑一致性
    protected final void initialize(T binding, ViewGroup parent) {
        this.binding = binding;
        binding.setLifecycleOwner(ViewTreeLifecycleOwner.get(parent));
    }

    public void doDomething() {
        // 通用操作逻辑
    }
}

子类实现 #

public class LoadElement extends BindingElement<LoadingElementBinding> {
    public LoadElement(ViewGroup parent) {
        LoadingElementBinding binding = LoadingElementBinding.inflate(
                LayoutInflater.from(parent.getContext()),
                parent,
                false
        );
        initialize(binding, parent);
    }

    // 子类自定义逻辑
    @Override
    public void doDomething() {
        super.doDomething();
        // 子类特有的操作
    }
}

优点：

• 保留了子类使用构造器创建的习惯，无需修改原有调用方的代码（如果原有代码是直接new LoadElement(parent)）
• 父类初始化逻辑通过final方法保证不可被篡改，维护性更强

两种方案都能解决构造器调用非final方法的问题，其中静态工厂方法更符合Java封装原则，推荐优先使用；如果需要兼容原有代码的实例创建方式，可以选择显式初始化方法方案。

内容的提问来源于stack exchange，提问作者Makc