Java基础深度总结：泛型

最新推荐文章于 2024-07-01 23:29:12 发布
最新推荐文章于 2024-07-01 23:29:12 发布
阅读量482 收藏 1
点赞数 1
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42080839/article/details/107898755
版权

不怕路长，只怕志短。

内容

1.泛型概述

泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

  • 在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，但要做显式的强制类型转换，且在强制类型转换时可能出现错误。
  • 在Java SE 1.5时，使用泛型可在编译阶段进行编译类型检查，保证了类型转换的安全性，并且所有的强制转换都是自动和隐式的。
public class GenericAndObjectTest {

    public static void main(String[] args) {
         Holder1 h1 = new Holder1("String");
        String str1  = (String) h1.getObj();
        //Integer num1 = (Integer) h1.getObj(); // 运行时报错：ClassCastException

        Holder2<String> h2 = new Holder2<String>("String");
        String str2 = h2.getT();
        //Integer num2 = h2.getT(); // 编译时报错：Incompatible types.
    }
}

class Holder1{

    private Object obj;

    public Holder1(Object obj) {
        this.obj = obj;
    }

    public Object getObj() {
        return obj;
    }
}

class Holder2<T>{

    private T t;

    public Holder2(T t) {
        this.t = t;
    }

    public T getT() {
        return t;
    }
}

上面的代码中分别定义了一个可以存放Object类型的容器Holder1，和一个使用泛型的容器Holder2，使用泛型的容器Holder2自动进行类型转换，并将可能出现的错误转移到编译时期。

注意：

  • < T >：泛型标识
  • T：泛型类型

Tips：

  • Java泛型是向前兼容的。
  • 泛型的设计初衷是为了减少类型转换错误产生的安全隐患。
2.泛型类型命名规范
  • 通用泛型类型：一般有T、S、U、V等，若需要多个通用泛型，依次定义即可。
  • 集合元素泛型类型：E
  • 映射中泛型类型：映射-键：K；映射-值：V
  • 数值泛型类型：N
3.泛型的定义和使用

泛型按照使用情况可以分为 3 种。

  • 泛型类
  • 泛型接口
  • 泛型方法
3.1 泛型类

泛型类就是具有一个或多个泛型类型的类，定义泛型类时，需要将 < T >泛型标识置于类名后。

class Holder<T>{

    private T t;
    
    public Holder(T t) {
        this.t = t;
    }

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

    public T getT() {
        return t;
    }

}

当你创建泛型类的实例时，通过<>来指定泛型类型，那么 T 就会被“替换”成对应的类型（实际上不是，原因会在类型擦除时讲到）。以Integer为例：

 Holder<Integer> holder = new Holder<Integer>(new Integer(3));

class Holder{

    private Integer t;
    
    public Holder(Integer t) {
        this.t = t;
    }

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

    public Integer getT() {
        return t;
    }

}

使用泛型类需要注意：

  • T代表任意的类型（Object及其子类），但不能使用基本数据类型作为泛型类型。
  • 不能定义静态泛型类型变量，也不能在静态方法中定义泛型参数。
 private static T t; //cannot be referenced from a static context
 public static void fun(T t){} //cannot be referenced from a static context
3.2 泛型接口

泛型也可用于接口，例如生成器：

interface Generator<T>{
	T next();
}

接口中使用泛型与类中使用泛型没什么区别，需要注意的是，接口中的成员默认是static final的，因此在接口中不能有泛型成员变量。

3.3 泛型方法

泛型方法是被泛型标识修饰的方法，泛型方法的定义格式：

[作用域修饰符] <泛型类型标识> [返回类型] 方法名(参数列表){}

示例：

public class GenericMethodTest<T> {

    private T t;

    public T getT() {
        return t;
    }

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

    public <E> void fun2(E e) { 
    }
}

注意：fun(T t) 不是泛型方法，fun2(E e)才是。

泛型方法有以下特点：

  • 参数列表中用到的泛型类型，需要在返回类型之前通过<>定义。
  • 泛型方法中的泛型类型只与实参类型有关，而与泛型类中的泛型类型无关。
public class GenericMethodTest<T> {

    private T t;

    public T getT() {
        return t;
    }

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

    public void fun(T t) {
        System.out.println(t);
    }

    public <E> void fun2(E e) {
        System.out.println(e);
    }

    public <T> void fun3(T t) {
        System.out.println(t);
    }


