Java泛型的那些事

浅浅的花香味﹌ 2023-10-03 18:24 19阅读 0赞

### 1.泛型概述 ###

#### 1.1.为什么使用泛型 ####

没有泛型，在编写代码时只能使用具体类型或Object类型，**无法做到使用者想要使用什么类型就是类型**。比如：创建一个方法，形参需要指定需要使用的数据类型，在**创建方法之初就已经决定**了该方法可以处理的数据类型，这大大限制了编程的灵活性。正因如此，才出现了**在使用时才决定**具体类型是什么的泛型编程。

#### 1.2.泛型是什么 ####

泛：广泛、普遍，非具体的东西，**泛型就是定义之初用符号表示不具体的类型，在使用的时候才动态地指定具体的类型。**更应该明白这种泛型编程设计思想，使用泛型带来的**好处是代码更加简洁、更加灵活、使程序更加健壮**（编译期没警告，运行期不会出现类强转异常--ClassCastException）。

### 2.泛型接口、类、方法 ###

泛型允许在定义**接口、类、方法**时使用，将在声明变量、创建对象、调用方法时动态地指定。

#### 2.1.泛型接口 ####

定义泛型接口：比如集合中的List接口

// 定义接口时指定泛型：E，E类型在接口中就可以作为类型使用
    public interface List<E> extends Collection<E>{
        ……
        boolean add(E e);
        Iterator<E> iterator();
        ……
    }
    // 定义接口时指定泛型：K 和 V，K和V类型在接口中就可以作为类型使用
    public interface Map<K,V>{
        ……
        Set<K> keySet();
        Collection<V> values();
        Set<Map.Entry<K, V>> entrySet();
        ……
    }

使用泛型接口：List接口的泛型类型E，在使用时指定为具体类型String

public static void main(String[] args) {
        List<String> list = new ArrayList<>();// 指定泛型类型E=String
        list.add("我只认识字符串");//boolean add(E e); 等价于boolean add(String e);
        Iterator<String> iterator = list.iterator();//Iterator<E> iterator();
    
        while (iterator.hasNext()){
            String next = iterator.next();//不需要强转为String
            System.out.println(next);
        }
    }

关于泛型接口Map<K,V> 集合怎么用，就自行编写感受下。

#### 2.2.泛型类 ####

**普通泛型类**

定义泛型类

使用泛型类

public static void main(String[] args) {
        DemoFx<String> stringDemoFx = new DemoFx<>();
        stringDemoFx.setDd("我是字符串类型");
        System.out.println(stringDemoFx.getDd());
    }

**泛型类的继承与实现**

定义泛型类：以ArrayList 类为例，继承泛型抽象类和实现泛型接口：

public class ArrayList<E> extends AbstractList<E> 
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
        ……
        public E get(int index) {
            rangeCheck(index);
            return elementData(index);
        }
        ……
    }

使用泛型类

public static void main(String[] args) {
        List<String> list = new ArrayList<String>();// 指定泛型类型E=String
        list.add("我只认识字符串");
        String s = list.get(0);// 返回值为String
    }

#### 2.3.泛型方法 ####

定义泛型方法：还是ArrayList案例

public class ArrayList<E> extends AbstractList<E> 
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
        ……
        public <T> T[] toArray(T[] a) {
            if (a.length < size)
                // Make a new array of a's runtime type, but my contents:
                return (T[]) Arrays.copyOf(elementData, size, a.getClass());
            System.arraycopy(elementData, 0, a, 0, size);
            if (a.length > size)
                a[size] = null;
            return a;
        }
        ……
    }

使用泛型方法：public <T> T\[\] toArray(T\[\] a)

public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("s1");
        list.add("s2");
        list.add("sn");
        // public <T> T[] toArray(T[] a) 
        String[] strings = list.toArray(new String[list.size()]);
        System.out.println(Arrays.asList(strings));
    }

### 3.类型通配符 ###

#### 3.1.使用类型通配符 ####

通配符表示符号是问号<**?**>，它是**未知类型**，可以匹配任何类型，也称为**无界通配符**。

