Java泛型

目录

1. 为什么要有泛型

2. 在集合中使用泛型

3. 自定义范型结构

4. 泛型在继承上的体现

5. 通配符的使用

6. 泛型应用举例

1 为什么要有泛型

• 泛型：标签

• 泛型的设计背景

  集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object, JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。Collection<E>，List<E>， ArrayList<E> 这个<E>就是类型参数，即泛型。

1. 泛型的概念

   所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时(例如，继承或实现这个接口，用这个类型声明变量、创建对象时)确定(即传入实际的类型参数，也称为类型实参)。

   从JDK1.5以后，java引入了“参数化类型”的概念，允许我们在创建集合时再指定集合元素的类型，正如：List<String>，这表明该List只能保存字符串类型的对象。

   JDK1.5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参。

   (类型不能是基本数据类型)：整形可以把int改成Integer类。

2 在集合中使用泛型

 package com.xue.java5;
 ​
 import org.junit.Test;
 ​
 import java.util.*;
 ​
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/20  20:22
  * Description:
  * 泛型的使用：
  * 1. jdk5.0 新增的特性
  * 2. 在集合中使用泛型
  * 总结：
  * 1） 集合接口或集合类在jdk5.0都修改为带泛型的结构。
  * 2） 在实例化集合类 时，可以指明具体的泛型类型。
  * 3） 指明完以后，在集合类或接口中凡是定义类或接口时，内部结构使用到类的泛型的位置，都指定为实例化的泛型类型。
  *     比如：add(E e) --->实例化以后： add(Integer e)
  * 4） 注意点： 泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换。
  * 5） 如果实例化时，没有指明泛型的类型。默认类型为java.lang.Object类型。
  */
 public class GenericTest {
     //在集合中使用泛型之前的情况
     @Test
     public void test1(){
         ArrayList list = new ArrayList();
         //需求：存放学生的成绩
         list.add(78);
         list.add(76);
         list.add(89);
         list.add(88);
         //问题一：类型不安全, 可以混入其他类型的数据
 //        list.add(Tom);
         for(Object score : list){
             //问题二： 强转时，可能出现ClassCastException
             int stuScore = (int) score;
             System.out.println(stuScore);
         }
     }
 ​
     //在集合中使用泛型的情况
     @Test
     public void test2(){
         ArrayList<Integer> list = new ArrayList<Integer>();
         list.add(78);
         list.add(76);
         list.add(89);
         list.add(88);
         //编译时，就会进行类型检查，保证数据的安全。
 //        list.add(Tom); //不能编译通过
         //方式一： 增强for循环
 //        for(Integer score : list){
 //            //避免了强转操作
 //            int stuScore = score;
 //            System.out.println(stuScore);
          //方式二：iterator
             Iterator<Integer> iterator = list.iterator();
             while(iterator.hasNext()){
                 System.out.println(iterator.next());
             }
     }
 ​
     //在集合中使用泛型的情况：以HashMap为例
     @Test
     public void test3(){
         Map<String, Integer> map = new HashMap<String, Integer>();
         map.put(Tom, 87);
         map.put(Jerry, 87);
         map.put(Jack, 67);
 ​
         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);
         }
     }
     
 }

注： 在自然排序和定制排序中也可以使用泛型，会极大地简化代码。在exer1文件中有显示。

3 自定义泛型结构

• 如何自定义泛型结构：泛型类、泛型接口；泛型方法

3.1 泛型类

 package com.xue.java5;
 ​
 import org.junit.Test;
 ​
 import java.util.ArrayList;
 import java.util.List;
 ​
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/21  9:13
  * Description:
  * 1. 关于自定义泛型类、泛型接口
  */
 public class GenericTest1 {
     @Test
     public void test1(){
         //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
         //要求：如果大家定义了类是带泛型的，建议在实例化时要指明类的泛型。
         Order order = new Order();
         order.setOrderT(123);
         order.setOrderT(ABC);
 ​
         Order<String> order1 = new Order<String>(orderAA, 1001, order:AA);
         order1.setOrderT(AA:hello);
         System.out.println(order1.getOrderT());  //AA:hello
     }
     
     @Test
     public void test2(){
         SubOrder sub1 = new SubOrder();
         //由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不在需要指明泛型类型；
         sub1.setOrderT(1122);
 ​
         SubOrder1<String> sub2 = new SubOrder1<>();
         sub2.setOrderT(order2...);
 ​
     }
 ​
     @Test void test3(){
         ArrayList<String> list1 = null;
         ArrayList<Integer> list2 = new ArrayList<Integer>();
         //泛型不同的引用不能相互赋值
 //        list1 = list2;
 ​
         Person p1 = null;
         Person p2 = null;
         p1 = p2;
     }
 ​
 ​
     //测试泛型方法
     @Test
     public void test4(){
         Order<String> order = new Order<>();
         Integer[] arr = new Integer[]{1, 2, 3, 4};
         //泛型方法在调用时，指明泛型参数的类型
         List<Integer> list = order.copyFromArrayList(arr);
 ​
         System.out.println(list);  //[1, 2, 3, 4]
     }
 }

