泛型

最新推荐文章于 2024-10-06 20:16:20 发布
最新推荐文章于 2024-10-06 20:16:20 发布
阅读量127 收藏
点赞数
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AmorFati1996/article/details/108932026
版权

1. 为什么使用泛型

在这里插入图片描述

2. 在集合中使用泛型

package org.example;

import org.junit.Test;

import java.util.*;

/**
 * 泛型的使用
 * 1. jdk 5.0新增特性
 * <p>
 * 2. 在集合中使用泛型：
 * 总结：
 * 1）集合接口或集合类在jdk5.0都修改为带泛型的结构。
 * 2）在实例化集合类时，可以指明具体的泛型类型。
 * 3）指明完之后，在集合接口或类中凡是定义类或接口时，内部结构使用到类的泛型的位置，
 * 都指定为实例化时的泛型类性
 * 如：add(E e) --->实例化以后 add(Integer e)
 *4) 注意点：泛型的类型必须是类，不能是基本数据类型。
 * 5）如果实例化时，没有指明泛型类型，默认类型为java.lang.Object.
 *
 * jdk7新特性：类型推断
 * Map<String, Integer> map = new Map<>();
 *
 * @author AmorFati
 * 2020/10/5 20:04
 */
public class GenericTest {
    @Test
    public void test1() {
        //需求：存放学生成绩
        ArrayList list = new ArrayList();
        list.add(33);
        list.add(44);
        list.add(77);
        list.add(88);
        //问题一：类型不安全
        list.add("Tom");
        for (Object score : list) {
            //问题二：强转时，可能出现ClassCastException
            int stuScore = (int) score;
        }

    }

    //在集合中使用泛型的情况
    @Test
    public void test2() {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(33);
        list.add(44);
        list.add(77);
        list.add(88);
        //编译时，就会进行类型检查，保证数据类型的安全
//        list.add("Tom");
        //方式一：
        for (Integer score : list) {
            //避免了强转操作
            int stuScore = score;
        }
        //方式二：
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

    //在集合中使用泛型的情况，以HashMap为例
    @Test
    public void test3() {
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("Tom", 88);
        map.put("Jack", 55);
        map.put("Sam", 78);
        map.put("Amy", 54);

        //泛型的嵌套
        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();

        while (iterator.hasNext()) {
            Map.Entry<String, Integer> next = iterator.next();
            System.out.println(next.getKey() + "=" + next.getValue());

        }
    }
}

3. 自定义泛型结构

自定义泛型类或接口

public class Order<T> {
    String orderName;
    int orderId;
    //类的内部结构可以使用类的泛型
    T orderT;

    public Order() {
        //编译不通过
//        T[] arr = new T[10];
        //编译通过
        T[] arr = (T[]) new Object[10];
    }

    public Order(String orderName, int orderId, T orderT) {
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }

    public T getOrderT() {
        return orderT;
    }
}


//SubOrder不是泛型
public class SubOrder extends Order<Integer> {
}


//SubOrder1<T>仍然是泛型
public class SubOrder1<T> extends Order<T> {

}

package org.example;

import org.junit.Test;

import java.util.ArrayList;

/**
 * 1. 关于自定义泛型类，泛型接口。
 */
public class GenericTest1 {
    @Test
    public void test1() {
        //要求：如果大家定义了类是带泛型的，建议在实例化时要指明类的泛型。
        Order<String> order = new Order<>();

    }

    @Test
    public void test2() {
        //由于子类在继承带泛型的父类时，指明了泛型类型， 则实例化子类对象时，不在需要指明泛型。
        SubOrder subOrder = new SubOrder();

        SubOrder1<String> subOrder1 = new SubOrder1<>();

    }

