泛型(Generics)

最新推荐文章于 2023-11-08 21:45:09 发布

学无止路

最新推荐文章于 2023-11-08 21:45:09 发布

阅读量603

点赞数 1

分类专栏： JavaSe 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/weixin_40055163/article/details/123127102

版权

JavaSe 专栏收录该内容

58 篇文章 16 订阅

订阅专栏

1 泛型

1.1 泛型基本概念

泛型是 JDK1.5 以后增加的，它可以帮助我们建立类型安全的集合。
泛型的本质就是“数据类型的参数化”，处理的数据类型不是固定的，而是可以作为参数传入。我们可以把“泛型”理解为数据类型的一个占位符(类似：形式参数)，即告诉编译器，在调用泛型时必须传入实际类型。这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

参数化类型，白话说就是： 
1.把类型当作是参数一样传递。
2.<数据类型> 只能是引用类型。

1.2 泛型的好处

在不使用泛型的情况下，我们可以使用 Object 类型来实现任意的参数类型，但是在使用时需要我们强制进行类型转换。这就要求程序员明确知道实际类型，不然可能引起类型转换错误；但是，在编译期我们无法识别这种错误，只能在运行期发现这种错误。使用泛型的好处就是可以在编译期就识别出这种错误，有了更好的安全性；同时，所有类型转换由编译器完成，在程序员看来都是自动转换的，提高了代码的可读性。
总结一下，就是使用泛型主要是两个好处：

1.代码可读性更好【不用强制转换】。
2.程序更加安全【只要编译时期没有警告，运行时期就不会出现 ClassCastException 异常】。

1.3 类型擦除

编码时采用泛型写的类型参数，编译器会在编译时去掉，这称之为“类型擦除”。泛型主要用于编译阶段，编译后生成的字节码 class 文件不包含泛型中的类型信息，涉及类型转换仍然是普通的强制类型转换。 类型参数在编译后会被替换成 Object，运行时虚拟机并不知道泛型。
泛型主要是方便了程序员的代码编写，以及更好的安全性检测。

2 泛型的使用

2.1 定义泛型

泛型字符可以是任何标识符，一般采用几个标记：E、T、K、V、N、？。如图所示：在这里插入图片描述

2.2 泛型类

泛型类就是把泛型定义在类上，用户使用该类的时候，才把类型明确下来。泛型类的具体使用方法是在类的名称后添加一个或多个类型参数声明，如：、<T,K,V>

2.2.1 语法结构

public class 类名<泛型表示符号> { 
}

2.2.2 演示

1.编写Generic的代码如下：

package com.txw.generic;

/**
 * 自定义泛型类
 * @param <T>
 */
@SuppressWarnings("all")  // 注解警告信息
public class Generic<T> {
    private T flag;

    public T getFlag() {
        return flag;
    }

    public void setFlag(T flag) {
        this.flag = flag;
    }
}

如图所示：在这里插入图片描述
2.编写Test的代码如下：

package com.txw.generic;

