Java泛型浅析一二

已于 2022-04-07 13:17:00 修改
阅读量539 收藏
点赞数
分类专栏： JAVA编程 文章标签： java 开发语言 设计模式 后端 架构
于 2022-04-07 13:14:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/EndlessProcess/article/details/124006411
版权

文章目录

Java泛型

1. 泛型的好处

1.1 能够适用于代码复用

<T extends Number> 指定了参数类型。

public class Test0 {
    public static <T extends Number> double add(T a,T b) {
        return a.doubleValue()+b.doubleValue();
    }

    public static void main(String[] args) {
        System.out.println(Test0.add(1.0f,2l));
    }
}

运行结果

3.0

1.2.泛型能够实现类型安全

无需强制转换
在这里插入图片描述

2. 泛型的使用

2.1 简单泛型

public class Test2 {

    static class Message<T> {
        private T t;

        public T getT() {
            return t;
        }

        public void setT(T t) {
            this.t = t;
        }
    }

    public static void main(String[] args) {
        Message<String> message = new Message<>();
        message.setT("abc");
        System.out.println(message.getT());
    }
}

运行结果

abc

2.2 多元泛型

public class Test3 {

    static class Entry<K,V> {
        private K key;
        private V val;

        public K getKey() {
            return key;
        }

        public void setKey(K key) {
            this.key = key;
        }

        public V getVal() {
            return val;
        }

        public void setVal(V val) {
            this.val = val;
        }
    }

    public static void main(String[] args) {
        Entry<Integer,String> entry = new Entry<>();
        entry.setKey(200);
        entry.setVal("成功");
        System.out.println(entry.getKey()+","+entry.getVal());
    }
}

运行结果

200,成功

2.3 泛型接口

public class Test4 {
    interface Response<T> {
        public T getVar();
    }

    static class ResponseImpl<T> implements Response<T> {
        private T var;

        @Override
        public T getVar() {
            return var;
        }

        public void setVar(T var) {
            this.var = var;
        }

        public ResponseImpl(T var) {
            this.var = var;
        }
    }

    public static void main(String[] args) {
        Response<String> response = new ResponseImpl<>("abc");
        System.out.println(response.getVar());
    }
}

运行结果

abc

2.4 泛型方法一：方法声明

<T>声明泛型方法持有T

public class Test5 {
    public static <T> void print(T[] arr) {
        for(T t:arr) {
            System.out.print(t+"\t");
        }
    }
    public static void main(String[] args) {
        Test5.print(new String[]{"a","b","c"});
    }
}

运行结果

a	b	c
2.4.1 泛型方法二：方法声明多参数
public class Test6 {
    public static <T,V> void print(T[] arr,V[] arr2) {
        for(T t:arr) {
            System.out.print(t+"\t");
        }
        for(V v:arr2) {
            System.out.print(v+"\t");
        }
    }
    public static void main(String[] args) {
        Test6.print(new String[]{"a","b","c"},new Integer[]{1,2,3,4,5});
    }
}

运行结果

a	b	c	1	2	3	4	5
2.4.2 泛型方法三：用反射生成对象

通过泛型与反射创建对象

public class Test7 {
    public static <T> T getInstance(Class<T> c) {
        T t = null;
        try {
            t = c.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return t;
    }
    public static void main(String[] args) throws ClassNotFoundException {
        Object instance = Test7.getInstance(Class.forName("com.generic.O"));
        System.out.println(instance.getClass());
    }
}

运行结果

class com.generic.O

2.5 泛型方法四：泛型方法调用

在调用泛型方法时，可以指定类型，此时编译器会校验参数类型
在这里插入图片描述

3. 泛型使用中需要注意的上限与下限

3.1 问题的引入：为什么需要上限与下限

  • 问题一
public class Test8 {

    static class A {

    }

    static class B extends A {

    }

    public void putA(A a ){

    }

    public void putB(B b) {
        putA(b);
        System.out.println("自动进行类型转换，里氏替换");
    }


