所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。

1、集合类和接口可以使用泛型结构。

2、在实例化集合类的时候可以指定具体的泛型类型

3、指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置，都指定为实例化的泛型类型。比如：add(E e) --->实例化以后：add(Integer e)

4、注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换

5、如果实例化时，没有指明泛型的类型。默认类型为java.lang.Object类型。

6、泛型的好处：可以在编译时进行类型检查，保证数据安全；可以避免强转。

7、异常是不能是泛型的。

//泛型嵌套
public void test2(){    Map<Integer,String> map=new HashMap<Integer,String>();    
//泛型的嵌套    
Set<Map.Entry<Integer, String>> entries = map.entrySet();    
Iterator<Map.Entry<Integer, String>> iterator = entries.iterator();   
   while (iterator.hasNext()){        
       Map.Entry<Integer, String> next = iterator.next();        System.out.println(next.getKey()+next.getValue());    
   }
}

public class Order<T> {    
    String name;    
    int orderId;   
    //类的内部结构就可以使用类的泛型    
    T orderT;    
    public Order() { 
    }   
    public Order(String name, int orderId, T orderT) {  
        this.name = name;    
        this.orderId = orderId;       
        this.orderT = orderT;  
    }   
    public String getName() {  
        return name;    
    }   
    public void setName(String name) {  
        this.name = name;  
    }    
    public int getOrderId() {   
        return orderId;   
    }   
    public void setOrderId(int orderId) {    
        this.orderId = orderId;   
    }    //该方法不是泛型方法  
    public T getOrderT() {  
        return orderT;   
    }    
    public void setOrderT(T orderT) {  
        this.orderT = orderT; 
    }   
    /**     * 泛型方法 和泛型类的结构和参数没关系     */ 
    public  <E>List<E> copyFromArrayToList(E[] arr){    
        ArrayList<E> list=new ArrayList<>();     
        for (E e:arr ) {    
            list.add(e);     
        }       
        return list;  
    }    
    class T{  
    }
}

8、泛型在继承方面的体现

虽然类A是类B的父类，但是G和G二者不具备子父关系，二者是并列关系。

补充：类A是类B的父类，A和B的父类。

public void test(){   
List<Person> list=new ArrayList<>();  
list.add(new Person());   
 list.add(new Student());   
List<Student> list1=new ArrayList<>();   
list.add(new Student());    
list=list1;   //不行的
Person<String> person=new Person<>();   
Student<String> student=new Student<>();   
person=student;}

9、通配符的使用

通配符：？

类A是类B的父类，G和G是没有关系的，二者共同的父类是G<?>

public void test2(){   
    List<Object>list=null;   
    List<String>list1=null; 
    list=list1; //不可以的  
    List<?> list2=null;   
    list2=list;    
    list2=list1;}

10.有限制条件的通配符的使用。

? extends A: G<? extends A> 可以作为G和G的父类，其中B是A的子类

? super A: G<? super A> 可以作为G和G的父类，其中B是A的父类

public void test3(){    
//List<Person> 或者 List<Person的子类> 都是 List<? extends Person>的子类  
List<? extends Person> list=null;   
List<Person> people=new ArrayList<>();   
list=people;    
List<Student> students=new ArrayList<>();    
list=students;   
/* List<Object> objects=new ArrayList<>();    
list=objects;*/
}

public void test4(){  
//List<Person> 或者 List<Person的父类> 都是 List<? super Person>的子类    
List<? super Person> list=null;  
List<Person> people=new ArrayList<>(); 
list=people;   
/* List<Student> students=new ArrayList<>();   
list=students;*/   
List<Object> objects=new ArrayList<>();  
list=objects;}