Java数据结构基础——泛型、通配符

已于 2022-09-15 21:20:16 修改
阅读量4.3k 收藏 72
点赞数 91
分类专栏： JavaSE零基础学习 文章标签： java 开发语言 数据结构
于 2022-09-15 16:37:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenchenchencl/article/details/126865282
版权

ced485cbb11e458d81a746890b32cf3f.gif

 作者：敲代码の流川枫

博客主页：流川枫的博客

专栏：和我一起学java

语录：Stay hungry stay foolish

工欲善其事必先利其器，给大家介绍一款超牛的斩获大厂offer利器——牛客网

点击免费注册和我一起刷题吧

文章目录

1. 泛型概念

泛型的引出

2. 泛型语法

3. 泛型的使用

类型推导(Type Inference)

裸类型(Raw Type)

4. 泛型的擦除机制

5. 泛型的上界

6. 泛型方法

7. 通配符

通配符上界

通配符下界

1. 泛型概念

泛型：就是适用于许多许多类型。从代码上讲，就是对类型实现了参数化

一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。  ——《Java编程思想》

泛型的引出

实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值

可以将数组定义为Object类，因为所有类默认继承于这个类

public class Test {
    public static void main(String[] args) {
        MyArray myArray = new MyArray();
        myArray.setVal(0,10);
        myArray.setVal(1, "s");//字符串也可以存放
        myArray.setVal(2,10.3);
        //String ret = myArray.getPos(1);//编译报错
        String ret = (String) myArray.getPos(1);
        System.out.println(ret);
    }
}
class MyArray {
    public Object[] array = new Object[10];
    public Object getPos(int pos) {
        return this.array[pos];
    }
    public void setVal(int pos,Object val) {
        this.array[pos] = val;
    }
}


        //String ret = myArray.getPos(1);//编译报错
        String ret = (String) myArray.getPos(1);
        System.out.println(ret);

这里我们看到发生了向下转型，需要手动强制类型转换才可以，这样数据很多的时候就会很麻烦

使用Object数组的缺点有二，存放元素时可以存放任何类型的元素，再者，取出元素的时候需要手动强转

此时泛型就解决了这些问题，它将类型参数化了

2. 泛型语法

class 泛型类名称<类型形参列表> {
// 这里可以使用类型参数
}
class ClassName<T1, T2, ..., Tn> {
}
class 泛型类名称<类型形参列表> extends 继承类/* 这里可以使用类型参数 */ {
// 这里可以使用类型参数
}
class ClassName<T1, T2, ..., Tn> extends ParentClass<T1> {
// 可以只使用部分类型参数
}

注意：

1. 类名后的 <T> 代表占位符，表示当前类是一个泛型类

类型形参一般使用一个大写字母表示，常用的名称有：
E 表示 Element
K 表示 Key
V 表示 Value
N 表示 Number
T 表示 Type
S, U, V 等等 - 第二、第三、第四个类型

2. 不能new 泛型类型的数组

T[] ts = new T[5];//是不对的

3.<>里必须是类类型，不能是简单类型

我们将上述代码改写: 

class MyArray<T> {
    public T[] array = (T[]) new Object[10];
    public T getPos(int pos) {
        return this.array[pos];
    }
    public void setVal(int pos,T val) {
        this.array[pos] = val;
    }
}

public class Test {
    public static void main(String[] args) {
        MyArray<Integer> myArray = new MyArray<Integer>();
        myArray.setVal(0,10);
        myArray.setVal(1, "s");//报错
        myArray.setVal(2,10.3);//报错
        int a = myArray.getPos(0);//不用强转
        System.out.println(a);
        MyArray<String> myArray1 = new MyArray<String>();
        myArray1.setVal(0,"hello");
        myArray1.setVal(1,"world");
        String b = myArray1.getPos(0);//不用强转
        System.out.println(b);
    }
}

泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译器去做检查。此时，就需要把类型作为参数传递。需要什么类型，就传入什么类型 

泛型存在的意义：

1.在存放类型的时候会进行类型的检查

2.取出元素的时候会自动强制类型转换

注意：泛型时在编译的时候的一种机制，在运行时是没有泛型的概念的

3. 泛型的使用

泛型类<类型实参> 变量名; // 定义一个泛型类引用
new 泛型类<类型实参>(构造方法实参); // 实例化一个泛型类对象

MyArray<Integer> list = new MyArray<Integer>();

类型推导(Type Inference)

public class Test {
    public static void main(String[] args) {

        MyArray<Integer> myArray = new MyArray<>();

        myArray.setVal(0,10);
        int a = myArray.getPos(0);//不用强转
        System.out.println(a);

        MyArray<String> myArray1 = new MyArray<>();

        myArray1.setVal(0,"hello");
        myArray1.setVal(1,"world");
        String b = myArray1.getPos(0);//不用强转
        System.out.println(b);
    }
}

编译器可以根据上下文推导出类型实参时，可以省略类型实参的填写

    MyArray<Integer> myArray = new MyArray<>();

    MyArray<String> myArray1 = new MyArray<>();

裸类型(Raw Type)

裸类型是一个泛型类型，但是没有实参，取值是还是要强转

注意： 我们不要自己去使用裸类型，裸类型是为了兼容老版本的 API 保留的机制

4. 泛型的擦除机制

编译的过程当中，将所有的T替换为Object这种机制，我们称为：擦除机制

getPos中返回值为T，被替换为Object，setVal中返回值为空，即V，val参数类型被替换为Object

先根据你制定了类型进行检查和转换，在编译的时候把T都擦除成了Object

因此，Java的泛型机制是在编译级别实现的。编译器生成的字节码在运行期间并不包含泛型的类型信息

5. 泛型的上界

在定义泛型类时，有时需要对传入的类型变量做一定的约束，可以通过类型边界来约束

语法

class 泛型类名称<类型形参 extends 类型边界> {
        //...
}

示例

public class MyArray<E extends Number> {
        //...
}

只接受 Number 的子类型作为 E 的类型，实参没有指定类型边界 E，可以视为 E extends Object

public class Test {
    public static void main(String[] args) {
        MyArray<Integer> myArray = new MyArray<>();
        MyArray<Float> myArray1 = new MyArray<>();
        MyArray<Double> myArray2 = new MyArray<>();
    }
}
class MyArray<E extends Number> {
}

6. 泛型方法

静态的泛型方法 需要在static后用<>声明泛型类型参数

class Util {
    public static <E> void swap(E[] array, int i, int j) {
        E t = array[i];
        array[i] = array[j];
        array[j] = t;
    }
}

<E>是泛型的形参，void是返回值，可以直接通过类名.来调用，不用new 

 非静态

7. 通配符

看一个例子：

class Message<T> {
    private T message ;
    public T getMessage() {
return message;
}
    public void setMessage(T message) {
this.message = message;
}
}
public class TestDemo {
    public static void main(String[] args) {
    Message<String> message = new Message() ;
    message.setMessage("hello");
    fun(message);
    Message<Integer> message1 = new Message() ;
    message1.setMessage(10);
    fun(message1);//报错
    }
    public static void fun(Message<String> temp){
        System.out.println(temp.getMessage());
    }
}

报错原因是fun方法只能接收Message<String>类型的参数，而传入的是Message<Integer>类型的参数

接下来我们体会通配符的作用

 public static void fun(Message<?> temp){
        System.out.println(temp.getMessage());
 }

此时不再报错

通配符可以接收所有的泛型类型，但是又不能够让用户随意修改

public class TestDemo {
    public static void main(String[] args) {
        Message<Integer> message = new Message() ;
        message.setMessage(55);
        fun(message);
    }
    // 此时使用通配符"?"描述的是它可以接收任意类型，但是由于不确定类型，所以无法修改
    public static void fun(Message<?> temp){
        temp.setMessage(100); //无法修改！
        System.out.println(temp.getMessage());
    }
}

通配符上界

<? extends 上界>
<? extends Number>//可以传入的实参类型是Number或者Number的子类
class Food {

}
class Fruit extends Food {

}
class Apple extends Fruit {

}
class Banana extends Fruit {

}
class Message<T> { // 设置泛型上限
    private T message ;
    public T getMessage() {
        return message;
    }
    public void setMessage(T message) {
        this.message = message;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Message<Apple> message = new Message<>() ;
        message.setMessage(new Apple());
        fun(message);
        Message<Banana> message2 = new Message<>() ;
        message2.setMessage(new Banana());
        fun(message2);
    }
    // 此时使用通配符"?"描述的是它可以接收任意类型，但是由于不确定类型，所以无法修改
    public static void fun(Message<? extends Fruit> temp){
    //temp.setMessage(new Banana()); //无法修改！
    //temp.setMessage(new Apple()); //无法修改！
        System.out.println(temp.getMessage());
    }
}

此时无法在fun函数中对temp进行添加元素，因为temp接收的是Fruit和他的子类，此时存储的元素应该是哪个子类无法确定。所以添加会报错，但是可以获取元素

