泛型&通配符

于 2024-05-02 20:32:54 发布
阅读量914 收藏 28
点赞数 14
分类专栏： java基础 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44525733/article/details/138393259
版权

泛型&通配符

文章目录

一、泛型介绍&理解

1.1 泛型概述&使用(集合/比较器)

泛型：类似于场景中的标签，即为类型参数，在声明它的类、接口或方法中，代表未知的某种通用类型。
比如使用集合存储数据时，除了元素的类型不确定，其他部分是确定的（例如关于这个元素如何保存，如何管理等）。
JDK1.5设计了泛型的概念，例如：JDK5.0改写了集合框架中的全部接口和类、java.lang.Comparable接口、java.util.Comparator接口、Class类等。为这些接口、类增加了泛型支持，从而可以在声明变量、创建对象时传入类型实参。

简单示例：不确定的类型用T来表示，如果不指定的话，可传入任意类型的

public class Teacher<T> {
    T name;
    int add(T num){
        return 0;
    }
}
//测试：不指定具体类型，缺点：会出现类型转换异常等等
@Test
public void test1(){
     Teacher tea = new Teacher();
     tea.name = 1;//可以是任意类型的
     tea.name ="23";
 }
 //测试：指定具体类型，此时所有T代表的类型参数全部替换为类型String
@Test
public void test2(){
     Teacher<String> tea = new Teacher<>();
     //tea.name = 1;//报错
     tea.name ="23";
 }

1.什么是泛型?
即类型参数，允许在定义类、接口、方法时通过一个标识表示类中某个属性的类型、某个方法的返回值或参数的类型
这个类型参数将在使用时(例如，继承或实现这个接口、创建对象或调用方法时)确定(即传入实际的类型参数，也称为类型实参)。

2、使用泛型之前可能存在的问题

  • 在集合中
    • 问题1：类型不安全，因为add()的参数是0bject类型，意味着任何类型的对象都可以添加成功
    • 问题2：需要使用强转操作，繁琐。还有可能导致ClassCastException异常。
  • 在比较器中
    • 不能确定是什么类型的对象比较大小，需要判断是否是该类型的实例、类型转换等操作，用了泛型之后，他就只能接受指定类型的对象

3、使用泛型的好处：以集合为例：把一个集合中的内容限制为一个特定的数据类型，这就是generic背后的核心思想。
Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。即，把不安全的因素在编译期间就排除了，而不是运行期；既然通过了编译，那么类型一定是符合要求的，就避免了类型转换。
比较器的泛型实现示例
集合使用泛型前后的对比

集合使用泛型示例：ArrayList，注意可以用类型推断
实现功能：使用集合的removeIf方法删除偶数，为Predicate接口指定泛型<Ineteger>

public class TestNumber {
    public static void main(String[] args) {
        ArrayList<Integer> coll = new ArrayList<Integer>();
        Random random = new Random();
        for (int i = 1; i <= 5 ; i++) {
            coll.add(random.nextInt(100));
        }
        System.out.println("coll中5个随机数是：");
        for (Integer integer : coll) {
            System.out.println(integer);
        }
        //方式1：使用集合的removeIf方法删除偶数
        coll.removeIf(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer % 2 == 0;
            }
        });
        //方式2：调用Iterator接口的remove()方法
        //Iterator<Integer> iterator1 = coll.iterator();
        //while(coll.hasNext()){
        //    Integer i = coll.next();
        //   if(i % 2 == 0){
        //       coll.remove();
        //    }
        //}

        System.out.println("coll中删除偶数后：");
        Iterator<Integer> iterator = coll.iterator();
        while(iterator.hasNext()){
            Integer number = iterator.next();
            System.out.println(number);
        }
    }
}

集合使用泛型示例：HashMap，注意可以用类型推断

//泛型在Map中的使用
@Test
public void test2(){
	//HashMap<String,Integer> map = new HashMap<String,Integer>();
    HashMap<String,Integer> map = new HashMap<>();//使用类型推断
    map.put("Tom",67);
    map.put("Jim",56);
    map.put("Rose",88);
    //编译不通过
    //ap.put(67,"Jack");

    //遍历key集
    Set<String> keySet = map.keySet();
    for(String str:keySet){
        System.out.println(str);
    }

    //遍历value集
    //var values = map.values();//可以使用类型推断
    Collection<Integer> values = map.values();
    Iterator<Integer> iterator = values.iterator();
    while(iterator.hasNext()){
        Integer value = iterator.next();
        System.out.println(value);
    }
    //遍历entry集
    Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
    Iterator<Map.Entry<String, Integer>> iterator1 = entrySet.iterator();
    while(iterator1.hasNext()){
        Map.Entry<String, Integer> entry = iterator1.next();
        String key = entry.getKey();
        Integer value = entry.getValue();
        System.out.println(key + ":" + value);
    }
}

