他是 JDK5 中引入的一个新特性，泛型提供了编译时类型安全监测机制，该机制允许我们在编译时检测到非法的类型数据结构。泛型的本质就是参数化类型，也就是所操作的数据类型被指定为一个参数

# 常见的泛型的类型表示
上面的 T 仅仅类似一个形参的作用，名字实际上是可以任意起的，但是我们写代码总该是要讲究可读性的。常见的参数通常有 :
E - Element (在集合中使用，因为集合中存放的是元素)
T - Type（表示Java 类，包括基本的类和我们自定义的类）
K - Key（表示键，比如Map中的key）
V - Value（表示值）
? - （表示不确定的java类型）

但是泛型的参数只能是类类型，不能是基本的数据类型，他的类型一定是自Object的

————————————————

一、泛型的优点

1.1优点

1.提交了java的类型安全
泛型在很大程度上来提高了java的程序安全。例如在没有泛型的情况下，很容易将字符串 123 转成 Integer 类型的 123 亦或者 Integer 转成 String，而这样的错误是在编译期无法检测。而使用泛型，则能很好的避免这样的情况发生。

2.不需要烦人的强制类型转换
泛型之所以能够消除强制类型转换，那是因为程序员在开发的时候就已经明确了自己使用的具体类型，这不但提高了代码的可读性，同样增加了代码的健壮性。

3. 提高了代码的重用性
泛型的程序设计，意味着编写的代码可以被很多不同类型的对象所重用

1.2为什么要使用泛型

二、泛型使用与不使用的区别

1、泛型的没有使用会造成什么后果呢？

import org.junit.Test;
import java.util.ArrayList;
/**
 * 泛型的使⽤
 * 1.jdk5.0新增的特征
 */
 public class GenericTest {
 //在集合中使⽤泛型之前的情况：
 @Test
 public void test(){
 ArrayList list = new ArrayList();
 //需求：存放学⽣的成绩
 list.add(78);
 list.add(49);
 list.add(72);
 list.add(81);
 list.add(89);
 //问题⼀：类型不安全
 // list.add("Tom");
 for(Object score : list){
 //问题⼆：强转时可能出现类型转化异常
 int stuScore = (Integer)score;
 
 System.out.println(stuScore);
 }
 }
}

那我们发现，没有添加泛型的时候呢，我们可以向list集合添加各种各样类型的数据，那么就会导致在数据类型转换的时候发生异常，那么我们添加泛型的好处也是很明显的了。

2.添加泛型的使用会发生什么效果呢？

public class GenericTest {
 //!在集合中使⽤泛型的情况：以ArrayList为例
 @Test
 public void test2(){
 //注意点：泛型的类型必须是类，不能是基本数据类型。需要⽤到基本数据类型的位置，拿包装类替换
 //看图例这⾥规定泛型是Integer，使⽤add⽅法的时候也是Integer
 ArrayList<Integer> list = new ArrayList<Integer>();
 
 list.add(78);
 list.add(49);
 list.add(72);
 list.add(81);
 list.add(89)

 //编译时，就会进⾏类型检查，保证数据的安全
// list.add("Tom");
 //⽅式⼀：
// for(Integer score :list){
// //避免了强转的操作
// int stuScore = score;
//
// System.out.println(stuScore);
// }

 //⽅式⼆：
 Iterator<Integer> iterator = list.iterator();
 while(iterator.hasNext()){
 int stuScore = iterator.next();
 System.out.println(stuScore);
     }
 }

 //在集合中使⽤泛型的情况：以HashMap为例
 @Test
 public void test3(){
 // Map<String,Integer> map = new HashMap<String,Integer>();
 //jdk7新特性：类型推断, 实例化的时候就可以不⽤写泛型，空即可
 Map<String,Integer> map = new HashMap<>();
 map.put("Tom",87);
 map.put("Tone",81);
 map.put("Jack",64);
// map.put(123,"ABC");
 //泛型的嵌套
 Set<Map.Entry<String,Integer>> entry = map.entrySet();
 Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
 
 while(iterator.hasNext()){
 Map.Entry<String, Integer> e = iterator.next();
 String key = e.getKey();
 Integer value = e.getValue();
 System.out.println(key + "----" + value);
     }
 }
 
}

