泛型的基本使用

最新推荐文章于 2024-07-26 12:28:02 发布
最新推荐文章于 2024-07-26 12:28:02 发布
阅读量697 收藏 3
点赞数 1
分类专栏： java基础 文章标签： java
原文链接：https://blog.csdn.net/harvic880925/article/details/49872903
版权

转载：
https://blog.csdn.net/harvic880925/article/details/49872903
https://www.bilibili.com/video/BV1eF411h7A5?p=3&share_medium=android&share_plat=android&share_session_id=0933dced-f38b-4439-8e49-f7e4c236828a&share_source=WEIXIN&share_tag=s_i&timestamp=1641741952&unique_k=jJ7NQeb

java中ArrayList就是一个泛型。泛型使用的引用类型，所以在定义泛型类型的时候不能为基本类型，如List 等，只能为List ,编译器在编译的时候会进行类型擦除。
泛型类型定义的字母，任意一个大写字母都可以。他们的意义是完全相同的，但为了提高可读性，大家还是用有意义的字母比较好，一般来讲，在不同的情境下使用的字母意义如下：
E — Element，常用在java Collection里，如：List,Iterator,Set
K,V — Key，Value，代表Map的键值对
N — Number，数字
T — Type，类型，如String，Integer等等
如果这些还不够用，那就自己随便取吧，反正26个英文字母呢。
再重复一遍，使用哪个字母是没有特定意义的！只是为了提高可读性！！！！

使用泛型的好处

上一节只是讲解了泛型的引入，那么泛型带来了哪些好处呢？

  • 将运行时期的ClassCastException，转移到了编译时期变成了编译失败。
  • 避免了类型强转的麻烦。

一.泛型类和泛型方法

泛型，用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。

定义和使用泛型的类

定义格式：

修饰符 class 类名<代表泛型的变量> {  }

例如，API中的ArrayList集合：

class ArrayList<E>{ 
    public boolean add(E e){ }

    public E get(int index){ }
   	....
}

使用泛型类
使用的时候必须要声明使用的泛型的具体类型,如下
List list = ……，Integer str = ……，String str=……；

List<String> list = new ArrayList<>();
list.add("qqq");
String str =list.get(0);



List<Integer> list = new ArrayList<>();
list.add(0);
Integer str  = list.get(0)

使用泛型： 即什么时候确定泛型。
在创建对象的时候确定泛型

例如，ArrayList<String> list = new ArrayList<String>();
ArrayList 表示定义的是个ArrayList 类型的具体类型为String，add(E e) ，类型E 和ArrayList 类型一致，表示是String类型；在定义类变量类型的时候就已经定义好了

示例二 定义泛型类
public class GenericsClassDto<T> {
    private T t;
    public void setParam(T t){
        System.out.println("GenericsClassDto.getParam:"+t);
    }

    public T getParam(T t){
        System.out.println("GenericsClassDto.getParam:"+t);
        return t;

    }
}

使用泛型类
在这里插入图片描述

泛型的方法

泛型方法可以优化泛型类在使用到时候声明的啰嗦的问题；省略先定义泛型类变量的问题；
定义格式：

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }

public class MyGenericMethod {	
  
    public <MVP> void show(MVP mvp) {
    	System.out.println(mvp.getClass());
	
    }
    
    public <MVP> MVP show2(MVP mvp) {	
    	return mvp;
    }
}

表示 修饰符泛型的变量类型 ，有了代表泛型的变量 ，就不要在类名后面进行声明变量了，这也是和泛型类的区别之一

使用格式：调用方法时，确定泛型的类型

public class GenericMethodDemo {
    public static void main(String[] args) {
        // 创建对象，
        MyGenericMethod mm = new MyGenericMethod();
        // 演示看方法提示
        mm.show("aaa");
        mm.show(123);
        mm.show(12.45);
        //编译器会自动推断出类型为double类型
var tt= mm.show(12.45); 
    }
}
示例二

定义泛型方法

public class GenericsMethodDto {

    public<T,M> T setParam(T t, M m){
        System.out.println("GenericsClassDto.getParam t:"+t);
        System.out.println("GenericsClassDto.getParam k:"+m);
        return t;
    }