    public static void main(String[] args) {
        Test8 test8 = new Test8();
        test8.putB(new B());
    }
}

在这个方法可以正常调用，因为编译器会识别 putA(b);的参数类型是B。

  • 问题二
    但是如果是List类型就会报错哦.因此此处是隐含的类型转换。在这里插入图片描述

  • 用泛型解决
    <? extends A>表示该类型参数可以是A(上边界)或者A的子类类型。编译通过。

    public void putA(List<? extends A> lista ){

    }

    public void putB(List<B> listb) {
        putA(listb);
        System.out.println("自动进行类型转换，里氏替换");
    }

3.2 泛型上限与下限应用

extends 关键字声明了类型的上界;super 关键字声明了类型的下界。

public class Test11 {

    static class Point<T> {

    }

    public static void main(String[] args) {
        Point<? super Number> p1 = new Point<Object>();
        Point<? extends Number> p2 = new Point<Integer>();
    }
}

3.3 泛型多限制：同时实现多个接口

<T extends Staff & Passenger>要求泛型必须同时实现两个接口。

public class Test12 {
    interface Staff{
        int getSalary();
    }

    interface Passenger{
        boolean isStanding();
    }

    static class Person implements Staff,Passenger {
        @Override
        public int getSalary() {
            return 11110;
        }

        @Override
        public boolean isStanding() {
            return false;
        }
    }

    //工资低于2500元的上斑族并且站立的乘客车票打8折
    public static <T extends Staff & Passenger> void discount(T t){
        if(t.getSalary()<2500 && t.isStanding()){
            System.out.println("恭喜你！您的车票打八折！");
        }
    }

    public static void main(String[] args) {
        discount(new Person());
    }
}

4. 泛型的原理——了解泛型擦除

Java在语法上支持泛型，但是在编译阶段会进行所谓的“类型擦除”（Type Erasure），将所有的泛型表示（尖括号中的内容）都替换为具体的类型（其对应的原生态类型），就像完全没有泛型一样。

    1. 无限制类型擦除
      当类定义中的类型参数没有任何限制时，在类型擦除中直接被替换为Object，即形如和<?>的类型参数都被替换为Object。
      在这里插入图片描述
    1. 擦除类定义中的类型参数
      在类型擦除中替换为类型参数的上界或者下界，比如形如和<? extends Number>的类型参数被替换为Number，<? super Number>被替换为Object。
      在这里插入图片描述
    1. 擦除方法定义中的类型参数
      擦除方法定义中的类型参数原则和擦除类定义中的类型参数是一样的
      在这里插入图片描述

4.1 泛型擦除的实验1

实验证明，l1 和 l2 的类型相同。

public class Test13 {
    public static void main(String[] args) {
        List<String> l1 = new ArrayList<>();
        List<Integer> l2= new ArrayList<>();
        System.out.println(l1.getClass());
        System.out.println(l2.getClass());
    }
}

运行结果

class java.util.ArrayList
class java.util.ArrayList

4.2 泛型擦除的实验2

通过反射，仍然可以向泛型类里存放字符串。

public class Test14 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        ArrayList<Integer> l1 = new ArrayList<>();
        l1.add(42);
        l1.getClass().getMethod("add",Object.class).invoke(l1,"abc");
        System.out.println(l1);
    }
}

运行结果

[42, abc]

4.3 泛型擦除的实验3

由于引用类型的声明没有声明为泛型，实际上什么都可以往里存。
所以泛型的检查是针对引用的，而无关它真正引用的对象。

public class Test16 {
    public static void main(String[] args) {
        List ls = new ArrayList<String>();
        ls.add("ba");
        ls.add(1);
        System.out.println(ls);
    }
}

5. 泛型的其他问题

5.1 泛型中的参数不考虑继承

泛型就是需要明确关系，如果参数是可以继承的，但是仍然不允许传递。
在这里插入图片描述

5.2 泛型的静态变量

因为泛型类中的泛型参数的实例化是在定义对象的时候指定的，而静态变量和静态方法不需要使用对象来调用。因此是错误的。
在这里插入图片描述
但是静态方法居然可以通过，请注意此T是方法声明，非类定义的泛型T。

    public static <T> T getT(){
        return null;
    }

