【Java SE】11. 泛型

最新推荐文章于 2022-05-17 16:47:30 发布
最新推荐文章于 2022-05-17 16:47:30 发布
阅读量167 收藏
点赞数
分类专栏： JavaSE 文章标签： 泛型
原文链接：https://blog.csdn.net/Qmilumilu/article/details/119518425
版权

11. 泛型

11.1 为什么要有泛型

  1. 标签，中药店， 每个抽屉外面贴着标签

  2. ArrayList.add( Object类的对象 )，所有的类都能往里放：缺点

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

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

  5. 没有泛型存在的问题：

    在这里插入图片描述

    List list = new ArrayList();
//需求存放学生编号
list.add(1);
list.add(2);
list.add(3);

//问题一：类型不安全
list.add("String");

for (Object obj:list
     ) {
    //问题二：强转时可能出现ClassCastException
    int stuID = (int) obj;
    System.out.println(stuID);
}

  6. 引入泛型：在集合中使用泛型

    1. ArrayList为例：

      ArrayList<Integer> integers = new ArrayList<Integer>();
//需求存放学生编号
integers.add(1);
integers.add(2);
integers.add(3);

//integers.add("String");
//1.编译时就会进行类型检查：
//Required type:Integer
//Provided:String

//foreach遍历：
for (Integer obj:integers
     ) {
    //2.避免了强转操作
    int stuID = obj;
    System.out.println(stuID);
}

//iterator遍历：
Iterator<Integer> iterator = integers.iterator();
while(iterator.hasNext()){
    System.out.println(iterator.next());
}

    2. HashMap为例：

      HashMap<Integer, Integer> hashMap = new HashMap<>();

hashMap.put(1,2);
hashMap.put(3,4);

//取到Entry
Set<Map.Entry<Integer, Integer>> set = hashMap.entrySet();

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

    3. 总结：

      1. 集合接口或集合类在jdk5时，都可以修改为带泛型的结构

      2. 在实例化集合类时，可以指明具体的泛型类型

      3. 在集合或接口中凡是定义类或接口时，内部结构使用到的类的泛型位置都指定为实例化时指定的泛型类型（将T替换成实例化时指定的类型）

        比如：add(E e) → \to → add(Integer e)

      4. 注意泛型的类型必须是类：不能使用基本数据类型，需要用包装类替换

      5. 如果实例化时，没有指明泛型的类型，默认类型为java.lang.util类型

        List list = new ArrayList();

11.2 自定义泛型结构

  1. 如何自定义泛型结构：泛型类、泛型接口；泛型方法

    1. 自定义泛型类泛型接口：

      1. 泛型类的定义和使用：

        public class Order<T> {
    String orderName;
    int orderID;

    T orderT;//类中所有的T都会被，实例化时指定的泛型类型替换

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

    public Order() {

    }

    public T getOrderT() {
        return orderT;
    }

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

public class Test {
    public static void main(String[] args) {
        
        //如果定义了泛型类，但实例化时没有指明泛型，则默认Object
        Order order = new Order();

        order.setOrderT("abc");
        order.setOrderT(123);

        //建议实例化时，添加泛型
        Order<String> objectOrder = new Order<String>("ab",001,"order:AA");
        //这里要求参数列表中的orderT为String类型

        //objectOrder.setOrderT(123);//Required type:String Provided:int
        objectOrder.setOrderT("order:aaa");
    }
}

      2. 继承时的泛型类：情况一

        class subOrder extends Order<String>{
    //subOrder不再是一个泛型类了，父类给他已经确定了
}

public class Test {
    public static void main(String[] args) {
        
        subOrder subOrder = new subOrder();
        //subOrder.setOrderT(123);//Required type:String Provided:int
        subOrder.setOrderT("ccc");
        //由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型
    }
}

      3. 继承时的泛型类：情况二

        class subOrder2<T> extends Order<T>{
    //subOrder仍然是一个泛型类

}

public class Test {
    public static void main(String[] args) {
        
        subOrder2<String> subOrder2 = new subOrder2<>();
    }
}

      4. 注意：

        1. 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。如<E1,E2,E3>

        2. 泛型类的构造器如下：public GenericClass(){}

          错误的：public GenericClass<E>(){}

        3. 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。

        4. 泛型不同的引用不能相互赋值。

          尽管在编译时ArrayList<String>和ArrayList<Integer>是两种类型，但在运行时只有一个ArrayList被加载到JVM中

        5. 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object。 经验： 泛型要使用一路都用。要不用，一路都不要用

        6. 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象

        7. jdk1.7，泛型的简化操作： ArrayList flist = new ArrayList<>()

        8. 泛型的指定中不能使用基本数据类型，可以使用包装类替换

        9. 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型（静态结构的创建早于对象的创建，而泛型类型是在实例化是才被指定）

        10. 异常类不能是泛型的

        11. 如果想要new一个T类型的数组：不能使用new T[10]

          但是可以： T[ ] elements = (T])new Object[10]; T实际还是一个变量

        12. 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型、还可以增加自己的泛型

          class Father<T1, T2> {}

          1. 子类不保留父类的泛型：

            1. 没有类型擦除，或者重新定义

              class Son1 extends Father {}