    public<T,V,K> List getParam(T t, V v){
        List list = new ArrayList();
        System.out.println("GenericsClassDto.getParam t:"+t);
        System.out.println("GenericsClassDto.getParam v:"+v);
        if(t instanceof String){
            list.add(t);
        }
        if(t instanceof Integer){
            list.add(v);
        }
        return list;
    }
}

使用泛型方法

在这里插入图片描述

泛型类和泛型方法的区别

定义上的区别

泛型类，在定义的时候需要在类上声明方法中含有的 泛型类变量
如： 修饰符 class 类名<代表泛型的变量>

class ArrayList<E>{ 
    public boolean add(E e){ }

    public E get(int index){ }
   	....
}

泛型方法

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }

<代表泛型的变量> 有了这块的泛型类型声明就不需要在类名后再此声明泛型变量

https://www.bilibili.com/video/BV1eF411h7A5?p=3&share_medium=android&share_plat=android&share_session_id=0933dced-f38b-4439-8e49-f7e4c236828a&share_source=WEIXIN&share_tag=s_i&timestamp=1641741952&unique_k=jJ7NQeb

泛型类和泛型方法在使用上的区别

泛型类必须要在使用时候定义好泛型类
使用的时候必须要声明使用的泛型的具体类型,如下
List list = ……，Integer str = ……，String str=……；

泛型方法
可以不需要在类型定义时定义这些

泛型的接口

修饰符 interface接口名<代表泛型的变量> { }

定义格式：

修饰符 interface接口名<代表泛型的变量> {  }

例如，

public interface MyGenericInterface<E>{
	public abstract void add(E e);
	
	public abstract E getE();  
}

使用格式：

1、定义类时确定泛型的类型

例如

public class MyImp1 implements MyGenericInterface<String> {
	@Override
    public void add(String e) {
        // 省略...
    }

	@Override
	public String getE() {
		return null;
	}
}

此时，泛型E的值就是String类型。

泛型类，泛型方法，泛型接口总结

<T> 加在哪个位置就是哪种类型，加载泛型接口上就是泛型接口，加载方法返回值前就是泛型方法，加载类名后就是泛型类；

示例二

定义泛型接口

/**
 * <T>加在哪里就是哪种类型
 * 加载泛型接口类上就是泛型接口类
 * 加载方法返回值前就是泛型方法
 * @param <T>
 */

public interface GenericsInterface<T> {

    public void setParam(T t);


    /**
     * 泛型方法
     * @param m
     * @param <M>
     * @return
     */
    public<M> M getParam(M m);
    
}

泛型接口的实现类
在这里插入图片描述
调用泛型接口
在这里插入图片描述
在实现的时候也需要在泛型接口类后面指定具体的类型；

2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型

例如

public class MyImp2<E> implements MyGenericInterface<E> {
	@Override
	public void add(E e) {
       	 // 省略...
	}

	@Override
	public E getE() {
		return null;
	}
}

确定泛型：

/*
 * 使用
 */
public class GenericInterface {
    public static void main(String[] args) {
        MyImp2<String>  my = new MyImp2<String>();  
        my.add("aa");
    }
}

泛型的使用一

1、泛型类定义及使用

//定义  
class Point<T>{// 此处可以随便写标识符号  
   //定义泛型属性 
    private T x ;        
    private T y ; 
    
   //定义泛型方法       
    public void setX(T x){//作为参数  
        this.x = x ;  
    }  
    public void setY(T y){  
        this.y = y ;  
    }  
    public T getX(){//作为返回值  
        return this.x ;  
    }  
    public T getY(){  
        return this.y ;  
    }  
};

泛型类的确定
泛型的类型的确定在创建类的时候确定，无论是泛型方法还是泛型属性，在泛型类的时候都需要在泛型类的类名后添加

//IntegerPoint使用  
Point<Integer> p = new Point<Integer>() ;   
p.setX(new Integer(100)) ;   
System.out.println(p.getX());    
  