使用了泛型，就可以达到很多方便开发的效果，可以实现泛型的嵌套，也不用担心数据转换异常问题，有错误编译期间就会报错。

【一、二】知识点小结

经过知识总结归纳，到目前的泛型学习，有几个知识点需要注意：

① 泛型是在JDK1.5版本之后出现的，改写了集合框架中所有的接口和类，为他们提供泛型的支持，从⽽可以在声明集合变量、创建集合对象时传⼊类型实参。

②泛型的出现使集合类型安全

③需要注意的是，泛型的类型必须是类，不能是基本数据类型。需要⽤到基本数据类型的位置，拿包装类替换。

如果实例化时，没有指明泛型的类型。默认类型为java.lang.Object类型。

关于包装类的延伸知识点

包装类

每个基本数据类型都提供了一个包装类，使用对应的包装类对象，对对应类型的数据进行了封装，又提供相应的方法对其封装的数据可以进行一些操作。

包装类(基本概念和一些使用方法)_Vicali的博客-CSDN博客_什么是包装类

三、自定义泛型结构

3.1泛型类举个栗子

3.1.1 OrderTest类

public class OrderTest<T> {
 String orderName;
 int orderId;
 //类的内部结构就可以使⽤类的泛型
 T orderT;
 public OrderTest(){
 };
 public OrderTest(String orderName,int orderId,T orderT){
 this.orderName = orderName;
 this.orderId = orderId;
 this.orderT = orderT;
 }
 //如下的三个⽅法都不是泛型⽅法
 public T getOrderT(){
 return orderT;
 }
 public void setOrderT(T orderT){
 this.orderT = orderT;
 }
    
@Override
 public String toString() {
 return "Order{" +
 "orderName='" + orderName + '\'' +
 ", orderId=" + orderId +
 ", orderT=" + orderT +
 '}';
     }
 }

@Test
 public void test(){
 /**
 * 如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
 * 要求：如果⼤家定义了类是带泛型的，建议在实例化时要指明类的泛型。
 */
 OrderTest order = new OrderTest();
 order.setOrderT(123);
 order.setOrderT("ABC");
 //建议：实例化时指明类的泛型
 OrderTest<String> order1 = new OrderTest<String>
("orderAA",1001,"order:AA");
 
 order1.setOrderT("AA:hello");
 }

使用类的泛型就可以在需要一些新增的属性的时候匹配到它。

3.2自定义泛型类的子类怎么处理？

那么就会有几种情况

3.3、在继承情况中使用泛型

简单情况↓↓

//1.⼦类不保留⽗类的泛型
class Father<T1, T2> {}
 
// 1)没有类型 擦除
class Son1 extends Father {// 等价于class Son extends Father<Object,Object>{}
}
// 2)具体类型
class Son2 extends Father<Integer, String> {}
//2.⼦类保留⽗类的泛型
// 1)全部保留
class Son3<T1, T2> extends Father<T1, T2> {}
// 2)部分保留
class Son4<T2> extends Father<Integer, T2> {}

复杂情况↓↓

①不保留

父类没有类型，子类保留自己提供的

父类有类型，子类保留自己提供的

父类有，子类保留自己提供的和父类全部的一起保留

父类有类型，子类保留自己提供的和部分父类的

//1.⼦类不保留⽗类的泛型
class Father<T1, T2> {}
 
// 1)没有类型 擦除
//⾃⼰提供两个
class Son<A, B> extends Father {// 等价于class Son extends Father<Object,Object>{}
}
// 2)具体类型
//⽗类指定了，⾃⼰也有
class Son2<A,B> extends Father<Integer, String> {}
//2.⼦类保留⽗类的泛型
// 1)全部保留
class Son3<T1, T2, A, B> extends Father<T1, T2> {}
// 2)部分保留
class Son4<T2, A, B> extends Father<Integer, T2> {}

