java泛型

已于 2022-08-01 22:49:59 修改
阅读量202 收藏
点赞数
分类专栏： java基础 文章标签： java
于 2022-04-12 20:18:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48303059/article/details/124133106
版权

泛型

泛型是一种未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型

泛型也可以看成是一个变量，用来接收数据类型

E e :Element 元素

T t Type 类型

ArrayList集合在定义的时候，不知道集合都会存储什么类型的数据，所以类型使用泛型

E ：未知的数据类型

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

当创建集合对象的时候，就会确定泛型的数据类型

​ ArrayList<String> list = new ArrayList<String>();会把数据类型String作为参数传递给E

1.使用泛型的好处

package package20Foreach.Demo01;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * @Author:Fwh
 * @Description:
 * @Date:Creat in 20:18 2021/10/7
 * @Modified By:
 */
public class Demo02Generic {
    public static void main(String[] args) {
        show01();
        show02();
    }

    /*
    * 创建集合对象，使用泛型
    * 好处：
    *   1.避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型
    *   2.把运行期异常（代码运行之后抛出的异常），提升到编译器（写代码的时候就会报错）
    * 弊端：
    *   泛型是什么类型，就只能存储什么类型的数据
    * */
    private static void show02() {
        ArrayList<String> list = new ArrayList<>();
        list.add("abc");
//        list.add(1);//报错

        //使用迭代器遍历list集合；
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s+"->"+s.length());

        }
    }

    /*
     * 创建集合对象，不使用泛型
     * 好处：集合不使用泛型，默认的类型就是Object类型，可以存储任意类型的数据
     * 弊端：不安全，引发异常
     * */
    private static void show01() {
        ArrayList list = new ArrayList();
        list.add("abs");
        list.add(1);

        //使用迭代器遍历集合
        //获取迭代器
        Iterator it = list.iterator();
        //使用迭代器中的方法hasNext和next遍历集合
        while (it.hasNext()){
            Object obj = it.next();
            System.out.println(obj);

            //想要使用String类特有的方法，length获取字符串的长度；不能使用    因为使用的是多态 Object obj = "abc"
            //需要向下转型
            //ClassCastException 会抛出类型转换异常，不能把Integer类型，转换成String类型
//            String s = (String)obj;
//            System.out.println(s.length());


        }
    }
}

2.定义和使用含有泛型的类

package package21FanXing.Demo02;

/**
 * @Author:Fwh
 * @Description:
 * @Date:Creat in 20:43 2021/10/7
 * @Modified By:
 */

/*
* 定义一个含有泛型的类，模拟ArrayList集合
* 泛型是一个未知的数据类型，当我们不确定什么什么数据类型的时候，可以使用泛型
* 泛型可以接收任意的数据类型，可以使用Integer、String、Student。。。
* 创建对象的时候确定泛型的数据类型
* */
public class GenericClass<E> {
    private E name;

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }
}


package package21FanXing.Demo02;

/**
 * @Author:Fwh
 * @Description:
 * @Date:Creat in 20:47 2021/10/7
 * @Modified By:
 */
public class Demo01GenericClass {
    public static void main(String[] args) {
        //不写泛型默认为Object类型
        GenericClass gc = new GenericClass();
        gc.setName("只能是字符串");
        Object name = gc.getName();
        System.out.println(name);

        //创建GenericClass对象，泛型使用Integer类型
        GenericClass<Integer> gc2 = new GenericClass<>();
        gc2.setName(1);

        Integer name1 = gc2.getName();
        System.out.println(name1);

        //创建GenericClass对象，泛型使用String 类型
        GenericClass<String> gc3 = new GenericClass<>();
        gc3.setName("小明");

        String name2 = gc3.getName();
        System.out.println(name2);
    }
}

3.含有泛型的方法

格式：

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

含有泛型的方法，在调用方法的时候确定泛型的数据类型

package package21FanXing.Demo02;

/**
 * @Author:Fwh
 * @Description:
 * @Date:Creat in 21:30 2021/10/7
 * @Modified By:
 */