    @Test
    public void test3() {
        ArrayList<Integer> list1 = new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();
        //泛型的不同引用不能相互赋值。
//        list1 = list2;
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

自定义泛型方法

    //泛型方法：在方法中出现了泛型结构，泛型参数与类的泛型参数没有任何关系
    //换句话说，泛型方法所属的类是不是泛型类都没有关系
    //泛型方法可以声明static
    //原因：泛型参数是在调用方法时确定的，并非在实例化时确定的。
    public <E> List<E> copyFromArrayToList(E[] arr) {
        ArrayList<E> list = new ArrayList<>();
        for (E e : arr) {
            list.add(e);
        }
        return list;
    }

    @Test
    public void test4() {
        Integer[] arr = new Integer[]{1, 2, 3, 4};
        List<Integer> list = copyFromArrayToList(arr);
        System.out.println(list);
    }

4. 泛型在继承上的体现

package org.example.java2;

import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

/**
 * 1. 泛型在继承方面的体现
 *虽然类A是类B的父类，但是G<A>和G<B>二者不具备子父类关系，二者是并列关系。如Test1
 *
 *类A是类B的父类，A<G>是B<G>的父类。如Test2
 *
 * @author AmorFati
 * @create 2020/10/5 21:31
 */
public class GenericTest {

    @Test
    public void test1() {

        Object[] arr1 = null;
        String[] arr2 = null;
        arr1 = arr2;//编译通过

        List<Object> list1 = null;
        List<String> list2 = null;
        //此时list1和list2不具备子父类关系，编译不通过。
//        list1 = list2;
        /*
        反证法：
        假设list1 = list2;成立
        list1.add(123);导致混入非String的数据，出错。
         */

    }

    @Test
    public void test2() {
        List<String> list1 = null;
        ArrayList<String> list2 = null;
        list1 = list2;
    }
}

5. 通配符的使用

package org.example.java2;

import org.junit.Test;

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

/**
 * 通配符的使用
 * 通配符：? (英文格式下）
 * <p>
 * 类A是类B的父类，G<A>和G<B>没有关系，二者共同的父类是G<?>
 *
 * @author AmorFati
 * @create 2020/10/5 21:46
 */
public class GenericTest1 {

    @Test
    public void test1() {
        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();

        List<?> list = null;

        list = list1;
        list = list2;

        List<String> list3 = new ArrayList<>();
        list3.add("AA");
        list3.add("BB");
        list3.add("CC");
        list = list3;
        //添加（写入），对于List<?>就不能向其内部添加数据
        //除了添加null之外。
//        list.add("DD");编译不通过

        //获取（读取）：允许读取数据，读取的数据类型为Object.
        Object o = list.get(0);

    }

    public void print(List<?> list) {
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println(obj);
        }
    }

}

有限制条件的通配符

在这里插入图片描述

public class Person {
}
public class Student extends Person {
}
 /*
    有限制条件的通配符的使用
    ? extends A:
    G<? extends A> 可以作为G<A>和G<B>的父类，其中B是A的子类。

    ? super A:
    G<? super A> 可以作为G<A>和G<B>的子类，其中B是A的父类。

     */
    @Test
    public void test2() {

        List<? extends Person> list1 = null;
        List<? super Person> list2 = null;

        List<Student> list3 = null;
        List<Person> list4 = null;
        List<Object> list5 = null;

        list1 = list3;
        list1 = list4;
//        list1 = list5;//编译不通过

//        list2 = list3;//编译不通过
        list2 = list4;
        list2 = list5;

        //读取数据
        Person person = list1.get(0);
//        Student student = list1.get(0);//编译不通过

        Object object = list2.get(0);
//        Person person1 = list2.get(0);//编译不通过

        //写入数据：
//        list1.add(new Student());//编译不通过
//        list1.add(new Person());//编译不通过

        list2.add(new Person());//通过
        list2.add(new Student());//通过
//        list2.add(new Object());//编译不通过
    }
AmorFati1996
关注
专栏目录
golang泛型
Jcduhdt的博客
04-03 7389
泛型 go1.18版本开始支持 在函数上使用[T 支持的类型] 表示泛型，比如 func AddSum[T int|float64](params ...T)(sum T){ // 一些操作 return sum } 自带泛型： any 表示任何类型，即interface comparable 表示可以被比较的类型 comparable is an interface that is implemented by all comparable types (booleans, numbers,
关于java基础的泛型的练习
04-24
Java泛型是Java SE 5.0引入的一个重要特性，它极大地增强了代码的类型安全性和可读性。泛型在编程中的应用广泛，特别是在集合框架中，使得我们可以在编译时就检查类型，避免了不必要的类型转换，并且提高了代码的...
Java 中的泛型（两万字超全详解）
林二月的博客
08-02 7万+
博主将用 CSDN 记录 Java 后端开发学习之路上的经验，并将自己整理的编程经验和知识分享出来，希望能帮助到有需要的小伙伴。博主也希望和一直在坚持努力学习的小伙伴们共勉！唯有努力钻研，多思考勤动手，方能在编程道路上行至所向。由于博主技术知识有限，博文中难免会有出错的地方，还望各位大佬包涵并批评指正，博主会及时改正；如果本文对小伙伴你有帮助的话，求求给博主一个赞支持一下，可以一起交流，一起加油！！Java泛型详解，史上最全图文详解java 泛型全解 - 绝对最详细Java 泛型，你了解类型擦除吗。
[Java]泛型
进步*于辰的博客
03-26 1万+
本篇文章是以一一举例总结的方式阐述泛型的思想与运用。 如果文中阐述不全或不对的，多多交流。
Java泛型
BroRiver
03-26 1321
泛型是一种在编译时实现类型安全的特性，它使得我们可以编写通用的代码，以适用于不同类型的数据。
Golang 泛型实现原理
Dablelv 的博客专栏。
12-23 2448
泛型（Generics）是 Go 语言在较早版本缺失的一个特性，直到 Go 1.18 版本中才引入了泛型。泛型提供了一种更灵活、更通用的方式来编写函数和数据结构，以处理不同类型的数据，而不必针对每种类型编写重复的代码。
java 泛型
Misszhoudandan的博客
06-10 1675
泛型就是将数据类型参数化，例如我们实现一个存储对象的容器时，并不是直接定义好只能存储一种类型，好的办法就是定义时将类型参数化，也就是泛型，在真实使用时再传入真正的参数，这种参数化类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
java 泛型详解-绝对是对泛型方法讲解最详细的，没有之一
热门推荐
s10461的博客
12-30 61万+
对java的泛型特性的了解仅限于表面的浅浅一层，直到在学习设计模式时发现有不了解的用法，才想起详细的记录一下。 本文参考java 泛型详解、Java中的泛型方法、 java泛型详解 1. 概述泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。什么是泛型？为什么要使用泛型？ 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传
Java泛型大全
weixin_45203607的博客
10-02 4360
Java泛型大全 1. 概述 泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。 什么是泛型？为什么要使用泛型？ 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法形参，然后调用此方法时 传递的 实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。 泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制
Java泛型入门篇: 泛型类、泛型接口以及泛型方法
笔墨的专栏
11-18 3169
专栏文章导航 Java泛型入门篇: 泛型类、泛型接口以及泛型方法 Java泛型进阶篇: 无界通配符、上界通配符以及下界通配符 Java泛型原理篇: 类型擦除以及桥接方法 文章目录前言1. 什么是泛型2. 泛型的使用泛型类使用方法泛型类继承泛型接口使用方法泛型接口实现类泛型方法使用方法静态泛型方法所属类为泛型类/泛型接口 前言     我们在平时的开发当中基本上无时无刻都在使用泛型，尤其是涉及到集合、多态或自定义类的场景，可以说是泛型是一个十分重要的特性。但包括我在内的大多数人，对泛型的掌握不够深刻，.
C#泛型类、泛型方法、泛型接口、泛型委托的实例
07-26
本文将深入探讨泛型类、泛型方法、泛型接口和泛型委托，并通过实例来阐述它们的应用。 首先，我们来看泛型类。泛型类是具有一个或多个类型参数的类。类型参数是在定义类时使用的占位符，实际的类型在创建类的实例时...
Java让泛型实例化的方法
08-18
Java让泛型实例化的方法 Java是一种静态类型语言，它可以在编译时检查类型的正确性，以避免运行时的类型错误。然而，在 Java 中使用泛型时，会出现一个问题：如何实例化泛型对象？在 Java 中，泛型擦除机制使得...
Golang 使用接口实现泛型的方法示例
09-19
### Golang 使用接口实现泛型的方法详解 #### 引言 在 Go 语言中，泛型的概念直到 Go 1.18 才正式引入。在此之前，开发者常常通过接口（interface）来实现类似泛型的效果。本文将深入探讨如何在 Go 语言中利用接口...
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1240
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 937
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 365
JDK1.0主要特性。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 706
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值