java – 如何获得一个内部类继承包围类的通用类型？

我正在使用 Java 6.

让我的内部类使用相同的泛型类作为它的封闭类.目前我有

public class TernarySearchTree < T > {
    ...
    protected class TSTNode < T > {
        // index values for accessing relatives array
        protected static final int PARENT = 0,LOKID = 1,EQKID = 2,HIKID = 3; 
        protected char splitchar;
        protected TSTNode < T > [] relatives;
        private T data;

        protected TSTNode(char splitchar,TSTNode < T > parent) {
            this.splitchar = splitchar;
            relatives = new TSTNode[4];
            relatives[PARENT] = parent;
        }
    }
}

现在我得到警告

The type parameter T is hiding the type T

如果我从内部类中删除类型参数(即从受保护的类TSTNode< T>行中删除< T>),则在relatives = new TSTNode [4]行上得到一个编译错误.

如何使一切正确？

解决方法

你可以：

>删除< T>来自TSTNode的类型参数(即使其成为非泛型) – 它仍然可以访问外部< T>.
>重命名< T>类TSTNode中的类型参数(说)U.

[UPDATE]

以下是重写代码的四种不同的方法.他们都编译我想你应该考虑使用EnumMap(见下面的第4版).

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

public class TernarySearchTree<T> {

    protected class TSTNode<U> {
      // index values for accessing relatives array:
      protected static final int PARENT = 0,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,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,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 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]
有一件事要记住：Use EnumMap instead of ordinal indexing