/*
* 定义含有泛型的方法：泛型定义在方法的修饰符和返回值之间；
* 含有泛型的方法，在调用方法的时候确定泛型的数据类型
* 传递什么类型的参数，泛型就是什么类型
* */
public class GenericMethod {
    //定义一个含有泛型的方法
    public<M> void method01(M m){
        System.out.println(m);
    }

    //定义一个含有泛型的静态方法
    public static<S> void method02(S s){
        System.out.println(s);
    }
}


package package21FanXing.Demo02;

/**
 * @Author:Fwh
 * @Description:
 * @Date:Creat in 21:34 2021/10/7
 * @Modified By:
 */

/*
* 测试含有泛型的方法
* */
public class Demo02GenericMethod {
    public static void main(String[] args) {
        //创建GenericMethod对象
        GenericMethod gm = new GenericMethod();

        /*
         * 调用含有泛型的方法method01()
         * 传递什么类型，泛型就是什么类型
         * */
        gm.method01(10);
        gm.method01("abc");
        gm.method01(8.8);
        gm.method01(true);

        gm.method02("静态方法不建议创建对象使用");

        //静态方法，通过类名.方法名(参数)，可以直接使用
        GenericMethod.method02("abc");
        GenericMethod.method02(1);
    }
}

4.定义含有泛型的接口

格式：

修饰符 interface 方法名<代表泛型的变量(I)> {
    public abstract void method(I i(使用泛型));
}

package package21FanXing.Demo02;

/**
 * @Author:Fwh
 * @Description:
 * @Date:Creat in 21:52 2021/10/7
 * @Modified By:
 */
public interface GenericInterface<I> {
    public abstract void method(I i);
}

含有泛型的接口，第一种使用方法：定义接口的实现类，实现接口，指定接口的泛型

package package21FanXing.Demo02;

/**
 * @Author:Fwh
 * @Description:
 * @Date:Creat in 21:53 2021/10/7
 * @Modified By:
 */

/*
* 含有泛型的接口，第一种使用方法：定义接口的实现类，实现接口，指定接口的泛型
*
* */
public class GenericInterfaceImpl1 implements GenericInterface<String>{
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}

含有泛型的接口，第二种使用方法，：接口使用什么类型，类就跟着接口走，就相当于定义了一个含有泛型的类

package package21FanXing.Demo02;

/**
 * @Author:Fwh
 * @Description:
 * @Date:Creat in 22:00 2021/10/7
 * @Modified By:
 */

/*
* 含有泛型的接口，第二种使用方法，：接口使用什么类型，类就跟着接口走
* 就相当于定义了一个含有泛型的类
* */
public class GenericInterfaceImpl2<I> implements GenericInterface<I> {
    @Override
    public void method(I i) {
        System.out.println(i);
    }
}

实例调用

package package21FanXing.Demo02;

/**
 * @Author:Fwh
 * @Description:
 * @Date:Creat in 21:58 2021/10/7
 * @Modified By:
 */

/*
* 测试含有泛型的接口
* */
public class Demo03GenericInterface {
    public static void main(String[] args) {
        //创建GenericInterfaceImpl1对象
        GenericInterfaceImpl1 gi1 = new GenericInterfaceImpl1();
        gi1.method("字符串");

        //创建GenericInterfaceImpl2对象
        GenericInterfaceImpl2<Integer> gi2 = new GenericInterfaceImpl2<>();
        gi2.method(10);

        GenericInterfaceImpl2<Double> gi3 = new GenericInterfaceImpl2<>();
        gi3.method(9.9);
    }
}

5.泛型通配符

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

通配符的基本使用

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

package package21FanXing.Demo02;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * @Author:Fwh
 * @Description:
 * @Date:Creat in 22:25 2021/10/7
 * @Modified By:
 */

/*
* 泛型通配符
*   ?: 代表任意的数据
* 使用方式：
*   不能创建对象使用
*   只能作为方法的参数使用
* */
public class Demo04Generic {
    public static void main(String[] args) {
        ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(1);
        list01.add(2);

        ArrayList<String> list02 = new ArrayList<>();
        list02.add("a");
        list02.add("b");

        printArray(list01);
        printArray(list02);
    }

