泛型详解.

最新推荐文章于 2024-07-27 13:31:57 发布
最新推荐文章于 2024-07-27 13:31:57 发布
阅读量312 收藏
点赞数
分类专栏： # JavaSE 文章标签： java jvm c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56444564/article/details/129338151
版权

1 泛型的引入
问题：我们之前实现过的顺序表，只能保存 int 类型的元素，如果现在需要保存 指向 Person 类型对象的引用的顺序表，请问应该如何解决？如果又需要保存指向 Book 对象类型的引用呢？

之前写的顺序表代码示例：

import java.util.Arrays;
 
public class MyArrayList {
    private int[] elem;
    private int usedSize;
    private static int capacity = 10;
 
    public MyArrayList() {
        this.elem = new int[capacity];
    }
 
    public boolean isFull() {
        if (this.usedSize == capacity) {
            return true;
        }
        return false;
    }
 
    public void add(int pos, int data) {
        if (pos < 0 || pos > this.usedSize) {
            System.out.println("pos位置不合法");
            return;
        }
        if (isFull()) {
            this.elem = Arrays.copyOf(this.elem, 2 * capacity);
            capacity *= 2;
        }
        for (int i = this.usedSize - 1; i >= pos; i--) {
            this.elem[i + 1] = this.elem[i];
        }
        this.elem[pos] = data;
        this.usedSize++;
    }
 
    public void display() {
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(this.elem[i] + " ");
        }
        System.out.println();
    }
 
    public boolean isEmpty() {
        if (this.usedSize == 0) {
            return true;
        }
        return false;
    }
 
    public boolean contains(int toFind) {
        if (isEmpty()) {
            return false;
        }
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == toFind) {
                return true;
            }
        }
        return false;
    }
 
    public int search(int toFind) {
        if (isEmpty()) {
            return -1;
        }
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == toFind) {
                return i;
            }
        }
        return -1;
    }
 
    public int getPos(int pos) {
        if (isEmpty()) {
            throw new RuntimeException("顺序表为空！");
        }
        if (pos < 0 || pos >= this.usedSize) {
            throw new RuntimeException("pos不合法");
        }
        return this.elem[pos];
    }
 
    public int size() {
        return this.usedSize;
    }
 
    public void setPos(int pos, int value) {
        if (pos < 0 || pos >= this.usedSize) {
            System.out.println("pos位置不合法！");
            return;
        }
        this.elem[pos] = value;
    }
 
    public void remove(int toRemove) {
        if (isEmpty()) {
            return;
        }
 
        int index = search(toRemove);
 
        if (index == -1) {
            System.out.println("没有你要删除的数字！");
        }
 
        for (int i = index; i < this.usedSize - 1; i++) {
            this.elem[i] = this.elem[i + 1];
        }
        this.usedSize--;
    }
 
    public void clear() {
        for (int i = 0; i < this.usedSize; i++) {
            this.elem[i] = 0;
        }
        this.usedSize = 0;
    }
 
 
    public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(0, 1);
        myArrayList.add(1, 2);
        myArrayList.add(2, 3);
        myArrayList.add(3, 4);
        System.out.println(myArrayList.size());
        myArrayList.display();
        System.out.println(myArrayList.contains(3));
        System.out.println(myArrayList.contains(2));
        System.out.println(myArrayList.search(5));
        System.out.println(myArrayList.search(2));
        System.out.println(myArrayList.getPos(0));
        System.out.println(myArrayList.usedSize);
        myArrayList.display();
        myArrayList.remove(1);
        myArrayList.remove(2);
        myArrayList.display();
        myArrayList.remove(4);
        myArrayList.display();
        myArrayList.clear();
        System.out.println("==============");
        myArrayList.display();
    }
}
  • 首先，我们在学习多态过程中已知一个前提，父类的引用可以指向子类的对象。
  • 其次，我们也已知 Object 是 java 中所有类的祖先类
     