Comparable接口使用泛型后

class CircleComparator1 implements Comparator<Circle> {//指定具体的泛型类型
    @Override
    public int compare(Circle o1, Circle o2) {
        //不再需要强制类型转换，代码更简洁
        return Double.compare(o1.getRadius(), o2.getRadius());
    }
}
//测试类
public class TestHasGeneric {
    public static void main(String[] args) {
        CircleComparator1 com = new CircleComparator1();
        System.out.println(com.compare(new Circle(1), new Circle(2)));//如果有错误，会在编译阶段就报错
        //System.out.println(com.compare("圆1", "圆2"));
        //编译错误，因为"圆1", "圆2"不是Circle类型，是String类型，编译器提前报错，
        //而不是冒着风险在运行时再报错。
    }
}

CompareTor构造器的定义方式：使用泛型实现，指定只接受某个类型的
只有比较的定义不一样，其它的部分都是一样的，这里以匿名内部类方式

//价格从小打到排序，价格一样，name从大到小排序
Comparator<Product> comp = new Comparator<Product>() {
    @Override
    public int compare(Product p1, Product p2) {
        int res = Double.compare(p1.price,p1.price);
        if(res != 0){
            return res;//从小到大排序
        }
        return -p1.name.compareTo(p2.name);//从大到小排序
    }
};

1.2 自定义范型结构(类/接口/方法)

1、<类型>这种语法形式就叫泛型。
<T>：称为类型参数，代表未知的数据类型，可以指定为<String>，<Integer>，<Circle>等。类比方法中形参将<T>称为类型形参，将<Circle>称为类型实参。T可以替换成K，V等任意字母

泛型类/接口的声明：在类名或接口名后面声明泛型类型，我们把这样的类或接口称为泛型类或泛型接口。
多个泛型参数声明：<E1,E2,E3>
JDK7.0 开始，泛型的简化操作：ArrayList<Fruit> flist = new ArrayList<>();

【修饰符】 class 类名<类型变量列表> 【extends 父类】 【implements 接口们】{
    
}
【修饰符】 interface 接口名<类型变量列表> 【implements 接口们】{
    
}
//例如：
public class ArrayList<E>    
public interface Map<K,V>{
    ....
}

泛型方法声明格式：在【修饰符】与返回值类型之间声明类型变量。把声明了类型变量的方法，称为泛型方法。

[修饰符] <类型变量列表> 返回值类型 方法名([形参列表])[throws 异常列表]{
    //...
}
public class DAO {
    public <E> E get(int id, E e) {
        E result = null;
        return result;
    }
}

1、自定义泛型类或泛型接口、方法：

  • 泛型类或接口：在类或接口中定义某个成员时，该成员的相关类型是不确定的，而这个类型需要在使用这个类或接口时才可以确定
    • 在类的内部（比如：属性、方法、构造器中）使用类的泛型。其在本类或本接口中即代表某种类型
    • 创建自定义泛型类的对象时：
      • 可指明泛型参数类型。一旦指明，内部凡是使用类的泛型参数的位置，都具体化为指定的类的泛型类型。
      • 泛型擦除：如果没有指明泛型参数类型，那么泛型对应的类型均按照Object处理，但不等价于Object。
    • 指定泛型类型：只能是引用数据类型，如果是基本则可以使用包装类型代替
    • 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。
    • 不可以在静态方法中使用类的泛型。
    • 异常类不能是带泛型的
    • 不能用new E[]，但可E[] elements = (E[])new Object[capacity];参考ArrayList源码声明：Object[] elementData，而非泛型参数类型数组。
  • 泛型方法：在没有定义泛型类/接口时，但是某个方法形参类型不确定时，可以单独定义<泛型参数>。
    • 方法可以被泛型化，并且可以被声明为static的，与所在类是否泛型无关，其中的泛型参数在方法被调用时确定。

2、泛型类/接口继承的一些特性

  • 泛型类型的继承性：继承/实现泛型类/接口时，子类/接口可以确定泛型结构中的泛型参数。如果不确定泛型的类型，则可以继续使用泛型参数，还可以新增泛型参数。
  • 如果B是A的一个子类型（子类或者子接口），而G是具有泛型声明的类或接口，G<B>并不是G<A>的子类型！
    比如：String是Object的子类，但是List<String>并不是List<Object>的子类。