    public static void main(String[] args) {
        GenericMethodTest<String> gmt = new GenericMethodTest<>();
        gmt.fun("abc");
        //gmt.fun(new Integer(3));// compile error
        System.out.println("--------");
        gmt.fun2("abc");
        gmt.fun2(new Integer(3));
        System.out.println("--------");
        gmt.fun3("abc");
        gmt.fun3(new Integer(3));
    }
}

输出：
abc
--------
abc
3
--------
abc
3

上面的例子充分说明了泛型方法中的泛型类型与泛型类中的泛型类型无关，即使泛型方法中的泛型类型与泛型类中的泛型类型相同。泛型类是通过实例化确定具体类型，泛型方式通过方法调用确定具体类型。

为了避免混淆，它们应该使用不同的泛型类型名称。

原则：如果使用泛型方法可以取代整个类泛化，那么就应该尽量使用泛型方法。

4.有界泛型类型

通过有界泛型类型，可以作用于类或接口，限制允许实例化的泛型类型，也可以作用于方法，限制泛型方法实参的泛型类型。

  • 继承父类：< T extends ClassA > 限定该泛型类型必须是ClassA或ClassA的子类。
  • 实现某接口： < T extends InterfaceB > 限定该泛型类型必须是InterfaceB的实现类。
  • 多重边界：< T extends ClassA & InterfaceB & InterfaceC…>

多重边界是根据Java单继承多实现接口的特点来限定的：

  • 可限定多个接口（则必须是同时实现这些接口的实现类），但最多只有一个限定类。
  • 若限定了一个类，则必须是限定列表中的第一个。
class Fu{}
class Zi extends Fu{}
class Sun extends Zi implements I1,I2{}
interface I1{}
interface I2{}

class GenericHolder<T extends Fu>{

    private T t;

    public GenericHolder(T t) {
        this.t = t;
    }

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

    public T getT() {
        return t;
    }

    public <E extends Zi> void test(E e) {
        System.out.println(e);
    }

    public <E extends Zi & I1 & I2> void test2(E e) {
        System.out.println(e);
    }
}

class GenericHolder2 <T extends Zi & I1 & I2>{
    
    private T t;

    public GenericHolder2(T t) {
        this.t = t;
    }

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

    public T getT() {
        return t;
    }
}

public class GenericBoundedTest {

    public static void main(String[] args) {

        GenericHolder<Fu> holder = new GenericHolder<Fu>(new Zi());
        holder.test(new Zi());
        holder.test2(new Sun());
        GenericHolder2<Sun> holder2 = new GenericHolder2<Sun>(new Sun());
    }
}

有界泛型类型的好处：

  • 在一定程度上限制了泛型类型，提高了程序安全性。
  • 定义了边界，则可以调用泛型类型变量的父类或父接口的方法，更加灵活。

Tip：
无界泛型类型：< T > 等同于有界泛型类型：< T extends Object >，因此在无界泛型类型中，也可以调用泛型类型变量的Object方法。

5.泛型实现原理：类型擦除（重点）

泛型类型擦除：泛型在编译阶段，生成的字节码中不包含泛型类型，只保留原始类型，也就是说泛型类和普通类在 Java 虚拟机中没什么不同。

  • 无界的泛型类型擦除之后的原始类型是Object类型。
  • 有界泛型类型擦除之后的原始类型是父类型
  • 多重有界泛型类型擦除之后的原始类型是第一个父类型
class A<T> {
    private T t;
}

class B<T extends Fu> {
    private T t;
}

class C<T extends I1 & I2>{
    private T t;
}

class Fu{}
class Zi extends Fu{}
class Sun extends Zi implements I1,I2{}
interface I1{}
interface I2{}

public class GenericErasureTest {

    public static void main(String[] args) throws Exception{
        
        // A ： 无界泛型
        A<String> a1 = new A<>();
        A<Integer> a2 = new A<>();
        System.out.println(a1.getClass() == a2.getClass());
        System.out.println(a1.getClass().getDeclaredField("t"));
        System.out.println(a2.getClass().getDeclaredField("t"));
        System.out.println("------------");

		// B ： 有界泛型
        B<Zi> b1 = new B<>();
        System.out.println(b1.getClass().getDeclaredField("t"));
        System.out.println("------------");
		
		// C ：多重有界泛型
        C<Sun> c1 = new C<>();
        System.out.println(c1.getClass().getDeclaredField("t"));
        System.out.println("------------");
    }
}

输出：
true
private java.lang.Object A.t
private java.lang.Object A.t
------------
private Fu B.t
------------
private I1 C.t
------------

Tip：
由于泛型会在编译阶段进行类型擦除，为了保证类型转换的安全性，编译器会在编译前检查类型合法性，最后由编译器自动、隐式的进行强制类型转换。