    /*
    * 定义一个方法，能遍历所有的ArrayList集合
    * 这时候我们不知道ArrayList集合使用什么数据类型，可以使用泛型的通配符“？”来接收数据类型
    * */
    public static void printArray(ArrayList<?> list){
        //使用迭代器遍历集合
        Iterator<?> it = list.iterator();
        while (it.hasNext()) {
            //it.next()方法，取出的元素是object，因为只有Object类型才能接收任意的数据类型
            Object next = it.next();
            System.out.println(next);
        }
    }
}

6.泛型通配符的高级使用

之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在java的泛型中可以指定一个泛型的上限和下限。

泛型的上限：

  • 格式：类型名称 <? extends 类> 对象名称
  • 意义：只能接收该类型及其子类

泛型的下限：

  • 格式：类型名称<? super 类> 对象名称
  • 意义：只能接收该类型及其父类型
package package21FanXing.Demo02;

import java.util.ArrayList;
import java.util.Collection;

/**
 * @Author:Fwh
 * @Description:
 * @Date:Creat in 22:41 2021/10/7
 * @Modified By:
 */

/*
* 泛型的上限：? extends E 代表使用的泛型只能是E类型的子类/本身
* 泛型的下限：? super E 代表使用的泛型是能是E类型的父类/本身
*
* */
public class Demo05Generic {
    public static void main(String[] args) {
        Collection<Integer> lsit1 = new ArrayList<>();
        Collection<String> lsit2 = new ArrayList<>();
        Collection<Number> lsit3 = new ArrayList<>();
        Collection<Object> lsit4 = new ArrayList<>();

        getElment1(lsit1);
//        getElment1(lsit2);//报错，只能访问Number的子类和Number本身
        getElment1(lsit3);
//        getElment1(lsit4);

//        getElment2(lsit1);//报错，只能访问Number的父类和Number本身
//        getElment2(lsit2);
        getElment2(lsit3);
        getElment2(lsit4);


        /*
        * 类与类之间的继承关系
        * Integer extends Number extends Object
        * String extends Object
        * */
    }

    /*
    * 泛型的下限：? super E 代表使用的泛型是能是E类型的父类/本身
    * */
    private static void getElment2(Collection<?super Number> coll ) {
    }

    /*
    * 泛型的上限：? extends E 代表使用的泛型只能是E类型的子类/本身
    * */
    private static void getElment1(Collection<?extends Number> coll) {
    }
}

在这里插入图片描述

