【JAVA入门】Day29 - 泛型

最新推荐文章于 2024-09-03 20:17:53 发布
最新推荐文章于 2024-09-03 20:17:53 发布
阅读量858 收藏 14
点赞数 19
分类专栏： JAVA入门 文章标签： java python windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oo00Z00oo/article/details/141713062
版权

【JAVA入门】Day29 - 泛型

文章目录

        泛型是 JDK5 中引入的新特性，可以在编译阶段约束操作的数据类型，并进行检查。泛型的格式很简单： 
<数据类型>

        要注意：泛型中只能写引用数据类型。
        泛型就像一个检查数据是否符合要求的质检员，如果数据符合泛型要求，就可以存入集合。

ArrayList<String> list1 = new ArrayList<>();
list1.add("aaa");
list1.add("bbb");
list1.add("ccc");

ArrayList<Integer> list2 = new ArrayList<>();
list2.add(111);
list2.add(222);
list2.add(333);

一、JDK5 之前集合如何存储数据

        在没有泛型之前，我们可以往集合中添加任意类型的数据，它们都被认为是 Object 类型，这就导致了一个问题：不能访问子类独有的方法。

package Generics;

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

public class GenericsDemo1 {
    public static void main(String[] args) {
        //没有泛型时，集合如何存储数据

        //1.创建集合对象
        ArrayList list = new ArrayList();

        //2.添加数据
        list.add(123);
        list.add("aaa");
        list.add(new Student("zhangsan", 123));

        //3.遍历结合获取里面的每一个元素
        Iterator it = list.iterator();
        while(it.hasNext()) {
            Object obj = it.next();
            System.out.println(obj);
            //这里的obj是多态
            //多态存在弊端：不能访问子类的特有功能
            //此时推出了泛型，约束我们在添加数据时，就约定了添加的元素类型
        }
    }
}

二、为什么要有泛型？

        引入泛型，就是为了统一数据类型。
        泛型将运行时期存在的问题提前到了编译期间，避免了运行过程中强制类型转换可能出现的异常，因为要添加的数据类型，在编译阶段就能确定下来。

三、伪泛型

        Java 中的泛型其实是伪泛型，即数据在进入集合前，是被泛型约束所检测的，一旦进入集合，内部其实统一还是按 Object 类型来处理，只是在移出集合时，又重新强制转换为了泛型要求的格式。这一点体现在： .java 文件转字节码 .class 文件时，泛型的相关代码就会消失。
        因此一定要注意：指定的泛型不能写基本数据类型，因为在内部操作时，Java 会把泛型转换为 Objct 类型，基本数据类型是无法转换的；在约束泛型后，传入集合的类型可以是该类类型，也可以是其子类类型（多态）；如果不写泛型，默认还是以 Object 形式传入。

四、泛型的三大用法

        泛型实际上不仅仅有集合这一个用途，泛型可以在很多地方进行定义。
        泛型可以在类后面定义，此时这个泛型变为泛型类；可以在方法上定义，此时这个方法变为泛型方法；可以在接口后面定义，此时这个接口变为泛型接口。

4.1 泛型类

        当我们创建一个类时，如果类中的某个变量数据类型我们不能确定，就可以定义为带有泛型的类。

修饰符 class 类名<类型> {

}

        比如我们常用的 ArrayList 类：

public class ArrayList<E> {

}

        用泛型<E>表示不确定类型，而是在创建该类对象时，E再确定类型。
        此时的 E 可以理解为一个变量，但他不用于记录数据，而是记录数据的类型，所以它本身也是不固定的，可以写作 T、E、K、V 等各种字母，它仅代表数据的类型。
        我们在编写类时，可以通过加泛型，把这个类变成一个泛型类。以下是我们利用泛型自己编写的 ArrayList 类。

package Generics;

/*
      当我在编写一个类的时候，如果不确定类型，那么这个类就可以定义为泛型类
*/

import java.util.Arrays;

public class MyArrayList<E> {

    Object[] obj = new Object[10];
    int size;

/*    E:表示是不确定的类型。该类型在类名后面已经定义过了。
    e:形参的名字，变量名
*/

    public boolean add(E e) {
        obj[size] = e;
        size++;
        return true;
    }

    public E get(int index) {
        return (E)obj[index];
    }

