泛型的设计背景

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

泛型的概念

泛型(Generics),是指在类定义时不指定类中信息的具体数据类型,而是暂时用一个标识符来替代,当外部实例化对象时再指定具体的数据类型。

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

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

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

为什么要有泛型?如何使用?

解决元素存储的安全性问题, 好比商品、 药品标签, 不会弄错。

解决获取数据元素时, 需要类型强制转换的问题, 好比不用每回拿商品、 药品都要辨别。

泛型的好处应用

优点:这样做极大地提升程序的灵活性,提升类的扩展性,泛型可以指代类中成员变量的数据类型,方法的返回值类型以及方法的参数类型。

在没有泛型时

// 以前在定义A类的时候就指定了b属性是B类型
public class A{
    private B b;

    public C test(D d){
        return new C();
    }

    // 问题所在
    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 = (Integer) score;
            System.out.println(stuScore);
        }
    }
}

在有泛型时

// 现在定义A类的时候不指定属性的类型
public class A<T,E,M>{
    private T b;
    public E test(M m){
        return E;
    }
}

// 实例化时定义类型
A<T,E,M> a = new A()<T,E,M>;

ArrayList 为例

public void test2(){
    ArrayList<Integer> list =  new ArrayList<Integer>();
    list.add(78);
    list.add(87);
    list.add(99);
    list.add(65);
    //编译时,就会进行类型检查,保证数据的安全
    //        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 为例

// 在集合中使用泛型的情况:以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("Jerry",87);
    map.put("Jack",67);
    // 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);
    }
}

应用总结

1、集合接口或集合类在jdk5.0时都修改为带泛型的结构。

2、在实例化集合类时,可以指明具体的泛型类型,可以保证如果程序在编译时没有发出警告,运行时就不会产生ClassCastException 异常。使得代码更加简洁、健壮。

3、指明完以后,在集合类或接口中凡是定义类或接口时,内部结构(比如:方法、构造器、属性等)使用到类的泛型的位置,都指定为实例化的泛型类型。比如:add(E e) 实例化以后:add(Integer e)

4、注意点:泛型的类型必须是类,不能是基本数据类型。需要用到基本数据类型时,拿包装类替换

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

泛型通配符

通配符:?

类A是类 B 的父类,G<A>G<B> 是没有关系的,二者共同的父类是:G<?> ,如下例子

public class Test {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        ArrayList<Integer> list2 = new ArrayList<>();
        test(list1);
        test(list2);
    }
    public static void test(ArrayList<?> list){
        System.out.println(list);
    }
}

使用通配符后,数据的读取和写入要求

  • 添加(写入):对于 List<?> ,不能向其内部添加数据。
  • 获取(读取):允许读取数据,读取的数据类型为 Object

如下例子

List<String> list3 = new ArrayList<>();
list3.add("AA");
list3.add("BB");
list3.add("CC");
// list为上一个示例定义
list = list3;
// 添加(写入):对于List<?>就不能向其内部添加数据,编译失败
// 除了添加null之外。
// list.add("DD");
// list.add('?');
 
list.add(null);
 
// 获取(读取):允许读取数据,读取的数据类型为Object。
Object o = list.get(0);
System.out.println(o);

泛型上限和下限

有限制条件的通配符的使用

上限:表示实例化时具体的数据类型,可以是上限类型的子类或者是上限类型本身,用 extends 表示。

下限:表示实例化时具体的数据类型,可以是下限类型的父类或者是下限类型本身,用 super 表示。

类名<泛型标识 extends 上限类名>

类名<泛型标识 super 下限类名>

public class Time<T> {
    public static void main(String[] args) {
        test(new Time<Float>());
        test(new Time<Integer>());
        test(new Time<Number>());

        test2(new Time<String>());
        test2(new Time<Object>());
    }
    
    /**
     * 泛型上限
     * @param time
     */
    public static void test(Time<? extends Number> time){}

    /**
     * 泛型下限
     * @param time
     */
    public static void test2(Time<? super String> time) {}
}

泛型接口

语法:接口<T>

public interface MyInterface<T> {
    public T getValue();
}

实现泛型接口

实现类在定义时继续使用泛型标识

public class MyInterfaceImpl<T> implements MyInterface  {
    private T obj;
    public MyInterfaceImpl(T obj) {
        this.obj = obj;
    }
    @Override
    public T getValue() {
        return this.obj;
    }
}

实现类在定义时直接给出具体的数据类型

public class MyInterfaceImpl2 implements MyInterface<String> {
    private String obj;
    public MyInterfaceImpl2(String obj) {
        this.obj = obj;
    }
    @Override
    public String getValue() {
        return this.obj;
    }
}
public class Test {
    public static void main(String[] args) {
        MyInterfaceImpl myInterface = new MyInterfaceImpl<String>("接口");
        String val = (String) myInterface.getValue();

        MyInterfaceImpl2 myInterface1 = new MyInterfaceImpl2("接口");
        val = myInterface1.getValue();
    }
}

应用举例

以操作数据库举例,在实际开发中,每一个数据库表对应一个 JAVA 实体类,对数据库表的一些操作行为的类,我们称作为 DAO ,现在我们需要编写一个通用于多个表的 DAO 类,它具有一些对多个表的共性操作,所以需要使用到泛型类,如下代码

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;
    }
}

定义具体到某个表的 DAO ,例如操作 Student

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

实体类