/**
 * 测试泛型
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")  // 注解警告信息
public class Test {
    public static void main(String[] args) {
        Generic<String> generic = new Generic<>();
        generic.setFlag("Adair");
        String flag = generic.getFlag();
        System.out.println(flag);
        Generic<Integer> generic1 = new Generic<>();
        generic1.setFlag(100);
        Integer flag1 = generic1.getFlag();
        System.out.println(flag1);
    }
}

如图所示：在这里插入图片描述

2.3 泛型接口

泛型接口和泛型类的声明方式一致。泛型接口的具体类型需要在实现类中进行声明。

2.3.1 语法结构

public interface 接口名<泛型表示符号> { 
}

2.3.2 演示

1.编写Igeneric的代码如下：

package com.txw.generic;

/**
 * 自定义泛型接口
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")     // 注解警告信息
public interface Igeneric<T> {
    T getName(T name);
}

如图所示：在这里插入图片描述
2.编写IgenericImpl的代码如下：

package com.txw.generic.impl;

import com.txw.generic.Igeneric;
/**
 * 实现自定义接口
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")  // 注解警告信息
public class IgenericImpl implements Igeneric<String> {
    @Override
    public String getName(String name) {
        return name;
    }
}

如图所示：在这里插入图片描述
3.编写Test1的代码如下：

package com.txw.generic;

import com.txw.generic.impl.IgenericImpl;
/**
 * 测试自定义接口
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")     // 注解警告信息
public class Test1 {
    public static void main(String[] args) {
        IgenericImpl igeneric = new IgenericImpl();
        String name = igeneric.getName("Adair");
        System.out.println("name = " + name);
        Igeneric<String> igeneric1 = new IgenericImpl();
        String name1 = igeneric1.getName("Mars");
        System.out.println(name1);
    }
}

如图所示：在这里插入图片描述

2.4 泛型方法

泛型类中所定义的泛型，在方法中也可以使用。但是，我们经常需要仅仅在某一个方法上使用泛型，这时候可以使用泛型方法。
**泛型方法是指将方法的参数类型定义成泛型，以便在调用时接收不同类型的参数。**类型参数可以有多个，用逗号隔开，如：<K,V>。定义时，类型参数一般放到返回值前面。
调用泛型方法时，不需要像泛型类那样告诉编译器是什么类型，编译器可以自动推断出类型来。

2.4.1 非静态方法

2.4.1.1 语法结构

public <泛型表示符号> void getName(泛型表示符号 name){ 
}

public <泛型表示符号> 泛型表示符号 getName(泛型表示符号 name){ 
}

2.4.1.2 演示

1.编写MethodGeneric的代码如下：

package com.txw.generic;

/**
 * 泛型的方法
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")     // 注解警告信息
public class MethodGeneric {
    public <T> void setName(T name){

    }
    public <T> T getName(T name){
        return name;
    }
}

如图所示：在这里插入图片描述
2.编写Test2的代码如下：

package com.txw.generic;

/**
 * 测试泛型方法
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")     // 注解警告信息
public class Test2 {
    public static void main(String[] args) {
        MethodGeneric methodGeneric = new MethodGeneric();
        methodGeneric.setName("Adair");
        methodGeneric.setName("Mars");
        MethodGeneric methodGeneric1 = new MethodGeneric();
        String name = methodGeneric1.getName("Adair");
        System.out.println("name = " + name);
    }
}

如图所示：在这里插入图片描述

2.4.2 静态方法

静态方法中使用泛型时有一种情况需要注意一下，那就是静态方法无法访问类上定义的泛型；如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。

2.4.2.1 语法结构

public static <泛型表示符号> void setName(泛型表示符号 name){ 

}

public static <泛型表示符号> 泛型表示符号 getName(泛型表示符号 name){ 

}

2.4.2.2 演示

1.编写MethodGeneric1的代码如下：

package com.txw.generic;

/**
 * 泛型的静态方法
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")     // 注解警告信息
public class MethodGeneric1 {

    public static <T> void setFlag(T flag){
        System.out.println(flag);
    }

    public static <T> T getFlag(T flag){
        return flag;
    }
}

如图所示：在这里插入图片描述
2.编写Test3的代码如下：

package com.txw.generic;

/**
 * 测试泛型的静态方法
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")     // 注解警告信息
public class Test3 {
    public static void main(String[] args) {
        MethodGeneric1 methodGeneric1 = new MethodGeneric1();
        methodGeneric1.setFlag("Adair");
        String flag = methodGeneric1.getFlag("Mars");
        System.out.println("flag = " + flag);
    }
}

如图所示：在这里插入图片描述

2.4.3 泛型方法与可变参数

在泛型方法中，泛型也可以定义可变参数类型。

2.4.3.1 语法结构

public <泛型表示符号> void showMsg(泛型表示符号... agrs){ 
}

2.4.3.2 演示

1.编写MethodGeneric2的代码如下：

package com.txw.generic;

/**
 * 泛型方法与可变参数
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")     // 注解警告信息
public class MethodGeneric2 {
    public <T> void  method(T ... args){
        for (T arg : args) {
            System.out.println(arg);
        }
    }
}

如图所示：在这里插入图片描述
2.编写Test4的代码如下：

package com.txw.generic;

/**
 * 测试泛型方法与可变参数
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")     // 注解警告信息
public class Test4 {
    public static void main(String[] args) {
        MethodGeneric2 methodGeneric2 = new MethodGeneric2();
        String[] arr = new String[]{"a","b","c"};
        Integer[] arr1 = new Integer[]{1,2,3};
        methodGeneric2.method(arr);
        methodGeneric2.method(arr1);
    }
}

如图所示：在这里插入图片描述

2.5 通配符和上下限定

2.5.1 无界通配符

“?”表示类型通配符，用于代替具体的类型。它只能在“<>”中使用。可以解决当具体类型不确定的问题。

2.5.1.1 语法结构

public void showFlag(Generic<?> generic){ 

}

2.5.1.2 演示

1.编写Generic的代码如下：

package com.txw.generic;

/**
 * 自定义泛型类(无界通配符)
 * @param <T>
 */
@SuppressWarnings("all")  // 注解警告信息
public class Generic<T> {
    private T flag;