public static void fun(Message<? extends Fruit> temp){
    //temp.setMessage(new Banana()); //无法修改！
    //temp.setMessage(new Apple()); //无法修改！
    Fruit b = temp.getMessage();
    System.out.println(b);
}

通配符的上界，不能进行写入数据，只能进行读取数据 

通配符下界

<? super 下界>
<? super Integer>//代表 可以传入的实参的类型是Integer或者Integer的父类类型

看一个例子

class Food {
}
class Fruit extends Food {
}
class Apple extends Fruit {
}
class Message<T> {
    private T message ;
    public T getMessage() {
        return message;
    }
    public void setMessage(T message) {
        this.message = message;
    }
}
public class TestDemo {
    public static void main(String[] args) {

        Message<Fruit> message = new Message<>() ;
        message.setMessage(new Fruit());
        fun(message);

        Message<Food> message2 = new Message<>() ;
        message2.setMessage(new Food());
        fun(message2);

        Message<Apple> message1 = new Message<>();
        fun(message1);//报错
    }

    //temp 接收Fruit及其子类的一个Message
    public static void fun(Message<? super Fruit> temp){

        // 此时可以修改 添加的是Fruit 或者Fruit的子类
        temp.setMessage(new Apple());//这个是Fruit的子类
        temp.setMessage(new Fruit());//这个是Fruit的本身

        //Fruit fruit = temp.getMessage(); 不能接收，这里无法确定是哪个父类

        System.out.println(temp.getMessage());//只能直接输出
    }
}

通配符的下界，不能进行读取数据，只能写入数据

因为无法确定是哪个父类

说明可以传入的实参的类型必须是Fruit或者Fruit的父类类型

“ 本期的分享就到这里了， 记得给博主一个三连哈，你的支持是我创作的最大动力！

ced485cbb11e458d81a746890b32cf3f.gif

YoLo♪
关注
  • 91
    点赞
  • 踩
  • 72
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 68
    评论