泛型继承的一些特性

class A<T>{
}
//1)没有类型 擦除
class B extends A{}
//子类：继承父类的泛型参数// 1)全部保留
class B extends A<T>{
}
//子类：指定父类的泛型参数类型 // 2)具体类型
class C extends A<Integer>{
}
//子类：在父类的基础上新增泛型参数
class D<E> extends A<Integer>{
}

泛型类/接口、方法的一些实现（及泛型方法的调用方式）

@Test
public void test8(){
	//T[] arr = new T[];//是错误的写法
	//T[] arr = (T[])new Object[6];
    Integer[] arr = new Integer[]{12,21,43,56};
    Integer[] arr1 = reverse(arr);
    for (int i = 0; i < arr1.length; i++) {
        System.out.println(arr1[i]);
    }

} //编写一个泛型方法，接收一个任意引用类型的数组，并反转数组中的所有元素
public <T> T[] reverse(T[] arr){
    for (int min = 0,max = arr.length-1; min <max; min++,max--) {
        T temp = arr[min];
        arr[min] = arr[max];
        arr[max] = temp;
    }
    return arr;
}

泛型类的使用场景：声明一个学生类，该学生包含姓名、成绩，而此时学生的成绩类型不确定，为什么呢，因为，语文老师希望成绩是“优秀”、“良好”、“及格”、“不及格”，数学老师希望成绩是89.5, 65.0，英语老师希望成绩是’A’,‘B’,‘C’,‘D’,‘E’。那么我们在设计这个学生类时，就可以使用泛型。

//省略了get/set方式
class Student<T>{
    String name;
    T score;

    public Student() {
        super();
    }
    public Student(String name, T score) {
        super();
        this.name = name;
        this.score = score;
    }
    @Override
    public String toString() {
        return "姓名：" + name + ", 成绩：" + score;
    }
}
public class TestStudent {
    public static void main(String[] args) {
        //语文老师使用时：
        Student<String> stu1 = new Student<String>("张三", "良好");

        //数学老师使用时：
        //Student<double> stu2 = new Student<double>("张三", 90.5);//错误，必须是引用数据类型
        Student<Double> stu2 = new Student<Double>("张三", 90.5);

        //英语老师使用时：
        Student<Character> stu3 = new Student<Character>("张三", 'C');

        //错误的指定
        //Student<Object> stu = new Student<String>();//错误的
    }
}

二、通配符&读写特点

1、通配符：?
注意：不能用在泛型方法声明上；不能用在泛型类的声明上；不能用在创建对象
2、通配符的使用：以ArrayList<?>为例 G\<?> 可以看做是G<A>类型的父类，G<?>引用/变量=G<A>对象

读写数据的特点(以集合ArrayList<?>为例说明)
读取数据：允许的，读取的值的类型为Object类型
写入数据：不允许的。特例写入null值。

4、有限制条件的通配符
List<? extends A>：理解"<=“(-∞,A]，可以将List<A>或List<B>赋值给List<? extends A>。其中B类是A类的子类。
List<? super A>：理解”>="[A,+∞)，可以将List<A>或List<B>赋值给List<?extends A>。其中B类是A类的父类。

读写数据的特点：技巧，开发中编译是否报错
? extends A：以集合为例：可以读取数据、不能写入数据（例外：null）
? super A：以集合为例：可以读取数据、可以写入A类型或A类型子类的数据（例外：null）

通配符的使用

//注意点1：编译错误：不能用在泛型方法声明上，返回值类型前面<>不能使用?
public static <?> void test(ArrayList<?> list){
}
//注意点2：编译错误：不能用在泛型类的声明上
class GenericTypeClass<?>{
}
//注意点3：编译错误：不能用在创建对象上，右边属于创建集合对象
ArrayList<?> list2 = new ArrayList<?>();

有限制的通配符

<? extends Number>     //(无穷小 , Number]
//只允许泛型为Number及Number子类的引用调用

<? super Number>      //[Number , 无穷大)
//只允许泛型为Number及Number父类的引用调用

<? extends Comparable>
//只允许泛型为实现Comparable接口的实现类的引用调用

测试通配符及有限制条件的通配符、读写特点