    public void setFlag(T flag){
        this.flag = flag;
    }
    
    public T getFlag(){
        return this.flag;
    }
}

如图所示：
2.编写ShowMsg的代码如下：

package com.txw.generic;

/**
 * (无界通配符)
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")  // 注解警告信息
public class ShowMsg {

    public void showFlag(Generic<?> generic){
        System.out.println(generic.getFlag());
    }
}

如图所示：在这里插入图片描述
3.编写Test的代码如下：

package com.txw.generic;

/**
 * 测试(无界通配符)
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")  // 注解警告信息
public class Test {
    public static void main(String[] args) {
        ShowMsg showMsg = new ShowMsg();
        Generic<Integer> generic = new Generic<>();
        generic.setFlag(20);
        showMsg.showFlag(generic);
        Generic<Number> generic1 = new Generic<>();
        generic1.setFlag(50);
        showMsg.showFlag(generic1);
        Generic<String> generic2 = new Generic<>();
        generic2.setFlag("Adair");
        showMsg.showFlag(generic2);
    }
}

如图所示：在这里插入图片描述

2.5.2 统配符的上限限定

上限限定表示通配符的类型是 T 类以及 T 类的子类或者 T 接口以及 T 接口的子接口。该方式同样适用于与泛型的上限限定。

2.5.2.1 语法结构

public void showFlag(Generic<? extends Number> generic){ 
}

2.5.2.2 演示

1.编写ShowMsg的代码如下：

package com.txw.generic;

/**
 * 统配符的上限限定
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")  // 注解警告信息
public class ShowMsg {

   public void showFlag(Generic<? extends Number> generic){
       System.out.println(generic.getFlag());
    }
}

如图所示：在这里插入图片描述
2.编写Test的代码如下：

package com.txw.generic;

/**
 * 测试统配符的上限限定
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")  // 注解警告信息
public class Test {
    public static void main(String[] args) {
        ShowMsg showMsg = new ShowMsg();
        Generic<Integer> generic = new Generic<>();
        generic.setFlag(20); showMsg.showFlag(generic);
        Generic<Number> generic1 = new Generic<>(); 
        generic1.setFlag(50);
        showMsg.showFlag(generic1);
    }
}

如图所示：在这里插入图片描述

2.5.3 通配符的下限限定

下限限定表示通配符的类型是 T 类以及 T 类的父类或者 T 接口以及 T 接口的父接口。
注意：该方法不适用泛型类。

2.5.3.1 语法结构

public void showFlag(Generic<? super Integer> generic){ 
}

2.5.3.2 演示

1.编写ShowMsg的代码如下：

package com.txw.generic;

/**
 * 通配符的下限限定
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")  // 注解警告信息
public class ShowMsg {

   public void showFlag(Generic<? super Integer> generic){
       System.out.println(generic.getFlag());
    }
}

如图所示：在这里插入图片描述
2.编写的代码如下：

package com.txw.generic;

/**
 * 测试通配符的下限限定
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")  // 注解警告信息
public class Test {
    public static void main(String[] args) {
        ShowMsg showMsg = new ShowMsg();
        Generic<Integer> generic = new Generic<>(); 
        generic.setFlag(20);
        showMsg.showFlag(generic);
        Generic<Number> generic1 = new Generic<>();
        generic1.setFlag(50);
        showMsg.showFlag(generic1);
    }
}

如图所示：在这里插入图片描述

3 泛型总结

泛型主要用于编译阶段，编译后生成的字节码 class 文件不包含泛型中的类型信息。 类型参数在编译后会被替换成 Object，运行时虚拟机并不知道泛型。因此，使用泛型时，如下几种情况是错误的：
1. 基本类型不能用于泛型。
Test t; 这样写法是错误，我们可以使用对应的包装类；Test t ;
2. 不能通过类型参数创建对象。
T elm = new T(); 运行时类型参数 T 会被替换成 Object，无法创建 T 类型的对象，容易引起误解，所以在 Java 中不支持这种写法。

学无止路

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
0
评论
泛型(Generics)

1 泛型1.1 泛型基本概念泛型是 JDK1.5 以后增加的，它可以帮助我们建立类型安全的集合。泛型的本质就是“数据类型的参数化”，处理的数据类型不是固定的，而是可以作为参数传入。我们可以把“泛型”理解为数据类型的一个占位符(类似：形式参数)，即告诉编译器，在调用泛型时必须传入实际类型。这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。参数化类型，白话说就是： 1.把类型当作是参数一样传递。2.<数据类型> 只能是引用类型。1.2 泛型的好处
复制链接

扫一扫