那么，要解决上述问题，我们很自然的想到一个解决办法，将我们的顺序表的元素类型定义成 Object 类型，这样我们的 Object 类型的引用可以指向 Person 类型的对象或者指向 Book 类型的对象了。

因为代码改动较多，现在指出主要代码：

这样，我们可以就可以很自由的存储指向任意类型对象的引用到我们的顺序表了。
 

改编后的代码： 

 

package test1;

import java.util.Arrays;

public class MyArrayList {
    private Object[] elem;
    private int usedSize;
    private static int capacity = 10;

    public MyArrayList() {
        this.elem = new Object[capacity];
    }

    public boolean isFull() {
        if (this.usedSize == capacity) {
            return true;
        }
        return false;
    }

    public void add(int pos, Object data) {
        if (pos < 0 || pos > this.usedSize) {
            System.out.println("pos位置不合法");
            return;
        }
        if (isFull()) {
            this.elem = Arrays.copyOf(this.elem, 2 * capacity);
            capacity *= 2;
        }
        for (int i = this.usedSize - 1; i >= pos; i--) {
            this.elem[i + 1] = this.elem[i];
        }
        this.elem[pos] = data;
        this.usedSize++;
    }

    public void display() {
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(this.elem[i] + " ");
            System.out.println();
        }
        System.out.println();
    }

    public boolean isEmpty() {
        if (this.usedSize == 0) {
            return true;
        }
        return false;
    }

    public boolean contains(Object toFind) {
        if (isEmpty()) {
            return false;
        }
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == toFind) {
                return true;
            }
        }
        return false;
    }

    public int search(Object toFind) {
        if (isEmpty()) {
            return -1;
        }
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == toFind) {
                return i;
            }
        }
        return -1;
    }

    public Object getPos(int pos) {
        if (isEmpty()) {
            throw new RuntimeException("顺序表为空！");
        }
        if (pos < 0 || pos >= this.usedSize) {
            throw new RuntimeException("pos不合法");
        }
        return this.elem[pos];
    }

    public int size() {
        return this.usedSize;
    }

    public void setPos(int pos, int value) {
        if (pos < 0 || pos >= this.usedSize) {
            System.out.println("pos位置不合法！");
            return;
        }
        this.elem[pos] = value;
    }

    public void remove(int toRemove) {
        if (isEmpty()) {
            return;
        }

        int index = search(toRemove);

        if (index == -1) {
            System.out.println("没有你要删除的数字！");
        }

        for (int i = index; i < this.usedSize - 1; i++) {
            this.elem[i] = this.elem[i + 1];
        }
        this.usedSize--;
    }

    public void clear() {
        for (int i = 0; i < this.usedSize; i++) {
            this.elem[i] = 0;
        }
        this.usedSize = 0;
    }


    public static void main(String[] args) {
        MyArrayList books = new MyArrayList();
        for (int i = 0; i < 10; i++) {
            books.add(i,new Book("三国演义", "罗贯中", 15));
        }
        books.display();
//        MyArrayList myArrayList = new MyArrayList();
//        myArrayList.add(0, 1);
//        myArrayList.add(1, 2);
//        myArrayList.add(2, 3);
//        myArrayList.add(3, 4);
//        System.out.println(myArrayList.size());
//        myArrayList.display();
//        System.out.println(myArrayList.contains(3));
//        System.out.println(myArrayList.contains(2));
//        System.out.println(myArrayList.search(5));
//        System.out.println(myArrayList.search(2));
//        System.out.println(myArrayList.getPos(0));
//        System.out.println(myArrayList.usedSize);
//        myArrayList.display();
//        myArrayList.remove(1);
//        myArrayList.remove(2);
//        myArrayList.display();
//        myArrayList.remove(4);
//        myArrayList.display();
//        myArrayList.clear();
//        System.out.println("==============");
//        myArrayList.display();
    }
}


遗留问题：现在的 MyArrayList 虽然可以做到添加任意类型的引用到其中了，但遇到以下代码就会产生问题。