    @Override
    public String toString() {
        return Arrays.toString(obj);
    }

}

4.2 泛型方法

        当方法中形参类型不确定时，可以使用类名后面定义的泛型。如果只有极少数方法的形参不确定类型，那么可以直接给这个方法加一个泛型，把它变成一个泛型方法。

    public <E> boolean add(E e) {
        obj[size] = e;
        size++;
        return true;
    }

        要注意，类的泛型在整个类中所有方法都能使用，而方法的泛型只能在方法本体中使用。
        泛型方法的格式如下：

修饰符 <类型> 返回值类型 方法名(类型 变量名) {

}

        举例：

public <T> void show(T t) {

}

        泛型方法的调用例如下所示：
        假如我们编写了一个泛型的工具类，里面有静态泛型方法addAll() 和 addAll2() ，用于添加四个或复数个集合元素。

package Generics;

import java.util.ArrayList;

public class ListUtil {
    private ListUtil(){}

    //类中定义一个静态方法addAll,用来添加多个集合的元素。

    /*
    参数一：集合
    参数二~最后：要添加的元素
     */

    public static <E> void addAll(ArrayList<E> list, E e1, E e2, E e3, E e4){
        list.add(e1);
        list.add(e2);
        list.add(e3);
        list.add(e4);
    }

    public static <E> void addAll2(ArrayList<E> list, E...e) {      //可变参数
        for (E element : e) {
            list.add(element);
        }
    }

    public void show() {
        System.out.println("这是一个泛型工具类");
    }
}

        然后我们用一个新的测试类来调用这个工具类中的泛型方法，可以看到，当我们传递 ArrayList<String> list1 为参数时，泛型 E 被自动转化为 String 类型；当我们传递 ArrayList<Integer> list2 为参数时，泛型 E 被自动转化为 Integer 类型。

package Generics;

import java.util.ArrayList;

public class GenericsDemo3 {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        ListUtil.addAll(list1, "aaa", "bbb", "ccc", "ddd");
        System.out.println(list1);

        ArrayList<Integer> list2 = new ArrayList<>();
        ListUtil.addAll2(list2, 111, 222, 333, 444, 555, 666, 777);             //可变参数
        System.out.println(list2);
    }
}

4.3 泛型接口

        当一个接口当中要添加的数据类型是不确定的，我们就可以用泛型约束接口，让它成为一个泛型接口。
        格式：

修饰符 interface 接口名<类型> {

}

        举例：

public interface List<E> {

}

        泛型接口的声明并不复杂，但关键是我们如何使用一个带泛型的接口。一般我们有两种用法：

  • 方式一：实现类给出具体的类型。
  • 方式二：实现类延续泛型，创建对象时再确定。

        第一种方式代码如下：
        先用实现类实现 List 接口，同时在实现时就声明给出具体的类型，然后这个实现类创建的集合对象中存储的数据就只能是约束的泛型类型了。

