解析Java 泛型什么情况下不能使用

T o=new T();  // 不允许

public class A<T>
{
  public static T t; //错误
  public T getA(){ //正确
    ......
  }
}

public class Generic<T>{
  // 不能将类声明的泛型类型作为静态变量
  public static T t;
  // 也不能将类声明的泛型类型作为 静态方法的返回值
  public static T rtval(List<T> list){
    return list.get(0);
  }
}

public class D<T> extends java.lang.Throwable //错误

// 不能间接地扩展 Throwable  
class IndirectException<T> extends Exception {}   

// 不能直接地扩展 Throwable 
class DirectException<T> extends Throwable {} 

 try {
    // ...
  } catch (T e) {  
    // 类型不确定 无法处理具体的异常逻辑
  }

class Parser<T extends Exception> {
  // 这样是对的
  public void okThrow(File file) throws T {   
    // ...
  }
  // 静态方法不能出现类声明的泛型类型作为返回值和异常
  public static void wrongThrow(File file) throws T {   
  }
}

T[] b = new T[10]; //错误

// OK
List[] arrayOfLists = new List[2];

//error
List<Integer>[] arrayOfLists = new List<Integer>[2];

// 如果上面的成立，则下面的也应该成立
Object[] stringLists = new List<String>[]; 
// 那么我们可以放入 字符串 List
stringLists[0] = new ArrayList<String>();  
// 放入 Integer list
stringLists[1] = new ArrayList<Integer>();
// 这显然不合理

// error 
Map<int,char> wrong= new HashMap<>()

// OK
Map<Integer,Character> wrong= new HashMap<>()

 public <E> E first(List<E> list){
   // error 
    E e = new E();
    return list.get(0);  
 }

public static <E> void wrong(List<E> list) {
  // error 
  if (list instanceof ArrayList<Integer>) {  
  }
}

public class NoReload {
  public void sets(Set<String> strSet) { }
  public void sets(Set<Integer> intSet) { }
}