目录
1、为什么需要泛型
2、什么是泛型
3、自定义泛型接口、泛型类
4、通配符
5、泛型方法
6、泛型的嵌套使用
1、为什么需要泛型
List list = new ArrayList();
list.add(“vince”);
list.add(10);
list.add(new Person());
list.add(obj);List中可以添加任意类型，因为参数是Object，这样一个我们在遍历这个集合时：
for(int i=0;i<list.size();i++){
//此处需要判断元素的类型，才能执行不同的操作
}以上操作主要存在两个问题：
1.当我们将一个对象放入集合中，集合不会记住此对象的类型，当再次从集合中取出此对象时，
改变对象的编译类型变成了Object类型，但其运行时类型依然为其本身类型。
2.因此，//取出集合元素时需要人为的强制类型转化到具体的目标类型，且很容易出现“java.lang.ClassCastException”异常。
那么有没有什么办法可以使集合能够记住集合内元素各类型，且能够达到只要编译时不出现问题，运行时就不会出现“java.lang.ClassCastException”异常呢？答案就是使用泛型。
2、什么是泛型
JDK 1.5之后出现了新的技术 —— 泛型（Generic），
此技术的最大特点是类中的属性的类型可以由外部决定。
泛型，即“参数化类型”。
一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。
那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
List<String> list = new ArrayList<String>();//... = new ArrayList<>(); //... = new ArrayList();
list.add("vince");
list.add("bin");
//list.add(100); // 提示编译错误
for (int i = 0; i < list.size(); i++) {
String name = list.get(i); // 2
System.out.println("name:" + name);
}规定String类型 添加10 和 Object就会在编译期报错
3、自定义泛型接口、泛型类
泛型类和方法定义：
class Node<T>{
private T data;
public Node(){}
public Node(T data){
this.data = data;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
}定义接口也一样
interface Shopping<T>{public void shopping(T name);}- 在泛型接口、泛型类和泛型方法的定义过程中，我们常见的如T、E、K、V等形式的参数常用于表示泛型形参，由于接收来自外部使用时候传入的类型实参，从编码的角度也称为参数化类型了。
- 泛型只是作用于代码编译阶段，在编译过程中，对于正确检验泛型结果后，会将泛型的相关信息擦除，
也就是说，成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。 - 泛型类
- T : 参数化类型，在实际使用时才会指定具体的类型
- 泛型只作用于编译期检查，在编译后，会被檫除
package com.vince;
/**
* Created by vince on 2017/6/15.
* 泛型类
* T : 参数化类型，在实际使用时才会指定具体的类型
* 泛型只作用于编译期检查，在编译后，会被檫除
*/
public class Node<T> {
private T data;
public Node(){}
public Node(T data){
this.data = data;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
}
通配符
问题：
Node c1 = new Node();
Node c2 = new Node() ;
c1 = c2; // 此时无法转换
public static void getData(Node data) {
System.out.println(“data :” + data.getData());
}
此时，我们可以使用通配符来解决
“?”表示的是可以接收任意的泛型类型，但是只是接收输出，并不能修改。
public static void getData(Node<?> data) {
System.out.println(“data :” + data.getData());
}
提示：
使用通配符可以引用其他各种参数化类型，通配符定义的变量主要用作引用，
可以调用与参数无关的方法，不能调用与参数有关的方法。
使用通配符就没问题了
只能取值 不能设值 因为它不知道你要放的什么类型
- 使用通配符定义泛型类型，此时只能输出，不能修改
泛型上限就指一个的操作泛型最大的操作父类，例如，现在最大的上限设置成“Number”类型，那么此时，所能够接收到的类型只能是Number及其子类（Integer）。
泛型的上限通过以下的语法完成：
? extends 类
public static void getUpperNumberData(Node<? extends Number> data){ //只能是Number类及其子类
System.out.println("data :" + data.getData());
}泛型的下限指的是只能设置其具体的类或者父类。设置的语法如下：
? super 类
test3中写的
结果
同样的 不能设值
5、泛型方法
泛型除了在类中定义之外，还可以在方法上定义，而且在方法上使用泛型，此方法所在的类不一定是泛型的操作类。
定义一个方法，实现任意类型数组中两个位置值的调换
public static <T> T[] func(T[] array,int i,int t){
T temp = array[i];
array[i] = array[t];
array[t] = temp;
return array;
}这么一个函数
注意在返回值 T[]前面加上 返回类型 < T >
在使用集合Map的时候，我们可以这样遍历：
Set<Entry<Integer, String>> entrys = map.entrySet();
package com.vince;
import org.junit.Test;
import java.util.*;
/**
* Created by vince on 2017/6/15.
*/
public class GenericDemo {
@Test
public void test5(){
Map<Integer,String> map = new HashMap<>();
map.put(1,"vince");
map.put(2,"tom");
Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
for(Map.Entry entry: entrySet){
System.out.println(entry.getKey()+"-"+entry.getValue());
}
}
@Test
public void test4(){
String[] arrays = {"vince","jack","Tom","lily"};
String[] strs = func(arrays, 0, 1);
System.out.println(Arrays.toString(strs));
}
@Test
public void test3(){
Node<Number> n1 = new Node<>(10);
Node<Integer> n2 = new Node<>(20);
// getData(n1);
// getData(n2);//报错
// n1 = n2; 不支持
// getData2(n2);
getUpperNumberData(n1);
getUpperNumberData(n2);
}
public static void getData(Node<Number> node){
System.out.println(node.getData());
}
/**
* 使用通配符定义泛型类型，此时只能输出，不能修改
* @param node
*/
public static void getData2(Node<?> node){
// node.setData(20);
System.out.println(node.getData());
}
public static void getUpperNumberData(Node<? extends Number> data){
//只能是Number类及其子类
System.out.println("data :" + data.getData());
}
/**
* 泛型方法
* @param array
* @param i
* @param t
* @param <T>
* @return
*/
public static <T> T[] func(T[] array,int i,int t){
T temp = array[i];
array[i] = array[t];
array[t] = temp;
return array;
}
@Test
public void test2(){
Node<String> stringNode = new Node<>("vince");
Node<Integer> intNode = new Node<>(10);
System.out.println(stringNode.getData());
System.out.println(intNode.getData());
}
@Test
public void test1(){
List<String> list = new ArrayList<>();
list.add("vince");
//list.add(10);
//list.add(new Object());
for (int i = 0; i < list.size(); i++) {
//如果我们不能确定集合中的元素类型，那么我们需要在处理元素时
//要判断元素的类型，才能做相应的操作
}
}
}
