如何获取内部类以继承封闭类的泛型类型？

您可以：

• 从中删除类型参数（即，使其成为非泛型） - 它仍然可以访问外部 。<T>TSTNode<T>

• 将类中的类型参数重命名为（比如说）。<T>TSTNodeU

[更新]

以下是重写代码的四种不同方法。它们都编译。我认为您应该考虑使用一个（请参阅下面的版本4）。EnumMap

版本 1：在内部类中使用不同名称的类型参数。您需要使用 List 而不是数组。

  public class TernarySearchTree<T> {

    protected class TSTNode<U> {
      // index values for accessing relatives array:
      protected static final int PARENT = 0, LOKID = 1, EQKID = 2, HIKID = 3;

      protected char splitchar;
      protected List<TSTNode<U>> relatives;
      private U data;

      protected TSTNode(char splitchar, TSTNode<U> parent) {
        this.splitchar = splitchar;
        relatives = new ArrayList<TSTNode<U>>();
        for (int i = 0; i < HIKID; ++i) {  // Allocate 4 slots in relatives
          relatives.add(null);
        }
        relatives.set(PARENT, parent);
      }          
    }

    private TSTNode<T> node; // When you use it, pass T as U

    public TernarySearchTree() {
      node = new TSTNode<T>(',', null);  // When you use it, pass T as U 
    }
  }

版本 2：从封闭类继承 T

  public class TernarySearchTree<T> {

    protected class TSTNode {
      // index values for accessing relatives array:
      protected static final int PARENT = 0, LOKID = 1, EQKID = 2, HIKID = 3;

      protected char splitchar;
      protected List<TSTNode> relatives;
      private T data;

      protected TSTNode(char splitchar, TSTNode parent) {
        this.splitchar = splitchar;
        relatives = new ArrayList<TSTNode>();
        for (int i = 0; i < HIKID; ++i) {  // Allocate 4 slots in relatives
          relatives.add(null);
        }
        relatives.set(PARENT, parent);
      }
    }

    private TSTNode node; 

    public TernarySearchTree() {
      node = new TSTNode(',', null);  
    }
  }

版本 3：使用地图（而不是列表）

  public class TernarySearchTree<T> {

    protected class TSTNode {
      // index values for accessing relatives array:
      protected static final int PARENT = 0, LOKID = 1, EQKID = 2, HIKID = 3;

      protected char splitchar;
      protected Map<Integer, TSTNode> relatives;
      private T data;

      protected TSTNode(char splitchar, TSTNode parent) {
        this.splitchar = splitchar;
        // Create a hash map. No need to pre-allocate!
        relatives = new HashMap<Integer, TSTNode>(); 
        relatives.put(PARENT, parent); // set -> put
      }
    }

    private TSTNode node; 

    public TernarySearchTree() {
      node = new TSTNode(',', null);  
    }
  }
}

版本 4：将索引定义为枚举 + 使用 EnunMap（而不是哈希映射）

  public class TernarySearchTree<T> {

    protected static enum Index {
      PARENT, LOKID, EQKID, HIKID;
    }

    protected class TSTNode {    
      protected char splitchar;
      protected EnumMap<Index, TSTNode> relatives;
      private T data;

      protected TSTNode(char splitchar, TSTNode parent) {
        this.splitchar = splitchar;
        // Create an EnumMap. 
        relatives = new EnumMap<Index, TSTNode>(Index.class);
        relatives.put(Index.PARENT, parent); 
      }
    }

    private TSTNode node; 

    public TernarySearchTree() {
      node = new TSTNode(',', null);  
    }
  }

[更新 2]要记住的一件事是：使用EnumMap而不是序号索引

至于从内部类中删除 T 时泛型数组创建的编译错误：

因为它是一个非静态的内部类，所以它在外部类的类型参数的范围内。这意味着它也通过其外部类的类型参数隐式参数化

所以当你写它时，它基本上是意味着（这里的T是外层T）。因此，仍然是泛型类型（即使您没有显式看到任何括号），并且创建泛型类型的数组将失败。TSTNodeTernarySearchTree<T>.TSTNodeTSTNode

您可以通过手动限定名称来引用 的原始类型：。TSTNodeTernarySearchTree.TSTNode

因此，新的TernarySearchTree.TSTNode[4]就是答案。

您将收到一个未选中的警告，您可以忽略该警告（这是您必须与泛型类型数组一起接受的东西）

P.S. 从内部类中删除类型参数几乎肯定是正确的选择，因为 Java 中的非静态内部类隐式具有对外部类实例的引用。因此，它已经与外部 T 一起参数化。如果您只想使用相同的 T，请不要声明另一个 T。