java泛型与通配符

àì夳堔傛蜴生んèń 2024-04-17 20:52 33阅读 0赞

# 1、泛型类、泛型接口、泛型方法 #

### 泛型类 ###

package com.asiainfo.group.generic;
    
    /**
     * 泛型类
     *
     */
    public class GenericClassDemo<T> {
    
    	private T obj;
    	
    	
    	public GenericClassDemo(T obj) {
            this.obj = obj;
        }
    
        public T getObj(){
            return obj;
        }
    }

### 泛型接口与实现类 ###

package com.asiainfo.group.generic;
    
    /**
     * 泛型接口
     *
     */
    public interface GenericInterfaceDemo<T> {
    
    	public T getObj();
    }

package com.asiainfo.group.generic;
    
    /**
     * 泛型接口实现类
     *
     */
    public class GenericInterfaceImpl<T> implements GenericInterfaceDemo<T>{
    
    	private T obj;
    	public GenericInterfaceImpl(T obj){
    		this.obj = obj;
    	}
    	@Override
    	public T getObj() {
    		return this.obj;
    	}
    
    }

### 泛型方法 ###

package com.asiainfo.group.generic;
    
    import java.util.Map;
    
    public class GenericMethodDemo {
    
    	/**
    	 * <T>表明该方法是个泛型方法
    	 */
    	public <T> T getObj(Class<T> c){
    		T obj = null;
    		try {
    			obj = c.newInstance();
    		} catch (InstantiationException e) {
    			e.printStackTrace();
    		} catch (IllegalAccessException e) {
    			e.printStackTrace();
    		}
    		return obj;
    		
    	}
    	
    	
    	/**
    	 * 泛型的数量可以任意多个
    	 */
    	public <K,V> V getValueByKey(K key,Map<K, V> map){
    		
    		V value = map.get(key);
    		return value;
    	}
    }

### 测试 ###

package com.asiainfo.group.generic.main;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.Map;
    
    import com.asiainfo.group.generic.GenericClassDemo;
    import com.asiainfo.group.generic.GenericInterfaceImpl;
    import com.asiainfo.group.generic.GenericMethodDemo;
    
    
    public class GenericDemo {
    	
    	
    	
        public static void main( String[] args ){
            //测试泛型类
        	GenericClassDemo<String> g = new GenericClassDemo<String>("hello");
        	String obj = g.getObj();
        	System.err.println(obj);
        	
        	//测试泛型接口
        	GenericInterfaceImpl<Date> g2 = new GenericInterfaceImpl<Date>(new Date());
        	Date d = g2.getObj();
        	System.err.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(d));
        	
        	//测试泛型方法
        	GenericMethodDemo g3 = new GenericMethodDemo();
        	//单个
        	StringBuffer sb = g3.getObj(StringBuffer.class);
        	sb.append("ok");
        	System.err.println(sb.toString());
        	//多个
        	Map<String, Integer> map = new HashMap<String,Integer>();
        	map.put("zhangsan", 20);
        	map.put("lisi", 25);
        	map.put("wangwu", 80);
        	
        	Integer value = g3.getValueByKey("lisi", map);
        	System.err.println(value);
        	
        	
        	
        }
    }

# 2、通配符 #

### 一些实体类 ###

package com.asiainfo.group.generic.wildcard;
    
    public interface Animal {
    	String sleep();
    }

package com.asiainfo.group.generic.wildcard;
    
    public class Cat implements Animal{
    
    	@Override
    	public String sleep() {
    		return "cat----sleep";
    	}
    
    }

package com.asiainfo.group.generic.wildcard;
    
    public class Dog implements Animal{
    
    	@Override
    	public String sleep() {
    		return "dog----sleep";
    	}
    
    }

package com.asiainfo.group.generic.wildcard;
    
    public class Apple{
    
    	
    }

### 测试 ###

package com.asiainfo.group.generic.main;
    
    import java.util.ArrayList;
    import java.util.List;
    
    import com.asiainfo.group.generic.wildcard.Animal;
    import com.asiainfo.group.generic.wildcard.Apple;
    import com.asiainfo.group.generic.wildcard.Cat;
    import com.asiainfo.group.generic.wildcard.Dog;
    
    public class WildcardDemo {
    
    	/**
    	 * 通常在方法参数中才会使用通配符
    	 */
    	public void printAnimalSleep(List<? extends Animal> list){
    		for (int i = 0; i < list.size(); i++) {
    			System.err.println(i+"----"+list.get(i).sleep());
    		}
    		
    	}
    	
    	
    	public static void main(String[] args) {
    		//？为无界通配符    extends为上界，super为下界
    		
    		
    		
    		//通配符？在修饰一个变量的时候用到
    		List<?> list = new ArrayList<String>();
    		//使用过通配符修饰的集合变量，只能add(null)，因为这个集合中包含的类型已经确定，只是类型信息已经丢失了，add(Object)也不行
    		list.add(null);
    		
    		//不加通配符修改变量，可以add任何类型，但不建议这样做
    		List list2 = new ArrayList<String>();
    		list2.add(1);
    		list2.add("hello");
    		
    		//测试通配符
    		WildcardDemo wildcardDemo = new WildcardDemo();
    		List<Cat> cats = new ArrayList<Cat>();
    		cats.add(new Cat());
    		cats.add(new Cat());
    		cats.add(new Cat());
    		List<Dog> dogs = new ArrayList<Dog>();
    		dogs.add(new Dog());
    		dogs.add(new Dog());
    		dogs.add(new Dog());
    		List<Apple> apples = new ArrayList<Apple>();
    		wildcardDemo.printAnimalSleep(cats);
    		wildcardDemo.printAnimalSleep(dogs);
    		//编译不通过
    		//wildcardDemo.printAnimalSleep(apples);
    	}
    }