java 泛型 万字详解（通俗易懂)

目录

一、前言

二、为什么需要泛型？

三、什么是泛型？

        1.泛型的定义 : 

        2.泛型的作用 : 

四、怎么用泛型？

        1.泛型的语法 : 

        2. 泛型的使用 : 

        3.自定义泛型类 : 

                1° 基本语法 : 

                2° 使用细节 : 

        4.自定义泛型接口 : 

                1° 基本语法 : 

                2° 使用细节 : 

五、泛型内容延申

        1.关于继承性 : 

        2.关于通配符 : 

        3.关于JUnit框架 : 

                ①为什么需要JUnit？

                ②什么是JUnit?

                ③怎么使用JUnit？

六、完结撒❀

---

一、前言

        大家好，本篇博文是对java——集合篇章的内容补充，主要是给大家讲讲泛型。
        注意 : ①代码中的注释也很重要；②不要眼高手低，自己跟着动手敲一遍代码；③点击文章前面的目录或者侧边栏的目录可以进行跳转。良工不示人以朴，up所有文章都会进行适时改进。感谢阅读！

二、为什么需要泛型？

        1.用传统的方法创建集合，并对集合进行添加元素等操作时，无法对加入到集合中的元素的类型进行约束，导致有可能在类型转换时出现“类型转换异常”的情况，不安全。

        2.用传统方式遍历集合时，如果集合中的数据量较大，频繁的类型转换会降低程序运行的效率。

                eg :
                up以Intro类为演示类，我们设法向集合中添加几个苹果类对象，但是又意外地添加了一个梨类对象，我们假装自己不知道这个意外，仍然抱着“集合中都是苹果对象”的心态对集合中苹果对象的name属性进行遍历。代码如下 : 

package csdn.knowledge.api_tools.gather.generic;

import java.util.ArrayList;

/**
 * @author : Cyan_RA9
 * @version : 21.0
 */
public class Intro {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList arrayList = new ArrayList();

        //向集合中添加元素
        arrayList.add(new Apple("Green Apple"));
        arrayList.add(new Apple("Banana Apple"));
        arrayList.add(new Apple("Red Apple"));
        //意外发生了
        arrayList.add(new Pear());

        for (Object o : arrayList) {
            Apple apple = (Apple) o;
            System.out.println(apple.getName());
        }
    }
}

class Apple {
    private String name;
    public Apple(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
}

class Pear {}

                运行结果 : 

                显然，IDEA不是格格巫，想把一个梨对象凭空转换成苹果对象是不现实的，果断给你报出“ClassCastException”（类型转换异常)。

三、什么是泛型？

        1.泛型的定义 : 

        1° 泛型，又称参数化类型(ParameterizedType)，是一种可以“表示其他数据类型”的数据类型。泛型是JDK5.0中出现的新特性，解决数据类型的安全性问题，在类声明或实例化时只要指定好具体的类型即可。

        2° java泛型可以保证——如果程序在编译时没有发出警告，运行时就不会产生类型转换异常（ClassCastException)，同时使得代码更加简洁和健壮。

        2.泛型的作用 : 

        1° 可以在类声明时通过一个标识来表示类中的某个属性的数据类型；

        2° 可以表示类中某个方法的返回值的数据类型；

        3° 可以表示某个方法或者构造器的形参的数据类型；

        PS : 可以理解为——将来会用指定的类型替换掉源代码中对应的“泛型”。

                eg : 
                up以Intro_2类为演示类，最终要实现——使用String类型“替换掉”Grape类中给出的泛型，代码如下 : 

package csdn.knowledge.api_tools.gather.generic;

/**
    利用泛型创建对象时，就比如当前情况下，如果直接传入非String类型，会直接报错；
    而如果仅对编译类型使用了泛型，构造器没有给出泛型，即写成下面这样子——
        Grape grape = new Grape(141);
    这时候就会造成——运行期异常—— “ClasCastException”。
 */
public class Intro_2 {
    public static void main(String[] args) {
        Grape grape = new Grape("grape");
        System.out.println("temp = " + grape.getTemp());
        System.out.println("temp's Class = " + grape.getTemp().getClass());
    }
}

class Grape {
    /*
        1. E可以表示temp变量的数据类型
            该类型在定义Grape类对象时可以指定，即在编译期间确定E是什么类型。
     */
    private E temp;

    /*
        2. E也可以表示形参的数据类型，用法同上。
     */
    public Grape(E temp) {
        this.temp = temp;
    }

    /*
        3. E也可以表示函数的返回值的数据类型，用法同上。
     */
    public E getTemp() {
        return temp;
    }
}

                运行结果 :  

                其实，当我们创建葡萄类对象给出的泛型时， 达到的效果如下——

class Grape {
    private String temp;

    public Grape(String temp) {
        this.temp = temp;
    }

    public String getTemp() {
        return temp;
    }
}

                即，在所有泛型E出现的地方，E都被替换为了String。

