• java基础 --泛型

    目录

    27、泛型

    1、概念

    2、泛型的语法

    3.使用细节

    自定义泛型类

    自定义泛型接口

    自定义泛型方法

    4.泛型的继承和通配符

    27、泛型

    在没引入泛型之前，传统方法有以下几个问题

    1. 不能对加入到集合中的数据类型进行约束（不安全）

    2. 遍历的时候，需要进行类型转换，如果集合中的数据量很大，对效率有影响

    如果使用泛型

    1. import java.util.ArrayList;
    2. import java.util.List;
    3. ​
    4. /**
    5.  * @author: wentao
    6.  * @date: 2022/11/2 17:11
    7.  * @version: 1.0
    8.  * @description: 泛型体验
    9.  */
    10. public class Generic_ {
    11.     public static void main(String[]args){
    12.         /*
    13.            1.如果编译器发现添加的类型，不符合要求 ，就会报错
    14.            2. 在遍历的时候，可以直接取出Integer类型而不是Object
    15.          */
    16.         List  list  = new ArrayList();
    17.         list.add(1);
    18.         list.add(12);
    19.         list.add(13);
    20.         //假如不小心输错数据了 添加了一个String类型
    21.         //编译器会进行检查
    22. //        list.add("tom"); 
    23.         for (Integer integer : list) {
    24.             System.out.println(integer);
    25.         }
    26.     }
    27. }
     

    1、概念
     

    1.  
      泛型又称为参数化类型，是jdk5出现的新特性，解决数据类型的安全性问题
       
    2.  
      在类声明或实例化时，只要指定好需要的具体类型即可
       
    3.  
      java泛型可以保证如果程序在编译时没有发出警告，运行的时候就不会产生ClassCastException异常，同时，代码更加简洁、健壮
       
    4.  
      泛型的作用：可以在类声明时通过一个标识表示 类中某个属性的类型，或者是某个方法的返回值类型，或者是参数类型
       
     

    ​

     

    1. import java.util.ArrayList;
    2. import java.util.List;
    3. ​
    4. /**
    5.  * @author: wentao
    6.  * @date: 2022/11/2 19:26
    7.  * @version: 1.0
    8.  */
    9. public class Generic2 {
    10.     public static void main(String[]args){
    11.         Person1 p =  new Person1("String");
    12.         System.out.println(p.e.getClass());//class java.lang.String
    13.         Person1 p1 =  new Person1(11);
    14.         System.out.println(p1.e.getClass());//class java.lang.Integer
    15.         Person1 p2 =  new Person1();
    16.         System.out.println(p2.e);//null
    17.     }
    18. }
    19. class Person1 {
    20.     E e;
    21. ​
    22.     public Person1() {
    23.     }
    24. ​
    25.     public Person1(E e) {
    26.         this.e = e;
    27.     }
    28. ​
    29.     @Override
    30.     public String toString() {
    31.         return "Person1{" +
    32.                 "e=" + e +
    33.                 '}';
    34.     }
    35. }
    36. ​
     

    2、泛型的语法
     

    •  
      泛型的声明
       
  
      1.  
        interface 接口 {} 和 class 类 {}
         
      2.  
        其中 T，k，v不代表值，而是表示数据类型
         
      3.  
        任意字母都可以 指定一般都是使用T,K,V,E这些
         
    •  
      泛型的实例化
       
  
      1.  
        List list = new ArrayList<>();
         
      2.  
        Iterator iterator = customers.iterator();
         
     

    3.使用细节
     

    自定义泛型类
     

    1.  
      泛型只能是引用数据类型
       
    2.  
      在指定泛型具体类型后，可以传入该类型或者其子类型
       
    3.  
      如果不添加泛型 默认泛型是Object类型
       
    4.  
      普通成员可以使用泛型（属性，方法）
       
    5.  
      使用泛型的数组，不能初始化
       
    6.  
      静态方法不能使用类的泛型
       
    7.  
      泛型类的类型，是在创建对象的时候确定的（因为创建对象的时候，需要指定确定类型）
       
     

    1. package com.sofwin.controller;
    2. ​
    3. /**
    4.  * @author: wentao
    5.  * @date: 2022/11/2 20:36
    6.  * @version: 1.0
    7.  * @description: 自定义泛型
    8.  */
    9. public class CustomGeneric {
    10. ​
    11. }
    12. //1.Tiger类后有泛型  --所以我们吧tiger就称为自定义泛型类
    13. //2. T R M 是泛型标识符，一般是单个大写字母
    14. //3.泛型的标识符可以有多个
    15. //4.普通成员可以使用泛型（属性 方法）
    16. //5. 使用泛型数组不能初始化
    17. //6.静态方法不能使用泛型
    18. //    也是泛型是实例化的时候指定，  但是出发类的时候 可以调用静态方法
    19. //      这个时候不知道泛型的类型
    20. class  Tiger {
    21.     String name;
    22.     R r;  //属性使用了泛型
    23.     T t;
    24.     M m;
    25.     //泛型的类型是对象实例化的时候指定
    26.     //但是这个类中数组  在类加载的时候就初始化了
    27.     // 因此当数组实例化的时候 T还不知道什么类型  无法分配空间
    28.     //因此只能声明  不能实例化
    29. //    T[] ts = new T[8];
    30.     T[] ts ;
    31.     public Tiger(String name, R r, T t, M m) {
    32.         this.name = name;
    33.         this.r = r;
    34.         this.t = t;
    35.         this.m = m;
    36.     }
    37. ​
    38.     public String getName() {
    39.         return name;
    40.     }
    41. ​
    42.     public void setName(String name) {
    43.         this.name = name;
    44.     }
    45.     //返回类型使用泛型
    46.     public R getR() {
    47.         return r;
    48.     }
    49.     //方法使用泛型
    50.     public void setR(R r) {
    51.         this.r = r;
    52.     }
    53. ​
    54.     public T getT() {
    55.         return t;
    56.     }
    57. ​
    58.     public void setT(T t) {
    59.         this.t = t;
    60.     }
    61. ​
    62.     public M getM() {
    63.         return m;
    64.     }
    65. ​
    66.     public void setM(M m) {
    67.         this.m = m;
    68.     }
    69. }
     

    ​
     

    自定义泛型接口
     

    1.  
      接口中，静态成员也不能使用泛型
       
    2.  
      泛型接口的类型，在继承接口或者实现接口时确定
       
    3.  
      没有指定类型，默认为Object
       
      1.  
      2. ​
      3. /**
      4.  * @author: wentao
      5.  * @date: 2022/11/2 20:58
      6.  * @version: 1.0
      7.  * @description: 自定义泛型接口
      8.  */
      9. public class InterfaceGeneric1 {
      10.     public static void main(String[]args){
      11. ​
      12.     }
      13. }
      14. ​
      15. ​
      16. ​
      17. //没有指定默认是Object
      18. class  UUTsb implements  Usb {
      19. ​
      20. ​
      21.     @Override
      22.     public Object get(Object o) {
      23.         return null;
      24.     }
      25. ​
      26.     @Override
      27.     public void hi(Object o) {
      28. ​
      29.     }
      30. ​
      31.     @Override
      32.     public void run(Object r1, Object r2, Object u1, Object u2) {
      33. ​
      34.     }
      35. }
      36. ​
      37. //实现的时候 可以自行指定了
      38. class  UUsb implements  Usb {
      39. ​
      40.     @Override
      41.     public Float get(Double aDouble) {
      42.         return null;
      43.     }
      44. ​
      45.     @Override
      46.     public void hi(Float aFloat) {
      47. ​
      48.     }
      49. ​
      50.     @Override
      51.     public void run(Float r1, Float r2, Double u1, Double u2) {
      52. ​
      53.     }
      54. }
      55. interface   IUsb extends Usb {
      56. ​
      57. }
      58. /*
      59. 1. 接口中，静态成员也不能使用翻新
      60. 2. 泛型接口的类型，在继承接口或者实现接口时确定
      61. 3. 没有指定类型，默认为Object
      62.  */
      63. interface Usb {
      64.     //接口中属性 默认是 public static final的
      65.     public  static  final  int i = 0;
      66. ​
      67. //    U u;
      68.     //普通方法在接口中 可以使用泛型
      69.     R get(U u);
      70. ​
      71.     void  hi(R r);
      72. ​
      73.     void  run(R r1, R r2, U u1, U u2);
      74. ​
      75.     //在jdk8中 可以在接口中，使用默认方法
      76.     default R method(U u) {
      77.         return  null;
      78.     }
      79. }
       
       
     

    自定义泛型方法
     

    基本语法
     

    修饰符  返回类型 方法名（参数列表）
     

    1.  
      泛型方法，可以定在普通类中，也可以定义的在泛型类中
       
    2.  
      当泛型方法被调用时，类型会确定
       
    3.  
      public void ear(E e ) {} ,修饰符后没有 eat方法不是泛型方法，而是使用了泛型
       
     

    1. package com.sofwin.controller;
    2. ​
    3. /**
    4.  * @author: wentao
    5.  * @date: 2022/11/2 21:30
    6.  * @version: 1.0
    7.  * @description: 泛型方法
    8.  */
    9. public class MethodGeneric1 {
    10.     public static void main(String[]args){
    11. ​
    12.         Car car = new  Car();
    13.         // 当泛型方法被调用时，类型会确定
    14.         //传入值的类型  编译器就自动确定了
    15.         car.fly("str");
    16.         car.fly(1);
    17.     }
    18. }
    19. //泛型方法 可以定义在普通类中，也可以定义在泛型类中
    20. class  Car {
    21.     //普通方法
    22.     public  void run() {}
    23. ​
    24.     //泛型方法
    25.     //就是泛型  是提供给fly使用的
    26.     public  void fly(T t) {
    27.         System.out.println(t.getClass());
    28.     }
    29.     public  void fly(T t,R r) {
    30.         System.out.println(t.getClass());
    31.     }
    32. }
    33. ​
    34. class  Car2 extends  Car {
    35.     @Override
    36.     public  void fly(T t) {
    37.         
    38.     }
    39. }
    40. //也可以定义在泛型类
    41. class  Fish {
    42.      public void  run () {}
    43. ​
    44.      public   void  ear(W w) {}
    45. }
    46. ​
     

    4.泛型的继承和通配符
     

    1.  
      泛型不具备继承性
       
      List list = new ArrayList() 是不对的
       
    2.  
      支持任意泛型类型
       
    3.  
       支持A类以及A类的子类，规定了泛型的上限
       
    4.  
       支持A类以及A类的父类 不限于直接父类，规定了泛型的下限
       
       
      5.  

      ​

       

      1. import org.omg.CORBA.PUBLIC_MEMBER;
      2. ​
      3. import java.util.ArrayList;
      4. import java.util.List;
      5. ​
      6. /**
      7.  * @author: wentao
      8.  * @date: 2022/11/2 22:16
      9.  * @version: 1.0
      10.  * @description: 泛型的基础和通配符
      11.  */
      12. public class GenericExtends {
      13.     public static void main(String[]args){
      14.         Object o = new String("xx");
      15.          //1.泛型没有继承性
      16.         //这个就不可以了
      17. //        List list = new ArrayList();
      18. ​
      19.         //举例说明下面的方法
      20.         List list1 = new ArrayList<>();
      21.         List list2 = new ArrayList<>();
      22.         List list3 = new ArrayList<>();
      23.         List list4 = new ArrayList<>();
      24.         List list5 = new ArrayList<>();
      25. ​
      26.         //        1. 支持任意泛型类型
      27.         printCollection(list1);
      28.         printCollection(list2);
      29.         printCollection(list3);
      30.         printCollection(list4);
      31.         printCollection(list5);
      32. ​
      33.         //        2.  支持A类以及A类的子类，规定了泛型的上限
      34.       //  printCollection2(list1);  //error  Object是A类的父类不是子类
      35.       //  printCollection2(list2);  //error String没有关系
      36.         printCollection2(list3); //ok 是AA类  
      37.         printCollection2(list4); //ok 是AA类的子类
      38.         printCollection2(list5);//ok 是AA类的子类(孙子)
      39. ​
      40.         //        3.  支持A类以及A类的父类  不限于直接父类，规定了泛型的下限
      41.     printCollection3(list1); //ok Object是A类的父类 
      42.    // printCollection3(list2); //error String不是 A类的父类  
      43.     printCollection3(list3);  //AA类是可以的
      44.    // printCollection3(list4);//error 是AA类的子类
      45.    // printCollection3(list5);//error 是AA类的子类(孙子)
      46.     }
      47.     //        1. 支持任意泛型类型
      48.     public static  void printCollection(List c) {
      49.         for (Object o : c) {
      50.             System.out.println(o);
      51.         }
      52.     }
      53.     
      54.     //        2.  支持A类以及A类的子类，规定了泛型的上限
      55.     public static  void printCollection2(List c) {
      56.         for (Object o : c) {
      57.             System.out.println(o);
      58.         }
      59.     }
      60. ​
      61.     //        3.  支持A类以及A类的父类  不限于直接父类，规定了泛型的下限
      62.     public static  void printCollection3(Listsuper   AA> c) {
      63.         for (Object o : c) {
      64.             System.out.println(o);
      65.         }
      66.     }
      67. }
      68. ​
      69. class  AA {
      70.     
      71. }
      72. ​
      73. class  BB extends AA {
      74.     
      75. }
      76. ​
      77. class  CC extends  BB {
      78.     
      79. }
      80. ​
        81. 
                
                    
                

                
      81. 

                    相关阅读:
        
                    
jenkins升级及基于jeecgboot 的nbcio-boot前端演示发布                            
        
前端postMessage跨域通讯                            
        
网络协议--IP选路                            
        
Javascript 中的堆、栈、引用和值指南                            
        
Golang Linux 安装与环境变量配置                            
        
Java开发面试常见的技术问题整理                            
        
python的数据类型转换以及运算符                            
        
【LeetCode-198】打家劫舍(回溯&动归)                            
        
聚酰胺改性乳清白蛋白/肌白蛋白/豆清白蛋白/蓖麻蛋白/豌豆白蛋白1b ( PA1b)纳米粒                            
        
代码管理（新手）                            
        
                            
                
        82. 
                
      82. 
                    原文地址：https://blog.csdn.net/weixin_52574640/article/details/127734561
                
        83.