JAVA进阶学习笔记(5)：泛型

最新推荐文章于 2024-04-13 13:29:46 发布
最新推荐文章于 2024-04-13 13:29:46 发布
阅读量245 收藏 2
点赞数
分类专栏： java进阶 文章标签： 1024程序员节 java 泛型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LeavingBook/article/details/109167695
版权
本文详细介绍了Java中的泛型概念，包括泛型的设计背景、意义和使用方法。通过示例展示了List和Map接口使用泛型的方式，以及自定义泛型类和接口。此外，还探讨了泛型在继承上的体现，通配符的使用，包括无限制和有限制条件的通配符。最后，通过DAO类和User类的示例展示了泛型在实际编程中的应用。
摘要由CSDN通过智能技术生成

这里写目录标题

1. 泛型概述

1.1 泛型的设计背景

集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的 对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。

1.2 泛型的概念

所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类 型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如， 继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实 际的类型参数，也称为类型实参。

1.3 泛型的意义

1.解决元素储存的安全性问题
2.解决获取元素时，需要强制转换的问题
在这里插入图片描述
在这里插入图片描述

2. 泛型的使用

2.1 List接口使用泛型

   //集合中使用泛型之前的情况
    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        //需求：存放学生成绩
        list.add(78);
        list.add(89);
        list.add(100);
        list.add(72);

        //问题一：类型不安全
        list.add("Tom");
        for (Object score :
                list) {
            //问题二：强转时出现ClassCastException异常
            int stuScore = (Integer)score;
            System.out.println(stuScore);
        }
    }

    //集合中使用泛型的情况:list
    @Test
    public void test2(){
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(100);
        list.add(10);
        list.add(20);
        list.add(120);
        //编译时就会进行类型检查，保证数据的安全
        //list.add("Tom");

        //方式一
        for (Integer score :
                list) {
            //避免了强制转换操作
            int stuSroce = score;
            System.out.println(stuSroce);
        }
        System.out.println("------------------------");
        //方式二
        Iterator<Integer> iterator = list.iterator();
        while(iterator.hasNext()){
            int stuScore = iterator.next();
            System.out.println(stuScore);
        }
    }

2.2 Map接口使用泛型

   //集合中使用泛型的情况:以HashMap为例
    @Test
    public void test3(){
        Map<String,Integer> map = new HashMap<String, Integer>();
        map.put("Tom",87);
        map.put("Jerry",76);
        map.put("Jack",79);

//        map.put(90,"Tom");
        //泛型的嵌套
        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();
        while(iterator.hasNext()){
            Map.Entry<String, Integer> entry = iterator.next();
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + "----->" + value);
        }
    }

3. 自定义泛型结构

3.1 自定义泛型类、泛型接口

  1. 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如： <E1,E2,E3>
  2. 泛型类的构造器如下：public GenericClass(){}。 而下面是错误的：public GenericClass(){}
  3. 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。
  4. 泛型不同的引用不能相互赋值。 >尽管在编译时ArrayList和ArrayList是两种类型，但是，在运行时只有 一个ArrayList被加载到JVM中。
    @Test
    public void test3(){
        ArrayList<String> list1 = null;
        ArrayList<Integer> list2 = new ArrayList<Integer>();
        //泛型不同并不能相互赋值
        //list1 = list2;
    }
  1. 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价 于Object。经验：泛型要使用一路都用。要不用，一路都不要用。
  2. 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。
  3. jdk1.7，泛型的简化操作：ArrayList flist = new ArrayList<>();
  4. 泛型的指定中不能使用基本数据类型，可以使用包装类替换。
  5. 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态 属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法 中不能使用类的泛型。
  6. 异常类不能是泛型的
  7. 不能使用new E[]。但是可以：E[] elements = (E[])new Object[capacity]; 参考：ArrayList源码中声明：Object[] elementData，而非泛型参数类型数组。
    在这里插入图片描述
public class GenericTest1 {

