泛型是一种“代码模板”，可以用一套代码套用各种类型。

反方向的钟

什么是泛型

在讲解什么是泛型之前，我们先观察Java标准库提供的ArrayList，它可以看作“可变长度”的数组，因为用起来比数组更方便。

实际上ArrayList内部就是一个Object[]数组，配合存储一个当前分配的长度，就可以充当“可变数组”：

publicclass ArrayList {
   private Object[] array;
   privateint size;
   public void add(Object e) {...}
   public void remove(int index) {...}
   public Object get(int index) {...}
}


如果用上述ArrayList存储String类型，会有这么几个缺点：

• 需要强制转型；

• 不方便，易出错。

例如，代码必须这么写：

ArrayList list = new ArrayList();
list.add("Hello");
// 获取到Object，必须强制转型为String:
String first = (String) list.get(0);


很容易出现ClassCastException，因为容易“误转型”：

list.add(new Integer(123));
// ERROR: ClassCastException:
String second = (String) list.get(1);


要解决上述问题，我们可以为String单独编写一种ArrayList：

publicclass StringArrayList {
   private String[] array;
   privateint size;
   public void add(String e) {...}
   public void remove(int index) {...}
   public String get(int index) {...}
}


这样一来，存入的必须是String，取出的也一定是String，不需要强制转型，因为编译器会强制检查放入的类型：

StringArrayList list = new StringArrayList();
list.add("Hello");
String first = list.get(0);
// 编译错误: 不允许放入非String类型:
list.add(new Integer(123));


问题暂时解决。

然而，新的问题是，如果要存储Integer，还需要为Integer单独编写一种ArrayList：

publicclass IntegerArrayList {
   private Integer[] array;
   privateint size;
   public void add(Integer e) {...}
   public void remove(int index) {...}
   public Integer get(int index) {...}
}


实际上，还需要为其他所有class单独编写一种ArrayList：

• LongArrayList

• DoubleArrayList

• PersonArrayList

• ...

这是不可能的，JDK的class就有上千个，而且它还不知道其他人编写的class。

为了解决新的问题，我们必须把ArrayList变成一种模板：ArrayList<T>，代码如下：

publicclass ArrayList<T> {
   private T[] array;
   privateint size;
   public void add(T e) {...}
   public void remove(int index) {...}
   public T get(int index) {...}
}


T可以是任何class。这样一来，我们就实现了：编写一次模版，可以创建任意类型的ArrayList：

// 创建可以存储String的ArrayList:
ArrayList<String> strList = new ArrayList<String>();
// 创建可以存储Float的ArrayList:
ArrayList<Float> floatList = new ArrayList<Float>();
// 创建可以存储Person的ArrayList:
ArrayList<Person> personList = new ArrayList<Person>();


因此，泛型就是定义一种模板，例如ArrayList<T>，然后在代码中为用到的类创建对应的ArrayList<类型>：

ArrayList<String> strList = new ArrayList<String>();


由编译器针对类型作检查：

strList.add("hello"); // OK
String s = strList.get(0); // OK
strList.add(new Integer(123)); // compile error!
Integer n = strList.get(0); // compile error!


这样一来，既实现了编写一次，万能匹配，又通过编译器保证了类型安全：这就是泛型。

向上转型

在Java标准库中的ArrayList<T>实现了List<T>接口，它可以向上转型为List<T>：

publicclass ArrayList<T> implements List<T> {
   ...
}

List<String> list = new ArrayList<String>();


即类型ArrayList<T>可以向上转型为List<T>。

要特别注意：不能把ArrayList<Integer>向上转型为ArrayList<Number>或List<Number>。

这是为什么呢？假设ArrayList<Integer>可以向上转型为ArrayList<Number>，观察一下代码：

// 创建ArrayList<Integer>类型：
ArrayList<Integer> integerList = new ArrayList<Integer>();
// 添加一个Integer：
integerList.add(new Integer(123));
// “向上转型”为ArrayList<Number>：
ArrayList<Number> numberList = integerList;
// 添加一个Float，因为Float也是Number：
numberList.add(new Float(12.34));
// 从ArrayList<Integer>获取索引为1的元素（即添加的Float）：
Integer n = integerList.get(1); // ClassCastException!


