Java 如何将具有不同参数的使用者添加到列表中？

我想收集一个可以操作不同参数的

处理器的列表

以下是一些示例类

public abstract class AbstractHistory { 
    public String getTlp() { return "";  }          
    }

public class SynchResourcConfig {
   public boolean isEnabled() { return true); }
  }

public class SynchClassTlpFilterConfig extends SynchResourcConfig {
    public String getClass() { return ""; } 
  }

public interface ConfigProcessingFilter<H extends AbstractHistory, C extends SynchResourceConfig> {
    public boolean shouldProcess(H history, C config);
}

public class ConfigProcessor<H extends AbstractHistory, C extends SynchResourceConfig> implements ConfigProcessingFilter<H, C> {

    private List<ConfigProcessingFilter<H, C>> filters = new ArrayList<>();

    public boolean shouldProcess(H history, C config) {
        return config.isEnabled() && filters.stream().anyMatch(
                (filter) -> filter.shouldProcess(history, config));
        }
    }

    public ConfigProcessor addFilter(ConfigProcessingFilter<H, C> filter) {
        filters.add(filter);
        return this;
    }
}

public class ClassTlpProcessingFilter<H extends AbstractHistory, C extends SynchClassTlpFilterConfig> extends ConfigProcessor<H, C> {

    public ClassTlpProcessingFilter() {
        addFilter((history, config) -> processByClassTlp(history, config));
    }

    public boolean processByClassTlp(AbstractHistory history, SynchClassTlpFilterConfig config) {
        return config.getClass().equals(history.getTlp());

    }
}

这是我希望列表中的每个元素实现的界面

public interface ConfigProcessingFilter {
    public boolean shouldProcess(AbstractHistory history, SynchResourceConfig config);
}

理想情况下，该类将容纳列表中的所有处理器

public interface ConfigProcessingFilter {
    public boolean shouldProcess(AbstractHistory history, SynchResourceConfig config);
}

其思想是，当调用“shouldProcess（）”时，它可以用包含的任何处理器的结果进行回复

public class ConfigProcessor {

    protected List<ConfigProcessingFilter> filters = new ArrayList<>();

    public boolean shouldProcess(AbstractHistory history, SynchResourceConfig config) {
        return config.isEnabled() && filters.stream().anyMatch(
            (filter) -> filter.shouldProcess(history, config));
    }

    public ConfigProcessor addFilter(ConfigProcessingFilter filter) {
        filters.add(filter);
        return this;
    }
}

看问题

该列表包含
ConfigProcessingFilter
。这些项中的每一项都有一个
shouldProcess（）
方法

我希望这将允许所描述类型的任何子类被接受为参数，但显然这是行不通的

有什么办法可以解决这个问题吗

提前谢谢
我想我知道怎么做了。如果我将元素的类型从最低的子类一直传播到父类，这似乎是可行的

使用类型参数更新界面

public abstract class AbstractHistory { 
    public String getTlp() { return "";  }          
    }

public class SynchResourcConfig {
   public boolean isEnabled() { return true); }
  }

public class SynchClassTlpFilterConfig extends SynchResourcConfig {
    public String getClass() { return ""; } 
  }

public interface ConfigProcessingFilter<H extends AbstractHistory, C extends SynchResourceConfig> {
    public boolean shouldProcess(H history, C config);
}

public class ConfigProcessor<H extends AbstractHistory, C extends SynchResourceConfig> implements ConfigProcessingFilter<H, C> {

    private List<ConfigProcessingFilter<H, C>> filters = new ArrayList<>();

    public boolean shouldProcess(H history, C config) {
        return config.isEnabled() && filters.stream().anyMatch(
                (filter) -> filter.shouldProcess(history, config));
        }
    }

    public ConfigProcessor addFilter(ConfigProcessingFilter<H, C> filter) {
        filters.add(filter);
        return this;
    }
}

public class ClassTlpProcessingFilter<H extends AbstractHistory, C extends SynchClassTlpFilterConfig> extends ConfigProcessor<H, C> {