    @Test
    public void test1(){
        //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
        //如果定义了类带泛型，那么在实例化时要指明类的泛型
        Order order = new Order();
        order.setOrderT(123);
        order.setOrderT("ABC");

        //建议：实例化时指明类的泛型
        Order<String> order1 = new Order<String>("order1",101,"A");
        order1.setOrderT("AA:hello");
    }

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

        SubOrder1<String> sub2 = new SubOrder1<String>();
        sub2.setOrderT("AA");
    }
}

public class Order<T> {

    String orderName;
    int orderID;

    //类的内部结构就可以使用类的泛型
    T orderT;
    public Order(){};

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

    public T getOrderT(){
        return orderT;
    }

    public void setOrderT(T orderT){
        this.orderT = orderT;
    }
}

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

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

3.2 泛型方法

在这里插入图片描述

4. 泛型在继承上的体现

虽然类A是类B的父类，但是G<A>和G<B>二者不具备子父类关系，二者是并列关系。
补充：类A是类B的父类，A<G> 是 B<G>的父类

    @Test
    public void test1(){

        Object obj = null;
        String str = null;
        obj = str;

        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的数据。出错。
         */


        AbstractList<String> l1 = null;
        List<String> l2 = null;
        ArrayList<String> l3 = null;
        l1 = l3;
        l2 = l3;
    }

5. 泛型中通配符的使用

5.1 通配符的使用

通配符：?
类A是类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是：G<?>

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

        List<?> list = null;

        list = list1;
        list = list2;
//        print(list1);
//        print(list2);

        //
        List<String> list3 = new ArrayList<>();
        list3.add("AA");
        list3.add("BB");
        list3.add("CC");
        //添加：对于List<?>就不能向其内部添加数据。
        //除了null
        list3.add(null);

        //读取：允许读取数据
        Object o = list.get(0);
        System.out.println(o);


    }

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

5.2 有限制条件的通配符的使用

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

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

本节练习

在这里插入图片描述
DAO.java:

import java.util.*;

public class DAO <T> {

    //如果在此不进行实例化，则会产生空指针异常
    private Map<String, T> map = new HashMap<String, T>();

    //保存 T 类型的对象到 Map 成员变量中
    public void save(String id,T entity){
        map.put(id,entity);
    }

    //从 map 中获取 id 对应的对象
    public T get(String id){
        return map.get(id);
    }

    //替换 map 中 key 为 id 的内容, 改为 entity 对象
    public void update(String id,T entity){
        if(map.containsKey(id)){
            map.put(id,entity);
        }else
        {
            System.out.println("没有key为" + id + "的项");
        }

    }
    //返回 map 中存放的所有 T 对象
    public List<T> list(){
        List<T> list = new ArrayList<>();
        Collection<T> values = map.values();
        for (T t : values) {
            list.add(t);
        }
        return list;
    }
    //删除指定 id 对象
    public void delete(String id){
        map.remove(id);
    }
}

User.java:

public class User {

    private int id;
    private int age;
    private String name;

    public User() {
    }

    public User(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        if (id != user.id) return false;
        if (age != user.age) return false;
        return name != null ? name.equals(user.name) : user.name == null;
    }