//测试：通配符?的使用
@Test
public void test1() {
    List<?> list = null;
    List<Object> list1 = null;
    List<String> list2 = null;
    list = list1;
    list = list2;
    method(list1);
    method(list2);
}
public void method(List<?> list) {
    for (Object obj : list) {
        System.out.println(obj);
    }
    //list.add("AA");//错误的
}
//测试：通配符?的读写数据的特点
@Test
public void test2() {
    List<?> list = null;
    List<String> list1 = new ArrayList<>();
    list1.add("AA");
    list = list1;
    //读取数据(以集合为例说明)
    Object obj = list.get(0);
    System.out.println(obj);
    //list.add("BB");//写入数据(以集合为例说明)//写入数据，操作失败。
    //特例:可以将null写入集合中。
    list.add(null);
}
//有限制条件的通配符的使用:? extends Father。范围(无穷小,Father]
@Test
public void test3(){
    List<? extends Father> list = null;
    List<Object> list1 = null;
    List<Father> list2 = null;
    List<Son> list3 = null;
    //list = list1;//编译错误，?不包括这个范围
    list = list2;
    list = list3;
}
//针对于? extends A的读写
@Test
public void test3_1() {
    List<? extends Father> list = null;
    List<Father> list1 = new ArrayList<>();
    list1.add(new Father());
    list = list1;
    //读取数据:可以的Father father = list.get(0);
    //写入数据:
    list.add(null);
    //list.add(new Father());
    //list.add(new Son());//编译错误，还可能是更小的
}
//有限制条件的通配符的使用:? super Father。范围[Father,无穷大)
@Test
public void test4() {
    List<? super Father> list = null;
    List <Object > list1 = null;
    List<Father> list2 = null;
    List<Son> list3 = null;
    list = list1;
    list = list2;
    //list = list3;//不包括这个范围
}
public void test4_1() {
    List<? super Father> list = null;
    List<Father> list1 = new ArrayList<>() list1.add(new Father());
    list = list1;
    //读取数据:可以的
    Object obj = list.get(0);
    //写入数据:
    list.add(null);
    //list.add(new Object());
    list.add(new Father());//多态的特性，小的可以添加给大的
    list.add(new Son());
}

三、企业真题

1、Java 的泛型是什么？有什么好处和优点？JDK 不同版本的泛型有什么区别？（软动力）
泛型，是程序中出现的不确定的类型。
以集合来举例：把一个集合中的内容限制为一个特定的数据类型，这就是generic背后的核心思想。
jdk7.0新特性：

ArrayList<String> list = new ArrayList<>(); //类型推断

后续版本的新特性：