Order类：

 package com.xue.java5;
 ​
 import java.util.ArrayList;
 import java.util.List;
 ​
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/20  22:12
  * Description:
  */
 public class Order<T> {
     String orderName;
     int orderId;
 ​
     //类的内部结构就可以使用类的泛型
     //自定义泛型类
     T orderT; //声明一个T类型的变量
     public Order(){
     };
 ​
     public Order(String orderName, int orderId, T orderT) {
         this.orderName = orderName;
         this.orderId = orderId;
         this.orderT = orderT;
     }
 ​
     public String getOrderName() {
         return orderName;
     }
 ​
     public void setOrderName(String orderName) {
         this.orderName = orderName;
     }
 ​
     public int getOrderId() {
         return orderId;
     }
 ​
     public void setOrderId(int orderId) {
         this.orderId = orderId;
     }
    //如下三个方法都不是泛型方法
     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 +
                 '}';
     }
 }

SubOrder类：

 package com.xue.java5;
 ​
 import org.junit.Test;
 ​
 import java.util.ArrayList;
 import java.util.List;
 ​
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/21  9:29
  * Description:
  */
 public class SubOrder extends Order<Integer>{ //SubOrder不是泛型类，但是里边可以有泛型方法
     public <E> List<E> copyFromArrayList(E[] arr){
         ArrayList<E> list = new ArrayList<>();
         for( E e : arr){
             list.add(e); //e是arr中的每一个元素
         }
         return list;
     }
 }

SubOrder1类：

 package com.xue.java5;
 ​
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/21  9:37
  * Description:
  */
 public class SubOrder1<T> extends Order<T>{  //SubOrder1<T>仍然是泛型类
 }

3.2 自定义泛型类泛型接口注意点

1. 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如：<E1, E2, E3>

2. 泛型类的构造器如下：public GenericClass(){}

   而下边是错误的：public GenericClass<E>(){}

3. 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。

4. 泛型不同的引用不能相互赋值。

   >尽管在编译时ArrayList<String>和ArrayList<Integer>是两种类型， 但是，在运行时只有。一个ArrayList被加载到JVM中。

 @Test void test3(){
         ArrayList<String> list1 = null;
         ArrayList<Integer> list2 = null;
         //泛型不同的引用不能相互赋值
 //        list1 = list2;
 ​
         Person p1 = null;
         Person p2 = null;
         p1 = p2;
     }

5. 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object。经验: 泛型要使用一路都用。要不用，一路都不要用。

6. 如果泛型类是一个接口或抽象类，则不可创建泛型类的对象。

7. jdk1.7, 泛型的简化操作: ArrayList<Fruit> flist = new ArrayList<>();

8. 泛型的指定中不能使用基本数据类型，可以使用包装类替换。int用Integer

9. 在类/接口土声明的泛型手在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态分法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。注意和泛型方法的区别。

     //静态方法中不能使用类的泛型
     //类的泛型是造对象即实例化时指定的，而静态结构早于对象的创建
 //    public static void show(T orderT){
 //        System.out.println(orderT);
 //    }

10. 异常类不能声明为泛型类。

 public class MyException<T> extends Exception {  //会报错
 }

11. 不能使用new E[]。但是可以: E[] elements = (E[])new Object[capacity];

参考: ArrayList源码中声明: Object[] elementData，而非泛型参数类型数组。

12. 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型:

    • 子类不保留父类的泛型: 按需实现

      • 没有类型 擦除

      • 具体类型

• • 子类保留父类的泛型:泛型子类

    • 全部保留

    • 部分保留

结论: 子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型

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

 class Father<T1, T2>{
 }
 //子类不保留父类的泛型
 //1） 没有泛型 擦除
 class Son1<A, B> extends Father {//等价于class Son extends Father<Object, Object>
 }   //自己额外定义的两个泛型参数A，B
 //2) 具体类型
 class Son2<A, B> extends Father<Integer, String> {
 }
 //子类保留父类的泛型
 //1)全部保留
 class Son3<T1, T2, A, B> extends Father<T1, T2> {
 }
 //2）部分保留
 class Son4<T2, A, B> extends Father<Integer, T2> {
 }

3.3 泛型方法

