Question

我正在尝试实现一个表示XML树的类，如下所示：

    public class XML<T extends XML<T>> {

        private final List<MarkupLanguage> nodeList = new ArrayList<>();

        private final Map<String, String> attributeList = new HashMap<>();

        public T attr(final String key, final String value) {
            if (value != null) {
                this.attributeList.put(key, value);
            } 
            return (T) this;
        }

        public T appendTo(final T node) {
            node.add(this);
            return (T) this;
        }
        ...
    }

我的问题是键入这些子句 - 我正在取消选中“for（T）this;”

当我尝试单独使用XML类时：

    final XML url = new XML("url");
    new XML("loc")
        .add("http://goout.cz")
        .appendTo(url);

我得到了：

    Unchecked cast to call appendTo(T) as a member of raw type XML.

如何改进我的代码以获得更好的输入？

Answer 1

只需输入：

final XML<T> url = new XML<T>("url");
new XML<T>("loc")
    .add("http://goout.cz")
    .appendTo(url);

看起来你真的想要XML<T>用于你的方法，而不是T，所以你可以避免演员表（但我可能错了）：

public XML<T> attr(String key, String value) {
    if (value != null) {
        this.attributeList.put(key, value);
    } 
    return this;
}

public XML<T> appendTo(XML<T> node) {
    node.add(this);
    return this;
}

Answer 2

下面的方法（简单继承加通用方法）如何：

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

import org.junit.Test;

public class XmlTest {

    @Test
    public void test() {
        XMLFirstSubclass url = new XMLFirstSubclass("url");
        XMLSecondSubclass xmlSecondSubclassInstance = new XMLSecondSubclass(
                "loc").add("http://goout.cz").appendTo(url);
    }
}

abstract class XML {

    private final List<String> texts = new ArrayList<String>();

    private final List<XML> nodes = new ArrayList<XML>();

    private final String nodeName;

    protected XML(String nodeName) {
        this.nodeName = nodeName;
    }

    @SuppressWarnings("unchecked")
    public <R extends XML> R add(String text) {
        texts.add(text);
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public <R extends XML, T extends XML> R add(T node) {
        nodes.add(node);
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public <R extends XML, T extends XML> R appendTo(T node) {
        node.add(this);
        return (R) this;
    }
}

class XMLFirstSubclass extends XML {
    public XMLFirstSubclass(String nodeName) {
        super(nodeName);
    }
}

class XMLSecondSubclass extends XML {
    public XMLSecondSubclass(String nodeName) {
        super(nodeName);
    }
}

请注意，泛型方法允许从一个类型T获取节点并返回实例的类型R，它可以与参数的类型不同。 T可以与R不同，但都继承XML。

关于问题中提出的方法的评论

你现在使用的方法可能导致奇怪的情绪化。让我们用一个例子说明这一点。

下面，我们尝试编写第一个专门研究XML的类：

public class XMLFirstSubclass extends XML<OtherXMLSubclass> { ... }

如果我们正在编写第一个XML子类，则OtherXMLSubclass唯一可能的值是XMLFirstSubclass，或者根本不声明泛型类型。

第一个选项：

public class XMLFirstSubclass extends XML<XMLFirstSubclass> { ... }

第二

public class XMLFirstSubclass extends XML { ... }

如果您选择在班级设计中使用泛型，第二种选择似乎很糟糕仔细研究第一个选项，它开启了获得子类的可能性：

class XMLSecondSubclass extends XML<XMLFirstSubclass> {
    ... 
}

请注意，这会完美编译，但会在运行时在XMLSecondSubclass方法调用中导致类强制转换异常。

Java中的递归泛型

2 个答案: