泛型

CodeWang_NC

已于 2022-04-19 22:13:30 修改

阅读量409

点赞数

分类专栏： javaee 文章标签： java

于 2022-04-11 15:07:40 首次发布

本文链接：https://blog.csdn.net/qq_45056135/article/details/124097059

版权

javaee 专栏收录该内容

15 篇文章 1 订阅

订阅专栏

java学习笔记之泛型

泛型的简介:
泛型的本质就是“数据类型的参数化”，处理的数据类型不是固定的，而是可以作为参
数传入。我们可以把“泛型”理解为数据类型的一个占位符(类似：形式参数)，即告诉编
译器，在调用泛型时必须传入实际类型。这种参数类型可以用在类、接口和方法中，分别被
称为泛型类、泛型接口、泛型方法。

1.泛型类别:

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

2 泛型类

.泛型类就是把泛型定义在类上，用户使用该类的时候，才把类型明确下来。泛型类的具
体使用方法是在类的名称后添加一个或多个类型参数声明，如：、<T,K,V>
注意:这里具体的T 如果是基本类型的话一般是包装类，如Integer 而不是Int

2.1语法结构:

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

2.2测试代码:

class Generic<T>{
    private T flag;

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

    public T getFlag() {
        return flag;
    }
}
public class AppTest {
    public static void main(String[] args) {
        Generic<String> generic = new Generic<>(); // 字符串泛型
        generic.setFlag("hello world");
        String flag = generic.getFlag();
        System.out.println(flag);

        Generic<Integer> generic1 = new Generic<>(); // Integer泛型
        generic1.setFlag(520);
        Integer flag1 = generic1.getFlag();
        System.out.println(flag1);
    }
}

运行代码输出:
在这里插入图片描述

3.泛型接口:

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

3.1 语法结构

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

3.2测试代码:

//泛型接口
interface Igeneric<T>{
    T getName(T name);
}

class IgenericImpl implements Igeneric<String>{ // 实现泛型接口为String类
    @Override
    public String getName(String name) {
        return name;
    }
}

public class AppTest{
    public static void main(String[] args) {
        IgenericImpl igeneric = new IgenericImpl(); // 直接生成实现类对象
        String name = igeneric.getName("吴彦祖");
        System.out.println(name);

        Igeneric<String> igeneric1 = new IgenericImpl(); // 父类(接口类)引用子类对象
        String name1 = igeneric1.getName("梁朝伟");
        System.out.println(name1);
    }
}

运行结果:
在这里插入图片描述

4.泛型方法

泛型类中所定义的泛型，在方法中也可以使用。但是，我们经常需要仅仅在某一个方法
上使用泛型，这时候可以使用泛型方法

4.1 非静态方法

4.1.1 语法结构

public <泛型表示符号> void getName(泛型表示符号 name){ 		//不带返回值
}
public <泛型表示符号> 泛型表示符号 getName(泛型表示符号 name){ 	//带返回值
}

4.1.2测试代码:

// 非静态方法
class MethodGeneric {
    public <T> void setName(T name){
        System.out.println(name);
    }
    public <T> T getName(T name){
        return name;
    }
}
public class AppTest{
    public static void main(String[] args) {
        MethodGeneric methodGeneric = new MethodGeneric();
        // 字符串泛型
        methodGeneric.setName("jordan");
        String name = methodGeneric.getName("kobe");
        System.out.println(name);
        // Integer泛型
        methodGeneric.setName(12345);
        Integer number = methodGeneric.getName(520);
        System.out.println(number);
    }
}

运行结果:
在这里插入图片描述

4.2静态泛型方法

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

4.2.1语法结构

public static <泛型表示符号> void setName(泛型表示符号 name){  		//不带返回值
}
public static <泛型表示符号> 泛型表示符号 getName(泛型表示符号 name){ //带返回值
}

4.2.2测试代码:

//静态泛型方法 相当于是给每个方法加一个static然后通过类.方法 调用即可
class MethodGeneric {
    public static <T> void setName(T name){
        System.out.println(name);
    }
    public static  <T> T getName(T name){
        return name;
    }
}

public class AppTest{
    public static void main(String[] args) {
        MethodGeneric.setName("jordan"); // 字符串泛型
        String name = MethodGeneric.getName("kobe");
        System.out.println(name);

        MethodGeneric.setName(12345); // 数字泛型 注意:使用的是Integer包装类而不是Int
        Integer number = MethodGeneric.getName(520);
        System.out.println(number);
    }
}

