泛型详解及使用及通配符(一)

原创 已于 2022-04-16 23:14:40 修改 · 916 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

于 2022-04-15 23:03:12 首次发布

目录

参考资料

一、泛型类

二、泛型接口

1.基本语法

三、泛型方法

1.概述

 2.难点及易混点解答​​​​​​​

参考资料

一、泛型类​​​​​​​

  • 首先泛型类的基本语法
public class 类名称 <泛型标识,泛型标识,...>{

    private 泛型标识 变量名;

    public 泛型标识 testMethod(泛型标识 a,泛型标识 b){}

    ...
}

常用的泛型标识: T ,E ,K ,V
  • 泛型的使用方式 
类名<具体的数据类型> 对象名 = new 类名<>();
  •  例如：
public class Demo01<T,E,K,V> {

    private T attribute1;

    private E attribute2;

    private K attribute3;

    private V attribute4;

    private String attribute5;

    public T test_01(String str,E e,K k,V v){
        return null;
    }
    
}

Demo01<String, Integer, Boolean, Double> Demo01 = new Demo01<>();
  •  下面是具体使用
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Pair<T> {

    private String orderName;
    private int orderId;
    private T first;
    private T last;

}

    @Test
    public void test_1(){
        //泛型类在创建对象的时候，来指定操作的具体数据类型。
        //泛型类在创建对象的时候，没有指定类型，将按照Object类型来操作。
        //泛型类，不支持基本数据类型。
        Pair<String> pair1 = new Pair<>("default",0,"firstStr","secondStr");
        Pair<Integer> pair2 = new Pair<>("default",0,1,2);
        //Pair<int> pair3 = new Pair<>("default",0,1,2);
        Pair pair4 = new Pair<>("default",0,1,"string");

        //同一泛型类，根据不同的数据类型创建的对象，本质上是同一类型。
        System.out.println(pair1.getClass());
        System.out.println(pair2.getClass());
        System.out.println(pair4.getClass());
        System.out.println(pair1.getClass() == pair2.getClass());
        System.out.println(pair2.getClass() == pair4.getClass());

    }
  •  泛型是在创建时声明，如果不声明，就会按照object类型来处理；
  •  泛型不支持基本数据类型；

  • 泛型类的继承
  1. 子类是泛型类，子类和父类的泛型类型要一致
  2. 子类不是泛型类，父类要明确泛型的数据类型
  3. 例如
  • 父类
public class Parent<E> {
    private E value;

    public E getValue() {
        return value;
    }

    public void setValue(E value) {
        this.value = value;
    }
}
  •  子类一（同父类一样依然是泛型）
/**
 * 泛型类派生子类，子类也是泛型类，那么子类的泛型标识要和父类一致。
 * @param <T>
 */
public class ChildFirst<T> extends Parent<T> {
    @Override
    public T getValue() {
        return super.getValue();
    }
}
  • 子类二（声明类型） 

/**
 * 泛型类派生子类，如果子类不是泛型类，那么父类要明确数据类型
 */
public class ChildSecond extends Parent<Integer> {
    @Override
    public Integer getValue() {
        return super.getValue();
    }

    @Override
    public void setValue(Integer value) {
        super.setValue(value);
    }
}
  • 他们的使用
public class Test02 {
    public static void main(String[] args) {
        
        ChildFirst<String> childFirst = new ChildFirst<>();
        childFirst.setValue("abc");
        String value = childFirst.getValue();
        System.out.println(value);
        
        
        System.out.println("---------------------------------");
        
        
        ChildSecond childSecond = new ChildSecond();
        childSecond.setValue(100);
        Integer value1 = childSecond.getValue();
        System.out.println(value1);
    }
}

二、泛型接口

1.基本语法

interface 接口名称 <泛型标识，泛型标识，…> {
  泛型标识 方法名(); 
  .....
}
  •  例如：
/**
 * 泛型接口
 * @param <T>
 */
public interface Generator<T> {
    T getKey();
}
  • 实现类不是泛型类，接口要明确数据类型
/**
 * 实现泛型接口的类，不是泛型类，需要明确实现泛型接口的数据类型。
 */
public class Apple implements Generator<String> {
    @Override
    public String getKey() {
        return "hello generic";
    }
}
  •  实现类也是泛型类，实现类和接口的泛型类型要一致

/**
 * 泛型接口的实现类，是一个泛型类，那么要保证实现接口的泛型类泛型标识包含泛型接口的泛型标识
 * @param <T>
 * @param <E>
 */
