Hello ! 我是小小。从一个啥也不会的Java小白，到Java大佬，就因为会了这一门杜门绝迹，泛型，成为令人仰慕的大佬，今天是本周的第六篇，主要内容是Java泛型

什么是泛型

例如一段代码

//创建一个List集合
ArrayList al = new ArrayList();
al.add(123); //添加基本数据类型对象
al.add("123"); //添加String对象
al.add(new Person("123")); //添加自定义Person对象

在这段代码中，如果需要添加 string类型，需要改成如下方式

//创建一个List集合 并指定集合的对象类型
ArrayList<String> al = new ArrayList<String>();
al.add("123");
al.add("iamxiarui");

即，当指定了集合中的对象类型后，集合只能保存相关的类型，如果保存的类型和指定的类型不匹配，需要进行更改。

泛型的本质是参数化类型，即，数据类型被指定为一个参数，这种参数类型可以用在类，接口和方法的创建中，即，泛型类，泛型接口，泛型方法。

格式可以更改如下

//List集合中 指定元素类型是Map集合 ，Map集合中指定的key是String类型，value是Object类型
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
for (int i = 0; i < icon.length; i++) {
Map<String, Object> map = new HashMap<String, Object>();
//Map中添加的key是String , value是数组中的元素，是Object类型
map.put("icon", icon[i]);
map.put("item", item[i]);
list.add(map);
}

泛型作用

解决代码中的安全

在代码编写过程中，使用泛型可以限定相关的类型，确定只有相关的类型才能使用相关的泛型。

可以把代码的异常转移到编译期间

在规定的集合中保存相应的类型，在编译期间可以检查到，减少在代码运行期间发生意外。

避免了强制类型转换的干扰

避免了代码在强制类型转换的时候，需要频繁的在前面加上括号，只需要直接使用泛型就包括的代码的类型。

限定

不明确类型的时候，用？表示。即占位符

public static void print(ArrayList<?> al){
Iterator<?> it = al.iterator();
}

该方法传入参数的时候，可以被任何类型所传入。
这样非常的简洁，也同样非常的简单。

泛型上限：？ extends E 当前集合类型可以是 E 类型或者E类型的子类型

//表示可以该集合存入Person类 或者 Person 类的子类型
public static void print(ArrayList<? extends Person> al){
Iterator< extends Person> it = al.iterator();
}

泛型下限：？ super E 表示当前集合类型可以是E类型或者E类型的父类型

//表示可以该集合存入Student类 或者 Student 类的父类型
public static void print(ArrayList<? super Student> al){
Iterator<? super Student> it = al.iterator();
}

自定义泛型

泛型类：当类中引用的数据类型不确定的时候，可以定义泛型类

// 自定义泛型：定义了Generic类的类型是Person对象
class Generic<Person> {
private Person p;
public Person getP() {
System.out.println(p);
return p;
}
public void setP(Person p) {
this.p = p;
}

泛型方法：在类中的方法上定义出泛型

// 自定义泛型：定义了Generic类的类型是Person对象
class Demo{
public <T> void show(T t){
System.out.println(t);
}
<pre> public <Q> void show(Q q){
System.out.println(q);
}
}

// 类上已经定义了泛型
class GenericMethod<B> {

// 方法上没有定义泛型 则根据类确定泛型
public void getB(B b) {
System.out.println("B — " + b);
}

// 方法上已经定义了泛型 根据方法泛型来
public <C> void getC(C c) {
System.out.println("C — " + c);
}

// 静态方法 必须自定义方法泛型 不能根据类上的泛型
public static <D> void getD(D d) {
System.out.println("D — " + d);
}

泛型接口：定义接口的泛型方法

// 定义接口的泛型
interface Intet<T> {
void show(T t);
}

// 类实现接口 并自定义泛型
class GenericInterface<T> implements Intet<T> {

public void show(T t) {
System.out.println("show — " + t);
}
}