    @Override
    public int hashCode() {
        int result = id;
        result = 31 * result + age;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        return result;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

DAOTest.java:

import org.junit.Test;

import java.util.List;

public class DAOTest {

    @Test
    public void test(){
        DAO<User> dao = new DAO<>();
        dao.save("1001",new User(1001,18, "Tom"));
        dao.save("1002",new User(1002,24, "Marry"));
        dao.save("1003",new User(1001,21, "Jenny"));

        dao.update("1003", new User(1003,35,"Killer"));
        dao.delete("1002");


        List<User> list = dao.list();
//        System.out.println(list);
        list.forEach(System.out::println);

    }
}

参考资料：
[1]尚硅谷宋康红java基础教程

大雪001
关注
专栏目录
Java进阶学习笔记（二）泛型方法＜T＞T 与 T不同点
TUTsmile的博客
07-21 322
结论 <T> T 方法可以接受任意类型参数， T 在初始化（new）的时候已经限定了T的类型，只能接受对应类型的参数 说明 定义的泛型如下所示 public class GenericsHolder<T> { private T data; /** * 这个<T> T 可以传入任何类型 * 参数T * 第一个 表示是泛型 * 第二个 表示返回的是T类型的数据 * 第三个 限制参数
java进阶学习笔记
m0_67265464的博客
07-29 109
深知大多数初中级java工程师，想要升技能，往往是需要自己摸索成长或是报班学习，但对于培训机构动则近万元的学费，着实压力不小。因此我收集了一份《java开发全套学习资料》送给大家，初衷也很简单，就是希望帮助到想自学又不知道该从何学起的朋友，同时减轻大家的负担。与此同时，内部类对象可以访问它所依附的外部类对象的成员(即使是private的成员)。11.一个接口不能继承一个抽象类，但可以通过extends同时继承多个接口，实现接口的多继承。2.List是有序的元素集合，所以可以使用下标来说明元素的位置。...
阿里内部发布最新版Java进阶笔记，金三银四看这份文档就够了
Fightevery的博客
06-23 113
大家都说程序员这个职业薪资高、待遇好，现在是程序员“跳槽”的黄金时期，你准备好了吗?有没有给自己定个小目标？是30K、40K，还是更高？短期内提高Java 核心能力最快、最有效的方法，到底是什么。你知道吗？ 你要跳出日常CRUD的工作，可以来学学这份阿里内部Java进阶笔记，它包含微服务架构、涉及 Spring Boot、SpringCloud 、Dubbo 等核心组件的应用，还有秒杀活动用到的 Nginx、Redis、MQ、DB、 JVM调优、mysql优化、高并发等等，从底层组件应用，到模块设计一应俱
泛型
weixin_44112242的博客
04-14 105
泛型 1.泛型是什么? 1)参数化的一种类型,例如:List,map<K,V> pageObject 2)编译时的一种类型,运行阶段无效,所有泛型运行时转换成Object类型 例如: package com.moon; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method...
泛型的意义和作用是啥？
qq_33380252的博客
08-19 745
简单的说，意义和作用有： 　　类型的参数化，就是可以把类型像方法的参数那样传递。这一点意义非凡。 　　泛型使编译器可以在编译期间对类型进行检查以提高类型安全，减少运行时由于对象类型不匹配引发的异常。 　　泛型方法，算法的复用。蛮神奇的。 想要理解为什么引入泛型，就要知道没有泛型的麻烦。 　　我们知道现在的程序开发都是面向对象了，所以程序里会有很多各种类型的对象，对象多了肯定需要有某种类型的容器来装。所以就有了一些容器类型，比如数组、ArrayList、HashMap、TreeSet等。 　　对于数组，我
泛型的详解
qq_48747560的博客
11-30 3544
泛型的使用
【JavaSE】泛型
weixin_44258092的博客
01-04 618
介绍了泛型的相关知识，先通过创建顺序表这个例子介绍了为什么要引入泛型，随后介绍了泛型类、编译机制(擦除机制)、泛型的上界和通配符的上下界。
Java进阶笔记.zip
04-13
这份“Java进阶笔记”很可能是为了帮助开发者深入理解Java语言的高级特性、设计模式以及最佳实践。以下是对这些笔记中可能包含的关键知识点的详细解释： 1. **多线程**：Java提供内置的多线程支持，包括Thread类和...
java学习笔记markdown
03-12
【Java学习笔记Markdown版】是针对Java初学者和进阶者的一份详尽教程，以Markdown格式编写，便于阅读和整理。Markdown是一种轻量级的标记语言，它允许用户使用易读易写的纯文本格式编写文档，然后转换成结构化的HTML...
Java进阶学习笔记（三） 反射教程详细笔记
TUTsmile的博客
07-22 244
主要参考HOW2J发射机制系列教程、Java 反射 -超详细讲解（附源码） 一、反射 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 或许有人奇怪，我在编写代码时，也能够获取这个类的所有属性和方法，为何需要反射呢？ 我们在编写代码的时候，是在编译前获取对象，而反射是在程序运行时获取对象。 结论： 运行时获取对象用的 应用场景： 之后学习切面的时候，
什么是泛型？
hncboy的博客
12-13 3364
一、泛型的概念 泛型是 Java SE5 出现的新特性，泛型的本质是类型参数化或参数化类型，在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型。 二、泛型的意义 一般的类和方法，只能使用具体的类型：要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。 Java 在引入泛型之前，表示可变对象，通常使用 Object 来实现，...
Java泛型的主要作用
叉叉不低头
02-28 1902
本文转载自：https://www.jianshu.com/p/5179ede4c4cf 简单的说，意义和作用有：类型的参数化，就是可以把类型像方法的参数那样传递。这一点意义非凡。泛型使编译器可以在编译期间对类型进行检查以提高类型安全，减少运行时由于对象类型不匹配引发的异常。泛型方法，算法的复用。蛮神奇的。想要理解为什么引入泛型，就要知道没有泛型的麻烦。 我们知道现在的程序开发都是面向对象了，所以...
泛型的理解
m0_53677355的博客
03-14 1321
泛型的意义：类型的参数化，就是可以把类型像方法的参数那样传递。 1、泛型只存在于编译期间 2、泛型在语法中的特征就是尖括号 3、泛型的核心原理：利用Object引用可以指向任意类型的对象 问题：Java中有些类型不是对象类类型咋办？ Java专门为8种基本类型定义了各自对应的类类型 int -> Integer char -> Character 其他的都是首字母大写即可 注：泛型的尖括号不可能出现基本类型 4、使用泛型 A<Strirng&...
泛型的介绍与原理
最新发布
m0_73625251的博客
04-13 306
大家都知道java泛型是伪泛型，这是因为在java编译期间，所有泛型信息都会被擦掉。泛型基本上都是在编译器这个层次上实现的，在生成的字节码文件中是不包含泛型的基本信息的，使用泛型的时候加上类型参数，在编译器编译的时候会去掉，这就是类型擦除一句话概括：在编译期完成类型检查后，把某个具体的泛型引用擦除成了Object而丢失了它运行时所赋予的类型信息。
泛型的重要性——举例说明
leehoward
09-06 1079
import java.util.*; /** *  * 泛型的好处是：在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率 * */public class test {  /**  * @param args  */ public static void main(String[] args) {  // TODO Auto-generated method st
泛型（一）之定义说明
wangdajiao的博客
07-16 1398
一、泛型类 1、使用Object类保存不同类型的对象class Point { private Object x; private Object y; public void setX(Object x) { this.x = x; } public void setY(Object y) { this.y = y; }
[Java] 浅谈泛型的意义与不足
陀氏
04-13 5913
示意 - 泛型代码 泛型是什么 有什么用 为什么要有泛型示意 - 泛型代码// 类的泛型 class Two<A,B> { public A first; public B second; public Two(A a, B b) { first = a; second = b; } } class Test { // 方法的泛
泛型编程：源起、实现与意义
热门推荐
刘未鹏|C++的罗浮宫
06-13 4万+
  泛型编程：源起、实现与意义 By 刘未鹏C++的罗浮宫(http://blog.csdn.net/pongba)(去年12月《程序员》的约稿)(以前也写过一篇相关的文章：Generic Programming - What Are You, anyway? ) 为什么泛型泛型编程（Generic Programming）最初提出时的动机很简单直接：发明一种语
JavaEE深度学习笔记：从基础到进阶
3. **Tiger学习笔记**：讲解了Java 5.0（也称为Tiger）的新特性，包括泛型、注解（Annotation）等，这些都是现代Java编程中不可或缺的部分。 4. **XML学习笔记**：从XML的基础概念、DTD（文档类型定义）、命名空间...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值