泛型

最新推荐文章于 2024-11-01 14:48:20 发布
最新推荐文章于 2024-11-01 14:48:20 发布
阅读量161 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/xuweiweiwoaini/p/11075136.html
版权

1 为什么要有泛型？

  • 集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存在的是什么类型的对象，所以在JDK1.5之前只能将元素类型设计为Object类型。
  • JDK1.5之后使用泛型来解决这个问题。因为这个时候除了元素的类型不确定外，其他的部分都是确定的。例如关于这个元素是如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型叫做泛型。
  • Collection<E>、List<E>等的这个<E>就是类型参数，即泛型。

 

2 泛型的概念

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

 

  • 从JDK1.5以后，Java引入了“参数化类型(parameterized type)”的概念，允许我们在创建集合的时候再指定集合元素的类型，正如List<String>，这表明该List只能保存字符串类型的对象。

 

  • JDK1.5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参。

 

3 为什么要使用泛型，直接Object不是也可以存储数据？

  • ①解决元素存储的安全性问题，比如商品、药品标签，不会弄错。
  • ②解决获取数据的时候，需要强制类型转换的问题。比如不用每次拿商品和药品的时候都需要辨别。

 

  • 在集合没有使用泛型的时候：

  • 在集合中使用泛型的时候：

 

 

  •  Java泛型可以保证如何程序在编译的时候没有发生警告，运行的时候就不会产生ClassCastException异常。同时，代码更加简洁、健壮。

 

4 在集合中使用泛型

  • 示例：
package day18;

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

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-23
 */
public class CollectionTest {
    public static void main(String[] args) {
       List<String> list = new ArrayList<>();
       list.add("张三");
       list.add("李四");
       list.add("王五");
       list.add("赵六");
       list.add("田七");
       list.add("王八");

        for (String s : list) {
            System.out.println("集合中的元素是：" + s);
        }
    }
}

 

  • 示例：
package day18;

import java.util.HashMap;
import java.util.Map;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-23
 */
public class CollectionTest {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();

        map.put("张三", 21);
        map.put("李四", 55);
        map.put("王五", 12);
        map.put("赵六", 8);
        map.put("田七", 9);
        map.put("王八", 70);

        for (Map.Entry<String, Integer> me : map.entrySet()) {
            String key = me.getKey();
            Integer value = me.getValue();
            System.out.println("map集合中的key是：" + key + "，对应的value是：" + value);
        }

    }
}

 

5 自定义泛型结构

5.1 泛型类和泛型接口

5.1.1 泛型的声明

  • 语法：泛型类
class 类名<T>(){}

 

  • 语法：泛型接口
interface 接口名<T1,T2>(){}

 

  •  注：其中T、T1、T2表示任何引用类型，可以是任何字母表示。常用T表示，是Type的缩写。

5.1.2 泛型的实例化

  • 一定要在类名后面指定类型参数的值（类型）。如下所示
List<String> list = new ArrayList<>();
  • 泛型参数只能是类，不可以是基本数据类型，但可以使用包装类填充（包装类当然是引用数据类型^_^）。
  • 把一个集合的内容限制为一个特定的数据类型，这就是泛型背后的核心思想。

5.1.3 泛型类、泛型接口的说明

  • 泛型类可能有多个参数，此时应该将多个参数一起放在<>中。如：
class A<T1,T2,T3>{}
  • 泛型类的构造器是没有泛型符号的，如：
public A(){}
  • 实例化后，操作原来泛型位置的结构必须和指定的泛型类型一致。
  • 泛型不同的引用不能相互赋值。如：List<String>和List<Integer>是不能相互赋值的。
  • 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object。
  • 如果泛型结构是一个接口或者抽象类，则不可以创建类的对象。
  • JDK1.7以后，泛型的简化操作：List<String> list = new ArrayList<>();
  • 泛型的指定中不能使用基本数据类型，可以使用包装类。
  • 在类、接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。因为加载时机不一致的。
package day18;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-24
 */
public class Person<T> {
    private T t ;

    public Person() {
    }

    public Person(T t) {
        this.t = t;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
    /**
     * 静态方法中不能使用类的泛型，因为静态方法是优先于类执行的
     */
//    public static T getStaticT(){
//        return t;
//    }
    
}
  • 异常类不能是泛型的（因为Exception等异常类不是泛型的）。
  • 不能使用new E[]。但是可以使用：E[] elements = (E[]) new Object[capacity];
  • 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型。　　
package day18;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-24
 */
public class Father<T1,T2> {
    
}
    • 子类不保留父类的泛型：　　
package day18;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-24
 */
//没有类型 擦除
public class Son extends Father {
}
package day18;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-24
 */
//有具体类型，即子类不是泛型类
public class Son extends Father<Integer,String> {
}
    • 子类保留父类泛型：　　
package day18;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-24
 */
//全部保留
public class Son<T1,T2> extends Father<T1,T2>  {
}
package day18;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-24
 */
//部分保留
public class Son<T2> extends Father<Integer,T2>  {
}

5.1.4 泛型方法