5.3 通过反射获取泛型参数类型

public class Test20<T> {

    public static void main(String[] args) {
        Test20<Integer> genericType = new Test20<Integer>() {
        };
        Type superclass = genericType.getClass().getGenericSuperclass();
        Type type = ((ParameterizedType) superclass).getActualTypeArguments()[0];
        System.out.println(type);//class java.lang.String
    }
}

结果：

class java.lang.Integer

5.4 关于泛型的一个思考题

看这个方法，D继承了C，覆写了C的方法。

public class Test18 {
   static class C<T>{
       private T val;

       public T getVal() {
           return val;
       }

       public void setVal(T val) {
           this.val = val;
       }
   }

   static class D extends C<String>{

       @Override
       public String getVal() {
           return super.getVal();
       }

       @Override
       public void setVal(String val) {
           super.setVal(val);
       }
   }

    public static void main(String[] args) {
        C c = new C();
        c.setVal(new Object());
        D d = new D();
        d.setVal(new Object());
   }
}

但是注意，C方法在编译期中会被擦除泛型参数，变为Object，因此D的get、set方法由于入参和返回值不一样，就不是对C的覆写了。
真的是这样吗？
运行显示，d不允许d.setVal(new Object());。可是我们之前的思路，应当父类的方法并没有被覆盖啊，是可以调用父类的方法的啊.
在这里插入图片描述
问题在于虚拟机的优化实现。
运行javap -c命令查看字节码，发现jvm帮助我们实现了子类的方法，一共有两套get和set方法，以匹配父类方法。
当然我们自己是无法这样实现的，以为编译不会通过，因为jvm违反了重载的约束，仅仅返回值不同就定义了多个方法。
在这里插入图片描述

6.常见问题

1.Java中的泛型是什么 ? 使用泛型的好处是什么?
泛型是一种参数化类型的机制。它可以使得代码适用于各种类型，从而编写更加通用的代码，例如集合框架。
泛型是一种编译时类型确认机制。它提供了编译期的类型安全，确保在泛型类型（通常为泛型集合）上只能使用正确类型的对象，避免了在运行时出现ClassCastException。

2.Java的泛型是如何工作的 ? 什么是类型擦除 ?
泛型的正常工作是依赖编译器在编译源码的时候，先进行类型检查，然后进行类型擦除并且在类型参数出现的地方插入强制转换的相关指令实现的。编译器在编译时擦除了所有类型相关的信息，所以在运行时不存在任何类型相关的信息。例如List在运行时仅用一个List类型来表示。为什么要进行擦除呢？这是为了避免类型膨胀。

3.什么是泛型中的限定通配符和非限定通配符 ?
限定通配符对类型进行了限制。有两种限定通配符，一种是<? extends T>它通过确保类型必须是T的子类来设定类型的上界，另一种是<? super T>它通过确保类型必须是T的父类来设定类型的下界。泛型类型必须用限定内的类型来进行初始化，否则会导致编译错误。另一方面<?>表示了非限定通配符，因为<?>可以用任意类型来替代。

4.List<? extends T>和List <? super T>之间有什么区别 ?
List<? extends T>可以接受任何继承自T的类型的List，而List<? super T>可以接受任何T的父类构成的List。例如List<? extends Number>可以接受List或List。

总结

泛型是一种参数化类型的机制。它可以使得代码适用于各种类型，从而编写更加通用的代码，例如集合框架。
泛型是一种编译时类型确认机制。它提供了编译期的类型安全，确保在泛型类型（通常为泛型集合）上只能使用正确类型的对象，避免了在运行时出现ClassCastException。

java基础 系列在github上有一个开源项目，主要是本系列博客的demo代码。https://github.com/forestnlp/javabasic
如果您对软件开发、机器学习、深度学习有兴趣请关注本博客，将持续推出Java、软件架构、深度学习相关专栏。
您的支持是对我最大的鼓励。