public class Student {
    
}

泛型方法

在方法中出现了泛型的结构,泛型参数与类的泛型参数没有任何关系。换句话说,泛型方法所属的类,是不是泛型类都没有关系。

并且,泛型方法可以是静态的,原因为:泛型参数是在调用方法时确定的。并非在实例化类时确定。如下代码如下

public static <E>  List<E> copyFromArrayToList(E[] arr){
 
    ArrayList<E> list = new ArrayList<>();
 
    for(E e : arr){
        list.add(e);
    }
    return list;
}
/**
 * 泛型方法的基本介绍
 * @param tClass 传入的泛型实参
 * @return T 返回值为T类型
 * 说明:
 *     1)public 与 返回值中间<T>非常重要,可以理解为声明此方法为泛型方法。
 *     2)只有声明了<T>的方法才是泛型方法,泛型类中的使用了泛型的成员方法并不是泛型方法。
 *     3)<T>表明该方法将使用泛型类型T,此时才可以在方法中使用泛型类型T。
 *     4)与泛型类的定义一样,此处T可以随便写为任意标识,常见的如T、E、K、V等形式的参数常用于表示泛型。
 */
public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
IllegalAccessException{
    T instance = tClass.newInstance();
    return instance;
}

注意事项

  • public 与 返回值中间<T>非常重要,可以理解为声明此方法为泛型方法。
  • 只有声明了<T>的方法才是泛型方法,泛型类中的使用了泛型的成员方法并不是泛型方法。
  • <T>表明该方法将使用泛型类型T,此时才可以在方法中使用泛型类型T
  • 与泛型类的定义一样,此处T可以随便写为任意标识,常见的如T、E、K、V等形式的参数常用于表示泛型。

泛型方法的使用情景:

  • 具有通用性
  • 返回值不确定
  • 例如这个方法提供了多个功能:获取表中一共有多少条记录?获取最大的员工入职时间?此时我们需要将该方法的返回值写为 “泛型”
// 泛型方法
// 举例:获取表中一共有多少条记录?获取最大的员工入职时间?
public <E> E getValue(){
    return null;
}

代码复原总结

下面是来自一个优秀的博主写的代码总结,能够更好理清泛型的来龙去脉。

public class GenericTest {
    //这个类是个泛型类,在上面已经介绍过
    public class Generic<T>{     
        private T key;

        public Generic(T key) {
            this.key = key;
        }

        //我想说的其实是这个,虽然在方法中使用了泛型,但是这并不是一个泛型方法。
        //这只是类中一个普通的成员方法,只不过他的返回值是在声明泛型类已经声明过的泛型。
        //所以在这个方法中才可以继续使用 T 这个泛型。
        public T getKey(){
            return key;
        }

        /**
         * 这个方法显然是有问题的,在编译器会给我们提示这样的错误信息"cannot reslove symbol E"
         * 因为在类的声明中并未声明泛型E,所以在使用E做形参和返回值类型时,编译器会无法识别。
        public E setKey(E key){
             this.key = keu
        }
        */
    }

    /** 
     * 这才是一个真正的泛型方法。
     * 首先在public与返回值之间的<T>必不可少,这表明这是一个泛型方法,并且声明了一个泛型T
     * 这个T可以出现在这个泛型方法的任意位置.
     * 泛型的数量也可以为任意多个 
     *    如:public <T,K> K showKeyName(Generic<T> container){
     *        ...
     *        }
     */
    public <T> T showKeyName(Generic<T> container){
        System.out.println("container key :" + container.getKey());
        //当然这个例子举的不太合适,只是为了说明泛型方法的特性。
        T test = container.getKey();
        return test;
    }

    //这也不是一个泛型方法,这就是一个普通的方法,只是使用了Generic<Number>这个泛型类做形参而已。
    public void showKeyValue1(Generic<Number> obj){
        Log.d("泛型测试","key value is " + obj.getKey());
    }

    //这也不是一个泛型方法,这也是一个普通的方法,只不过使用了泛型通配符?
    //同时这也印证了泛型通配符章节所描述的,?是一种类型实参,可以看做为Number等所有类的父类
    public void showKeyValue2(Generic<?> obj){
        Log.d("泛型测试","key value is " + obj.getKey());
    }

    /**
     * 这个方法是有问题的,编译器会为我们提示错误信息:"UnKnown class 'E' "
     * 虽然我们声明了<T>,也表明了这是一个可以处理泛型的类型的泛型方法。
     * 但是只声明了泛型类型T,并未声明泛型类型E,因此编译器并不知道该如何处理E这个类型。
    public <T> T showKeyName(Generic<E> container){
        ...
    }  
    */

    /**
     * 这个方法也是有问题的,编译器会为我们提示错误信息:"UnKnown class 'T' "
     * 对于编译器来说T这个类型并未项目中声明过,因此编译也不知道该如何编译这个类。
     * 所以这也不是一个正确的泛型方法声明。
    public void showkey(T genericObj){

    }
    */
}

本次复习总结参考了两位优秀的博主和一位优秀的阿婆主

https://blog.csdn.net/s10461/article/details/53941091

https://codeyee.com/archives/java-generics.html

https://www.bilibili.com/video/BV16i4y157GW?p=100


腾讯云社区邀请各位技术博主加入,福利多多噢!
Last modification:January 22nd, 2021 at 11:17 pm
如果觉得我的文章对你有用,请随意赞赏