package Generics;

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class MyArrayList2 implements List<String> {

    @Override
    public int size() {
        return 0;
    }

    @Override
    public boolean isEmpty() {
        return false;
    }

    @Override
    public boolean contains(Object o) {
        return false;
    }

    @Override
    public Iterator<String> iterator() {
        return null;
    }

    @Override
    public Object[] toArray() {
        return new Object[0];
    }

    @Override
    public <T> T[] toArray(T[] a) {
        return null;
    }

    @Override
    public boolean add(String s) {
        return false;
    }

    @Override
    public boolean remove(Object o) {
        return false;
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean addAll(Collection<? extends String> c) {
        return false;
    }

    @Override
    public boolean addAll(int index, Collection<? extends String> c) {
        return false;
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        return false;
    }

    @Override
    public void clear() {

    }

    @Override
    public String get(int index) {
        return null;
    }

    @Override
    public String set(int index, String element) {
        return null;
    }

    @Override
    public void add(int index, String element) {

    }

    @Override
    public String remove(int index) {
        return null;
    }

    @Override
    public int indexOf(Object o) {
        return 0;
    }

    @Override
    public int lastIndexOf(Object o) {
        return 0;
    }

    @Override
    public ListIterator<String> listIterator() {
        return null;
    }

    @Override
    public ListIterator<String> listIterator(int index) {
        return null;
    }

    @Override
    public List<String> subList(int fromIndex, int toIndex) {
        return null;
    }
}

        测试类生成实现类对象，调用 add() 方法测试：

package Generics;

public class GenericsDemo4 {
    public static void main(String[] args) {
        MyArrayList2 list = new MyArrayList2();
        list.add("aaa");
        list.add(123);	//报错，泛型给的String，只能添加字符串数据类型
    }
}

        第二种方式代码如下：
        在实现类实现接口时，把泛型延续下来，还用 <E> 表示。
        要注意，在实现类继续声明泛型时，要在类名和接口名后面同时加上 <E> 。

package Generics;

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class MyArrayList3<E> implements List<E> {
    @Override
    public int size() {
        return 0;
    }

    @Override
    public boolean isEmpty() {
        return false;
    }

    @Override
    public boolean contains(Object o) {
        return false;
    }

    @Override
    public Iterator<E> iterator() {
        return null;
    }

    @Override
    public Object[] toArray() {
        return new Object[0];
    }

    @Override
    public <T> T[] toArray(T[] a) {
        return null;
    }

    @Override
    public boolean add(E e) {
        return false;
    }

    @Override
    public boolean remove(Object o) {
        return false;
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        return false;
    }

    @Override
    public boolean addAll(int index, Collection<? extends E> c) {
        return false;
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        return false;
    }

    @Override
    public void clear() {

    }

    @Override
    public E get(int index) {
        return null;
    }

    @Override
    public E set(int index, E element) {
        return null;
    }

    @Override
    public void add(int index, E element) {

    }

    @Override
    public E remove(int index) {
        return null;
    }

    @Override
    public int indexOf(Object o) {
        return 0;
    }

    @Override
    public int lastIndexOf(Object o) {
        return 0;
    }

    @Override
    public ListIterator<E> listIterator() {
        return null;
    }

    @Override
    public ListIterator<E> listIterator(int index) {
        return null;
    }

    @Override
    public List<E> subList(int fromIndex, int toIndex) {
        return null;
    }
}

        在测试类中，创建实现类对象时，再声明泛型的类型，这样想创建什么类型的对象，就声明什么类型即可。

package Generics;

public class GenericsDemo5 {
    public static void main(String[] args) {
        MyArrayList3<String> list = new MyArrayList3<>();
        list.add("aaa");

        MyArrayList3<Integer> integerlist = new MyArrayList3<>();
        integerlist.add(123);
    }
}

五、泛型的继承性和通配符

        泛型本身不具备继承性，但是数据是具备继承性的。

package Generics;

import java.util.ArrayList;

public class GenericsDemo6 {
    /*
        泛型不具备继承性，但是数据具备继承性
     */
    public static void main(String[] args) {
        //创建集合的对象
        ArrayList<Ye> list1 = new ArrayList<>();
        ArrayList<Fu> list2 = new ArrayList<>();
        ArrayList<Zi> list3 = new ArrayList<>();

        //调用method方法
        method(list1);
        method(list2);	//报错，method方法约束泛型为Ye
        method(list3);	//报错，method方法约束泛型为Ye

		//在<Ye>泛型的list1集合中，可以添加Ye、Fu、Zi三种类型数据，因为数据是可以多态的
        list1.add(new Ye());
        list1.add(new Fu());
        list1.add(new Zi());
    }

    /*
      此时，泛型里写的什么类型，那么只能传什么类型的数据
     */

    public static void method(ArrayList<Ye> list){

    }
}

class Ye{}
class Fu extends Ye{}
class Zi extends Fu{}

        如果我们的需求是，定义一个方法，传递参数的类型不确定，但不希望任何类型都能传递，还是有一个限定的范围，就可以利用类的继承和泛型的通配符来实现。

package Generics;

import JavaStudy1.Array.Array;

import java.util.ArrayList;

public class GenericsDemo7 {
    public static void main(String[] args) {
        /*
        需求：定义一个方法，形参是一个集合，但是集合中的数据类型不确定
        虽然不确定类型，但是只希望能传递 Ye Fu Zi 三种类型
         */
        ArrayList<Ye> list1 = new ArrayList<>();
        ArrayList<Fu> list2 = new ArrayList<>();
        ArrayList<Zi> list3 = new ArrayList<>();

        ArrayList<Student> list4 = new ArrayList<>();

        method(list1);      //Ye
        method(list2);      //Fu
        method(list3);      //Zi
        //method(list4);      //Student
    }

    //泛型方法实现
    //小弊端：此方法可以接收任意的数据类型
    //因此Student类也能传递过来，这不符合需求
   // public static <E> void method(ArrayList<E> list) {

    //}

    //解决方案，使用泛型通配符
    // ? 表示不确定的类型
    // 但是他可以进行类型的限定
    // ? extends E: 表示可以传递E或者E所有的子类类型
    // ? super E:   表示可以传递E或者E的所有父类类型
    public static void method(ArrayList<? extends Ye> list) {

    }
}

        泛型通配符的应用场景：

  • 在定义类、方法、接口的时候，如果类型不确定，就可以定义泛型类、泛型方法、泛型接口。
  • 在定义类、方法、接口的时候，在类型不确定的前提下，能知道以后只能传递某个继承体系中的类型，就可以使用泛型通配符。
Clown Piece
关注
  • 19
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
集合进阶-Java入门-黑马程序员2022年新视频DAY23笔记
weixin_56633661的博客
03-13 198
集合进阶知识。包括了泛型的说明，每个集合的一些底层原理，使用的数据结构，以及不同集合对应的不同的使用场景。
----java基础 - 0基础 - 入门 - 新手专用
开开心心的博客
09-10 295
本文全面介绍了Java编程语言的最基础部分，从语法和语句，到多态创建对象、集合、反射、IO流和多线程等高级概念。每一部分都提供了详细的说明和相应的源代码案例。通过学习本文，读者将能够更快速地掌握Java编程，并扎实地理解这些关键概念。
Java入门Day12：泛型
Niccch的博客
12-28 236
这几天我明显感觉自己的学习效率下降了，我仔细的思考了这个问题，我觉得主要有两个方面的原因。1.学习的内容不断增加，前面的学习内容，需要时间来消化吸收，不断的去追源码，去看底层，其实本身是很累的，加上在集合这部分内容，底层的东西是混在一起的，比如HashSet是Set接口的实现类，但它的底层实际上联系到Map接口下的HashMap，这使得我的大脑总是在将他们混乱，再理清，在混乱。
【Java学习笔记】58 - 泛型
qq_41891655的博客
11-02 253
泛型的介绍 泛型=> E =Integer、String、Dog（表示某种数据类型，表示数据类型的数据类型） 1) 泛型又称参数化类型，是Jdk5.0 出现的新特性,解决数据类型的安全性问题 2) 在类声明或实例化时只要指定好需要的具体的类型即可。 3) Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。 同时，代码更加简洁、健壮 4) 泛型的作用是:可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的
JAVA零基础小白入门上手教程day15-泛型&File
张晨光老师的播客
01-01 215
​ 在前面学习集合时，我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。//由于集合没有做任何限定，任何类型都可以给其中存放 Iterator it = coll . iterator();//需要打印每个字符串的长度,就要把迭代出来的对象转成String类型 String str =(String) it . next();} } }程序在运行时发生了问题。
【JAVA入门】Day07 - ArrayList
oo00Z00oo的博客
06-11 490
集合看似与数组有密不可分的关系，但是集合和数组有两个非常明显的区别。集合在 Java 编程中有着非常重要的作用，Java 内置了很多种不同的集合，我们以最常用的集合 ArrayList 为引入，逐步拉开集合的幕布。
黑马java快速入门day01
10-25
### 黑马 Java 快速入门 Day01 #### Java 的前世今生 ##### Java 是什么？ Java 是一种广泛使用的高级编程语言，它以其跨平台的能力（即“一次编写，到处运行”的理念）而闻名。这个名字源于咖啡，象征着开发者...
day09-ArrayList集合&学生管理系统.pdf
08-17
ArrayList是Java集合框架中的重要组成部分，它是一个可以动态变化的数组，允许我们在运行时动态地添加和删除元素。 ### ArrayList类概述 #### 集合框架 在Java中，集合框架是用于存储、操作、控制和传递一组对象...
Java快速入门教程资料_Java快速入门教程资料_JAVA教程资料_most5st_源码
10-01
这个"Java快速入门教程资料"集合提供了全面的学习资源，适合初学者系统地了解和掌握Java编程基础。下面将按照标签和压缩包中的文件名称，详细解析其中可能包含的知识点。 1. **Java基本语法** - `day01资料`：通常...
浅析synchronized锁升级的原理与实现 1
水w的博客
09-01 1192
浅析synchronized锁升级的原理与实现
在Java Web开发中，如何保障应用的安全性？请列举常见的安全策略和措施。请解释Spring框架中的事务管理，包括声明式事务和编程式事务。
最新发布
weixin_53180424的博客
09-03 676
在实际开发中，声明式事务管理因其非侵入性和易维护性而更受欢迎。它允许开发者将注意力集中在业务逻辑上，而不是事务管理的细节上。然而，在某些特殊场景下，编程式事务管理可能提供更灵活的控制力。因此，在选择事务管理方式时，应根据实际需求和场景来决定。
计算机毕业设计选题推荐-任务管理系统-项目任务分配系统-Java/Python项目实战
IT研究室的博客
09-03 567
随着信息化技术的迅猛发展，各类企业和组织越来越依赖于高效的任务管理系统以保证其日常运营的顺利进行。根据IDC（国际数据公司）发布的报告显示，全球企业在数字化转型上的投入已达数千亿美元，其中相当一部分资金用于提升企业内部的管理效率。任务管理系统作为企业信息化的重要组成部分，能有效帮助企业分配、监控和反馈任务，从而提高工作效率。然而，尽管市场上已有多种任务管理系统，它们在功能、用户体验和适用性上存在显著差异。
操作系统原子操作
zzt_is_me的博客
08-28 8680
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
MapStruct-Java实体转换利器
m0_63622279的博客
09-02 400
MapStruct 是一个用于生成映射器接口的代码生成库，主要用于简化 Java 对象之间的转换过程。在处理不同模型之间数据转换时，MapStruct 可以自动生成实现类减少手工转换逻辑的工作量。使用场景：各种模型之间的转换。BODTOVOPOJO引入mapstruct的pom依赖定义mapper接口（注意，这里不是MyBatis的Mapper哦），使用@Mapper注解标记，并在接口中声明映射方法。编写映射方法，（从xxxO转换为yyyO,模型之间的转换）在业务层中使用Mapper。
JavaWeb（基于SpringBoot开发）全总结（1）
2302_81420820的博客
09-02 843
再到spring boot中去设置，当我们遇到报错不要紧，我们直接再复制我们在DG上面写的sql语句，到idea那个数据库那里再运行一次，2.由于使用不同开发工具开发出来的略有不同，导致不能够互通，所以国际规定，使用maven创建的项目为统一标准结构，也就是下图所示的结构。还有我们写的案例里面的mapper层写的sql语句的新增，删除，等等操作，都是基于mybatis来实现的。例如：传入的是路径参数，json格式的参数等等，根据不同的参数我们使用不同的注解。
输入三个正整数，找出不大不小的值
laocooon的博客
08-30 1685
/ 找出最大值，找出最小值，然后不是最大值也不是最小值的。// 2、输入三个正整数，找出不大不小的值。
SpringBoot日常：扩展接口之CommandLineRunner和ApplicationRunner
qq_32590535的博客
08-28 545
日常开发中我们可能经常会遇到这样的场景，像启动容器完成后需要去执行一些业务逻辑，SpringBoot给我们提供了两个接口来帮助我们实现这种需求，两个启动加载接口分别是CommandLineRunner和ApplicationRunner。本文简单介绍如何使用该扩展点实现业务。
Java并发编程 进程与线程
m0_56369671的博客
08-28 1386
操作系统中有一个组件叫做任务调度器，将 cpu 的时间片（windows下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于 cpu 在线程间（时间片很短）的切换非常快，人类感觉是 同时运行的。但如果是四核 cpu，各个核心分别使用线程 1 执行计算 1，线程 2 执行计算 2，线程 3 执行计算 3，那么 3 个线程是并行的，花费时间只取决于最长的那个线程运行的时间，即 11ms 最后加上汇总时间只会花费 12ms 注：需要在多核 cpu 才能提高效率，单核仍然时是轮流执行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值