对比”通配符“和”泛型“创建的方法

// 通配符定义
    public void foreach(List<?> list){
        for (int i =0 ;i<list.size();i++) {
            Object o = list.get(i);
            System.out.println(o.toString());
        }
    }
    // 泛型定义
    public <T> void foreach2(List<T> list){
        for(T t : list){
            System.out.println(t.toString());
        }
    }
    // 使用
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("s1");
        list.add("s2");
        list.add("sn");
        Demo demo = new Demo();
        demo.foreach(list); // 通配符
        demo.foreach2(list); // 泛型
    }

通配符和泛型都可以实现相同的效果，并且泛型方法还可以使用本身定义的泛型类型，而通配符的”?“不可以当作数据类型来使用，所以通配符方法案例中只能用Object来接收list的元素，这也是通配符的缺点：无法确定未知类型是什么类型。

**所以通配符的出现到底有什么用呢？**

通配符为泛型的一种特例，无需定义既可在形参中使用的未知类型。

泛型和通配符的区别

*  Java编译器把泛型【T】推断成T类型，在代码块中允许出现 T类型变量；而把通配符【?】推断成未知类型，不存在 ?类型变量；
 *  Class<T>需要依赖于T，需要在方法声明时指定<T>，而Class<?>则不需要；

这样可能更好理解泛型和通配符：**泛型 强调的是类型，通配符 强调的是符号**。

Class<?> 表示任意类型，但又不等同于Class<Object>，前者在类型不匹配的情况下只能够插入**null**，但是后者可以插入Object或任何Object对象的子类。

例如：不能往List<?> list里添加任意类型的对象，除了null

![7c9fde53b7f74e149569e3c126871004.png][]

#### 3.2.类型上限 ####

通配符上限：**<? extends Demo>** ，通配符【?】的上限是Demo类型，既是<? extends Demo> 的范围是Demo或其子类类型。

泛型上限：**<T extends Demo>** ，和通配符理解一样。类型上限如图

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmF2YeWFqOagiOW4g-mBk-W4iA_size_10_color_FFFFFF_t_70_g_se_x_16][]

**案例**：

创建三个类DemoFather、Demo、DemoChildren，关系如上图

public class DemoTest {
    
        public static void main(String[] args) {
            List<DemoChildren> demoChildrens = new ArrayList<>();
            demoChildrens.add(new DemoChildren());
            demoChildrens.add(new DemoChildren());
    
            DemoTest test = new DemoTest();
            test.testDemo(demoChildrens); // 通配符
            test.testDemo2(demoChildrens);// 泛型
    
        }
    
        // 通配符上限：控制list 集合允许的类型范围为Demo或其子类
        public void testDemo(List<? extends Demo> list){
            // 若无上限，这里只能用Object类型代替Demo类型
            for (Demo demo : list){
                System.out.println(demo.toString());
            }
        }
    
        // 泛型上限：控制list 集合允许的类型范围为Demo或其子类
        public <T extends Demo> void testDemo2(List<T> list){
            for (T t : list){
                System.out.println(t.toString());
            }
            // or
            for(Demo demo:list){
                System.out.println(demo.toString());
            }
        }
    
    }

泛型的上限是在定义时确定上限<T extends Demo>；通配符直接在形参上确定上限<? extends Demo>。其实都很好理解，类型上限就是在一般写法的基础上加入范围“上限”，既是 extends xxx。

**源码的一些例子**

// 接口泛型上限
    public interface ObservableArray<T extends ObservableArray<T>> extends Observable {……}
    // 抽象类泛型上限
    public abstract class ArrayListenerHelper<T extends ObservableArray<T>> extends ExpressionHelperBase {……}
    public abstract class CellBehaviorBase<T extends Cell> extends BehaviorBase<T> {……}
    // 方法泛型上限
    public static <T extends Number> ReadOnlyLongProperty readOnlyLongProperty(final ReadOnlyProperty<T> property) {……}
    
    // 通配符上限
    void putAll(Map<? extends K, ? extends V> m);