悟空学编程
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java 带两个类型参数的泛型
06-21
java 带两个类型参数的泛型 java 带两个类型参数的泛型
Java泛型中的多态
最佳 Java 编程
05-28 914
从作为Java程序员的早期开始，我们都知道如何实例化和使用Collection对象。 实例化为具体类的List接口将如下所示。 List myArrayList = new ArrayList(); 如果myArrayList应该仅保存Integer对象，则从Java 5编译器开始，按照Java Generics规范，实例化将如下所示： List<Integer> my...
java 多态 泛型_java泛型多态性
weixin_42128676的博客
02-16 76
在下面的代码中public class Animal {public void eat() {System.out.println("Animal eating");}}public class Cat extends Animal {public void eat() {System.out.println("Cat eating");}}public class Dog extends Ani...
Java泛型（泛型类、泛型方法、泛型接口）
one goto one 的博客
09-12 3470
目录标题泛型引入1. 泛型类特点2. 最简单泛型类3. 泛型方法4. 泛型接口5. 泛型类可是同时设置多个类型参数6. 泛型的类型参数可以是泛型类7. 泛型类可以继承泛型类8. 泛型类可以实现泛型接口 泛型引入 如果我们需要产生多个对象，每个对象的逻辑完全一样，只是对象内的成员变量的类型不同，那我们如何去做？ 此时，我们就引入了泛型。 泛型：让数据类型变得参数化。定义泛型时，对应的数据类型是不确定的。泛型方法被调用时，才指定具体类型 这样就解决了多个相似的类（方法、接口 ）创建的问题，一个泛型类即可代替所
Java中的泛型
m0_62969222的博客
05-08 816
文章目录为什么要使用泛型程序定义泛型类定义泛型方法类型变量的限定 为什么要使用泛型程序 使用泛型前： public class GenericTest01 { public static void main(String[] args) { List l = new ArrayList(); l.add("abcd"); l.add(100); for(Object obj : l){ String s = (S
java泛型总结
04-09
深入理解java泛型，包括类名泛型的定义，方法泛型定义，泛型的返回
Java泛型定义与用法实例详解
08-27
主要介绍了Java泛型定义与用法,结合实例形式较为详细的分析了Java中泛型的概念、原理、定义、使用方法及相关操作注意事项,需要的朋友可以参考下
Eclipse3.1中的Java泛型支持
02-04
火龙果软件工程技术中心 Java5提供泛型...Java中的泛型几乎从第一个版本开始，Java技术的创立者们就已经开始讨论对该语言添加泛型支持。C++通过标准模板库对泛型进行支持，但是由于缺少所有其他类（嵌入在Java语言中
Java泛型的简单实例
09-04
介绍了Java泛型的简单实例，有需要的朋友可以参考一下
Java泛型的用法及T.class的获取过程解析
08-25
主要介绍了Java泛型的用法及T.class的获取过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java 泛型全解 - 绝对最详细
热门推荐
zjjcchina的博客
11-19 1万+
背景 对于java的泛型我一直属于一知半解的，平常真心用的不多。直到阅读《Effect Java》,看到很多平常不了解的用法，才下定决心，需要系统的学习，并且记录下来。 1、泛型的概述： 1.1 泛型的由来 根据《Java编程思想》中的描述，泛型出现的动机： 有很多原因促成了泛型的出现，而最引人注意的一个原因，就是为了创建容器类。 复制代码 泛型的思想很早就存在，如C++中的模板（Templates）。模板的精神：参数化类型 1.2 基本概述 泛型的本质就是"参数化类型"。一提到参数，最熟
java 泛型t get()_java 泛型（一）
weixin_33277564的博客
02-28 564
我们在学习java的继承规则时，已经知道任何需要父类型的地方，都可以被替换成子类型，现在我们有如下类的继承结构：//子类Student可以转换成父类PersonStudentstudent=newStudent();Personperson=student;然而泛型机制规定如下的转换是错误的：//Erro:Typemismatch:cannotconvertfromR...
Java泛型详解（史上最全泛型知识详解）
最新发布
m0_70325779的博客
07-25 5496
泛型是在JDK5之后引入的一个新特性，可以在编译阶段约束操作的数据类型，并进行检查。泛型的格式为用大白话来说，泛型就好比是给一个标签，通常情况下我们会在开发过程中或者个人学习或练习的过程中使用到泛型；就拿数组的泛型举例来说，我们把数组比作一个药瓶子，我们药瓶子贴上了什么标签，就只能放什么药，如果不管什么药都放在一个药瓶子里，那不得出大事吗？同样容器(数组)写上什么泛型，就只能存放什么数据；这样就不会导致我们存取数据的混乱。这样就解决了我们引言中提到的问题，也就解释了什么是泛型。
Java学习笔记——泛型（一）
m0_53127728的博客
02-21 1246
概述 泛型即为参数化类型。就是将数据类型参数化，作为一种类型安全机制而产生的。 使用泛型集合时，可以将一个集合中的所有元素限定为一个特定类型，这样集合中就只能存储特定的类型的对象， 这样比较安全；并且获取集合中存储的数据时，编译器也直到这个元素的类型，不需要进行窄化处理，这样使用也比较方便。 为什么使用泛型？ 没有泛型的时候 public class node { public int value;//节点的结果 node next;//下一个连接的节点 public node(){
Java泛型大全
weixin_45203607的博客
10-02 4207
Java泛型大全 1. 概述 泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。 什么是泛型？为什么要使用泛型？ 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法形参，然后调用此方法时 传递的 实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。 泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制
java 多态 泛型_Java基础之多态和泛型浅析
weixin_27006759的博客
02-13 627
Java基础之多态和泛型浅析一、前言：楼主看了许多资料后，算是对多态和泛型有了一些浅显的理解，这里做一简单总结二、什么是多态？多态(Polymorphism)按字面的意思就是“多种状态”。在面向对象语言中，接口(这里所谓的接口是楼主自己发明的，这里不是局限于Java的interface，可以把它看作为广义定义的对象源)的多种不同的实现方式即为多态。引用Charlie Calverts对多态的描述—...
《Java编程思想》学习笔记8——泛型编程高级
Tony Chen的专栏
09-22 1万+
1.泛型边界： Java泛型编程时，编译器忽略泛型参数的具体类型，认为使用泛型的类、方法对Object都适用，这在泛型编程中称为类型信息檫除。 例如： class GenericType{ public static void main(String[] args){ System.out.println(new ArrayList().getClass()); System.ou
java泛型之带有两个类型参数的泛型示例
weixin_34018169的博客
07-12 1871
为什么80%的码农都做不了架构师？>>> ...
[ JAVA ] 多个泛型对象接口定义
架构探险之道
02-27 7473
泛型接口定义 有些时候我们在定义一个类去实现泛型接口时，我们并不确定这个类将要实现哪种类型的类，这时我们就不能确定接口中的泛型，那么接口中的泛型尚未确认，这时就要求这个类也必须定义泛型，而且泛型名称要一致。 代码背景 Spring MVC 框架下： 三个相似模块实现功能，通过接口定义和继承的方式动态传入相应的查询体Qo和数据体Do。 比如： A类人员的导入、导出、查询等 B类... ...
Java泛型
05-27
Java 泛型是一种强类型编程机制，它允许在编译时检查程序中的类型安全性，并提供了参数化类型的支持。使用泛型可以在编译时检查类型错误，避免了运行时错误，并提高了代码的可读性和重用性。 Java 泛型的语法使用尖括号（<>）来定义类型参数。在定义泛型类、泛型接口、泛型方法时，可以使用泛型参数来表示类型。 例如，定义一个泛型类： ``` public class MyClass<T> { private T value; public MyClass(T value) { this.value = value; } public T getValue() { return value; } } ``` 在这个例子中，T 是一个类型参数，代表一个占位符类型。在实例化 MyClass 类时，可以指定 T 的具体类型，例如： ``` MyClass<String> myClass = new MyClass<>("Hello World"); String value = myClass.getValue(); ``` 这样就会创建一个 MyClass 实例，其 value 属性的类型被限制为 String 类型，从而保证了类型安全性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

悟空学编程

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值