四、怎么用泛型？

        1.泛型的语法 : 

        1° interface 接口名 或者 interface 接口名

        2° class 类名 或者 class 类名

        Δ注意 : 

        ①尖括号<>中可以填写任意字母作为泛型的标识符，一般均为大写，常用T，K和V，分别表示Type，Key和Value。

        ②字母本身不代表任何值，而代表类型，即程序员手动指定的数据类型。

        ③在指定泛型时，必须要求最终确定的数据类型为引用类型，不可以是基本数据类型。

        ④实际传入的类型可以是泛型指定类型的子类型。

        ⑤若在定义类时使用了泛型，实例化该类时却什么都没有传入，默认使用Object类型。

        2. 泛型的使用 : 

        从JDK7开始，等号后边的泛型可以不用写了，称为“菱形泛型”。     

        以上文“泛型的作用”中的代码为例，我们可以将其改写为如下的形式——

                Grape grape = new Grape<>("grape"); //菱形泛型

        在实际开发中，菱形泛型的使用非常广泛，因此，推荐这种写法。

                up以Generic_Demo1类为演示类，代码如下 : 

package csdn.knowledge.api_tools.gather.generic;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * @author : Cyan_RA9
 * @version : 21.0
 */
public class Generic_Demo1 {
    public static void main(String[] args) {
        //1.创建集合对象（使用泛型）
        ArrayList arrayList = new ArrayList<>();

        //2.向集合中添加元素
        arrayList.add(141);
        arrayList.add(141);
        arrayList.add(5);
        arrayList.add(11);
        arrayList.add(233);
        arrayList.add(233);

        //3.遍历集合
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext())
        {
            System.out.println(iterator.next());
        }   //不再需要进行类型转换
    }
}

                运行结果 : 

        3.自定义泛型类 : 

                其实，我们在上文中举过的例子———
                class Grape {
                }
                ———就是自定义泛型的应用。

                1° 基本语法 : 

        class 类名 {        //可以同时定义多个泛型

                //类体

        }

                2° 使用细节 : 

        ①类的非静态成员可以使用泛型（属性，方法，构造器等）。

        ②静态成员中不可以使用类的泛型。

           原因也很简单，我们在“代码块”一文中讲过，static修饰的成员的初始化——在类加载时就会执行完毕，而泛型最终代表的数据类型是在创建对象时才确定的，所以，jvm在对静态成员初始化时，无法得知它们的实际类型，也就没法儿初始化了。

        ③在自定义泛型类中，使用了泛型的数组只可以定义，不可以被初始化。

            因为jvm无法确定数组的实际类型，也就没法在内存中开辟空间。

        ④自定义泛型类中，泛型最后代表的数据类型是在创建对象时确定的。

        ⑤如果在创建泛型类对象时没有给出指定类型，默认以Object替代。

                eg : 
                up以Generic_Demo2类为演示类，代码如下 : 

package csdn.knowledge.api_tools.gather.generic;

import java.util.ArrayList;

/**
 * @author : Cyan_RA9
 * @version : 21.0
 */
public class Generic_Demo2 {
    public static void main(String[] args) {
        ArrayList phones = new ArrayList<>();

        phones.add(new Phone("Huawei", "mate50", 6000));
        phones.add(new Phone("Huawei", "mate40", 4000));
        phones.add(new Phone("Huawei", "mate30", 3500));

        System.out.println("phones = " + phones);

        Phone apple = new Phone<>("Apple", "iphone 14", 6000);
        /*
            泛型方法中，泛型最终表示的实际的数据类型————即传入的形参的类型。（引用类型）
         */
        apple.charge(Integer.valueOf(100));
        apple.charge(Long.valueOf(2333));
    }
}

class Phone {
    //使用了泛型的成员变量
    private T brand;
    private T model;
    private E price;

    //使用了泛型的构造器
    public Phone() {}
    public Phone(T brand, T model, E price) {
        this.brand = brand;
        this.model = model;
        this.price = price;
    }

    //使用了泛型的成员方法
    public T getBrand() {
        return brand;
    }
    public void setBrand(T brand) {
        this.brand = brand;
    }

    public T getModel() {
        return model;
    }
    public void setModel(T model) {
        this.model = model;
    }

    public E getPrice() {
        return price;
    }
    public void setPrice(E price) {
        this.price = price;
    }

    //使用了泛型的成员方法的第二种形式
    public void charge(M m) {
        /*
            getClass()方法可以获取当前类的正名（包名 + 类名）;
            而后面再加上getSimpleName()方法就可以直接获取到类的类名。
         */
        System.out.println("传入的引用类型 = " + m.getClass().getSimpleName());
        System.out.println("当前的" + getModel() + "手机已经充电了 " + m + " 分钟。");
    }

    @Override
    public String toString() {
        return "\nPhone{" +
                "brand=" + brand +
                ", model=" + model +
                ", price=" + price +
                '}';
    }
}

                运行结果 :  

                如果我们在静态成员中使用泛型，IDEA会报错，如下图所示 : 

        4.自定义泛型接口 : 

                1° 基本语法 : 

        interface 接口名 {        //可以同时定义多个泛型

                //body
        }

                2° 使用细节 : 

        ①同自定义泛型类一个道理，自定义泛型接口的静态成员也不能使用泛型。

        ②自定义泛型接口中，泛型最终代表的数据类型是在继承该接口或者实现该接口时确定的。

        ③若在使用时没有给出具体泛型，默认使用Object类型替代。
            PS : 尽管默认以Object类型替换，但是建议——在不指定泛型的情况下，手动添加