class Son<A, B> extends Father{}
//定义自己的A、B

            2. 具体类型

              //只有父类指定的具体的泛型类型
class Son2 extends Father<Integer, String> {}

//不仅有父类指定的具体的泛型类型，还有子类新添加的
class Son2<A, B> extends Father<Integer, String> {}

          2. 子类保留父类的泛型：泛型子类

            1. 全部保留

              class Son3<T1, T2> extends Father<T1, T2> {}

class Son3<T1, T2, A, B> extends Father<T1, T2> {}

            2. 部分保留

              class Son4<T2> extends Father<Integer, T2> {}

class Son4<T2, A, B> extends Father<Integer, T2> {}

    2. 自定义泛型方法：

      1. 方法也可以被泛型化，不管此时定义在其中的类是不是泛型类

      2. 泛型方法中可以定义泛型参数，此时参数的类型就是传入数据的类型，且于类的泛型参数没有任何关系

      3. 泛型方法的格式：
        [访问权限] <泛型> 返回类型 方法名([泛型标识 参数名称]) 抛出的异常

      4. 示例：

        public class Order<T> {
    String orderName;
    int orderID;
    T orderT;
    
		//定义泛型方法
    public <E> List<E> arrayToArrayList(E[] arr){
        List<E> eList = new ArrayList<>();
        for (E e:arr
             ) {
            eList.add(e);
        }
        return eList;
    }
}

public class Test {
    public static void main(String[] args) {
       
        Order<Object> order1 = new Order<>();
        Integer[] arr = {1, 2, 3};
        List<Integer> list = order1.arrayToArrayList(arr);

        System.out.println(list);
    }
}

      5. 泛型方法可以声明为静态的

        原因：泛型参数是在调用方法时确定的，并非在实例化类时确定

        public static <E> List<E> arrayToArrayList(E[] arr){}

    3. 泛型类的使用情形：

      //DAO : data access object
public class DAO<T>{
    //增
    public void add(T t){

    }
    //删
    public void remove(int index){

    }
    //改
    public void update(int index,T t){

    }
}

public class student {}

public class studentDAO extends DAO<student>{}

public class Test {
    public static void main(String[] args) {
        studentDAO studentDAO = new studentDAO();
        studentDAO.add(new student());
        studentDAO.remove(2);
        studentDAO.update(1,new student());
    }
}

      之前写的web底层代码：

      在这里插入图片描述

      如果使用泛型的话可以抽取出表的共性操作的DAO

    4. 泛型方法的使用情形：

      public class DAO<T>{
    //增
    public void add(T t){

    }
    
    //泛型方法：
    //举例：获取表中一共有多少条记录？获取最大员工入职时间？
    //各种诉求的返回值类型不确定，所以定义成泛型方法
    public <E> E getValue(){
        return null;
    }
}

11.3 泛型在继承上的体现

  1. 类A是类B的父类，G<A>和G<B> 二者不具备子父类关系，二者是并列关系

    在这里插入图片描述

    示例：

    public class Test {
    public static void main(String[] args) {
        Object obj = null;
        String str = null;
        //str可以赋值给obj,多态的体现
        obj = str;

        List<Object> list1 = null;
        List<String> list2 = null;
        //编译错误
        //list1 = list2;
       
        show(list1);
        //编译错误
        //show(list2)
        
    }
    public static <E> void show(List<Object> List1){
        
    }
}

  2. 类A是类B的父类，A<G>和B<G> 二者具备子父类关系

    示例：

    public class Test {
    public static void main(String[] args) {
        List<String> list1 = null;
        ArrayList<String> list2 = null;
        list1 = list2;//允许

    }
}