#### 3.3.类型下限 ####

通配符下限：**<? super Demo>** ，通配符【?】的下限是Demo类型，既是<? super Demo> 的范围是Demo的父类类型。

泛型下限：**无**。主要是因为类型下限会令人困惑并且不是特别有用。为什么类型参数没有下限的一些解释：[AngelikaLanger.com - Java Generics FAQs - Type Parameters - Angelika Langer Training/Consulting][AngelikaLanger.com - Java Generics FAQs - Type Parameters - Angelika Langer Training_Consulting]

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmF2YeWFqOagiOW4g-mBk-W4iA_size_10_color_FFFFFF_t_70_g_se_x_16 1][]

public static void main(String[] args) {
        Demo demo = new Demo();
        List<Demo> demos = new ArrayList<>();
        demos.add(demo);
        DemoTest test = new DemoTest();
        test.testSuper(demos);
    
        DemoFather demoFather = new DemoFather();
        List<DemoFather> demoFathers = new ArrayList<>();
        demoFathers.add(demoFather);
        DemoTest test2 = new DemoTest();
        test2.testSuper(demoFathers);
    }
    
    public void testSuper(List<? super Demo> list){
        // 虽然有下限，但无法直接使用Demo类型接收参数
        for (Object obj : list){
            System.out.println(obj.toString());
        }
    }

虽然有下限，但无法直接使用Demo类型接收参数。这就像“向上转型”和“向下转型”，向上转型是自动的，向下转型需要强转；类型上限可以使用最大类型（父类）接收比它小的类型（子类），类型下限不可以使用最小类型（子类）接受可能比它大的类型（父类）。

**源码的一些例子**

public class ArrayList<E> extends AbstractList<E>
            implements List<E>, RandomAccess, Cloneable, java.io.Serializable
    {
        ……
        public void sort(Comparator<? super E> c) {
            final int expectedModCount = modCount;
            Arrays.sort((E[]) elementData, 0, size, c);
            if (modCount != expectedModCount) {
                throw new ConcurrentModificationException();
            }
            modCount++;
        }
    }
    
    public class Arrays {
        public static <T> void sort(T[] a, int fromIndex, int toIndex,
                                    Comparator<? super T> c) {
            if (c == null) {
                sort(a, fromIndex, toIndex);
            } else {
                rangeCheck(a.length, fromIndex, toIndex);
                if (LegacyMergeSort.userRequested)
                    legacyMergeSort(a, fromIndex, toIndex, c);
                else
                    TimSort.sort(a, fromIndex, toIndex, c, null, 0, 0);
            }
        }
    }

**关于泛型字母E、K、V、T是什么？**

*  E表示Element，
 *  K表示Key，
 *  V表示Value，
 *  T表示Type，
 *  N表示Number，
 *  ? 表示 未知类型

除了【?】，其他泛型符号你写成字符串都可以，但要注意可读性，一般都是使用单个大写字母表示，不然代码反而不简洁、不易阅读。

### 4.泛型实现原理--类型擦除 ###

把一个**具有泛型信息**的对象 赋给 另一个没**有泛型信息**的变量引用，类型信息都将**被擦除**。

**案例一：**不指定泛型上限，类型擦除后为Object

public static void main(String[] args) {
        // 定义集合泛型E = String
        List<String> stringArrayList = new ArrayList<>();
        stringArrayList.add("test1");
        // 获取到的类型为：String
        String s = stringArrayList.get(0);
        // 把带有泛型信息的stringArrayList 对象赋给不确定泛型的List
        List listObject = stringArrayList;
        // listObject 只知道get的类型为Object，而不是String
        Object obj = listObject.get(0);
    }

**案例二：**指定泛型上限，类型擦除后为上限的类型