//FloatPoint使用  
//创建泛型类
Point<Float> p = new Point<Float>() ;
//调用泛型类的方法   
p.setX(new Float(100.12f)) ;  
 
System.out.println(p.getX());
泛型的使用案例2
@Data
public class Persion<T, E, Y,M> {

    private T message;

    private Y area;

    public void save(E filter) {
        System.out.println(message);
        System.out.println(area);
        System.out.println(filter);

    }
    public M query(E filter) {

       return (M) filter;

    }
}

泛型的使用

public class GenericTest {

    public static void main(String[] args) {

        Persion<String,Integer,String,String>  persion = new Persion<>();

        persion.setArea("陕西");
        persion.setMessage("商务办公");
        persion.save(1);
        //创建了泛型类，泛型的入参已经确定了
        //persion.save("aa");//报错

        String   stringResult =persion.query(2);
        //在创建类型的时候，泛型类的泛型参数，泛型返回值都已经去确定，因此报错
       // Integer    intergetResult =persion.query(2);  //报错

        Persion<String,String,String,Integer>  man = new Persion<>();
        man.save("aa");//报错

        Integer  intergetResult =man.query("2");  //报错
        System.out.println( persion.query(2));

    }
}

泛型方法的使用三

有时候泛型类和泛型方法中含有泛型的参数和返回值，类，也可以不定义为泛型

public class GenericTest {
    //有返回值
    public  <T,M>   M StaticMethod(T a){
        System.out.println("harvic StaticMethod: "+a.toString());
        return (M) a;
    }
    //无返回值
    public <T>  void OtherMethod(T a){
        System.out.println("harvicOtherMethod: "+a.toString());
    }
    public static void main(String[] args) {
        GenericTest genericTest = new GenericTest();
        genericTest.OtherMethod("123");
        }
   }

在方法修饰符后定义泛型的参数和返回类型public <T,M>，这个样就不用在类名后跟泛型标识<T，M>

二.泛型接口和泛型方法

方式一
1.定义 泛型接口

public interface CorPorration<T,R> {

    public R queryCorPorrationNum(T  filter);
}

2.定义泛型接口的实现类

public class CorPorrationImpl implements CorPorration<String,Integer>{
    @Override
    public Integer queryCorPorrationNum(String filter) {
        return 5;
    }
}```

3.调用定义好的泛型接口

```java
 CorPorration<String,Integer> corPorration = new CorPorrationImpl();
   Integer  num= corPorration.queryCorPorrationNum("1233");

泛型的类型确定在，实现类中已经定义好了

方式二

1.定义泛型接口

public interface CorPorration<T,R> {
    public R queryCorPorrationNum(T  filter);
}

2、定义泛型的实现类

public class CorPorrationTwoImpl<T,R> implements CorPorration<T,R>{
    @Override
    public R queryCorPorrationNum(T filter) {
        return (R) filter;
    }
}

泛型类型的实现如果还是泛型，则要在类名称后跟上<T,R>

三、泛型类的创建

CorPorration<String,Integer> corPorrationTwo = new CorPorrationTwoImpl();
Integer  numTwo= corPorrationTwo.queryCorPorrationNum("1233");

泛型类型的确定在创建类的时候

泛型类型返回值

上面我们的函数中，返回值都是void，但现实中不可能都是void，有时，我们需要将泛型变量返回，比如下面这个函数：

静态方法中也可以含有泛型如下，静态类型中含有的泛型da

public class GenericTest {