3.4自定义泛型方法

3.4.2泛型⽅法的格式

[访问权限] <泛型> 返回类型 ⽅法名([泛型标识参数名称]) 抛出的异常
 
 
 例如：
 public <E> List<E> ⽅法名(E[] arr)　throws Exception{
 //。。。。
 }

所以，需要在返回值类型前⾯加泛型，编译器才理解这个E不是类，是泛型。↓↓

public class OrderTest<T> {
 /**
 * 泛型⽅法：在⽅法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。
 * 换句话说，泛型⽅法所属的类是不是泛型类都没有关系。
 */
 public <E> List<E> copyFromArrayToList(E[] arr){
 ArrayList<E> list = new ArrayList<>();
 for(E e : arr){
 list.add(e);
 }
 return list;
 }
}

测试类↓↓

public class GenericTest1 {
 //测试泛型⽅法
 @Test
 public void test4(){
 OrderTest<String> order = new OrderTest<>();
 Integer[] arr = new Integer[]{1,2,3,4};
 //泛型⽅法在调⽤时，指明泛型参数的类型。
 List<Integer> list = order.copyFromArrayToList(arr);
 System.out.println(list);
 }
}

3.4.3、子类重写泛型方法

import java.util.ArrayList;
import java.util.List;
public class SubOrder extends OrderTest<Integer>{ //SubOrder:不是泛型类
 
 public static <E> List<E> copyFromArrayToList(E[] arr){//静态的泛型⽅法
 
     ArrayList<E> list = new ArrayList<>();
 
     for(E e : arr){
         list.add(e);
     }
     return list;
 
     }
}

3.5、泛型类和泛型方法的使用情景

* 1编写Dao类，实现增删改查方法

*2 编写Customer类，其实就是数据库中的Customer表

*3 编写Student类，其实就是数据库中的Student表

* 4编写StudentDao和CustomerDao类来操作各自对应的表(使用泛型实现操作对应的表)

* 5编写测试类

1↓

import java.util.List;
public class DAO<T> { //表的共性操作的DAO
 //添加⼀条记录
 public void add(T t){
 
 }
 
 //删除⼀条记录
 public boolean remove(int index){
 
 return false;
 }
 
 //修改⼀条记录
 public void update(int index,T t){
 
 }
 
 //查询⼀条记录
 public T getIndex(int index){
 
 return null;
 }
 
 //查询多条记录
 public List<T> getForList(int index){
 
 return null;
 }

2↓

public class Customer { 
}

3↓

public class Student {
}

public class CustomerDAO extends DAO<Customer>{
}




public class StudentDAO extends DAO<Student> {//只能操作某⼀个表的DAO
}

5↓

import org.junit.Test;
import java.util.List;
public class DAOTest {
 @Test
 public void test(){
 CustomerDAO dao1 = new CustomerDAO();
 
 dao1.add(new Customer());
 List<Customer> list = dao1.getForList(10);
 StudentDAO dao2 = new StudentDAO();
 Student student = dao2.getIndex(1);
 }
}

四、通配符的使用

4.2使用场景

比如这两个方法都是用来遍历List集合,只是泛型不同，使用通配符就可以合二为一。

public void show2(List<String> list){
 }
 public void show(List<Object> list){
 }

4.3具体使用说明

总结：

1.使用泛型的好处集合类型安全，代码更健壮；

2.泛型标记符要认识，T->java类 E->集合元素 K->键 V->值？->不确定的java类型

3.泛型分为泛型类，泛型方法，泛型接口；这里面再细分就是

自定义泛型类->类定义了泛型的话，那么类的内部结构就可以使用类的泛型；

继承泛型类时的子类泛型继承方式、使用方式等等...

泛型方法的格式，静态方法也可以是泛型方法，但是静态方法不能定义泛型

4.通配符？上限通配符只能读，下限通配符只能写，又读又写不用通配符。

泛型的类型必须是类，不能是基本数据类型。需要⽤到基本数据类型的位置，拿包装类替换。

Java基础—泛型的使用（详细）

零、概念