运行结果:
在这里插入图片描述

4.3泛型方法中的可变参数

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

4.3.1 语法结构

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

4.3.2测试代码:

// 泛型方法可变参数
class MethodGeneric {
    public <T> void method(T...args){
        for (T t:args){  // 这里使用的是foreach循环遍历
            System.out.println(t);
        }
    }
}
public class AppTest{
    public static void main(String[] args) {
        MethodGeneric methodGeneric = new MethodGeneric();
        String[] strs = new String[] {"a", "b", "c"};  // 右边可以直接写成{"a", "b", "c"}
        Integer[] arr = new Integer[] {1, 2, 3}; // 右边可以直接写成 {1, 2, 3}

        methodGeneric.method(strs);
        methodGeneric.method(arr);
    }
}

运行结果:
在这里插入图片描述

5.通配符号

5.1无界通配符

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

5.1.1 语法结构

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

5.1.2测试代码:

// 无界通配符 ?
class Generic<T>{
    private T flag;

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

    public T getFlag() {
        return flag;
    }
}
class ShowMsg{
    public void showFlag(Generic<?> generic){  // 使用无界通配符
        System.out.println(generic.getFlag());
    }
}
public class AppTest {
    public static void main(String[] args) {
        ShowMsg showMsg = new ShowMsg();

        Generic<String> generic = new Generic<>(); // 字符串类型
        generic.setFlag("Air Jordan");
        showMsg.showFlag(generic);

        Generic<Integer> integer = new Generic<>();// Integer类型
        integer.setFlag(520);
        showMsg.showFlag(integer);  
    }
}

运行结果:
在这里插入图片描述

5.2通配符上限限定: 利用关键字 `extend`

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

5.2.1 语法结构

public void showFlag(Generic<? extends Number> generic){ // 这里表示?只能是Number类或者是Number的子类对象
}

5.2.2测试代码:

注意:Integer类和Nubmer类的关系: Integer类是Number类的子类

// 通配符上限限定 <? extends Number> ， 这里Number就是上限类
class Generic<T>{
    private T flag;

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

    public T getFlag() {
        return flag;
    }
}
class ShowMsg{
    public void showFlag(Generic<? extends Number> generic){ //通配符上限限定
        System.out.println(generic.getFlag());
    }
}
public class AppTest {
    public static void main(String[] args) {
        ShowMsg showMsg = new ShowMsg();

        Generic<Number> generic = new Generic<>(); // Number类型
        generic.setFlag(12345);
        showMsg.showFlag(generic);

        Generic<Integer> integer = new Generic<>();
        integer.setFlag(520);
        showMsg.showFlag(integer);  // Integer类型
    }
}

运行结果:
在这里插入图片描述

5.3配符下限限定

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

5.3.1语法结构

public void showFlag(Generic<? super Integer> generic){ // 这里表示?只能是Integer类或者是Integer的f父类对象
}

5.3.2测试代码:

注意:Integer类和Nubmer类的关系: Integer类是Number类的子类

// 通配符下限限定 ? super (下限类)Integer
class Generic<T>{
    private T flag;

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

    public T getFlag() {
        return flag;
    }
}
class ShowMsg{
    public void showFlag(Generic<? super Integer> generic){
        System.out.println(generic.getFlag());
    }
}
public class AppTest {
    public static void main(String[] args) {
        ShowMsg showMsg = new ShowMsg();

        Generic<Number> generic = new Generic<>(); // Number类型
        generic.setFlag(12345);
        showMsg.showFlag(generic);

        Generic<Integer> integer = new Generic<>();
        integer.setFlag(520);
        showMsg.showFlag(integer);  // Integer类型
    }
}

运行结果:
在这里插入图片描述

6.泛型总结

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

CodeWang_NC

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
泛型

java学习笔记之泛型泛型的简介:泛型的本质就是“数据类型的参数化”，处理的数据类型不是固定的，而是可以作为参数传入。我们可以把“泛型”理解为数据类型的一个占位符(类似：形式参数)，即告诉编译器，在调用泛型时必须传入实际类型。这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。1.泛型类别:泛型字符可以是任何标识符，一般采用几个标记：E、T、K、V、N、？2 泛型类.泛型类就是把泛型定义在类上，用户使用该类的时候，才把类型明确下来。泛型类的具体使用方法是在类的
复制链接

扫一扫