Special case
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java泛型总结
04-09
深入理解java泛型，包括类名泛型的定义，方法泛型定义，泛型的返回
Java泛型的简单实例
09-04
Java泛型的简单实例 Java泛型是一种类型系统特性，它允许开发者在编写代码时指定类型参数，从而使代码更加灵活、可重用和类型安全。在本文中，我们将通过一个简单的示例来介绍Java泛型的使用。 泛型的概念 泛型是...
Java泛型
BroRiver
03-26 1133
泛型是一种在编译时实现类型安全的特性，它使得我们可以编写通用的代码，以适用于不同类型的数据。
java 泛型
最新发布
Misszhoudandan的博客
06-10 1298
泛型就是将数据类型参数化，例如我们实现一个存储对象的容器时，并不是直接定义好只能存储一种类型，好的办法就是定义时将类型参数化，也就是泛型，在真实使用时再传入真正的参数，这种参数化类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
java 泛型详解-绝对是对泛型方法讲解最详细的，没有之一
热门推荐
s10461的博客
12-30 60万+
对java的泛型特性的了解仅限于表面的浅浅一层，直到在学习设计模式时发现有不了解的用法，才想起详细的记录一下。 本文参考java 泛型详解、Java中的泛型方法、 java泛型详解 1. 概述泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。什么是泛型？为什么要使用泛型？ 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传
Java 中的泛型（两万字超全详解）
林二月的博客
08-02 6万+
博主将用 CSDN 记录 Java 后端开发学习之路上的经验，并将自己整理的编程经验和知识分享出来，希望能帮助到有需要的小伙伴。博主也希望和一直在坚持努力学习的小伙伴们共勉！唯有努力钻研，多思考勤动手，方能在编程道路上行至所向。由于博主技术知识有限，博文中难免会有出错的地方，还望各位大佬包涵并批评指正，博主会及时改正；如果本文对小伙伴你有帮助的话，求求给博主一个赞支持一下，可以一起交流，一起加油！！Java泛型详解，史上最全图文详解java 泛型全解 - 绝对最详细Java 泛型，你了解类型擦除吗。
Java泛型详解
梦想不会灭
05-30 809
一、泛型的本质 Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。 泛型的本质是参数化类型，即给类型指定一个参数，然后在使用时再指定此参数具体的值，那样这个类型就可以在使用时决定了。这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。 二、泛型的作用 泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率 1、保证类型的安全性 在没有泛型之前，从集合中
JAVA泛型
weixin_40294256的博客
07-11 950
java泛型
Java泛型大全
weixin_45203607的博客
10-02 4226
Java泛型大全 1. 概述 泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。 什么是泛型？为什么要使用泛型？ 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法形参，然后调用此方法时 传递的 实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。 泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制
java泛型详解
qq_42003527的博客
08-24 1万+
java泛型详解
Java泛型详解，史上最全图文详解
mikechen的互联网架构
02-15 5万+
泛型在java中有很重要的地位，无论是开源框架还是JDK源码都能看到它。 毫不夸张的说，泛型是通用设计上必不可少的元素，所以真正理解与正确使用泛型，是一门必修课。 一：泛型本质 Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。 泛型的本质是参数化类型，即给类型指定一个参数，然后在使用时再指定此参数具体的值，那样这个类型就可以在使用时决定了。这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛.
Java泛型定义与用法实例详解
08-27
Java泛型定义与用法实例详解 Java泛型是Java语言中的一种重要机制，用于在编译期检查类型安全，避免在运行期引发ClassCastException。泛型的引入使得Java语言更加灵活和强大，本文将详细介绍Java泛型的定义、原理、...
详谈Java泛型中T和问号(通配符)的区别
08-28
Java泛型中T和问号(通配符)的区别 Java泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、...
Java泛型的用法及T.class的获取过程解析
08-25
Java泛型的用法及T.class的获取过程解析 Java泛型是Java编程语言中的一种重要特性，它允许开发者在编写代码时指定类型参数，从而提高代码的灵活性和可读性。本文将详细介绍Java泛型的用法 及T.class的获取过程解析...
java自动装箱与拆箱
weixin_48303059的博客
04-06 4484
包装类 基本数据类型，使用起来非常方便，但是没有对应的方法来操作这些基本数据类型的数据 可以使用一个类，把基本类型的数据装起来，在类中定义一些方法，这个类叫做包装类，我们呢可以调用类当中的方法来操作这些基本类型的数据 包装类有8种，包装类位于 java.lang.文件下 基本类型 对应的包装类（位于java.lang包中） byte Byte short Short int Integer long Long float Float double Double cha
java四种权限修饰符
weixin_48303059的博客
04-10 3341
四种权限修饰符 java中有四种权限修饰符： public（公有的） > protected（受保护的） > (default)（缺省的） > private(私有的) default并不是关键字 default，而是根本不写 1.在同一个类当中 在同一个类当中，四种权限修饰符都能被同类的方法访问 2.在同一个包 在同一个包当中，四种权限修饰符当中，另一个类当中只能访问到缺省的权限，私有的成员无法访问 3.不同的包父子关系 在不同包的父子关系的两个类当中，只能访问到受保护的层面，剩下的缺省
BigDecimal的原理
weixin_48303059的博客
03-02 1080
BigDecimal的使用原理
java对象创建之匿名对象的使用
weixin_48303059的博客
07-13 824
java对象创建之匿名对象的使用 1. 匿名对象的创建 创建对象的标准格式： 类名称 对象名 = new 类名称(); 匿名对象就是只有右边的对象，没有左边的名字和赋值运算符 new 类名称(); 注意事项：匿名对象只能使用唯一的一次，因为创建的对象的地址值没有交给任何一个对象来保存，下次使用就不得不再次创建一个新对象 使用建议：如果确定一个对象只需要使用唯一的一次，就可以用匿名对象 匿名对象作为方法的参数以及匿名对象作为返回值 package package05.Demo02; import java.

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值