11.4 通配符的使用

  1. 上面例子中G<A>和G<B>不具有子父类关系了，所以就需要重载很多的方法

    public class Test {
    public static void main(String[] args) {

        List<Object> list1 = null;
        List<String> list2 = null;

        show(list1);
        show1(list2);

    }
    public static <E> void show(List<Object> List){

    }
    public static <E> void show1(List<String> list){

    }
}

  2. 同配符：？

  3. 类A是类B的父类，G<A>和G<B> 二者不具备子父类关系，二者共同的父类是 :G<?>

    public class Test {
    public static void main(String[] args) {

        List<Object> list1 = null;
        List<String> list2 = null;

        List<?> list = null;
        list = list1;
        list = list2;

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

  4. 读取和写入时的注意点：

    1. 添加（写入）：对于 List<?> 不能向其内部添加数据

      List<String> list1 = new ArrayList<>();
list1.add("AA");
list1.add("BB");

List<?> list = null;

list = list1;
//对于List<?>不能想起内部添加数据
//list.add("CC");

    2. 获取（读取）：允许读取数据，读取的数据类型为Object

      List<String> list1 = new ArrayList<>();
list1.add("AA");
list1.add("BB");

List<?> list = null;

list = list1;

Object o = list.get(0);
System.out.println(o);

  5. 有限制条件的通配符的使用：

    1. 条件：

      1. <? extends Person>

        继承于Person的类，包括Person

      2. <? super Person>

        被Person继承的类，包括Person

    2. 示例：

      public class Test {
    public static void main(String[] args) {

        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;
        //extends相当于表示范围 <=
        //list1 = list5;编译不通过

        //list2 = list3;编译不通过
        //super相当于表示范围 >=
        list2= list4;
        list2 = list5;
    }
}

    3. 读数据时：使用范围内最大的数据类型接收

    4. 写入数据时：写入比条件中的类相等或者更小的类型

11.5 泛型应用举例

//泛型嵌套
public static void main(String[] args) {
    HashMap<String, ArrayList<Citizen>> map = new HashMap<String, ArrayList<Citizen>>();
    ArrayList<Citizen> list = new ArrayList<Citizen>();
    list.add(new Citizen("刘恺威"));
    list.add(new Citizen("杨幂"));
    list.add(new Citizen("小糯米"));
    map.put("刘恺威", list);
    Set<Entry<String, ArrayList<Citizen>>> entrySet = map.entrySet();
    Iterator<Entry<String, ArrayList<Citizen>>> iterator = entrySet.iterator();
    while (iterator.hasNext()) {
        Entry<String, ArrayList<Citizen>> entry = iterator.next();
        String key = entry.getKey();
        ArrayList<Citizen> value = entry.getValue();
        System.out.println("户主： " + key);
        System.out.println("家庭成员： " + value);
    }
}
coolcoo1cool
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java.SE 自定义泛型与泛型的常见陷阱
02-06
Java.SE 自定义泛型与泛型的常见陷阱Java.SE 自定义泛型与泛型的常见陷阱
The Java Language Specification, Java SE 11 Edition.rar
07-27
《Java语言规范，Java SE 11版》是Java开发者不可或缺的重要参考资料，它详细定义了Java 11的语法、语义以及编程模型。这份规范是理解Java平台核心特性的基石，涵盖了从基本类型到复杂类结构，从内存管理到异常处理...
SpringBoot基础--输出日志报错Required type: Supplier ＜java.lang.String＞ Provided: String
qq_44660367的博客
07-17 5215
logger.trace("这是trace日志"); logger.debug("debug日志"); logger.info("info日志"); logger.warn("warn日志"); logger.error("error日志"); 解决方式 导入包错误，去掉上面俩个包，导入下面俩个包 //import org.junit.platform.commons.logging.Logger; //import org.junit.p
位移中的类型转换
shang_fengyue的博客
05-17 279
最近在看<Java编程思想>，看到操作符章节中的位移操作，突然意识到一个情况 java中不能向下转型，会提示错误 位移操作中,short,char,byte类型在进行位移操作的时候，会先转换成int型，最后的结果也是int型， 例如： byte b = 1; b = b >>> 10; // 提示provide是int， 但是required type是byte 如果这样写 b>>>=10; //这样是可以的，最后得到的b亦是byte类型 ...
SpringBoot --输出日志报错Required type: Supplier ＜java.lang.String＞ Provided: String
weixin_43630166的博客
11-22 9902
// 记录器 Logger logger = LoggerFactory.getLogger(getClass()); @Test void contextLoads() { logger.trace("这是trace日志..."); logger.debug("这是debug日志..."); logger.info("这是info日志..."); logger.warn("这是warn日志..."); ...
spring源码学习(3)：bean的加载
qq_35217284的博客
12-11 562
对于加载bean的功能，在Spring中的调用方法为： MyTestBean bean = (MyTestBean)bf.getBean("myTestBean"); 这句代码实现了什么样的功能呢？ 来看看AbstractBeanFactory里咋写的 getBean public Object getBean(String name) throws BeansException { return doGetBean(name, null, null, false); } protected &
Java SE编程入门教程 java泛型（共11页）.pptx
12-04
Java SE编程入门教程涵盖了许多核心概念，其中包括Java泛型，它是从Java 1.5版本开始引入的一个重要特性。泛型允许我们在编写代码时指定类型参数，从而在编译时提供类型安全性和代码复用性。 Java中的泛型定义： ...
java-generic.rar_泛型
最新发布
09-24
Java泛型是Java编程语言中的一个关键特性，它在2004年随着Java SE 5.0的发布而引入。泛型的主要目的是提供类型安全，同时减少在编写和使用集合类时的冗余代码。它允许开发者在类、接口和方法中定义参数化的类型，...
Java Platform SE 8.zip
03-31
Java Platform Standard Edition 8（Java SE 8）是Java编程语言和平台的一个重要版本，它在2014年发布，引入了许多创新功能，极大地增强了开发者的工作效率和代码质量。这个压缩包“Java Platform SE 8.zip”包含了...
JAVA基础知识（二）数据类型及运算符
Teolih的博客
06-20 678
JAVA基础知识（二）JAVA程序基础 注释 单行注释 // 这是单行注释 System.out.println("hello, world") 多行注释 /* 这是多行注释 */ System.out.println("hello, world") 文档注释 /** * 这是文档注释，用以对函数、类等进行注释说明 * @param args */ public static void main(String[] args) { System.out.println(); } 基本
Common Lisp 函数 require 和 provide 源代码分析
weixin_34258078的博客
08-19 264
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring Boot 统一异常处理的案例
热门推荐
Good Luck
11-29 8万+
1.返回页面的数据类型为:Json格式 package com.example.demo.error; /** * Create by szw on 2017/11/29 16:31 */ public class ErrorInfoT> { public static final Integer OK = 0; public static final Integer
Java开发常见异常|错误
a111042555的博客
12-29 6564
常见错误
简明 Java 泛型
大鱼的博客
05-31 1530
用简单明了的文字， 记录对于泛型的认知。泛型在**编译阶段**有效, 其实本质是一种语法糖。
只用这一篇Java泛型的文章，保证你面试对答如流
程序新视界
02-26 1万+
最近技术交流群里，有朋友问：Object和泛型T有啥区别。回答完问题，不禁在想，面试在即，还有那么多朋友不了泛型？是时候给大家整理一篇泛型相关的文章了，一篇文章全面搞定泛型，让大家再也不愁面试或实践中泛型相关的问题了。 什么是泛型 泛型是在JDK 5时就引入的新特性，也就是“参数化类型”，通俗来讲就是将原来的具体类型通过参数化来定义，使用或调用时再传入具体的类型（类型实参）。 泛型的本质是为了参数化类型（在不创建新类型的前提下，通过泛型指定的不同类型来控制形参具体的类型）。在泛型使用过程中，操作的数据类型被
报错：Failed to convert value of type 'java.lang.String' to required type 'int'
数据知道的博客
05-10 1万+
页面上报错：{“status”:500,“message”:“Failed to convert value of type ‘java.lang.String’ to required type ‘int’; nested exception is java.lang.NumberFormatException: For input string: “””,“callback”:""} 把访问路...
Failed to convert value of type 'java.lang.String[]' to required type 'java.lang.Integer[]'
wxd_xiaocaiji的博客
05-01 2375
我把value打成values 导致数据格式出错
【程序员养成之路】Java基础篇 3-反手就能写个冒泡排序的数组
正则表达式
06-20 199
拓展1：Java运算自动提升类型 public class Demo01 { public static void main(String[] args) { short a = 10; short b = 2; // 报错：Inconvertible types; cannot cast 'int' to 'java.lang.String' System.out.println((String)(a + b));

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值