java接口避免强制转换

我有两节课。实现“Node”的接口类“Node”和“Nodegraph”。“Node”有一个参数化方法add，其中我使用Node Node作为参数。在NodeGraph中，我需要强制转换（NodeGraph）节点以使用NodeGraph对象。有没有更好的方法来避免铸造

import java.util.Set;

public interface Node {
    public String getId();
    public void add(Node node);
    public boolean remove(Node node);
}


import java.util.Iterator;
import java.util.LinkedList;

public class NodeGraph implements Node {

    private int row;
    private int column;
    private String id;
    private LinkedList<NodeGraph> neighbourds = new LinkedList<NodeGraph>();

    public NodeGraph(int row, int column) {
        this.row = row;
        this.column = column;
        id = "" + row + column;
    }

    @Override
    public String getId() {
        return id;
    }

    @Override
    public void add(Node node) {
        neighbourds.add((NodeGraph) node);
    }

    @Override
    public boolean remove(Node node) {
        return neighbourds.remove((NodeGraph) node);
    }

}

import java.util.Set；
公共接口节点{
公共字符串getId（）；
公共作废新增（节点）；
公共布尔移除（节点）；
}
导入java.util.Iterator；
导入java.util.LinkedList；
公共类NodeGraph实现节点{
私人int row；
私有int列；
私有字符串id；
私有LinkedList Neigurds=新LinkedList（）；
公共节点图（int行，int列）{
this.row=行；
this.column=列；
id=”“+行+列；
}
@凌驾
公共字符串getId（）{
返回id；
}
@凌驾
公共无效添加（节点）{
添加（（NodeGraph）节点）；
}
@凌驾
公共布尔删除（节点）{
返回neighbords.remove（（NodeGraph）节点）；
}
}

发生这种情况是因为

邻域列表是不变的，这意味着您只能插入参数化类型，即
NodeGraph
。在这种情况下，将列表定义为
节点的协变将允许您添加
节点的任何子类：

private LinkedList<? extends Node> neighbourds = new LinkedList<>();

private List<Node> neighbourds = new LinkedList<>();

private LinkedList这是因为
neigurds
列表是不变的，这意味着您只能插入参数化类型，即
NodeGraph
。在这种情况下，将列表定义为
Node
的协变将允许您添加
Node
的任何子类：

private LinkedList<? extends Node> neighbourds = new LinkedList<>();

private List<Node> neighbourds = new LinkedList<>();

private LinkedList您应该使用接口声明
邻居
列表（对于
列表
和
节点
）：

private-List-neighturds=new-LinkedList（）；
您应该使用界面声明
邻居
列表（对于
列表
和
节点
）：

private-List-neighturds=new-LinkedList（）；
我假设您有正当理由将
邻域
列表绑定到
节点图
类型。
如果是这样，则可以通过参数化节点接口来避免强制转换：

public interface Node< T extends Node<T> > {
    public String getId();
    public void add(T node);
    public boolean remove(T node);
}

public class NodeGraph implements Node<NodeGraph> {

    private int row;
    private int column;
    private String id;
    private LinkedList<NodeGraph> neighbourds = new LinkedList<NodeGraph>();

    public NodeGraph(int row, int column) {
        this.row = row;
        this.column = column;
        id = "" + row + column;
    }

    @Override
    public String getId() {
        return id;
    }

    @Override
    public void add(NodeGraph node) {
        neighbourds.add(node);
    }

    @Override
    public boolean remove(NodeGraph node) {
        return neighbourds.remove(node);
    }
}

公共接口节点{
公共字符串getId（）；
公共无效添加（T节点）；
公共布尔移除（T节点）；
}
公共类NodeGraph实现节点{
私人int row；
私有int列；
私有字符串id；
私有LinkedList Neigurds=新LinkedList（）；
公共节点图（int行，int列）{
this.row=行；
this.column=列；
id=”“+行+列；
}
@凌驾
公共字符串getId（）{
返回id；
}
@凌驾
公共void添加（NodeGraph节点）{
添加（节点）；
}
@凌驾
公共布尔删除（NodeGraph节点）{
返回邻域。删除（节点）；
}
}
我假设您有正当理由将
邻域
列表绑定到
节点图
类型。
如果是这样，则可以通过参数化节点接口来避免强制转换：

public interface Node< T extends Node<T> > {
    public String getId();
    public void add(T node);
    public boolean remove(T node);
}

public class NodeGraph implements Node<NodeGraph> {

    private int row;
    private int column;
    private String id;
    private LinkedList<NodeGraph> neighbourds = new LinkedList<NodeGraph>();

    public NodeGraph(int row, int column) {
        this.row = row;
        this.column = column;
        id = "" + row + column;
    }

    @Override
    public String getId() {
        return id;
    }

    @Override
    public void add(NodeGraph node) {
        neighbourds.add(node);
    }

    @Override
    public boolean remove(NodeGraph node) {
        return neighbourds.remove(node);
    }
}

公共接口节点{
公共字符串getId（）；
公共无效添加（T节点）；
公共布尔移除（T节点）；
}
公共类NodeGraph实现节点{
私人int row；
私有int列；
私有字符串id；
私有LinkedList Neigurds=新LinkedList（）；
公共节点图（int行，int列）{
this.row=行；
this.column=列；
id=”“+行+列；
}
@凌驾
公共字符串getId（）{
返回id；
}
@凌驾
公共void添加（NodeGraph节点）{
添加（节点）；
}
@凌驾
公共布尔删除（NodeGraph节点）{
返回邻域。删除（节点）；
}
}
谢谢，但当我更改私有LinkedList邻居时，我遇到了一个错误：s=new LinkedList（）；在私有列表中，neighturds=newlinkedlist（）；或者我没有得到你的帮助怎么了？我只能假设它与“菱形”操作符有关，并且项目的语言级别为1.6或更低）。如果是这样，请使用
newlinkedlist（）
或（更好的）升级到java8。还要注意，您必须导入
java.util.List
才能使其工作。谢谢，但当我更改私有LinkedList neighbourds=new LinkedList（）时，出现了一个错误；在私有列表中，neighturds=newlinkedlist（）；或者我没有得到你的帮助怎么了？我只能假设它与“菱形”操作符有关，并且项目的语言级别为1.6或更低）。如果是这样，请使用
newlinkedlist（）
或（更好的）升级到java8。还要注意，必须导入
java.util.List
才能使其正常工作。避免强制转换是否也有性能方面的好处？我在Scala中见过这种类型的模式，您能推荐一些好的资源来研究Java的类型边界吗？避免强制转换是否也有性能优势？我在Scala中见过这种类型的模式，您能推荐一些好的资源来研究Java的类型边界吗？