Comparator<Employee> comparator = new Comparator<>(){} //类型推断
张颖..
关注
  • 14
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
泛型&通配符常见面试题总结
03-18
泛型和通配符是Java编程中的重要概念，它们在处理类型安全和代码复用方面起着关键作用。本文将深入探讨这两个主题，并提供一些常见的面试题，帮助开发者理解和掌握这些知识点。 首先，我们来理解泛型。泛型是Java 5...
Java中泛型通配符的使用方法示例
08-25
Java中泛型通配符的使用方法示例 Java 中泛型通配符的使用方法示例主要介绍了 Java 中泛型通配符的使用方法，结合实例形式分析了 Java 中泛型通配符的功能、语法及在泛型类创建泛型对象中的使用方法。以下是 Java ...
Java泛型&注解
m0_46938055的博客
12-20 1774
泛型 1. 什么是泛型? **泛型**:类在定义时不为类中的属性，方法[返回值，参数]设置数据类型。在创建该类的对象时为其指定相应的数据类型。 2. 为什么要使用泛型？ 解决数据类型一致性的安全问题。使用泛型。 消除强制类型转换。泛型的一个附带好处是，消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。 潜在的性能收益。 泛型为较大的优化带来可能。在泛型的初始实现中，编译器将强制类型转换（没有泛型的话，程序员会指定这些强制类型转换）插入生成的字节码中。但是更多类型信息可用于编译
java泛型常用通配符实例解析
08-25
主要介绍了java泛型常用通配符实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
泛型和通配符
Fighting！！！
08-06 619
泛型，泛型是如何编译的，泛型的上界，泛型方法，通配符，通配符的上界，通配符的下界
泛型通配符详解
jarniyy的博客
03-28 5246
为什么要用通配符呢? 在java中，数组是可以协变的，比如dog extends Animal，那么Animal[] 与dog[]是兼容的。而集合是不能协变的，也就是说List<Animal>不是List<dog>的父类，这时候就可以用到通配符了。 一、基本概念： 在学习Java泛型的过程中, 通配符是较难理解的一部分. 主要有以下三类: 1. 无边界的通配符(Unb...
泛型与通配符详解
weixin_30770783的博客
11-21 267
1回顾泛型类　　泛型类：具有一个或多个泛型变量的类被称之为泛型类。 class ClassGenericity<T> { //在类里面可以直接使用T的类型 T aa; public void test11(T bb) { //................ } //静态方法 在类上面定义的泛型，不能再静态方...
Java泛型类型通配符和C#对比分析
09-01
本文将深入探讨Java中的类型通配符及其与C#泛型约束的对比。 首先，让我们来看看Java中的类型通配符。在Java中，类型通配符允许程序员在泛型参数中使用问号（`?`）来表示任意类型。例如，`List<?>`表示一个列表，...
详谈Java泛型中T和问号(通配符)的区别
08-28
Java泛型中T和问号(通配符)的区别 Java泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、...
数据结构之泛型总结
Poem_coder的博客
04-20 694
目录 一、泛型类的引出 二、泛型类的定义和使用 三、泛型的编译 四、泛型的上界 五、泛型方法 六、通配符 1.什么是通配符： 2.通配符可以解决的泛型问题： 3.通配符的上界 4.通配符的下界 一、泛型类的引出 1.什么是泛型 一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。泛型是在JDK1.5引入的新的语法，通俗讲，泛型：就是适用于许多类型。从代码上讲，就是对类型实现了参数化。
Java泛型中通配符的使用详解
小鲁蛋的博客
08-17 4477
?extends T>确定了上界为T，那么获取值时类型一定是T或T的父类，但赋值时由于不能确定具体是T或者T的某个子类而赋值失败。
【Java基础】Java泛型和泛型通配符详解
大脑不能为空
10-31 1938
Java泛型的详解，总结了泛型通配符所有的含义，以及用法，并且说明了各个用法之间的区别。
【Java数据结构】泛型详解+图文，通配符上界、下界
Original0的博客
10-09 2736
无边界通配符 可以传入任意实参类型，不能写入，不能读取，只能输出。 public static void fun(Food
泛型-通配符
qq_52889028的博客
03-12 1822
泛型 泛型是 JDK1.5 引入的一种类型机制，就是将数据类型参数化，作为一种类型安全机制而产生的。 泛型机制就是将类型检查从运行时提前到了编译期，使用泛型编写的代码比杂乱的使用 Object，并在需要时再执 行窄化处理的机制具备更好的可读性和安全性。 泛型在本质上就是进行类型的参数化 泛型的定义 public interface List<E> extends Collection<E> { //这里<>中的内容就是类型参数，一般建议使用全大写的方式进行定义，例如 T、
泛型的通配符
buhuisuanfa的博客
09-15 1854
如果没有指定类型的边界，可以认可 T extends Object,当指定了某个类型为上界，那么只接受某类型本身和子类型作为E的类型实参
Java 泛型中的通配符详解
swadian2008的博客
01-09 6931
可以使用上界通配符来放宽对变量的限制。例如，你想编写一个方法，该方法适用于List， List 和 List；就可以通过使用上界通配符来实现这一点。声明一个上界通配符，需要使用通配符 ('?')，跟上 extends 关键字，然后再跟它的上界。比如，编写用于 Number 列表和 Number 子类型（如 Integer、Double 和 Float）的方法，可以指定 List
Java基础之泛型的上限和下限
独狼的博客
09-23 336
package cn.itcast.p5.generic.advance.demo; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; import cn.itcast.p2.bean.Person; import cn.itcast.p2.bean.Student; import cn.itcast.p2.bean.Worker; public class GenericAdvanc
java 泛型通配符
最新发布
10-12
java中的泛型通配符是指使用"?"来表示未知的类型，在泛型中可以使用通配符来表示某种类型的集合。通配符有三种使用方式：无限制通配符、上界通配符和下界通配符。 1. 无限制通配符：使用"?"表示未知类型，可以匹配任何类型。例如，List<?>表示一个未知元素类型的列表。 2. 上界通配符：使用"extends"关键字表示上界，表示只能接受指定类型及其子类。例如，List<? extends Number>表示一个接受Number类型及其子类的列表。 3. 下界通配符：使用"super"关键字表示下界，表示只能接受指定类型及其父类。例如，List<? super Integer>表示一个接受Integer类型及其父类的列表。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值