深入Java泛型（三）：泛型的上下边界

泛型的命名规范

为了更好地去理解泛型，我们也需要去理解java泛型的命名规范。

为了与java关键字区别开来，java泛型参数只是使用一个大写字母来定义。各种常用泛型参数的意义如下：

E — Element，常用在java Collection里，如：List<E>,Iterator<E>,Set<E>
<br />K,V — Key，Value，代表Map的键值对<br />
N — Number，数字<br />
T — Type，类型，如String，Integer等等<br />
S,U,V etc. - 2nd, 3rd, 4th 类型，和T的用法一样

上下限 概览

public TreeSet(Comparator<? super E> comparator) {
       this(new TreeMap<>(comparator));
 }
? 所代表的类型必须是E的父类或就是E 
   
Collection的addAll：
addAll(Collection<? extends E> c) 
? 所代表的类型得是E的子类或就是E

List<?>
List<?> 通常用来当作方法参数类型或方法的返回值类型，其参数或其返回值是一个未知类型，可以肯定的是，?是Object，联想一下多态，就会有些明白了。

下面的代码是会出现异常的：

   List<?> poems = new ArrayList<String>();
    poems.add("life is a song");

?表示这个List集合中保存的元素是未知类型的，Java不允许把对象放进一个未知类型的集合中，正常的：

package generic;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by zhoujie on 1/25/16.
 */
public class First {
    /**
     * ? 都处理成Object, 处理所有类型
     * 可以通过返回一个 List<?>的值, 都被当成Object来处理
     * @param c
     */
    public static void display(List<?> c) {
        for (int i = 0; i < c.size(); i++) {
            // c.get(i) 是Object类型的
            System.out.println(c.get(i));
        }
    }

    public static void main(String[] args) {
        List<String> poems = new ArrayList<>();
        poems.add("life is a song");
        poems.add("some one like you");
        poems.add("you are so beautiful");
        display(poems);
    }
}

List<? extends Animal>， 通配符的上限

Animal.java:

public abstract class Animal {
   public abstract void sing(Perform p);
}

Cat.java:

public class Cat extends Animal {
    @Override
    public void sing(Perform p) {
        System.out.println("Hello, audience, I'm a Cat.");
    }
}

Dog.java:

public class Dog extends Animal {
    @Override
    public void sing(Perform p) {
        System.out.println("Hello, audience, I'm a dog.");
    }
}

Perform.java:

public class Perform {
    public void perform(List<Animal> animals) {
        for (Animal a : animals) {
            a.sing(this);
        }
    }

}

下面写一个类测试一下上面的几个类：

public class TestGeric {
    public static void main(String[] args) {
        List<Dog> dogs = new ArrayList<>();
        Perform p = new Perform();
        dogs.add(new Dog());
        p.perform(dogs);  // 此处代码编译出现异常
    }
}

List不能和perform中的参数 List animals对应起来，说明List并不是List的子类型，可以将Perform类的代码改成：

public class Perform {
    public void perform(List<?> animals) {
        for (Object o : animals) {
            Animal a = (Animal)o;
            a.sing(this);
        }
    }
}

这样的改进使用了泛型却还需要进行强制类型转换，略显繁琐。
继续改进Perform类：

public class Perform {
    public void perform(List<? extends Animal> animals) {
        for (Animal a : animals) {
            a.sing(this);
        }
    }
}

终于引出了可爱的List<? extends Animal>，?表示的类型可以是Animal类型和Animal的子类。可以把Animal称为这个通配符(?)的上限(upper bound)。
和一开始讲的List<?>一样，List<? extends Animal> 通常也是当作函数的参数来指定，

public void addMonkey(List<? extends Animal> animals) {
    // 下行代码出现编译错误
    animals.add(0, new Monkey());
}

带 ?的泛型表达一般都当做方法参数或方法返回值来使用，也就是本笔记中讲述的泛型方法相关。
还有就是，如下代码：

public class Apple<T extends Number> {
    T col;
    public static void main(String[] args) {
        //类型只能是Number类型或Number的子类型
        Apple<Integer> ai = new Apple<>();
        //编译错误
        //Apple<String> as = new Apple<>();
    }
}

<? super E>通配符的下限
来看一段代码：

public static <T> T copy(Collection<? super T> dest, Collection<T> src){
    T last = null;
    for (T ele : src) {
        last = ele;
        dest.add(ele);
    }
    return last; //返回一个T类型的变量
}
/*
<? super Type> 通配符 ? 表示它必须是Type本身，或是Type的父类
*/

// 栗子
List<Number> ln = new ArrayList<>();
List<Integer> li = new ArrayList<>();
li.add(2016);
// 此处可准确地知道最后一个被复制的元素是Integer类型 
// 与src集合的元素类型相同
Integer ele = copy(ln, li);

在集合框架中的 TreeSet有一个构造器也用到了这种设定通配符下限的语法，

TreeSet(Comparator<? super E> c)

Comparator接口也是一个带泛型声明的接口：

public interface Comparator<T> {
    int compare(T fst, T snd);
}

看栗子：
Person类下面有一个子类 Student

class CompByName implements Comparator<Person>
{
    @Override
    public int compare(Person o1, Person o2) {
        int temp = o1.getName().compareTo(o2.getName());
        //如果姓名相等，根据年龄来排序
        return (temp == 0) ? (o1.getAge() - o2.getAge()) : temp; 
        
    }
    
}

class CompByStuName implements Comparator<Student>
{
    @Override
    public int compare(Student o1, Student o2) {
        int temp = o1.getName().compareTo(o2.getName());
        //如果姓名相等，根据年龄来排序
        return (temp == 0) ? (o1.getAge() - o2.getAge()) : temp; 
    }
}

/*
TreeSet(Comparator<? super E> comparator)
此处E类型是Person
下面的代码是编译不通过的 
看TreeSet的构造器(Comparator<? super E> comparator) 
根据下面代码的声明，E是Person类型，?表示的类型须是Person类型或Person的父类
而CompByStuName()是Comparator<Student>类型的
Student是Person的子类，根据TreeSet(Comparator<? super E> comparator)的约定所有就编译通不过啦

正确的：
TreeSet<Person> persons = new TreeSet<>(new CompByName()); 
TreeSet<Student> students = new TreeSet<>(new CompByName());
TreeSet<Student> students1 = new TreeSet<>(new CompByStuName());
*/   
TreeSet<Person> persons = new TreeSet<>(new CompByStuName());
//没有指定泛型，add()中的形参就是Object
persons.add(new Person("jiaobuchong", 22));
persons.add(new Person("mesi", 21));
persons.add(new Person("mark", 23));

定义泛型接口

public interface World<T> {
    void show(T t);
}

实现上面的接口：

//实现方式1：
public class WorldImpl implements World<String> {
    public void show(String t) {
        System.out.println(t);
    }
}

//实现方式2：
public class WorldImpl implements World<T> {
    public void show(T t) {
        System.out.println(t);
    }
}

测试：

//实现方式1的测试
World<String> w = new WorldImpl();
w.show("hello, girl");

//实现方式2的测试
World<String> w1 = new WorldImpl<String>();
w1.show("hello, jiaobuchong");