public class Pair<T,E> implements Generator<T> {

    private T key;
    private E value;

    public Pair(T key, E value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public T getKey() {
        return key;
    }

    public E getValue() {
        return value;
    }
}
  •  然后就是泛型接口的使用
/**
 * 泛型接口
 */
public class Test03 {
    public static void main(String[] args) {
        Apple apple = new Apple();
        String key = apple.getKey();
        System.out.println(key);

        System.out.println("---------------------------------");
        Pair<String, Integer> pair =  new Pair<>("count",100);
        String key1 = pair.getKey();
        Integer value = pair.getValue();
        System.out.println(key1 + "=" + value);
    }
}

三、泛型方法

1.概述

  1. 重点以及难点来了，泛型方法
  2. 首先泛型方法的语法
修饰符 <T，E, ...> 返回值类型 方法名(形参列表) {
    方法体...
}
  •  例子
public class Demo01 {
    private static Random random = new Random();

    //非静态  单一泛型 有返回值
    public <T> T trans_01(List<T> list){
        return list.get(random.nextInt(4));
    }

    //非静态  单一泛型 无返回值
    public <T> void trans_02(List<T> list){
        list.forEach(x->{
            System.out.println(x);
        });
    }

    //非静态 多泛型 有返回值
    public <T,E> T trans_03(List<T> tList,List<E> eList){
        tList.addAll((Collection<? extends T>) eList);
        return tList.get(random.nextInt(6));
    }

    //非静态 多泛型 无返回值
    public <T,E> void trans_04(List<T> tList,List<E> eList){
        tList.forEach(t-> System.out.println(t));
        eList.forEach(e-> System.out.println(e));
    }

    //可变参数
    public <T> List<T> trans_05(T... param){
        return Arrays.asList(param);
    }

}

class Demo02{

    private static Random random = new Random();

    //静态 单泛型  无返回值
    public static <E> void trans_06(List<E> eList){
        eList.forEach(e->{
            System.out.println(e);
        });
    }
    //静态 多泛型 有返回值
    public static <T,E> T trans_07(List<T> tList,List<E> eList){
        tList.addAll((Collection<? extends T>) eList);
        return tList.get(random.nextInt(6));
    }

}
  • 然后就是它们的使用
class Demo03{
    public static void main(String[] args) {
        //数据准备
        Demo01 demo01 = new Demo01();
        List<String> list1 = Arrays.asList("a","b","c","d","e");
        List<Integer> list2 = Arrays.asList(1,2,3,4,5,6);
        String[] strs = {"a","b","c","d","e"};

        String trans01 = demo01.trans_01(list1);
        demo01.trans_02(list1);
        String trans03 = demo01.trans_03(list1, list2);
        demo01.trans_04(list1,list2);
        demo01.trans_05(strs);
        Demo02.trans_06(list1);
        Demo02.trans_07(list1,list2);
    }
}

 2.难点及易混点解答

  • 首先上面已经把泛型方法所涉及的出现情况涵盖了，下面将引用简单的例子将问题说清楚
  • 根据泛型方法的语法，泛型方法前必须有尖括号包含的通配符<T,E,K,V>如下：
    public <T,E> T trans_03(List<T> tList,List<E> eList){
        tList.addAll((Collection<? extends T>) eList);
        return tList.get(random.nextInt(6));
    }

    public static <T,E,K> void printType(T t, E e, K k) {
        System.out.println(t + "\t" + t.getClass().getSimpleName());
        System.out.println(e + "\t" + e.getClass().getSimpleName());
        System.out.println(k + "\t" + k.getClass().getSimpleName());
    }
  •  也就是说没有尖括号包括的通配符修饰的方法，就不是泛型方法，如下：
public class Demo01<T,K> {

    public T test_01(List<T> tList,List<K> kList){
        tList.addAll((Collection<? extends T>) kList);
        return tList.get(0);
    }

    public void test_02(List<T> tList){
        tList.forEach(t->{
            System.out.println(t);
        });
    }
}

使用如下：

public class Test01 {

    @Test
    public void test_01(){

        Demo01<String,Integer> demo01 =  new Demo01<>();
        List<String> list1 = Arrays.asList("a","b","c","d","e");
        List<Integer> list2 = Arrays.asList(1,2,3,4,5,6);

        String test01 = demo01.test_01(list1, list2);
        demo01.test_02(list1);
        
    }
}
  •  上面的方法就不是泛型方法，仅仅是使用了类泛型的普通方法，他们的泛型是严格和类的泛型一样的，比如test_01的T就必须和类的泛型T一致
  • 但是包含泛型方法的类，不一定是泛型类，如下：
public class Demo01 {
    private static Random random = new Random();