//泛型方法：在方法中出现了泛型的结构，泛型的参数与类的泛型参数没有任何关系 ​ //换句话说，泛型方法所属的类是不是泛型类都没有关系。 ​ //泛型方法，可以声明为静态的。原因：泛型方法中泛型参数是在调用方法时确定的，并非在实例化类时调用的，并没有用类的泛型。

 //泛型方法
 public static <E> List<E> copyFromArrayToList(E[] arr){
     ArrayList<E> list = new ArrayList<>();
     for( E e : arr){
         list.add(e); //e是arr中的每一个元素
     }
     return list;
 }

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

3.4 泛型类和泛型方法使用场景

• 用于对于表的增删改查

DAO:

 package com.xue.java6;
 ​
 import java.util.List;
 ​
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/21  10:56
  * Description:
  * DAO: data(base) access object 数据访问对象
  */
 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;
     }
 ​
     public <E> E getValue(){
         return null;
     }
 ​
 }

DAOTest:

 package com.xue.java6;
 ​
 import org.junit.Test;
 ​
 import java.util.List;
 ​
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/22  10:21
  * Description:
  */
 public class DAOTest {
     @Test
     public void test1(){
         CustomerDAO dao1 = new CustomerDAO();
         dao1.add(new Customer());
         List<Customer> forList = dao1.getForList(10);
 ​
         StudentDAO dao2 = new StudentDAO();
         Student student = dao2.getIndex(1);
     }
 }

CustomerDAO:

 package com.xue.java6;
 ​
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/22  10:15
  * Description:
  */
 public class CustomerDAO extends DAO<Customer>{  //只能操作某一个表的DAO
 }

StudentDAO:

 package com.xue.java6;
 ​
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/22  10:24
  * Description:
  */
 public class StudentDAO extends DAO<Student>{ //只能操作某一个表的DAO
 }

Customer:

 package com.xue.java6;
 ​
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/22  10:15
  * Description:
  */
 public class Customer {
 }

Student:

 package com.xue.java6;
 ​
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/22  10:24
  * Description:
  */
 public class Student {
 }

3.5 泛型在继承上的体现

 package com.xue.java6;
 ​
 import org.junit.Test;
 ​
 import java.util.AbstractList;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 ​
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/22  11:19
  * Description:
  *
  *  * 1. 泛型在继承方面的体现
  *  *
  *  * 2. 通配符的使用
  */
 public class GenericTest {
 ​
     /*1. 泛型在继承方面的体现
          虽然类A是类B的父亲，但是G<A>和G<B>不具备子父类关系，二者是并列关系
          补充：类A是类B的父亲，A<G>是B<G>的父类。
 ​
      */
     @Test
     public void test1(){
         Object obj = null;
         String str = null;
         obj = str;
 ​
         Object[] arr1 = null;
         String[] arr2 = null;
         arr1 = arr2;   //在数组方面也是成立的,String是Object的子类
 ​
         List<Object> list1 = null;
         List<String> list2 = null;
 //        list1 = list2;  //不具备子父类关系，是并列关系
     }
 ​
     @Test
     public void test2(){
         AbstractList<String> list1 =null;
         List<String> list2 = null;
         ArrayList<String> list3 = null;
 ​
         list1 = list3;
         list2 = list3;
     }
 }

3.6 通配符的使用

 /*2. 通配符的使用
          通配符：？
          类A是类B的父亲，G<A>和G<B>是没有关系，二者共同的父类是：G<?>
 ​
      */
     @Test
     public void Test3(){
         List<Object> list1 = null;
         List<String> list2 = null;
         List<?> list = null;
         list = list1;
         list = list2;
         //编译通过了，但是指针为空，打印会出错
 //        print(list1);
 //        print(list2);
 ​
         List<String> list3 = new ArrayList<>();
         list3.add(AA);
         list3.add(BB);
         list3.add(CC);
         list = list3;
 ​
         //添加(写入)：对于List<?>就不能向其内部添加数据了.
         //除了添加null
 //        list.add(DD);  //编译错误
 //        list.add('?');  //编译错误
 ​
         //获取(读取）：允许读取数据，读取的数据类型为Object
         Object o = list.get(0);
         System.out.println(o);  //AA
     }
 ​
     public void print(List<?> list){
         Iterator<?> iterator = list.iterator();
         while(iterator.hasNext()){
             Object obj = iterator.next();
             System.out.println(obj);
         }
     }

• 有限制的通配符

  • 通配符指定上限

    • 上限extends: 使用时指定的类型必须是继承某个类，或者实现某个接口，即<=

  • 通配符指定下限

    • 下限super: 使用时指定的类型不能小于操作的类，即>=