6.类型擦除的问题

（1）类型擦除导致了有关参数的类型信息全部丢失了，因此下列和运行时的类型信息相关的操作都是不合法的：

  • 泛型不可实例化。
  • 不能使用instanceof进行运行时类型检查。
  • 不能创建泛型数组
  • 泛型作为参数不能重载
class Erased<T> {

    private final int size = 10;
    private T t;

    public void test(Object o) {

        T t1 = new T();			 // Error
        if (o instanceof T) {}   // Error
        T[] array = new T[size]; // Error
        List<Integer>[] lists = new List<>[size]; // Error
    }

    void test(List<Integer> list){}
    //Error 类型擦除之后，两个方法是一样的参数列表，无法重载。
    void test(List<Double> list){}
}

（2）利用Java反射可以跳过类型检查

class Holder<T>{

    private T t;

    public Holder() {}

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

    public T getT() {
        return t;
    }
}

class GenericReflexTest{

    public static void main(String[] args) throws Exception{
        Holder<String> holder = new Holder<>();
        Class<Holder> clz = Holder.class;
        Method setT = clz.getDeclaredMethod("setT", Object.class);// 无界泛型类型擦除后的原始类型为Object
        setT.invoke(holder,new Integer(3));

        //String t = holder.getT(); //java.lang.Integer cannot be cast to java.lang.String
        Object o = holder.getT();
        System.out.println(o + "---" + o.getClass());// 3---class java.lang.Integer
    }

}
7.通配符

通配符的作用就是在泛型实例化时，指定泛型中的类型范围。

请看如下代码：Apple 继承自 Fruit

List<Apple> appleList = new ArrayList<>();
List<Fruit> fruitList = appleList; //Error : Incompatible types

虽然 Fruit 是 Apple 的父类，但 List< Fruit > 和 List< Apple >之间却没有继承关系，所以示例代码编译不通过，但有时就是想让两个容器之间产生联系，通配符正是起到这样的作用。

Java泛型中的通配符有三种：

  • 无边界通配符：< ? >
  • 上边界通配符：< ? extends T >
  • 下边界通配符：< ? super T >

Tip：
通配符和有界泛型类型十分相似，它们最大的区别就是，通配符用于泛型实例化时指定泛型中的类型范围；而有界泛型类型用于定义泛型类、接口或者方法，是用来限定泛型类型的。

7.1 上边界通配符：< ? extends T >
/**
 *              Fruit
 *            /       \
 *         Apple     Orange
 */
class Fruit{
}

class Apple extends Fruit{
}

class Orange extends Fruit{
}

class Holder<T>{

    private T t;

    public Holder() {}

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

    public T getT() {
        return t;
    }
}

public class GenericWildcardTest {

    public static void main(String[] args) {

        Holder<Apple> appleHolder = new Holder<>();
        appleHolder.setT(new Apple());

        Holder<Orange> orangeHolder = new Holder<>();
        orangeHolder.setT(new Orange());

        Holder<? extends Fruit> fruitHolder;

        fruitHolder = appleHolder; //OK

        fruitHolder = orangeHolder; //OK
    }
}

使用上边界通配符使得 Holder<? extends Fruit>成为了Holder< Apple >和 Holder< Orange >的基类。

7.2 无边界通配符：< ? >

无边界通配符：< ? > 等同于 上边界通配符：< ? extends Object >

7.3 下边界通配符：< ? super T >
public class GenericWildcardTest {

    public static void main(String[] args) {

        Holder<Apple> appleHolder = new Holder<>();
        appleHolder.setT(new Apple());

        Holder<Orange> orangeHolder = new Holder<>();
        orangeHolder.setT(new Orange());

        Holder<Fruit> fruitHolder = new Holder<>();
        fruitHolder.setT(new Fruit());

        Holder<? super Apple> superAppleHolder;
        superAppleHolder = appleHolder;     // OK
        superAppleHolder = fruitHolder;     // OK
        //superAppleHolder = orangeHolder;  //Error : Incompatible types

    }
}

与上边界通配符不同，Holder<? super Apple>表示，Holder< Apple > 及其父类是 Holder<? super Apple>的基类，而 Holder< Orange >不是。

7.4 上下边界通配符的副作用
  • 上边界通配符：可以从父类型获取数据（向上转型），不能写入数据。
  • 下边界通配符：可以通过子类型写入数据（向上转型），通过Object获取数据。

Tip：

  • 如果你需要一个只读容器，用它来生产 T，那么使用? extends T。
  • 如果你需要一个只写容器，用它来消费 T，那么使用 ? super T。
  • 如果需要同时读取以及写入，那么我们就不能使用通配符了。