  • 方法，也可以被泛型化，不管此时定义在其中的类是不是泛型类。
  • 在泛型方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型。

 

  • 泛型方法的语法：
[访问权限] <泛型> 返回值类型 方法名([泛型标识 参数名称]) 抛出的异常{}

 

  • 示例：
package day18;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-24
 */
public class Dao {
    
    public <E> E get(int id,E e){
        return null;
    }
}

 

6 泛型在继承上的体现

  • 如果B是A的一个子类型（子类或子接口），而G是具有泛型声明的类或接口，G<B>并不是G<A>的子类型。
  • 如：String是Object的子类，但是List<String>并不是List<Object>的子类。

 

  • 示例：
package day18;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-24
 */
public class Person {
}
package day18;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-24
 */
public class Man extends Person {
}
package day18;

import java.util.List;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-23
 */
public class CollectionTest {
    public static void main(String[] args) {
        Person[] people = null;
        Man[] man = null;
        //Person[]是Man[]的父类
        people = man;

        List<Person> personList = null;
        List<Man> manList = null;
        //报错
//        personList = manList;
    }
}

 

7 在泛型中通配符

7.1 使用通配符

  • 使用通配符<?>，例如List<?>，Map<?,?>。注意：List<?>是List<String>和List<Integer>的父类。
package day19;

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

/**
 * @author xuweiwei
 * @version 1.0
 * @since 2019-06-26
 */
public class CollectionTest {
    public static void main(String[] args) {
        List<?> list = new ArrayList<>();
        
        List<Object> objectList =  new ArrayList<>();
        
        List<String> stringList = new ArrayList<>();
        
        List<Integer> integerList = new ArrayList<>(); 
        
        list = objectList;
        list = stringList;
        list = integerList;

    }
}
  • 读取List<?>对象中List的元素时，永远是安全的，因为不管List中的元素的真实类型是什么，它包含的都是Object。
  • 写入List<?>中的时候，除了null，其他类型的元素都不可以。
package day18;

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

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-27
 */
public class CollectionTest {
    public static void main(String[] args) {
        List<?> list = new ArrayList<>();
        /**
         * 下面的写法是错误的。
         * 在List集合中add方法的定义是add(E e)和List<E>中的E一致，需要我们传入特定的已知的类型。
         * 而我们却传入的是?，?表明? extends Object,当然是未知类型了。
         */
        //list.add(1);
    }
}

7.2 通配符的注意点

  • 注意点：不能将通配符用在泛型方法声明处，返回值类型前面不能用<?>。比如：下面的写法是错误的。
package day18;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-27
 */
public class CollectionTest {
    //错误的写法
   /* public static <?> void add(List<?> list){
    }*/

}
  • 注意点：不能用在泛型类的声明上。比如：下面的写法是错误的。
package day18;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-24
 */
//写法是错误的，不能用在泛型类上
public class Person<?> {
}
  • 注意点：不能用在创建集合对象上。
package day18;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-27
 */
public class CollectionTest {
    

    public static void main(String[] args) {
        //写法错误，不能用在创建集合对象上
//        List<?> list = new ArrayList<?>();
        
    }

}

7.3 有限制的通配符

  • <?>允许所有泛型的引用调用。
package day18;

import java.util.List;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-27
 */
public class Person {
    public void printElement(List<?> list) {
        for (Object o : list) {
            System.out.println(o);
        }
    }
}
package day18;

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

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-27
 */
public class CollectionTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aa");
        list.add("bb");

        Person person = new Person();
        person.printElement(list);
    }
}
  • 通配符指定上限：<? extends 类或接口>，使用指定的类型必须是继承某个类或者实现某个接口。即<=。
package day18;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-27
 */
public class Person {
    
}
package day18;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-27
 */
public class Man extends Person {
}
package day18;

import java.util.List;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-27
 */
public class CollectionTest {
    /**
     *
     * @param list 只能传入List集合中包含Person或其子类的元素
     */
    public static void printElement(List<? extends Person> list){
        for (Person person : list) {
            System.out.println(person);
        }
    }


    public static void main(String[] args) {

    }
}
  • 通配符指定下限：<? super 类>，指定的类型不能小于操作的类。
package day18;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-27
 */
public class Person {

}
package day18;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-27
 */
public class Man extends Person {
}
package day18;

import java.util.List;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-27
 */
public class CollectionTest {
    /**
     *
     * @param list 只能传入List集合中包含Person或其父类的元素
     */
    public static void printElement(List<? super Person> list){
        for (Object o : list) {
            System.out.println(o);
        }
    }


    public static void main(String[] args) {

    }
}

 

转载于:https://www.cnblogs.com/xuweiweiwoaini/p/11075136.html

