Java 泛型T的class java 泛型类型

 

1.

<E>与<E extends Object>相同，<?>与<? extends Object>相同。

还要了解一下，泛型是为了更好地编程，防止程序员在调用时出错，比如一个类的方法只能用int，而你用了string，此时编译器会显示警告。

2.

泛型类型指的是<E>,<E extends 类>，主要是为了定义类,方法,接口，使方法和类中定义了的泛型类型和调用方法时匹配或类的定义匹配。

（1）

public class ABC{ 
 public static void main(String[] args){ 
 Interger[] integers={1,2,3,4}; 
 ABC.<Interger>print(integers);   //调用方法中的参数类型会跟方法print中一样 
 } 
 public static <E> void print(E[] list){ 
 for(Object element:list) 
 System.out.println(element[i]); 
 }
 }

这个例子还不能看出什么，那么下面一个例子就会很直观。

public class JavaApplication86 {

     public static void main(String[] args) {
         Integer a=new Integer(1);
         Double b=new Double(2.1);
         System.out.print(abc(a,b));
     }
     
     public static <E extends Number> boolean abc(E object1,E object2){
         return object1==object2;
     }
 }

这个编译会通过，首先<E exends Number>指的是Number的子类，并且要求object1和object2都要继承Number。

如果b定义成 String  b=new Double(2.1)就会出错，不匹配。(受限的泛型)

（2）

在一个定义了泛型的类里面，

如public class ABC<E>{ 
 pubic void print(E o){ 
 } 
 }

如果我ABC<String> ll=new ABC<String>()后，调用ABC.print(1)就会报错，

因为1是整数，现在ABC的print的参数只能是串，除非你ABC<Integer>=new ABC<Integer>();

3.

通配泛型指的是<?>(=Object),<? extends T>(=T的子类),<? super T>(=T的父类)，其实跟泛型类型差不多，不过它主要是对参数进行检查。

它们之间的比较，看一下它们的定义：

通配泛型：(告诉别人    类名<?>或<? extends T>或<? super T>的限制，你使用它就要接受它的限制 )

public static void print(GenericStack<?> stack){    
 } 
 public stactic double max(GenericStack<? extends Number> stack){  //stack中的?必须是Number的子类或Number。 
 } 
 public static <T> void add(GenericStack<T> stack1,GenericStack<? super T> stack2){   //stack2中的?必须是stack1<T>中T的父类或T。 
 }

泛型类型：(主要是告诉别人，我用了<E>的泛型的定义，你new或调用的时候就要指明是哪个类或方法。第二种就是有限制的泛型)

public static <E extends Number> boolean abc(E object1,E object2){//有限制的泛型
         return object1==object2;
 }  public class ABC<E>{ 
 pubic void print(E o){ 
 } 
 }

区分

<E extends Number>前面没有类，<? extends T>前面有类，前者是告诉别人<E extends Number>这个类型的匹配，后者是限制类里面的类型。

public static <E extends Number> boolean abc(E object1,E object2)    //E object1中的E则是告诉别人object1的类型匹配是E，而<E extends Number> 是限制条件，所以E有了一些限制，就是E必须是Number的子类。

public stactic double max(GenericStack<? extends Number> stack)  //<? extends Number>前面有一个类，告诉别人GenericStack的通配类型是<? extends Number>，即Number的子类或Number。

简单来说，有 关<E>等泛型类型主要是告诉类是E，至于E是什么类型，在new或调用的时候定义，<E extends Number>这种也是告诉类是E，只不过有了一些限制。    <?>等有关的是告诉类的限制是什么（这个意会一下），如GenericStack<? extends Number> stack，我所说的里面是指GenericStack<? extends Number> stack中的“<>”。