    public static <T> List<T> parseArray(String response,Class<T> object){
        List<T> modelList = JSON.parseArray(response, object);
        return modelList;
    }

函数返回值是List类型。至于传入参数Class object的意义，我们下面会讲。这里也就是想通过这个例子来告诉大家，泛型变量其实跟String,Integer，Double等等的类的使用上没有任何区别，T只是一个符号，可以代表String,Integer，Double……这些类的符号，在泛型函数使用时，直接把T看到String,Integer，Double……中的任一个来写代码就可以了。唯一不同的是，要在函数定义的中在返回值前加上标识泛型；

静态方法中的类型和参数可以是泛型，在定义类的时候不需要是在类名称后跟上泛型参数；

其它用法:Class类传递及泛型数组

有时候需要传递Class类的泛型，示例如下
首先，我们应该把SuccessModel单独抽出来做为泛型变量，但parseArray（）中用到的SuccessModel.class要怎么弄呢？
先来看代码


public static List<SuccessModel> parseArray(String response){
    List<SuccessModel> modelList = JSON.parseArray(response, SuccessModel.class);
    return modelList;

使用泛型后如下，传递Class 类型的 class 泛型如下


public static <T> List<T> parseArray(String response,Class<T> object){
    List<T> modelList = JSON.parseArray(response, object);
    return modelList;
}

泛型类、泛型接口整合类
模仿List 泛型接口实现

泛型接口定义

在这里插入图片描述

泛型接口的实现

在这里插入图片描述
接口调用
在这里插入图片描述

泛型数组

在写程序时，大家可能会遇到类似String[] list = new String[8];的需求，这里可以定义String数组，当然我们也可以定义泛型数组，泛型数组的定义方法为 T[]，与String[]是一致的，下面看看用法：

//定义
public static <T> T[] fun1(T...arg){  // 接收可变参数  
       return arg ;            // 返回泛型数组  
}  

//使用
public static void main(String args[]){  
       Integer i[] = fun1(1,2,3,4,5,6) ;
       Integer[] result = fun1(i) ;
}

我们先看看 定义时的代码：

public static <T> T[] fun1(T...arg){  // 接收可变参数  
       return arg ;            // 返回泛型数组  
}

首先，定义了一个静态函数，然后定义返回值为T[]，参数为接收的T类型的可变长参数。如果有同学对T…arg的用法不了解，可以去找下JAVA 可变长参数方面的知识。
由于可变长参数在输入后，会保存在arg这个数组中，所以，我们直接把数组返回即可。

三.泛型的通配符

当使用类或者泛型接口的时候，传递的参数中，泛型的类型不确定可以通过通配符<?>表示。但是一旦使用通配符后，只能使用Objecct类的共性方法，集合中元素自身的方法无法使用；

在这里插入图片描述
？代表任意待待确定的类型，只能使用Object的方法，同时List<?> 定义变量只能遍历，不能添加和修改；许多源码中也这样使用，告诉读者集合不存在方法内修改和添加；

在这里插入图片描述
![在这里插入图片描述](https://img-blog.csdnimg.cn/cef6c504a7404942a52ae7ac2fba3f75.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5oeS6bif5LiA5p6a,size_20,color_FFFFFF,t_70,g_se,x_16

通配符的基本使用

泛型的通配符不知道用什么类型来接受的时候，此时可以使用？表示未知通配符；此时只能接受数据不能往该集合中存储数据。

ist<?> , ?通配符定义的变量只能遍历不能修改

在这里插入图片描述

泛型擦除机制

所谓的泛型擦除机制是指

将 一个List 集合赋值给一个没有使用到泛型集合，直接使用泛型擦除机制

泛型是在编译阶段限制类型传递的，在运行阶段都是擦除底层class 文件在运行里面是没有泛型

在这里插入图片描述

懒鸟一枚
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
泛型的使用
qq_46603402的博客
04-18 2072
1. 什么是泛型 ​ 泛型，即“参数化类型”，将参数的类型泛化。在声明时不指定参数类型，根据传入的实际参数的类型来决定。是jdk1.5的特性 泛型可以随便写，但默认的规则为： E—Element，常用在Java的集合中 K,V-----key,value 代表Map中的键值对 N-----Number 代表数字 T----Type 类型，如String，Integer等等 注意：基本数据类型不能作为泛型 ​ 在集合中不使用泛型时，可以存储任意类型的对象，集合中的元素是对象。
泛型通配符的基本使用
chunzhenwangluo的博客
11-08 338
这是我参与11月更文挑战的第7天，活动详情查看：2021最后一次更文挑战」。 茫茫人海千千万万，感谢这一秒你看到这里。希望我的文章对你的有所帮助！ 愿你在未来的日子，保持热爱，奔赴山海！ 前言：昨天我们终于讲完了泛型通配符的基本使用， 所以，接下来我们将会对泛型通配符的学习--泛型通配符的高级使用！ ????泛型通配符 在我们之前的学习泛型的过程当中，在当我们使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Ob
TypeScript（ts）泛型说明及基本使用
m0_65349389的博客
12-17 1048
TypeScript（ts）泛型说明及基本使用
ts 泛型的基本使用场景
weixin_42289080的博客
06-06 1753
泛型的基本语法、多个泛型参数的使用、函数使用泛型、类型别名使用泛型、泛型类、泛型约束
java泛型的基本使用
Star's Tech Blog
04-21 6050
对java的泛型特性的了解仅限于表面的浅浅一层，直到在学习设计模式时发现有不了解的用法，才想起详细的记录一下。本文参考java 泛型详解、Java中的泛型方法、 java泛型详解1. 概述泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。什么是泛型？为什么要使用泛型？泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化...
java 泛型使用场景_泛型的使用场景，可以作用在什么位置，使用泛型有什么好处...
weixin_29268385的博客
02-25 2741
1.什么是泛型，泛型有什么用，为什么要用1.1 泛型就是一种未知的类，将未知的类型声明在集合、对象上，泛型的默认类型为Object。例如： ArrayList str = new ArrayList();这是将String类型指定在str这个集合内，这个集合存储或者读取的类型只能为String类型。1.2 使用泛型可以在传参的时候(使用占位符 ? 占位)不固定传入什么类型，即可通用类型，如果不设置...
java泛型的使用
悦分享
11-14 989
java泛型的使用 泛型的产生机制就是放什么类型的数据进去，取出来的就是什么类型，而不用进行类型转换 泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 泛型是在编译阶段有效 Java 泛型只在编译阶段有效，即在编译过程中，程序会正确的检验泛型结果。而编译成...
.NET泛型的基本使用方法
qq_59218918的博客
06-23 354
.NET泛型的基本使用方法（小白笔记，请各位大佬批评指正！）
Java泛型的使用
aaqian1的博客
01-15 403
泛型有三种使用方式：泛型类、泛型接口、泛型方法 一、泛型类 泛型类用于类的定义中，被称为泛型类。最典型的就是各种容器类，如List、Set和Map。 泛型类的最基本用法： class 类名称<泛型标识：可以随便写> https://blog.csdn.net/s10461/article/details/53941091 ...
Java高级之—泛型的使用
12-21
- **基本类型与封装类**：由于泛型不能直接使用基本类型，需使用对应的包装类，如int对应Integer。 **三、自定义泛型结构** 1. **泛型类**：在定义类时，可以在类名后面添加尖括号来声明泛型，如`public class ...
Java泛型的基本应用
12-22
使用泛型（<>）。将要操作的引用数据类型传入即可，其实<>是一个用于接收具体引用数据类型的参数范围。 　在程序中，只要用到了带有<>的类或者接口，要明确传入的具体引用数据类型。 　泛型技术是给...
详细分析Java 泛型的使用
08-18
2. **泛型的基本概念** Java泛型允许在类、接口和方法声明中使用类型参数。例如，`List<String>`就是一个泛型，其中`String`是类型参数。请注意，Java泛型不支持原始类型（如`int`、`double`等），而是需要使用它们...
java泛型基本知识及通用方法
08-26
Java 泛型基本知识及通用方法 Java 泛型是一种参数化类型系统，允许开发者在编译期指定类型，从而提高代码的安全性和可读性。Java 中的泛型系统包括泛型类、泛型接口、泛型方法三个方面。 泛型基础 泛型的基本...
浅谈java泛型的作用及其基本概念
09-01
首先，泛型的基本概念是允许在定义类、接口和方法时使用类型参数，这些类型参数可以是任意的引用类型，而不是固定的类。例如，`ArrayList<T>`中的`T`就是一个类型参数，代表某种未知的引用类型。在Java中，泛型在...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1262
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
golang 接口
m0_70982551的博客
07-24 810
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
最新发布
a1058926697的博客
07-26 365
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 498
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值