专栏目录
[java]泛型和通配符
qq_61925446的博客
04-20 276
但是我们得好好说说三号错误，三号错误在很多时候被认为是正确的代码，他创建了一个T类型的数组，我们可以往这个数组里面传入T类型的变量，也能正确的从这个数组中正确的拿到这个T类型变量,但是这个数组本质上是一个Object数组，他并没有被切换成T类型的数组，这样写也被java设计人员认为是不安全的，因为将一个Object类型数组强行转换成一个T[]类型是不安全的，除非这个T是Object，否则会报类型转换异常；首先，我们需要了解什么是泛型，泛型你可以理解为是一个容器，这个容器可以装入且只能装入你指定的类型变量。
java通配符有哪些
很酷的站长的博客
11-07 2804
下限定义，有阅读能力和部分写作能力，子类可以写入父类。这种方法表明参数化的类型可以是指定的类型，也可以是父类。如果类型参数之间有依赖关系，返回值依赖类型参数，或者需要写作，则只能使用类型参数。这种方法表明参数化的类型可能是指定的类型或子类型。代表未知类型，代表不关心或无法确定实际操作的类型，一般与容器类配合使用。能够使用通配符的人使用通配符，因为通配符在形式上往往更简单，可读性更好。以上就是java通配符的介绍，希望对大家有所帮助。通配符的形式和类型参数经常一起使用。类型参数的形式可以取代通配符。
Java数据结构基础——泛型、通配符_java通配符和泛型
2401_84181326的博客
04-27 866
*一个人可以走的很快，但一群人才能走的更远！**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)****[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**//temp.setMessage(new Banana());
java-泛型和通配符详解
坚持不懈做贡献
11-13 1027
为什么引入泛型 在我们代码编写中我们一个类常理来说一个属性只能接受一种类型。而我们如果需要多个类型转换就需要多个属性。而对应这个属性又有多个方法对之对应。这样就是的代码的复用性差。为了节省代码量，提供泛型。 泛型的定义 泛型有两种形式。泛型类和泛型方法。 泛型类的类型擦除 所谓的泛型类其实只是语法糖，也就是说泛型类仅存在用源码阶段，当代码进行编译后泛型就会被类型擦除，当进入JVM虚拟机后，和泛型有...
Java通配符：灵活使用泛型，提升代码可复用性
小虎哥的技术博客
08-08 249
通配符是一种泛型技术，它可以接受不同类型的参数，而不需要在编译时指定具体的类型。通配符使用符号 "?" 表示，它表示一个不确定的类型参数，可以用于方法的参数列表，类的定义，方法返回值等。
Java泛型通配符
hj1993的博客
07-16 615
泛型通配符是一种特殊的类型参数，用于表示一个未知的类型。?和?extends T。其中，?表示任何类型，?extends T表示T或T的子类。泛型通配符是Java泛型的一个重要特性，可以帮助我们更灵活地使用泛型。使用泛型通配符时，需要注意其上下界限制，以提高类型的安全性。在实际编程中，我们可以根据具体情况选择使用无限制的通配符、有限制的通配符或有限制的下界通配符。
Java泛型中通配符的使用详解
小鲁蛋的博客
08-17 4282
?extends T>确定了上界为T，那么获取值时类型一定是T或T的父类，但赋值时由于不能确定具体是T或者T的某个子类而赋值失败。
Java——泛型与通配符的详解
m0_60867520的博客
06-29 557
泛型与通配符相关语法和使用实例，泛型数组的创建，包装类的使用
Java泛型中的通配符
即使再小的帆也能远航，加油~
09-17 839
今天我们来聊一聊Java中的通配符~ 由于严格的泛型类型让程序员使用起来并不是那么方便，Java设计者于是就设计了一种巧妙并且安全的解决方案——通配符
类型通配符
熊猫拿铁
12-01 499
类型通配符 类型通配符的作用 ​ 为了表示各种泛型List的父类，可以使用类型通配符 类型通配符的分类 类型通配符：<?> List<?>：表示元素类型未知的List，它的元素可以匹配任何的类型 这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中 类型通配符上限：<? extends 类型> List<? ex...
java中的泛型（三）——通配符
最新发布
qq_59750520的博客
04-28 680
本文简要介绍了泛型中的通配符
【JavaSE】泛型中的通配符
沉迷写代码的程序猿的博客
03-21 545
Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许开发者在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。在定义泛型类、泛型方法、泛型接口的时候会经常碰到很多泛型通配符，比如 T，E，K，V 等等。？表示不确定的 java 类型，用作 参数类型、字段类型、局部变量类型，有时作为返回类型（但请避免这样做）
Java 通配符 ?
小湘西的博客
01-01 519
通配符?是Java泛型中的一个关键概念，通过其灵活的使用，可以编写出更加通用和类型安全的代码。
java泛型与通配符
K371910951的博客
09-06 306
java泛型与通配符 泛型 泛型：1.参数化类型，类似于方法的形式参数 2.在成员变量和成员方法，以及静态方法中使用泛型，表示类型不确定，当创建对象的时候要确定具体的类型 3.创建对象的时候省略不写表示Object类型 4.泛型不包含继承关系 5.泛型类的不同类型的对象的字节码对象是同一个,字节码对象中不包含泛型 代码 public cla...
java 类型通配符_Java 之 类型通配符
weixin_39870092的博客
02-16 453
一、类型通配符当声明一个方法时，某个形参的类型是一个泛型类或泛型接口类型，但是在声明方法时，又不确定该泛型实际类型，可以考虑使用类型通配符。先来看下面一个案例1 public static voidtest(List c){2 for (int i = 0; i < c.size(); i++) {3 System.out.println(c.get(i));4 }5...
JAVA通配符
lionest的专栏
06-06 3599
上限通配符　　我们想要的是一个确切元素类型未知的列表，这一点与数组是不同的。 List是一个列表，其元素类型是具体类型Number。 List是一个确切元素类型未知的列表。它是Number或其子类型。 上限　　如果我们更新初始的例子，并赋值给List，那么现在赋值就会成功了： List iList = new ArrayList();List nList = iList
聊一聊Java 泛型通配符 T，E，K，V，?
java思维导图
12-04 181
来源：https://juejin.cn/post/6844903917835419661| 前言Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类...
JAVA 泛型与通配符的使用
weixin_30408165的博客
08-04 101
泛型的本质是参数化类型。即所操作的数据类型被指定为一个参数。 1.jdk 1.5/1.6 必须显式的写出泛型的类型。 2.jdk 1.7/1.8 不必显式的写出泛型的类型。 一、泛型声明 可以用<T>、<K,V>、<T extends Number>等进行泛型的声明。其中，<T extends...
java 泛型通配符
10-12
java中的泛型通配符是指使用"?"来表示未知的类型，在泛型中可以使用通配符来表示某种类型的集合。通配符有三种使用方式：无限制通配符、上界通配符和下界通配符。 1. 无限制通配符：使用"?"表示未知类型，可以匹配...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

YoLo♪

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

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

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

打赏作者

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

抵扣说明：

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

余额充值