写一个Person类：

 接下来我称之为牛马操作：

编译竟然正确，没有报红，我们运行一下看看：

 

运行时会抛出了异常
 

提示：问题暴露的越早，影响越小。编译期间的问题只会让开发者感觉到，运行期间的错误会让所有的软件使用者承受错误风险。

所以我们需要一种机制，可以 1. 增加编译期间的类型检查 2. 取消类型转换的使用 泛型就此诞生！
 

2.泛型的分类

  • 1. 泛型类
  • 2. 泛型方法

3 泛型类的定义的简单演示


 注意： 泛型类可以一次有多个类型变量，用逗号分割。
 

4 泛型背后作用时期和背后的简单原理

  • 1. 泛型是作用在编译期间的一种机制，即运行期间没有泛型的概念。
  • 2. 泛型代码在运行期间，就是我们上面提到的，利用 Object 达到的效果（这里不是很准确，以后会做说明）。
     

5 泛型类的使用


 

通过以上代码，我们可以看到泛型类的一个使用方式：只需要在所有类型后边跟尖括号，并且尖括号内是真正的类型，即 E 可以看作的最后的类型。
 

看具体代码：

package test1;

import java.util.Arrays;

public class MyArrayList<E> {
    private Object[] elem;
    private int usedSize;
    private static int capacity = 10;

    private E e;

    public MyArrayList() {
        this.elem = new Object[capacity];
        this.e = e;
    }

    public boolean isFull() {
        if (this.usedSize == capacity) {
            return true;
        }
        return false;
    }

    public void add(int pos, E data) {
        if (pos < 0 || pos > this.usedSize) {
            System.out.println("pos位置不合法");
            return;
        }
        if (isFull()) {
            this.elem = Arrays.copyOf(this.elem, 2 * capacity);
            capacity *= 2;
        }
        for (int i = this.usedSize - 1; i >= pos; i--) {
            this.elem[i + 1] = this.elem[i];
        }
        this.elem[pos] = data;
        this.usedSize++;
    }

    public void display() {
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(this.elem[i] + " ");
            System.out.println();
        }
        System.out.println();
    }

    public boolean isEmpty() {
        if (this.usedSize == 0) {
            return true;
        }
        return false;
    }

    public boolean contains(E toFind) {
        if (isEmpty()) {
            return false;
        }
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == toFind) {
                return true;
            }
        }
        return false;
    }

    public int search(E toFind) {
        if (isEmpty()) {
            return -1;
        }
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == toFind) {
                return i;
            }
        }
        return -1;
    }

    public Object getPos(int pos) {
        if (isEmpty()) {
            throw new RuntimeException("顺序表为空！");
        }
        if (pos < 0 || pos >= this.usedSize) {
            throw new RuntimeException("pos不合法");
        }
        return this.elem[pos];
    }

    public int size() {
        return this.usedSize;
    }

    public void setPos(int pos, int value) {
        if (pos < 0 || pos >= this.usedSize) {
            System.out.println("pos位置不合法！");
            return;
        }
        this.elem[pos] = value;
    }

    public void remove(E toRemove) {
        if (isEmpty()) {
            return;
        }

        int index = search(toRemove);

        if (index == -1) {
            System.out.println("没有你要删除的数字！");
        }

        for (int i = index; i < this.usedSize - 1; i++) {
            this.elem[i] = this.elem[i + 1];
        }
        this.usedSize--;
    }

    public void clear() {
        for (int i = 0; i < this.usedSize; i++) {
            this.elem[i] = 0;
        }
        this.usedSize = 0;
    }


    public static void main(String[] args) {
        MyArrayList<Book> books = new MyArrayList<Book>();
        books.add(0, new Book("红楼梦", "曹雪芹", 18));
        books.add(2, new Person("lisi", "lll"));

//        Book book1 = new Book("红楼梦", "曹雪芹", 18);
//        for (int i = 0; i < 10; i++) {
//            if (i == 0) {
//                books.add(i, book1);
//            } else {
//                books.add(i, new Book("三国演义", "罗贯中", 15));
//            }
//        }
//        books.display();
//        Person person = (Person) books.getPos(0);
//        MyArrayList myArrayList = new MyArrayList();
//        myArrayList.add(0, 1);
//        myArrayList.add(1, 2);
//        myArrayList.add(2, 3);
//        myArrayList.add(3, 4);
//        System.out.println(myArrayList.size());
//        myArrayList.display();
//        System.out.println(myArrayList.contains(3));
//        System.out.println(myArrayList.contains(2));
//        System.out.println(myArrayList.search(5));
//        System.out.println(myArrayList.search(2));
//        System.out.println(myArrayList.getPos(0));
//        System.out.println(myArrayList.usedSize);
//        myArrayList.display();
//        myArrayList.remove(1);
//        myArrayList.remove(2);
//        myArrayList.display();
//        myArrayList.remove(4);
//        myArrayList.display();
//        myArrayList.clear();
//        System.out.println("==============");
//        myArrayList.display();
    }
}

 

