泛型的命名规范
为了更好地去理解泛型，我们也需要去理解java泛型的命名规范。<br />
为了与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<Dog>不能和perform中的参数 List<Animal> animals对应起来，说明List<Dog>并不是List<Animal>的子类型，可以将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<E>有一个构造器也用到了这种设定通配符下限的语法，
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");