我们把一个ArrayList<Integer>转型为ArrayList<Number>类型后，这个ArrayList<Number>就可以接受Float类型，因为Float是Number的子类。但是，ArrayList<Number>实际上和ArrayList<Integer>是同一个对象，也就是ArrayList<Integer>类型，它不可能接受Float类型， 所以在获取Integer的时候将产生ClassCastException。

实际上，编译器为了避免这种错误，根本就不允许把ArrayList<Integer>转型为ArrayList<Number>。

ArrayList和ArrayList两者完全没有继承关系。

使用泛型

使用泛型时，把泛型参数<T>替换为需要的class类型，例如：ArrayList<String>，ArrayList<Number>等；

可以省略编译器能自动推断出的类型，例如：List<String> list = new ArrayList<>();；

不指定泛型参数类型时，编译器会给出警告，且只能将<T>视为Object类型；

可以在接口中定义泛型类型，实现此接口的类必须实现正确的泛型类型。

编写泛型

编写泛型类比普通类要复杂。通常来说，泛型类一般用在集合类中，例如ArrayList<T>，我们很少需要编写泛型类。

如果我们确实需要编写一个泛型类，那么，应该如何编写它？

可以按照以下步骤来编写一个泛型类。

首先，按照某种类型，例如：String，来编写类：

publicclass Pair {
   private String first;
   private String last;
   public Pair(String first, String last) {
       this.first = first;
       this.last = last;
   }
   public String getFirst() {
       return first;
   }
   public String getLast() {
       return last;
   }
}


然后，标记所有的特定类型，这里是String：

publicclass Pair {
   private String first;
   private String last;
   public Pair(String first, String last) {
       this.first = first;
       this.last = last;
   }
   public String getFirst() {
       return first;
   }
   public String getLast() {
       return last;
   }
}


最后，把特定类型String替换为T，并申明<T>：

publicclass Pair<T> {
   private T first;
   private T last;
   public Pair(T first, T last) {
       this.first = first;
       this.last = last;
   }
   public T getFirst() {
       return first;
   }
   public T getLast() {
       return last;
   }
}


熟练后即可直接从T开始编写。

静态方法

编写泛型类时，要特别注意，泛型类型<T>不能用于静态方法。

多个泛型类型

泛型可以同时定义多种类型，例如Map<K, V>。

擦拭法

Java的泛型是采用擦拭法实现的；

擦拭法决定了泛型<T>：

• 不能是基本类型，例如：int；

• 不能获取带泛型类型的Class，例如：Pair<String>.class；

• 不能判断带泛型类型的类型，例如：x instanceof Pair<String>；

• 不能实例化T类型，例如：new T()。

泛型方法要防止重复定义方法，例如：public boolean equals(T obj)；

子类可以获取父类的泛型类型<T>。

通配符

使用类似<? extends Number>通配符作为方法参数时表示：

• 方法内部可以调用获取Number引用的方法，例如：Number n = obj.getFirst();；

• 方法内部无法调用传入Number引用的方法（null除外），例如：obj.setFirst(Number n);。

即一句话总结：使用extends通配符表示可以读，不能写。

使用类似<T extends Number>定义泛型类时表示：

• 泛型类型限定为Number以及Number的子类。

super

使用类似<? super Integer>通配符作为方法参数时表示：

• 方法内部可以调用传入Integer引用的方法，例如：obj.setFirst(Integer n);；

• 方法内部无法调用获取Integer引用的方法（Object除外），例如：Integer n = obj.getFirst();。

即使用super通配符表示只能写不能读。

使用extends和super通配符要遵循PECS原则。

无限定通配符<?>很少使用，可以用<T>替换，同时它是所有<T>类型的超类。

泛型和反射

Java的部分反射API也是泛型、例如：Class<T>就是泛型：Constructor<T>；

可以声明带泛型的数组，但不能直接创建带泛型的数组，必须强制转型；

可以通过Array.newInstance(Class<T>, int)创建T[]数组，需要强制转型；

同时使用泛型和可变参数时需要特别小心。

结尾

下一章我们来讲讲‘反射’，他在Java中的应用是非常广泛的，学会了你会又掌握了一项技巧。

总结：

1.集合中也大量了应用的范型，来简化代码，让代码更加的健壮。

2.范型有的时候就是一个模板，你按照他的方式去实现，就可以完成你的需求和功能

3.在反射中.class也是应用到了反射，去获取私有类中的对象和属性

4.范型使得代码更加的简洁和规范了

5.范型可以向上转型，向他的父类直接定义