weixin_33974433
关注
Java：高级之泛型概念引入，泛型可以设置多个类型参数，泛型继承和泛型接口实现，限制泛型可用类型，泛型通配的方式，泛型方法，泛型方法限制泛型可用类型
m0_57089315的博客
11-26 5986
目录页 泛型简介 泛型类 限制泛型可用类型 类型通配声明 泛型方法 问题引入 如果我们需要产生多个对象，每个对象的逻辑完全一样，只是对象内的成员变量的类型不同。那我们如何去做？ 我们新建一个工程 做一个构造方法public Cls1(int a){ this.a =a; ...
关于java基础的泛型的练习
04-24
Java泛型是Java SE 5.0引入的一个重要特性，它极大地增强了代码的类型安全性和可读性。泛型在编程中的应用广泛，特别是在集合框架中，使得我们可以在编译时就检查类型，避免了不必要的类型转换，并且提高了代码的...
Java-泛型
weixin_30273175的博客
06-21 145
package com.lxl.java; import org.junit.Test; import java.util.*; /** * * 泛型的使用 * 1.jdk 5.0新增的特性 * * 2.在集合中使用泛型： * 总结： * ① 集合接口或集合类在jdk5.0时都修改为带泛型的结构。 * ② 在实例化集合类...
Java 中的泛型（两万字超全详解）
热门推荐
林二月的博客
08-02 8万+
博主将用 CSDN 记录 Java 后端开发学习之路上的经验，并将自己整理的编程经验和知识分享出来，希望能帮助到有需要的小伙伴。博主也希望和一直在坚持努力学习的小伙伴们共勉！唯有努力钻研，多思考勤动手，方能在编程道路上行至所向。由于博主技术知识有限，博文中难免会有出错的地方，还望各位大佬包涵并批评指正，博主会及时改正；如果本文对小伙伴你有帮助的话，求求给博主一个赞支持一下，可以一起交流，一起加油！！Java泛型详解，史上最全图文详解java 泛型全解 - 绝对最详细Java 泛型，你了解类型擦除吗。
8.0 泛型
探索软件工程的奥秘
11-27 1075
使用泛型编程，会在使用或者调用时传入具体的类型时才确定最终的数据类型，所以集合需要存储什么类型的数据，在创建集合时传入对应的类型即可。定义泛型时类型形参由一对尖括号（）包含在中间，使用或者调用泛型时，需要将类型实参写在尖括号（）之间。JDK 5之后的类库中很多重要的类和接口都引入了泛型，例如集合体系中的类和接口。下面分别演示未引入泛型和使用泛型编程的区别，体验泛型具体有什么好处。（1）未引入泛型前@Test// 创建一个只保存Integer类型的List集合。
[Java]泛型
进步*于辰的博客
03-26 1万+
本篇文章是以一一举例总结的方式阐述泛型的思想与运用。 如果文中阐述不全或不对的，多多交流。
Java泛型
BroRiver
03-26 1361
泛型是一种在编译时实现类型安全的特性，它使得我们可以编写通用的代码，以适用于不同类型的数据。
Golang 泛型实现原理
Dablelv 的博客专栏。
12-23 2497
泛型（Generics）是 Go 语言在较早版本缺失的一个特性，直到 Go 1.18 版本中才引入了泛型。泛型提供了一种更灵活、更通用的方式来编写函数和数据结构，以处理不同类型的数据，而不必针对每种类型编写重复的代码。
java 泛型
Misszhoudandan的博客
06-10 1709
泛型就是将数据类型参数化，例如我们实现一个存储对象的容器时，并不是直接定义好只能存储一种类型，好的办法就是定义时将类型参数化，也就是泛型，在真实使用时再传入真正的参数，这种参数化类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
C#泛型类、泛型方法、泛型接口、泛型委托的实例
07-26
本文将深入探讨泛型类、泛型方法、泛型接口和泛型委托，并通过实例来阐述它们的应用。 首先，我们来看泛型类。泛型类是具有一个或多个类型参数的类。类型参数是在定义类时使用的占位符，实际的类型在创建类的实例时...
C# 泛型参数转换
12-26
泛型不同参数类型生成的对象是相互独立的。 //如 Tuple<string> ts; Tuple<object> to; //ts to 是两个类型的对象。 很多时候，我们希望实现 to = ts 这种操作，为什么？因为看上去它应该如此。 为了达到这个...
Java让泛型实例化的方法
08-18
Java让泛型实例化的方法 Java是一种静态类型语言，它可以在编译时检查类型的正确性，以避免运行时的类型错误。然而，在 Java 中使用泛型时，会出现一个问题：如何实例化泛型对象？在 Java 中，泛型擦除机制使得...
Spring 中优雅的获取泛型信息的方法
08-26
Spring 中优雅的获取泛型信息的方法 在 Spring 框架中，获取泛型信息是非常重要的，在实际开发中经常会遇到这种情况。今天，我们来讨论如何在 Spring 中优雅地获取泛型信息。 第一种方法：通过反射获取泛型信息 ...
[自用，更新自day5]瑞吉外卖代码及笔记
最新发布
lapiii的博客
11-01 610
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
10-29 1348
项目功能：商品分类,商品信息,用户。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 828
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
SpringSession源码分析
lkr_lkr的博客
11-01 203
默认对常规Session的理解和使用，如何使用Set-Cookie。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值