将链表重用于另一种类型(泛型类型)

Question

所以我有这个链表类：

public class LinkedList {
    private LLNode rootNode;
    public Node FindItemByData(String data) {
        if(rootNode == null)
            return null;
        else
            return rootNode.findItemByData(data);
    }

而这个节点类：

public class LLNode {

   LLNode tail; //tail node
   Node data; //some data

   public LLNode(LLNode tail, Node data)
   {
       this.tail = tail;
       this.data = data;
   }
   public Node findItemByData(String data) {
       if(this.data.name.equals(data))
           return this.data;
       else
           return this.tail.findItemByData(data);
   }

我想重用链表在LLNode的每个Node data的图形中存储边缘。我尝试使用泛型类型替换类型，但这破坏了findItemByData函数的功能，因为它依赖于显式声明为 Node 的数据。

有什么方法可以为多种类型重用此类吗？还是我不应该在泛型类中引用data.name？

实现上下文：

public class Graph {
    //USE LINKED LIST
    LinkedList Nodes;
    //Node[] Nodes;   
    int noOfNodes;
    public Graph() {
        noOfNodes = 0;
        //Nodes = new Node[25];
        Nodes = new LinkedList();
    }
    public void AddNode(String name, int x, int y) {
        //Nodes[noOfNodes++] = new Node(name,x,y);
        Nodes.AddItem(new Node(name,x,y));
    }

..

public class Node {
    String name;    //Node's name
    int x,y;        //Node's coords
    LinkedList Adjacencies;
    int noOfAdj = 0;
    int size = 0;

    public Node(String name, int x, int y) {    //Constructor
        this.name = name;
        this.x = x;
        this.y = y;
        Adjacencies = new LinkedList();
    }
    public void addAdjacency(String dest, double distance) {
        Adjacencies.AddItem(new Edge(this.name, dest, distance)); //I want to do this
    }
}

编辑：尝试使用泛型：

public class LinkedList<T> {
    private LLNode rootNode;
    public T FindItemByData(String data) {
        if(rootNode == null)
            return null;
        else
            return rootNode.findItemByData(data);
    }
}
public class LLNode<T> {

   LLNode tail; //tail node
   T data; //some data

   public LLNode(LLNode tail, T data)
   {
       this.tail = tail;
       this.data = data;
   }
   public T findItemByData(String data) {
       if(this.data.name.equals(data))
           return (T) this.data;
       else
           return (T) this.tail.findItemByData(data);
   }
}
public class Graph {
    LinkedList<Node> Nodes;
    int noOfNodes;
    public Graph() {
        noOfNodes = 0;
        Nodes = new LinkedList();
    }
    public void AddNode(String name, int x, int y) {
        Nodes.AddItem(new Node(name,x,y));
    }
}
public class Node {
    String name;    //Node's name
    int x,y;        //Node's coords
    LinkedList<Edge> Adjacencies;
    int noOfAdj = 0;
    int size = 0;

    public Node(String name, int x, int y) {    //Constructor
        this.name = name;
        this.x = x;
        this.y = y;
        Adjacencies = new LinkedList();
    }
    public void addAdjacency(String dest, double distance) {
        Adjacencies.AddItem(new Edge(this.name, dest, distance)); //I want to do this
    }
}

Answer 1

基本上你是说Node和Edge应该遵守相同的契约。为此，你们都应该让他们实现一个接口，其中包含作为该协定一部分的所有方法。

在这种情况下，这可能只会getData()。然后将此接口用于可以采用任何 Edge 或节点的方法。

另一种方法是使Edge成为Node的扩展。 public class Edge extends Node .然后，您可以在需要节点的任何地方使用它。

Answer 2

我认为您对泛型的尝试实际上非常接近。它的优点是使编译器能够判断特定LinkedList是Nodes还是Edges。所以我建议你保留LinkedList的通用参数化，但让它的含义有点不同。T应该是保存在LLNode中的数据类型。诀窍是您的数据有一个 String name ，因此您需要从中进行扩展才能获得该name。

interface Named {
  String getName();
}
public class LinkedList<T extends Named> {
  private LLNode<T> rootNode;
  // etc.
}
public class LLNode<T extends Named> {
  LLNode<T> tail; //tail node
  T data; //some data
  public LLNode(LLNode<T> tail, T data) {
    this.tail = tail;
    this.data = data;
  }
  public T findItemByData(String data) {
    if(this.data.getName().equals(data))
      return this.data;
    else
      return this.tail.findItemByData(data);
  }
  // etc.
}

现在你可以实例化一个只保存Nodes的LinkedList，另一个只保存Edges，假设Node和Edge都实现Named。

我已经提到过，但想再次强调：这优于仅使用超类型的Node和LinkedList Edge的方法。在这种情况下，您可以将Node和Edge实例放在同一个LinkedList中，编译器将无法警告您。通用方法使您能够创建限制为 Node 、 Edge 或不受限制 （new LinkedList<Named>() ） 的LinkedList实例。在所有情况下，编译器都会为您提供保持列表直截了当所需的支持。