那么现在就会出现编译错误 ，这就是泛型的作用！

注意： Book 只能想象成 E 的类型，但实际上 E 的类型还是 Object。
 

6 泛型总结

  • 1. 泛型是为了解决某些容器、算法等代码的通用性而引入，并且能在编译期间做类型检查。
  • 2. 泛型利用的是 Object 是所有类的祖先类，并且父类的引用可以指向子类对象的特定而工作。
  • 3. 泛型是一种编译期间的机制，即 MyArrayList<Person> 和 MyArrayList<Book> 在运行期间是一个类型。
  • 4. 泛型是 java 中的一种合法语法，标志就是尖括号 <>
     
阿瞒有我良计15
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C#之泛型详解.docx
09-15
泛型是C#编程语言中的一个重要特性，它允许开发者创建可重用的代码模板，这些模板可以在多种数据类型上工作，从而提高了代码的灵活性、效率和安全性。泛型的引入解决了在处理不同类型数据时需要重复编写类似代码的...
Java核心知识1：泛型机制详解.pdf
11-17
Java核心知识1：泛型机制详解 泛型机制是Java语言中的一种重要特性，自JDK 1.5开始引入，提供了编译时类型安全检测机制，允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型，即给类型指定一个参数，然后...
java泛型详解
qq_42003527的博客
08-24 1万+
java泛型详解
泛型-详解
VIBE的博客
09-05 555
class 泛型类名称 < 类型形参列表 > {// 这里可以使用类型参数 } class ClassName < T1 , T2 , . . . , Tn > {} class 泛型类名称 < 类型形参列表 > extends 继承类 /* 这里可以使用类型参数 */ {// 这里可以使用类型参数 } class ClassName < T1 , T2 , . . . , Tn > extends ParentClass < T1 > {// 可以只使用部分类型参数 }
java泛型详解_Java泛型详解
weixin_39553705的博客
02-16 91
一. 泛型概念的提出(为什么需要泛型)？首先，我们看下下面这段简短的代码:1 public classGenericTest {23 public static voidmain(String[] args) {4 List list = newArrayList();5 list.add("qqyumidi");6 list.add("co...
golang 泛型详解
擅长后端研发
02-28 1734
Go 在1.18 中添加了泛型，这样Go 就可以在定义时不定义类型，而是在使用时进行类型的定义，并且还可以在编译期间对参数类型进行校验。Go 目前只支持泛型方法，还不支持泛型接口，下面我会详细介绍Go的泛型使用以及常见的使用错误。其他概念性的东西我不想说太多，大家可以自己百度。
Java 中的泛型（两万字超全详解）
热门推荐
林二月的博客
08-02 6万+
博主将用 CSDN 记录 Java 后端开发学习之路上的经验，并将自己整理的编程经验和知识分享出来，希望能帮助到有需要的小伙伴。博主也希望和一直在坚持努力学习的小伙伴们共勉！唯有努力钻研，多思考勤动手，方能在编程道路上行至所向。由于博主技术知识有限，博文中难免会有出错的地方，还望各位大佬包涵并批评指正，博主会及时改正；如果本文对小伙伴你有帮助的话，求求给博主一个赞支持一下，可以一起交流，一起加油！！Java泛型详解，史上最全图文详解java 泛型全解 - 绝对最详细Java 泛型，你了解类型擦除吗。
java泛型详解_Java泛型详解（下）
weixin_33467739的博客
02-22 122
九. 泛型类型的继承规则假设现在有一个类Employee和它的子类Manager现在问题来了： Pair是Pair的子类吗？答案是：不是例如，下面的代码将不会编译成功：Manager[] topHonchos = ...;Pair result = ArrayAlg.minmax(topHonchos); //Error//minmax方法返回Pair, 而不是Pair, 这样的赋值是不合法的也就...
Java泛型详解
qq_37752223的博客
03-30 144
http://www.importnew.com/24029.html
Java泛型详解（史上最全泛型知识详解）
m0_70325779的博客
07-25 8920
泛型是在JDK5之后引入的一个新特性，可以在编译阶段约束操作的数据类型，并进行检查。泛型的格式为用大白话来说，泛型就好比是给一个标签，通常情况下我们会在开发过程中或者个人学习或练习的过程中使用到泛型；就拿数组的泛型举例来说，我们把数组比作一个药瓶子，我们药瓶子贴上了什么标签，就只能放什么药，如果不管什么药都放在一个药瓶子里，那不得出大事吗？同样容器(数组)写上什么泛型，就只能存放什么数据；这样就不会导致我们存取数据的混乱。这样就解决了我们引言中提到的问题，也就解释了什么是泛型。
C#高级--泛型详解
李宥的博客
07-26 9238
C#高级–泛型详解 一、泛型是什么？ 泛型是C#2.0推出的新语法，不是语法糖，而是2.0由框架升级提供的功能。 我们在编程程序时，经常会遇到功能非常相似的模块，只是它们处理的数据不一样。但我们没有办法，只能分别写多个方法来处理不同的数据类型。这个时候，那么问题来了，有没有一种办法，用同一个方法来处理传入不同种类型参数的办法呢？泛型的出现就是专门来解决这个问题的。 使用泛型是一种增强程序功能的技术，具体表现在以下几个方面： 它有助于您最大限度地重用代码、保护类型的安全以及提高性能。 您可以创建泛型集合类。
java 泛型详解
bob's blog
06-04 128
java 泛型详解-绝对是对泛型方法讲解最详细的，没有之一 2016年12月30日 11:44:29VieLei阅读数：252622 对java的泛型特性的了解仅限于表面的浅浅一层，直到在学习设计模式时发现有不了解的用法，才想起详细的记录一下。 本文参考java 泛型详解、Java中的泛型方法、java泛型详解 1. 概述 泛型在java中有很重要的地位，在面向对象编程及各种设...
java泛型详解.pdf
10-02
java泛型详解.pdf
java泛型详解java泛型详解.doc
06-10
Java 泛型是一种强大的语言特性，它允许在类、接口和方法中使用类型参数，以实现类型的安全性和代码的重用性。泛型是 Java 从 JDK 5.0 版本开始引入的重要特性，目的是增强类型系统，提高程序的类型安全性，减少运行...
Java 泛型详解
09-18
Java泛型详解，Java泛型详解，Java泛型详解，Java泛型详解
golang 接口
m0_70982551的博客
07-24 872
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 460
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 566
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 550
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java泛型详解：类型安全与代码复用
"本章深入探讨了Java泛型的概念，它是自JDK1.5版本引入的一种增强类型安全和代码重用的特性。泛型允许开发者在类、接口和方法中使用类型参数，使得代码更加灵活，无需为不同数据类型重复编写相同逻辑。通过泛型，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

阿瞒有我良计15

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

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

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

打赏作者

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

抵扣说明：

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

余额充值