• 举例：

  • <? extends Number> (无穷小，Number]

    • 只允许泛型为Number及Number子类的引用调用

  • <? super Number> [Number, 无穷大）

    • 只允许泛型为NumberNumber父类的引用调用

  • <? extends Comparable>

    • 只允许泛型为实现Comparable接口的实现类的引用调用

 3. 有限制条件的通配符的使用
     ? extends Person:
     ? super Person:
      */
     @Test
     public void test4(){
         List<? extends Person> list1 = null; //可以把此时的extends看成小于等于
         List<? super Person> list2 = null;  //可以把此时的super看成大于等于
 ​
         List<Student2> list3 = null;
         List<Person> list4 = null;
         List<Object> list5 = null;
 ​
         list1 = list3;
         list1 = list4;
 //        list1 = list5;  //编译错误
 ​
 //        list2 = list3;  //编译错误
         list2 = list4;
         list2 = list5;
     }

3.7 自定义泛型类练习

DAOTest：

 package com.xue.java6.exer1;
 ​
 import org.w3c.dom.ls.LSOutput;
 ​
 import java.sql.SQLOutput;
 import java.util.List;
 ​
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/22  21:26
  * Description:
  */
 public class DAOTest {
     public static void main(String[] args) {
         DAO<User> dao = new DAO<>();
         dao.save(1001, new User(1001, 34, 周杰伦));
         dao.save(1002, new User(1002, 20, 昆凌));
         dao.save(1003, new User(1003, 25, 蔡依林));
 ​
         dao.update(1003, new User(1003, 30, 方文山));
 ​
         dao.delete(1002);
 ​
         List<User> list = dao.list();
 //        System.out.println(list);
         list.forEach(System.out::println);  //新的遍历方法
 ​
 ​
     }
 }

DAO:

 package com.xue.java6.exer1;
 ​
 import java.util.*;
 ​
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/22  20:35
  * Description:
  * 定义个泛型类DAO<T>，在其中定义一个Map成员变量，Map的键为String类型，值为T类型。
  * 分别创建以下方法:
  * public void save(String id,T entity): 保存 T类型的对象到Map成员变量中
  * public T get(String id): 从map中获取id对应的对象
  * public void update(String id,T entity):替换map中key为id的内容, 改为entity对象
  * public list<T> list(): 返回map中存放的所有T对象
  * public void delete(String id): 删除指定id对象
  */
 public class DAO<T> {
     private Map<String, T> map = new HashMap<String,T>();
 ​
     //保存 T类型的对象到Map成员变量中
     public void save(String id,T entity){
         map.put(id, entity);
     }
     //从map中获取id对应的对象
     public T get(String id){
         return map.get(id);
     }
     //替换map中key为id的内容, 改为entity对象
     public void update(String id,T entity){
         if(map.containsKey(id)){  //如果没有为id的key，就不修改了
             map.put(id, entity);
         }
 ​
     }
     //返回map中存放的所有T对象
     public List<T> list(){
         //错误的
 //        Collection<T> values = map.values();
 //        values存在Collection中，不能强转为list，如果之前存在于list，变为Collection,那么可以强转
 //        return (List<T>) values;
 ​
         //正确的
         ArrayList<T> list = new ArrayList<>();
         Collection<T> values = map.values();
         for(T t : values){
             list.add(t);
         }
         return list;
     }
     //删除指定id对象
     public void delete(String id){
         map.remove(id);
     }
 }

User:

 package com.xue.java6.exer1;
 ​
 import java.util.Objects;
 ​
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/22  21:22
  * Description:
  * 定义一个User类：
  * 该类包含： private成员变量（int类型） id, age; (String 类型）name.
  */
 public class User {
     private int id;
     private int age;
     private String name;
 ​
     public User() {
     }
 ​
     public User(int id, int age, String name) {
         this.id = id;
         this.age = age;
         this.name = name;
     }
 ​
     @Override
     public String toString() {
         return User{ +
                 id= + id +
                 , age= + age +
                 , name=' + name + '\'' +
                 '}';
     }
 ​
     public int getId() {
         return id;
     }
 ​
     public void setId(int id) {
         this.id = id;
     }
 ​
     public int getAge() {
         return age;
     }
 ​
     public void setAge(int age) {
         this.age = age;
     }
 ​
     public String getName() {
         return name;
     }
 ​
     public void setName(String name) {
         this.name = name;
     }
 ​
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
         User user = (User) o;
         return id == user.id &&
                 age == user.age &&
                 Objects.equals(name, user.name);
     }
 ​
     @Override
     public int hashCode() {
         return Objects.hash(id, age, name);
     }
 }

 

 

 

 

知识补充

1 Object

• Object类型的数据可以通过强转为其他类对象，进行相关操作或者调用相关类的方法。

•