    //非静态  单一泛型 有返回值
    public <T> T trans_01(List<T> list) {
        return list.get(random.nextInt(4));
    }

}
  •  并且泛型方法的泛型是独立于类的，也就是说即使泛型方法和类的泛型都是T，也是不一样的，如下：
public class Demo01<T,K> {

    public <T, K> T test_03(List<T> tList, List<K> kList) {
        tList.addAll((Collection<? extends T>) kList);
        return tList.get(0);
    }

    public T test_01(List<T> tList,List<K> kList){
        tList.addAll((Collection<? extends T>) kList);
        return tList.get(0);
    }

    public void test_02(List<T> tList){
        tList.forEach(t->{
            System.out.println(t);
        });
    }
}

它的使用

public class Test01 {

    @Test
    public void test_01(){

        Demo01<String,Integer> demo01 =  new Demo01<>();

        List<String> list1 = Arrays.asList("a","b","c","d","e");
        List<Integer> list2 = Arrays.asList(1,2,3,4,5,6);

        List<Boolean> list3 = Arrays.asList(true,false,false,true);
        List<Double> list4 = Arrays.asList(5.22,2.33,5.66);


        //和类泛型一致
        String test01 = demo01.test_01(list1, list2);
        demo01.test_02(list1);

        //和类泛型不一致
        String test11 = demo01.test_01(list3, list4);
        demo01.test_02(list3);
        Boolean aBoolean = demo01.test_03(list3, list4);
        
    }
}

可以看到，只有使用了泛型类的test_03能使用和类的泛型不一样的类型

 

关于通配符的使用见下一节

泛型通配符的基本使用
chunzhenwangluo的博客
11-08 434
这是我参与11月更文挑战的第7天，活动详情查看：2021最后一次更文挑战」。 茫茫人海千千万万，感谢这一秒你看到这里。希望我的文章对你的有所帮助！ 愿你在未来的日子，保持热爱，奔赴山海！ 前言：昨天我们终于讲完了泛型通配符的基本使用， 所以，接下来我们将会对泛型通配符的学习--泛型通配符的高级使用！ ????泛型通配符 在我们之前的学习泛型的过程当中，在当我们使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Ob
Java 泛型中的通配符详解
swadian2008的博客
01-09 8462
可以使用上界通配符来放宽对变量的限制。例如，你想编写一个方法，该方法适用于List， List 和 List；就可以通过使用上界通配符来实现这一点。声明一个上界通配符，需要使用通配符 ('?')，跟上 extends 关键字，然后再跟它的上界。比如，编写用于 Number 列表和 Number 子类型（如 Integer、Double 和 Float）的方法，可以指定 List
Java泛型的学习
qq_461491877的博客
07-08 273
哔哩哔哩链接：参考资料：1.背景：JAVA推出泛型以前，程序员可以构建一个元素类型为Object的集合，该集合能够存储任意的数据类型对象，而在使用该集合的过程中，需要程序员明确知道存储每个元素的数据类型，否则很容易引发异常。2.概念：Java泛型（generics）是中引入的一个新特性，泛型提供了编译时类型安全监测机制，该机制允许我们在编译时检测到非法的类型数据结构。泛型的本质就是参数化类型，也就是所操作的数据类型被指定为一个参数。3.好处：4.类型： 2.泛型使用 3.泛型类 4.泛型类的使用 5.
【Java基础六】泛型基础语法小结
weixin_43397300的博客
03-28 260
从java虚拟机的角度，逐步介绍java泛型的演变及基础语法。深入阐述泛型代码在虚拟机中的“类型擦除”现象，并根据此现象来探索java泛型编程的继承规则、限制与局限性。
Java中泛型中的几个符号
Veyron_wu
02-13 3445
Java泛型中的标记符含义：   E - Element (在集合中使用，因为集合中存放的是元素)  T - Type（Java 类）  K - Key（键）  V - Value（值）  N - Number（数值类型） ？ -  表示不确定的java类型  S、U、V  - 2nd、3rd、4th types
泛型通配符的使用
爱码士的博客
07-17 409
泛型是java1.5后推出的新特性之一。通过使用泛型，我们可以更加灵活的指定java中代码的类型，从而程序可以更加灵活。 泛型通配符一般有三种，第一种是<?> 无限定通配符; 第二种<? extends E> 固定上限通配符，类型只能是E或E的子类; 第三种<? super T> 固定下限通配符，类型只能是T或T的父类; public class FxTest...
泛型&通配符
最新发布
weixin_44525733的博客
05-02 1485
泛型&通配符
一看就懂 详解JAVA泛型通配符T，E，K，V区别
08-25
Java泛型通配符T、E、K、V区别详解 Java泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口...
Java泛型之上界下界通配符详解
08-25
理解并正确使用Java泛型的上界和下界通配符是编写类型安全、灵活且易于维护的代码的关键。这有助于避免运行时类型转换异常，提高代码的可读性和可维护性。在实际编程中，应根据具体需求和场景选择合适的通配符类型。
Java 泛型总结及详解
09-01
4. **边界通配符**：在泛型使用中，我们可以限制类型参数的范围，如`List<? extends Number> list`表示`list`可以是任何`Number`子类的列表。 5. **类型擦除**：Java的泛型是编译时的概念，运行时所有的泛型信息...
泛型通配符
qq_40927385的博客
05-22 788
###泛型通配符的由来 看下面的一段代码 B[] b = new B[5]; A[] a = b; try { a[0] = new A(); }catch (Exception p ){ } class A{ } class B extends A{ } 上面的代码中在编译的时候没有问题但是在运行的时候会报错。这是因为在编译阶段该数组是A类型的，在运行阶段jvm才转化为B类型，所以我们在编译的时候将a[0]赋值为A
泛型使用详解
西瓜
05-13 415
https://qijian.blog.youkuaiyun.com/article/details/49883589
泛型和通配符
Fighting！！！
08-06 1010
泛型，泛型是如何编译的，泛型的上界，泛型方法，通配符，通配符的上界，通配符的下界
Java泛型 通配符详解
热门推荐
anlian523的博客
10-07 1万+
对于<? super 类型>，编译器将只允许写操作，不允许读操作。即只可以设值（比如set操作），不可以取值（比如get操作）。 对于<? extends 类型>，编译器将只允许读操作，不允许写操作。即只可以取值，不可以设值。 以上两点都是针对于源码里涉及到了类型参数的函数而言的。比如对于List而言，不允许的写操作有add函数，因为它的函数签名是boolean add(E e);，此时这个形参E就变成了一个涉及了通配符的类型；而不允许的读操作有get函数，因为它的函数签名是E get(int index)
泛型,泛型基本语法
weixin_30493321的博客
11-07 276
.NET泛型或许是借鉴于C++泛型模版，借助它可以实现对类型的抽象化、泛型处理，实现了类型和方法之间的解耦。一个最经典的运用是在三层架构中，针对不同的领域模型，在基接口、基类中实现针对各个领域模型的泛型处理。 为什么需要泛型 不用泛型 来看一个比较类型的方法。 public class Calculator { public static b...
泛型的了解与使用
w7486的博客
12-17 213
本质:参数化类型 泛型的擦除: 泛型只在编译阶段有效，编译之后VM会采取去泛型化的措施. 泛型在运行阶段是没有效果 泛型通配符的介绍 1.无边界通配符 List<?> //所有类型都可以 2.上边界通配符 List<? extends Number> //表示 Number以及以下的都可以 例如 Number IntegerLong Double 都可以Object就不行 3.下边界通配符 List<? super Intege...
泛型的简介和应用
XiaoBoYes的博客
07-18 308
泛型的简介和应用
泛型详解及其应用
分享技术，共同进步!
08-14 1252
泛型(Generics,通用的类型)的本质是为了参数化类型（通过泛型指定的不同类型来控制形参具体限制的类型）。 Java中的泛型，只在编译阶段有效。在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦除，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。
泛型方法和泛型通配符的学习
m0_45046813的博客
01-30 155
泛型方法 指返回值或参数使用泛型的方法，需要在方法返回类型前添加声明 package Java; public class Student3 { static <T> T say(T t){ System.out.println("t:" +t); return null; } public static void main(String[] args) { say("你好"); } } 泛型通配符:? 将泛
简化Java泛型使用：通配符详解及技巧
在Java编程中，通配符（wildcards）是泛型概念中的一个重要组成部分，它允许我们在不确定类型的情况下进行操作。自Java 5引入泛型以来，通配符一直是开发者们学习和适应的难点。通配符通常通过问号`?`来表示，最初并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

PH = 7

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

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

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

打赏作者

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

抵扣说明：

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

余额充值