    public ClassTlpProcessingFilter() {
        addFilter((history, config) -> processByClassTlp(history, config));
    }

    public boolean processByClassTlp(AbstractHistory history, SynchClassTlpFilterConfig config) {
        return config.getClass().equals(history.getTlp());

    }
}

公共接口配置处理过滤器{
公共布尔shouldProcess（H历史，C配置）；
}

处理器更新为在通用类型上运行

public abstract class AbstractHistory { 
    public String getTlp() { return "";  }          
    }

public class SynchResourcConfig {
   public boolean isEnabled() { return true); }
  }

public class SynchClassTlpFilterConfig extends SynchResourcConfig {
    public String getClass() { return ""; } 
  }

public interface ConfigProcessingFilter<H extends AbstractHistory, C extends SynchResourceConfig> {
    public boolean shouldProcess(H history, C config);
}

public class ConfigProcessor<H extends AbstractHistory, C extends SynchResourceConfig> implements ConfigProcessingFilter<H, C> {

    private List<ConfigProcessingFilter<H, C>> filters = new ArrayList<>();

    public boolean shouldProcess(H history, C config) {
        return config.isEnabled() && filters.stream().anyMatch(
                (filter) -> filter.shouldProcess(history, config));
        }
    }

    public ConfigProcessor addFilter(ConfigProcessingFilter<H, C> filter) {
        filters.add(filter);
        return this;
    }
}

public class ClassTlpProcessingFilter<H extends AbstractHistory, C extends SynchClassTlpFilterConfig> extends ConfigProcessor<H, C> {

    public ClassTlpProcessingFilter() {
        addFilter((history, config) -> processByClassTlp(history, config));
    }

    public boolean processByClassTlp(AbstractHistory history, SynchClassTlpFilterConfig config) {
        return config.getClass().equals(history.getTlp());

    }
}

公共类ConfigProcessor实现ConfigProcessingFilter{
私有列表筛选器=新的ArrayList（）；
公共布尔shouldProcess（H历史记录，C配置）{
返回config.isEnabled（）&&filters.stream（）.anyMatch(
（filter）->filter.shouldProcess（history，config））；
}
}
公共ConfigProcessor addFilter（ConfigProcessingFilter筛选器）{
过滤器。添加（过滤器）；
归还这个；
}
}

更新子类

public abstract class AbstractHistory { 
    public String getTlp() { return "";  }          
    }

public class SynchResourcConfig {
   public boolean isEnabled() { return true); }
  }

public class SynchClassTlpFilterConfig extends SynchResourcConfig {
    public String getClass() { return ""; } 
  }

public interface ConfigProcessingFilter<H extends AbstractHistory, C extends SynchResourceConfig> {
    public boolean shouldProcess(H history, C config);
}

public class ConfigProcessor<H extends AbstractHistory, C extends SynchResourceConfig> implements ConfigProcessingFilter<H, C> {

    private List<ConfigProcessingFilter<H, C>> filters = new ArrayList<>();

    public boolean shouldProcess(H history, C config) {
        return config.isEnabled() && filters.stream().anyMatch(
                (filter) -> filter.shouldProcess(history, config));
        }
    }

    public ConfigProcessor addFilter(ConfigProcessingFilter<H, C> filter) {
        filters.add(filter);
        return this;
    }
}

public class ClassTlpProcessingFilter<H extends AbstractHistory, C extends SynchClassTlpFilterConfig> extends ConfigProcessor<H, C> {

    public ClassTlpProcessingFilter() {
        addFilter((history, config) -> processByClassTlp(history, config));
    }

    public boolean processByClassTlp(AbstractHistory history, SynchClassTlpFilterConfig config) {
        return config.getClass().equals(history.getTlp());

    }
}

公共类ClassTlpProcessingFilter扩展了ConfigProcessor{
公共类TLPProcessingFilter（）{
addFilter（（历史记录，配置）->processByClassTlp（历史记录，配置））；
}
公共布尔processByClassTlp（抽象历史记录，SynchClassTlpFilterConfig配置）{
返回config.getClass（）.equals（history.getTlp（））；
}
}