白日梦想家　
关注
专栏目录
Java基础篇泛型的总结
iijik55的博客
05-17 87
CSDN话题挑战赛第1期 活动详情地址：活动链接地址 参赛话题：Java学习记录 话题描述：可以记录一下平时学习Java中的一些知识点、心得、例题、常见的问题解决 泛型总结目录 1. 泛型概述 1.1 泛型的概念 1.2 泛型的引入 2. 泛型在集合中的使用 2.1 泛型在集合Collection及Map中的使用 2.2 泛型在 Comparable及Comparator中使用泛型 2.3 自定义泛型结构 3. 小知识点 3.1 泛型在继承上的使用 3.2 通配符的使用 1. 泛
Java基础之泛型
mojiezhao的博客
02-09 153
十八 泛型 泛型（Generic）的作用，在JDK5以前，对象保存到集合中就会失去其特性（任何类型传入，都会变成Object），取出时通常要程序员手工进行类型的强制转换，这样不可避免就会引起程序的一些安全性问题，例如： ArrayList list =new ArrayList(); list.add("abc"); Integer num=(Integer)list.get[0];//运行时会...
Java基础深度总结：目录
白日梦想家的博客
07-20 320
Java语言概述 |----Java语言特性 |---- JDK、JRE与JVM Java语言基础 |----数据类型 |----String |----关键字
Java泛型深度解析：通配符、泛型方法与集合
最新发布
weixin_43337246的博客
07-01 307
Java泛型深度解析：通配符、泛型方法与集合
Java深度历险之Java泛型.docx
06-28
### Java泛型详解 #### 一、Java泛型概述 Java泛型（Generics）是Java SE 5.0引入的一项重要新特性，它允许开发者在定义类、接口或方法时使用类型参数（Type Parameters）。类型参数在使用时可以用具体的类型来...
Java泛型深度解析：通配符与边界技巧全掌握
Java泛型基础介绍 Java泛型是一种在编译时提供类型安全检查的机制，它允许开发者在定义类、接口和方法时参数化类型。通过泛型，可以在不牺牲类型安全的前提下，编写更具有通用性的代码。泛型的主要好处是，它能够...
【Java集合框架源码精讲】：泛型应用与异常处理策略
[【Java集合框架源码精讲】：泛型应用与异常处理策略](https://img-blog.csdnimg.cn/20210928230946895.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5L2g5oCO5LmI5pWi...
java 泛型 json_Java泛型与Json反序列化
weixin_35733852的博客
02-12 1347
Java的JSON库有很多，本文分析google的Gson和alibaba的fastjson，在Java泛型场景反序列化的一些有意思的行为。考虑下面的json字符串：["2147483648","2147483647"]用fastjson在不指定类型的情况下解析，下面的代码输出啥：JSON.parseArray(s).forEach(o -> { System.out.println(o.g...
探索Java泛型：设计泛型栈与队列的专家方法
[探索Java泛型：设计泛型栈与队列的专家方法](https://opengraph.githubassets.com/1ee0dd0494978e94df99bac739759c7a2e5c37d2814a182fd0d40e1778f9e6ec/steve-afrin/type-erasure) # 1. Java泛型基础概述 ## 1.1 ...
Java基础深度总结：Object类-hashCode方法
白日梦想家的博客
07-23 2524
行动是治愈恐惧的良药，而犹豫、拖延将不断滋养恐惧。 内容1.Hash概述2.hashCode的作用3.为什么重写equals的同时还得重写hashCode（重点）4.hashCode的实现 1.Hash概述 Hash称为“散列”或者音译“哈希”，本质上是一种压缩映射，也就是说把任意长度的消息，通过散列算法压缩成某一固定长度的消息，由于散列的空间通常远小于输入的空间，因此不同的输入可能会散列出相同的输出。 2.hashCode的作用 hashCode方法返回一个hash code值，这个方法是为了更好的支持
Java基础深度总结：Object类-clone方法
白日梦想家的博客
07-25 1004
凡心所向，素履所往，生如逆旅，一苇以航。 内容1.clone概述2.Cloneable接口3.clone与new的区别4.浅拷贝与深拷贝5.Object.clone6.浅拷贝存在的问题 1.clone概述 clone() 是 Object 的 protected 方法，它不是 public，一个类不显式去重写 clone()，其它类就不能直接去调用该类实例的 clone() 方法。 protected native Object clone() throws CloneNotSupportedExcept
Java基础深度总结：Object类-equals方法
白日梦想家的博客
07-23 589
现在的我不配喊累，因为我一无所有。 内容1.equals概述2.何时才要覆盖equals方法3.覆盖equals的通约4.重写equals()中的getClass与instanceof 1.equals概述 Object类的equals方法用“==”来比较两个对象，因此它的含义是两个对象是否一样，这里的一样指它们是否为同一个对象。 public boolean equals(Object obj) { return (this == obj); } == 与 equals ‘==’ 与
Java基础深度总结：访问权限
白日梦想家的博客
07-27 510
流过泪的眼睛会更明亮，滴过血的心灵会更坚强。 内容1.访问权限概述2.Java中的四种访问权限3.使用场景 1.访问权限概述 访问权限控制： 指的是本类及本类内部的成员（成员变量、成员方法、内部类）对其他类的可见性，即这些内容是否允许其他类访问。 类可见表示其它类可以用这个类创建实例对象。 成员可见表示其它类可以用这个类的实例对象访问到该成员。 使用访问权限控制的原因： 为了使用户不要触碰那些他们不该触碰的部分，这些部分对于类内部的操作时必要的，但是它并不属于客户端程序员所需接口的一部分。 为
Java基础深度总结：抽象类和接口
白日梦想家的博客
07-30 501
没有比人更高的山没有比脚更长的路。 内容1.抽象2.抽象类2.1 什么是抽象类2.2 抽象类的特点2.3 抽象类与普通类3.接口3.1 什么是接口3.2 接口成员3.3 接口特点4.接口与抽象类的异同5.使用选择 1.抽象 抽象性和具体性都是相对的，不是绝对的。概念的内涵越小，则其抽象程度就越高，其外延也越大，反之亦然。比如“人”比“男人”抽象一点，而“生物”又比“人”更抽象一点，“物质”则比“生物”更抽象。 抽象的概念是由具体概念依其“共性”而产生的，把具体概念的诸多个性排除，集中描述其共性，就会产生.
Java基础深度总结：Object类-toString方法
白日梦想家的博客
07-24 488
怕输的人永远赢不了。 内容1.Object.toString2.toString被自动调用3.始终覆盖toString4.需要注意的地方 1.Object.toString Object.toString返回一个用于表达一个对象的字符串，它包含类名称，一个“@”符号，以及散列码的无符号十六进制表示法。这通常不是用户期望看到。 public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCod
Java基础深度总结：异常
白日梦想家的博客
08-04 449
君志所向，一往无前，愈挫愈勇，再接再厉。 内容1.异常概述2.Java的异常处理机制3.Java异常体系和分类4.throw和throws：异常抛出和异常声明5.try-catch-finally异常处理5.1 语法形式 1.异常概述 异常指不期而至的各种状况，如：文件找不到、网络连接失败、除0操作、非法参数等。异常是一个事件，它发生在程序运行期间，干扰了正常的指令流程。为了应对运行期间可能出现的错误，提高程序的的稳健性，Java中定义了强大的异常处理机制，使用异常处理机制可以降低错误处理代码的复杂度：.
Java基础深度总结：反射
白日梦想家的博客
08-06 447
我自是年少，韶华倾负。 内容1.Java反射机制2.Class对象 1.Java反射机制 动态语言：是在程序运行时可以改变其结构的语言。例如：C#，JavaScript，Python等。 静态语言：是在运行时结构不可变的语言。例如：Java，C，C++。 Java是静态语言，但是因为有了反射机制的存在，使得Java有了类似动态语言的特性。 反射指应用程序访问、检测、修改自身状态与行为的能力。Java的反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，.
Java基础深度总结：Java语言概述
白日梦想家的博客
07-20 329
我很平凡，但骨子里的我却很勇敢。 一.Java语言特性 1.简单 Java语言的语法简单明了，容易掌握且提供了丰富的类库和API文档，以及第三方开发包工具包。 2.面向对象 Java是一种纯面向对象的程序设计语言。 3.分布性 分布性主要包括两大方面，分别是操作分布和数据分布，其中操作分布指的是在多个不同的主机上布置相关操作，数据分布是将数据分别存放在多个网络中不同的主机上，借助的是URL（统一资源定位符）访问网络对象，访问方式和访问本地系统相似。 4.可移植性 java程序具有与体系结构无关的特性，可以
疯狂Java语言编程：泛型深度解析
泛型与数组的关系需要注意，因为数组是Java的原始特性，它们在编译后的字节码中保留了具体类型信息，而泛型在编译时会被擦除，这个过程称为类型擦除。这意味着我们不能创建一个泛型数组，如`T[] array = new T[10];`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值