Java中带有Document和BasicDBObject的泛型方法

我正在学习泛型，并试图在我正在从事的项目中编写泛型方法。我有一个用例，其中我有一个递归的方法，它完全相同，但参数类型不是Document就是BasicDBObject。这些参数具有嵌套的对象列表，因此它们中的每一个都具有Document或BasicDBObject类型的对象。因此，我用这两种类型重载了方法。我可以使用泛型将此方法更改为接受任何类型吗

public <T> String convertToRules(T rulesObj) {
    final StringBuilder expressionBuilder = new StringBuilder("${");
    if (rulesObj.getString("condition") != null) {
        String condition = rulesObj.getString("condition");
        if (rulesObj.get("rules") != null) {
           ArrayList<BasicDBObject> rules = (ArrayList<BasicDBObject>) rulesObj.get("rules");
           // rules can be ArrayList<BasicDBObject> or ArrayList<Document> so just mentioning them 
           // both here in question to avoid confusion of what type they are.
           ArrayList<Document> rules = (ArrayList<Document>) rulesObj.get("rules");
           rules.forEach(rule -> {
            // Some code
            expressionBuilder.append(convertToRules(rule));
       }
    }
 }

公共字符串转换器（T rulesObj）{
最终StringBuilder expressionBuilder=新StringBuilder（“${”）；
if（rulesObj.getString（“条件”）！=null）{
字符串条件=rulesObj.getString（“条件”）；
if（rulesObj.get（“规则”）！=null）{
ArrayList规则=（ArrayList）rulesObj.get（“规则”）；
//规则可以是ArrayList或ArrayList，所以只需提及它们即可
//这两个问题都是为了避免混淆它们是什么类型。
ArrayList规则=（ArrayList）rulesObj.get（“规则”）；
规则。forEach（规则->{
//一些代码
append（convertToRules（rule））；
}
}
}

当我试图将现有方法转换为泛型方法时，上面的代码中存在编译器错误。下面是实际的方法

public String convertToRules(BasicDBObject rulesObj) {
    final StringBuilder expressionBuilder = new StringBuilder("${");
    if (rulesObj.getString("condition") != null) {
        String condition = rulesObj.getString("condition");
        if (rulesObj.get("rules") != null) {
           ArrayList<BasicDBObject> rules = (ArrayList<BasicDBObject>) rulesObj.get("rules");
           rules.forEach(rule -> {
            // Some code
            expressionBuilder.append(convertToRules(rule));
       }
    }
 }


public String convertToRules(Document rulesObj) {
    final StringBuilder expressionBuilder = new StringBuilder("${");
    if (rulesObj.getString("condition") != null) {
        String condition = rulesObj.getString("condition");
        if (rulesObj.get("rules") != null) {
           ArrayList<Document> rules = (ArrayList<Document>) rulesObj.get("rules");
           rules.forEach(rule -> {
            // Some code
            expressionBuilder.append(convertToRules(rule));
       }
    }
 }

公共字符串转换器（基本CDBObObject rulesObj）{
最终StringBuilder expressionBuilder=新StringBuilder（“${”）；
if（rulesObj.getString（“条件”）！=null）{
字符串条件=rulesObj.getString（“条件”）；
if（rulesObj.get（“规则”）！=null）{
ArrayList规则=（ArrayList）rulesObj.get（“规则”）；
规则。forEach（规则->{
//一些代码
append（convertToRules（rule））；
}
}
}
公共字符串转换器（文档规则sobj）{
最终StringBuilder expressionBuilder=新StringBuilder（“${”）；
if（rulesObj.getString（“条件”）！=null）{
字符串条件=rulesObj.getString（“条件”）；
if（rulesObj.get（“规则”）！=null）{
ArrayList规则=（ArrayList）rulesObj.get（“规则”）；
规则。forEach（规则->{
//一些代码
append（convertToRules（rule））；
}
}
}

---

我很确定这不是正确的方法，需要一些关于如何实现这一点的指导。我想知道我是在思考泛型的正确方法，还是这个实现是错误的。

你可以为这两个类都创建一个抽象超类或接口。比如说，使用getString（）等常用方法的超类然后，重写这两个类中的方法。然后，对于泛型方法，您可以像一样为这两个类创建一个抽象超类或接口。比如说，使用诸如getString（）之类的常用方法创建超类然后，重写这两个类中的方法。然后对于泛型方法，可以将其设置为两个对象的契约

import java.util.List;

public interface RuleType<T> {
    String getString(String parameter);
    List<T> get(String param);
}

import java.util.List；
公共接口规则类型{
字符串getString（字符串参数）；
列表获取（字符串参数）；
}

基本对象

import java.util.ArrayList;
import java.util.List;

public class BasicDBObject implements RuleType<BasicDBObject> {

    @Override
    public String getString(String parameter) {
        return "Something";
    }

    @Override
    public List<BasicDBObject> get(String param) {
        return new ArrayList<>();
    }
}

import java.util.ArrayList；
导入java.util.List；
公共类BasicDBObject实现规则类型{
@凌驾
公共字符串getString（字符串参数）{
返回“某物”；
}
@凌驾
公共列表获取（字符串参数）{
返回新的ArrayList（）；
}
}

冲洗

import java.util.ArrayList;
import java.util.List;

public class Document implements RuleType<Document> {

    @Override
    public String getString(String parameter) {
        return "Something";
    }

    @Override
    public List<Document> get(String param) {
        return new ArrayList<>();
    }
}

import java.util.ArrayList；
导入java.util.List；
公共类文档实现规则类型{
@凌驾
公共字符串getString（字符串参数）{
返回“某物”；
}
@凌驾
公共列表获取（字符串参数）{
返回新的ArrayList（）；
}
}

通用方法（逻辑实现）

公共字符串转换器（T rulesObj）{
最终StringBuilder expressionBuilder=新StringBuilder（“${”）；
if（rulesObj.getString（“条件”）！=null）{
字符串条件=rulesObj.getString（“条件”）；
if（rulesObj.get（“规则”）！=null）{
列表规则=rulesObj.get（“规则”）；
规则。forEach（规则->
//一些代码
expressionBuilder.append（转换器规则）
);
}
}
返回expressionBuilder.toString（）；
}

规则类型-两个对象的契约

import java.util.List;

public interface RuleType<T> {
    String getString(String parameter);
    List<T> get(String param);
}

import java.util.List；
公共接口规则类型{
字符串getString（字符串参数）；
列表获取（字符串参数）；
}

基本对象

import java.util.ArrayList;
import java.util.List;

public class BasicDBObject implements RuleType<BasicDBObject> {

    @Override
    public String getString(String parameter) {
        return "Something";
    }

    @Override
    public List<BasicDBObject> get(String param) {
        return new ArrayList<>();
    }
}

import java.util.ArrayList；
导入java.util.List；
公共类BasicDBObject实现规则类型{
@凌驾
公共字符串getString（字符串参数）{
返回“某物”；
}
@凌驾
公共列表获取（字符串参数）{
返回新的ArrayList（）；
}
}

冲洗

import java.util.ArrayList;
import java.util.List;

public class Document implements RuleType<Document> {

    @Override
    public String getString(String parameter) {
        return "Something";
    }

    @Override
    public List<Document> get(String param) {
        return new ArrayList<>();
    }
}

import java.util.ArrayList；
导入java.util.List；
公共类文档实现规则类型{
@凌驾
公共字符串getString（字符串参数）{
返回“某物”；
}
@凌驾
公共列表获取（字符串参数）{
返回新的ArrayList（）；
}
}

通用方法（逻辑实现）

公共字符串转换器（T rulesObj）{
最终StringBuilder expressionBuilder=新StringBuilder（“${”）；
if（rulesObj.getString（“条件”）！=null）{
字符串条件=rulesObj.getString（“条件”）；
if（rulesObj.get（“规则”）！=null）{
列表规则=rulesObj.get（“规则”）；
规则。forEach（规则->
//一些代码
expressionBuilder.append（转换器规则）
);
}
}
返回expressionBuilder.toString（）；
}