public class DemoFather {}
    public class Demo extends DemoFather{}
    public class DemoChildren<T extends DemoFather> {
        private T t;
        public T getT(){
            return this.t;
        }
        public void setT(T t){
            this.t= t;
        }
    }
    // 测试
    public class DemoTest {
        public static void main(String[] args) {
            //class DemoChildren<T extends DemoFather>,指定泛型T=Demo类型
            DemoChildren<Demo> demoChildren = new DemoChildren<Demo>();
            // 拿到的方法类型确实是T=Demo类型
            Demo demo = demoChildren.getT();
            // 把带有泛型信息的 demoChildren 对象赋给不确定泛型的demoChildren2
            DemoChildren demoChildren2 =demoChildren;
            // 再来获取方法的类型时，变为了上限的DemoFather类型
            DemoFather demoFather = demoChildren2.getT();
        }
    }

结论：

> 指定泛型上限时，类型擦除后为上限的类型；反之是Object类型，因为Java中所有类都默认继承了Object类。

所以**案例二的泛型类在编译阶段**是长这样的

public class DemoChildren {
        private DemoFather t;
        public DemoFather getT(){
            return this.t;
        }
        public void setT(DemoFather t){
            this.t= t;
        }
    }
    // 原来的泛型类，对比一下
    public class DemoChildren<T extends DemoFather> {
        private T t;
        public T getT(){
            return this.t;
        }
        public void setT(T t){
            this.t= t;
        }
    }

![a4745c6c953c249c1ee7e2d702f189ef.gif][]

[Java往期文章][Java]  
[Java全栈学习路线、学习资源和面试题一条龙][Java 1]  
[我心里优秀架构师是怎样的？][Link 1]  
[免费下载经典编程书籍][Link 2]

![ab5a44e434144849f81973bf1d62f7a9.png][]

[7c9fde53b7f74e149569e3c126871004.png]: https://img-blog.csdnimg.cn/7c9fde53b7f74e149569e3c126871004.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmF2YeWFqOagiOW4g-mBk-W4iA_size_10_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/45b142f11b154ed38db681eb412656b1.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBASmF2YeWFqOagiOW4g-mBk-W4iA==,size_10,color_FFFFFF,t_70,g_se,x_16
[AngelikaLanger.com - Java Generics FAQs - Type Parameters - Angelika Langer Training_Consulting]: http://www.angelikalanger.com/GenericsFAQ/FAQSections/TypeParameters.html#FAQ107
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmF2YeWFqOagiOW4g-mBk-W4iA_size_10_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/d701ada04af74f71aff45b2817597846.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBASmF2YeWFqOagiOW4g-mBk-W4iA==,size_10,color_FFFFFF,t_70,g_se,x_16
[a4745c6c953c249c1ee7e2d702f189ef.gif]: https://img-blog.csdnimg.cn/img_convert/a4745c6c953c249c1ee7e2d702f189ef.gif
[Java]: https://mp.weixin.qq.com/mp/appmsgalbum?__biz=MzI5NDM5NDM1NA==&action=getalbum&album_id=2209403024081485826#wechat_redirect
[Java 1]: http://mp.weixin.qq.com/s?__biz=MzI5NDM5NDM1NA==&mid=2247485015&idx=1&sn=862bc2b379726b89cdb396ec0d325cc0&chksm=ec62c6cadb154fdc533111a253d72001534ab92de317cbde5c1c9f575548500bc734c3028484&scene=21#wechat_redirect
[Link 1]: http://mp.weixin.qq.com/s?__biz=MzI5NDM5NDM1NA==&mid=2247484980&idx=1&sn=cae79359673b411222f6108e8104e37a&chksm=ec62c6a9db154fbf1a7660547631dbc1ea3c764e1ccf30d223dab897dd7397aa730f3db56bf4&scene=21#wechat_redirect
[Link 2]: http://mp.weixin.qq.com/s?__biz=MzI5NDM5NDM1NA==&mid=2247485023&idx=1&sn=fda1a3f2c557fb75b6da46d2f70faf0e&chksm=ec62c6c2db154fd42ec992515ccbbb2614e3213501004067c222e594526c4922943206c2585b&scene=21#wechat_redirect
[ab5a44e434144849f81973bf1d62f7a9.png]: https://img-blog.csdnimg.cn/img_convert/ab5a44e434144849f81973bf1d62f7a9.png