java的泛型

 泛型   -->  应用在不确定的类型上面

    泛型是使用     
         a. 泛型在集合上的应用    
             1.如果集合中不指定泛型类型，那么默认是Object
             2.集合中的泛型是规定当前集合中存储的数据类型
             3.右边的泛型要和左边的泛型保持一致(没有兼容这种事情)
             4.jdk1.7之后右侧的泛型可以省略
             5.集合中使用了泛型之后，操作集合时都会被指定为泛型类型(避免一些类型转换异常)
             6.泛型不支持基本数据类型
    
         b. 泛型在排序机制上的应用
             Comparable<Person>
             Comparator<Person>
             主要是设置比较方法的参数类型

 

自定义泛型类

     a. 先创建一个类
         class Animal{
         }
    b. 在类名后加<任意字母,任意字母...>   泛型的个数没有要求
    c. 泛型在类中都可以在哪些地方出现
        属性的类型  private A birthday;
        方法的参数  public void setBirthday(A birthday)
        方法的返回值  public A getBirthday()
       d. 泛型不能够作为静态资源出现
                泛型也不能用于声明数组
                
       e. 自定义泛型类的使用
           e.1   自己创建本类对象，直接指定泛型类型，直接使用
               Animal<Date> a=new Animal<>();
           e.2  作为父类，指定泛型类型
               class Dog extends Animal<Date>{}‘
               作为父类暂时不指定类型，需要子类去指定类型   子类的泛型个数和类型必须包含父类的个数和类型
               class Dog<A> extends Animal<A>{}

public class Test2 {
       public static void main(String[] args) {
		Dao<Integer>d1=new Dao<>(); //在声明时声明T的类型
		d1.save("123",12);
		d1.save("wert",96);
		d1.save("1asdfg23",787);
		d1.save("asdfg",78);
		System.out.println(d1.getMap("123"));
		System.out.println(d1.list());
		Dao<Double>d2=new Dao<>();
		d2.save("asdfg",78.0);
	}
}
 class Dao<T>{//定义泛型
	 
	 
	 private Map<String ,T> map;

	public Dao() {
		super();
		map=new HashMap<String ,T>();
		
	}
   public void save(String id,T entity){
	   map.put(id, entity);
   }
	public T getMap(String id) {
		return map.get(id);
	}

	public void update(String id,T entity){
		map.replace(id, entity);
	}
	@SuppressWarnings("unchecked")
	public List<T>list(){
	 List<T> list=new ArrayList<>();
	 Set set=map.keySet();
	 for (Object obj : set) {
		list.add((T)obj);
	}
		return list ;
           //return new ArrayList(map.values());       //直接返回强转的类型会报错
	}
	public void delete(String id){
		map.remove(id);
	}
	 
 }

自定义泛型接口

     a. 创建一个接口
     b. 在接口名后面加<任意字母...>
     c. 特点
         可以作为抽象方法和默认方法的参数和方法的返回值(静态方法不行)
         泛型不可以应用在属性上(因为属性是静态资源)
     d. 使用
         实现类去实现该接口时，就指定泛型类型
             class Impl implements Super<String,Integer>
         实现类去实现该接口时，不指定泛型类型
             class Impl<H,J> implements Super<H,J>

class Impl<H,J> implements Super<H,J>{

	@Override
	public J method(H h) {
		// TODO Auto-generated method stub
		return null;
	}

	
}
interface Super<H,J>{
	String NAME="abc";
	public J method(H h);
	public default H fun(J j){
		return null;
	}

自定义泛型方法  

     a. 创建一个方法  
     b. 在方法的修饰符后面加<任意字母...>
         //自定义泛型方法 (设置泛型只能在当前方法使用)
        public<G,H> H fun2(G g){
            return null;
        }
    c. 如何使用
        在调用方法时，传进去什么参数类型，泛型就是什么类型    
        接收返回值时，用什么类型接收，就是什么类型 

 

通配符

     <?>   可以匹配任意泛型类型  
     <? extends Animal>   设置泛型的上限  
     <? super Dog>    设置泛型的下限 

 

public static void main(String[] args) {
		List<Animal> list=new ArrayList<>();//
		new Demo8().test2(list);
	}
	
       //只能是animal的子类或者是animal类型的泛型
	public void test1(List<? extends Animal> list){//Animal   Dog extend Animal  Cat
		
	}
       //最低是Dog类型或者是他的父类，但是不能是跟他同意级的类型
	public void test2(List<? super Dog> list){//Animal   Dog extend Animal  Cat
		
	}