Java 泛型 通配符

泛型类的定义：

在类声明时通过一个标识符表示类中某个字段的类型或者某个方法的返回值或参数的类型 ，在类声明或实例化时只需要指定自己需要的类型即可。

声明带泛型的类:
class 类名<泛型类型 1,泛型类型 2……>{
泛型类型 变量名；
泛型类型 方法名(){}
返回值类型 方法名(泛型类型 变量名){}
}
使用带泛型的类：
类名<具体类> 对象名 = new 类名<具体类>();

//定义泛型类Point
class Point<T> {
    private T x;
    private T y;

    public T getX(){
        return this.x;
    }

    public T getY(){
        return this.y;
    }

    public void setX(T x){
        this.x = x;
    }

    public void setY(T y){
        this.y = y;
    }
}

泛型中使用“ ？”

在进行引用传递的时候泛型类型必须匹配才可以传递 ，否则编译不通过； 使用通配符“ ？” ，表示未知类型的泛型对象：

这种带通配符的List仅表示各种泛型List的父类，并不能把元素加入集合中；（因为不能确定内部对象类型）

设置泛型的上限与下限：

设置泛型对象的上限使用 extends,表示参数类型只能是该类型或该类型的子类：
声明对象：类名<? extends 类> 对象名
定义类：类名<泛型标签 extends 类>{}
设置泛型对象的下限使用 super,表示参数类型只能是该类型或该类型的父类：
声明对象：类名<? super 类> 对象名称
定义类：类名<泛型标签 extends 类>{}

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

class Person implements Comparable<Person>{
    private final String name;
    private final Integer age;
    public Person(String name,Integer age){
        this.age = age;
        this.name = name;
    }
    public Integer getAge(){
        return this.age;
    }
    public  String getName(){
        return this.name;
    }
    @Override
    public int compareTo(Person o) {
        return this.age.compareTo(o.getAge());
    }
	//使用通配符定义方法
    public static void show(List<? extends Person> list){
        Iterator<Person> it = (Iterator<Person>) list.iterator();
        while (it.hasNext())
            System.out.println(it.next().getAge());
    }

    public static void main(String[] args){
        List<childPerson> list = new LinkedList<childPerson>();
        list.add(new childPerson("1",13));
        list.add(new childPerson("2",12));
        list.add(new childPerson("3",14));
        list.add(new childPerson("4",11));
        list.add(new childPerson("5",15));

        show(list);
    }
}

class childPerson extends Person{
    public childPerson(String name,Integer age){
        super(name,age);
    }
}

泛型的接口和方法：

java5 后，可以声明泛型接口，声明方式和声明泛型类是一样的。
public interface IDAO{}
泛型接口子类有两种方式：

1. 直接在子类后申明泛型：

​ public class DaoImpl implements IDAO{}

2. 在子类实现的接口中给出具体的泛型类型

   public class DaoImpl implements IDAO{}

示例：实现针对 Map类的Value进行排序

    public static <K,V extends Comparable<? super V>> Map<K,V> sortByValue(Map<K,V> map){
        List<Map.Entry<K, V>> list = new LinkedList<Map.Entry<K, V>>(map.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
            @Override
            public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
                return (o1.getValue()).compareTo(o2.getValue());
            }
        });
        Map<K,V> result = new LinkedHashMap<K,V>();
        for(Map.Entry<K,V> entry : list)
            result.put(entry.getKey(),entry.getValue());
        return result;
    }