Java学习笔记-泛型

13.Java 泛型

13.1 泛型介绍

  1. 基本介绍

    1. Java泛型(generics)是JDK 5中引入的一个新特性,在很大的程度上方便在集合上的使用。

    2. 泛型的本质是 参数化类型,即给类型指定一个参数,然后在使用时再指定此参数具体的值,那样这个类型就可以在使用时决定了

  2. 泛型的好处

    注意:泛型只是编译时约束,运行时可以通过反射添加其他类型元素

13.2 泛型语法

  1. 泛型的声明

    java 复制代码
    class Person<E> {
        //E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间,就确定E是什么类型
        E s ;
        public Person(E s) {//E也可以是参数类型
            this.s = s;
        }
        public E f() {//返回类型使用E
            return s;
        }
        public void show() {
            System.out.println(s.getClass());//显示s的运行类型
        }
    }
  2. 泛型的实例化

  3. 泛型使用的注意事项和细节

    java 复制代码
    public class GenericDetail {
        public static void main(String[] args) {
            //1.给泛型指向数据类型是,要求是引用类型,不能是基本数据类型
            List<Integer> list = new ArrayList<Integer>(); //OK
            //List<int> list2 = new ArrayList<int>();//错误
    
            //2. 说明
            //因为 E 指定了 A 类型, 构造器传入了 new A()
            //在给泛型指定具体类型后,可以传入该类型或者其子类类型
            Pig<A> aPig = new Pig<A>(new A());
            aPig.f();
            Pig<A> aPig2 = new Pig<A>(new B());
            aPig2.f();
    
            //3. 泛型的使用形式
            ArrayList<Integer> list1 = new ArrayList<Integer>();
            List<Integer> list2 = new ArrayList<Integer>();
            //在实际开发中,我们往往简写
            //编译器会进行类型推断, 老师推荐使用下面写法
            ArrayList<Integer> list3 = new ArrayList<>();
            List<Integer> list4 = new ArrayList<>();
            ArrayList<Pig> pigs = new ArrayList<>();
    
            //4. 如果是这样写 泛型默认是 Object
            ArrayList arrayList = new ArrayList();//等价 ArrayList<Object> arrayList = new ArrayList<Object>();
            /*
                public boolean add(Object e) {
                    ensureCapacityInternal(size + 1);  // Increments modCount!!
                    elementData[size++] = e;
                    return true;
                }
             */
            Tiger tiger = new Tiger();
            /*
                class Tiger {//类
                    Object e;
    
                    public Tiger() {}
    
                    public Tiger(Object e) {
                        this.e = e;
                    }
                }
             */
    
        }
    }
    class Tiger<E> {//类
        E e;
    
        public Tiger() {}
    
        public Tiger(E e) {
            this.e = e;
        }
    }
    
    class A {}
    class B extends A {}
    
    class Pig<E> {//
        E e;
        public Pig(E e) { this.e = e; }
        public void f() {
            System.out.println(e.getClass()); //运行类型
        }
    }

13.3 自定义泛型

13.3.1 自定义泛型类

  1. 自定义泛型类

    java 复制代码
    //解读
    //1. Tiger 后面泛型,所以我们把 Tiger 就称为自定义泛型类
    //2, T, R, M 泛型的标识符, 一般是单个大写字母
    //3. 泛型标识符可以有多个.
    //4. 普通成员可以使用泛型 (属性、方法)
    //5. 使用泛型的数组,不能初始化
    //6. 静态方法中不能使用类的泛型
    class Tiger<T, R, M> {
        String name;
        R r; //属性使用到泛型
        M m;
        T t;
        //因为数组在new 不能确定T的类型,就无法在内存开空间
        T[] ts;
    
        public Tiger(String name) {
            this.name = name;
        }
        public Tiger(R r, M m, T t,T[] ts) {//构造器使用泛型
            //不能直接ts = new T[10];这样写
            this.ts=ts;
            this.r = r;
            this.m = m;
            this.t = t;
        }
        //因为静态是和类相关的,在类加载时,对象还没有创建
        //所以,如果静态方法和静态属性使用了泛型,JVM就无法完成初始化
    //    static R r2;
    //    public static void m1(M m) {
    //
    //    }  
        //方法使用泛型
        public void setR(R r) {//方法使用到泛型
            this.r = r;
        }
        public M getM() {//返回类型可以使用泛型.
            return m;
        }
    
    }

13.3.2 自定义泛型接口

  1. 自定义泛型接口

    java 复制代码
    //在继承接口 指定泛型接口的类型
    interface IA extends IUsb<String, Double> {
        
    }
    //当我们去实现IA接口时,因为IA在继承IUsu 接口时,指定了U 为String R为Double
    //,在实现IUsu接口的方法时,使用String替换U, 是Double替换R
    class AA implements IA {
    
        @Override
        public Double get(String s) { return null; }
        
        @Override
        public void hi(Double aDouble) {}
        
        @Override
        public void run(Double r1, Double r2, String u1, String u2) {}
        
    }
    
    //实现接口时,直接指定泛型接口的类型
    //给U 指定Integer 给 R 指定了 Float
    //所以,当我们实现IUsb方法时,会使用Integer替换U, 使用Float替换R
    class BB implements IUsb<Integer, Float> {
        
        @Override
        public Float get(Integer integer) { return null; }
        
        @Override
        public void hi(Float aFloat) {}
        
        @Override
        public void run(Float r1, Float r2, Integer u1, Integer u2) {}
    }
    //没有指定类型,默认为Object
    //建议直接写成 IUsb<Object,Object>
    class CC implements IUsb { //等价 class CC implements IUsb<Object,Object> {
        
        @Override
        public Object get(Object o) { return null; }
        
        @Override
        public void hi(Object o) {}
        
        @Override
        public void run(Object r1, Object r2, Object u1, Object u2) {}
    
    }
    
    interface IUsb<U, R> {
    
        int n = 10;
        //U name; 不能这样使用,neme一看就应该是String类型
    
        //普通方法中,可以使用接口泛型
        R get(U u);
    
        void hi(R r);
    
        void run(R r1, R r2, U u1, U u2);
    
        //在jdk8 中,可以在接口中,使用默认方法, 也是可以使用泛型
        default R method(U u) {
            return null;
        }
    }

13.3.3 自定义泛型方法

  1. 自定义泛型方法

    java 复制代码
    public class CustomMethodGeneric {
        public static void main(String[] args) {
            Car car = new Car();
            car.fly("宝马", 100);//当调用方法时,传入参数,编译器,就会确定类型
            System.out.println("=======");
            car.fly(300, 100.1);//当调用方法时,传入参数,编译器,就会确定类型
    
            //测试
            //T->String, R-> ArrayList
            Fish<String, ArrayList> fish = new Fish<>();
            fish.hello(new ArrayList(), 11.3f);
        }
    }
    
    //泛型方法,可以定义在普通类中, 也可以定义在泛型类中
    class Car {//普通类
    
        public void run() {//普通方法
        }
        //说明 泛型方法
        //1. <T,R> 就是泛型
        //2. 是提供给 fly使用的
        public <T, R> void fly(T t, R r) {//泛型方法
            System.out.println(t.getClass());//String
            System.out.println(r.getClass());//Integer
        }
    }
    
    class Fish<T, R> {//泛型类
        public void run() {//普通方法
        }
        public<U,M> void eat(U u, M m) {//泛型方法
    
        }
        //说明
        //1. 下面hi方法不是泛型方法
        //2. 是hi方法使用了类声明的 泛型
        public void hi(T t) {
        }
        //泛型方法,可以使用类声明的泛型,也可以使用自己声明泛型
        public<K> void hello(R r, K k) {
            System.out.println(r.getClass());//ArrayList
            System.out.println(k.getClass());//Float
        }
    }
  2. 练习

13.4 泛型的继承和通配符

  1. 基本介绍

  2. 举例

    java 复制代码
    public class GenericExtends {
        public static void main(String[] args) {
    
            Object o = new String("xx");
    
            //泛型没有继承性
    //        List<Object> list = new ArrayList<String>(); //报错
    
            //举例说明下面三个方法的使用
            List<Object> list1 = new ArrayList<>();
            List<String> list2 = new ArrayList<>();
            List<AA> list3 = new ArrayList<>();
            List<BB> list4 = new ArrayList<>();
            List<CC> list5 = new ArrayList<>();
    
            //如果是 List<?> c ,可以接受任意的泛型类型
            printCollection1(list1);
            printCollection1(list2);
            printCollection1(list3);
            printCollection1(list4);
            printCollection1(list5);
    
            //List<? extends AA> c: 表示 上限,可以接受 AA或者AA子类
    //        printCollection2(list1);//×
    //        printCollection2(list2);//×
            printCollection2(list3);//√
            printCollection2(list4);//√
            printCollection2(list5);//√
    
            //List<? super AA> c: 支持AA类以及AA类的父类,不限于直接父类
            printCollection3(list1);//√
            //printCollection3(list2);//×
            printCollection3(list3);//√
            //printCollection3(list4);//×
            //printCollection3(list5);//×
            
        }
        // ? extends AA 表示 上限,可以接受 AA或者AA子类
        public static void printCollection2(List<? extends AA> c) {
            for (Object object : c) {
                System.out.println(object);
            }
        }
    
        //说明: List<?> 表示 任意的泛型类型都可以接受
        public static void printCollection1(List<?> c) {
            for (Object object : c) { // 通配符,取出时,就是Object
                System.out.println(object);
            }
        }
        
        // ? super 子类类名AA:支持AA类以及AA类的父类,不限于直接父类,
        //规定了泛型的下限
        public static void printCollection3(List<? super AA> c) {
            for (Object object : c) {
                System.out.println(object);
            }
        }
    
    }
    
    class AA {
    }
    
    class BB extends AA {
    }
    
    class CC extends BB {
    }

13.5 JUnit 单元测试

  1. 为什么要 Junit

    目前测试方法是怎么进行的,存在什么问题

    • 只有一个main方法,如果一个方法的测试失败了,其他方法测试会受到影响。
    • 无法得到测试的结果报告,需要程序员自己去观察测试是否成功。
    • 无法实现自动化测试。

    比如要测试一个方法或一段代码,这个时候就要去main方法里面去调用,测试了这个之后要测试别的,此时还要将原来的代码注释掉,这个时候就可以用JUnit,即单独运行一个函数,相当于main方法来运行

  2. JUnit基本介绍

    1. JUnit是一个 Java 语言的单元测试框架

    2. 多数Java开发环境都已经集成了JUnit作为单元测试工具

    3. JUnit优点

      • JUnit可以灵活的选择执行哪些测试方法,可以一键执行全部测试方法。

      • Junit可以生成全部方法的测试报告。

      • 单元测试中的某个方法测试失败了,不会影响其他测试方法的测试。

  3. JUnit导入及使用方法

    1. 方法一:手动导入jar包

      1. 将JUnit的jar包导入到项目中

        • IDEA通常整合好了Junit框架,一般不需要导入。

        • 如果IDEA没有整合好,需要自己手工导入如下2个JUnit的jar包到模块

      2. 编写测试方法:该测试方法通常是公共的无参数无返回值的非静态方法

      3. 在测试方法上使用@Test注解:标注该方法是一个测试方法

      4. 在测试方法中完成被测试方法的预期正确性测试。

      5. 选中测试方法,选择"JUnit运行" ,如果测试良好则是绿色;如果测试失败,则是红色

        • 点类中的空白处(非方法体内)或者绿色箭头,可以运行类中的所有测试方法

    2. 方法二:自动导入jar包

      1. 首先在要测试的方法前面加上@Test,刚开始的时候是红的

      2. 之后Alt + 回车,便会自动弄啥maven之类的东西,等test不是红色后,左边就会出现运行按钮了

      3. 一般是加JUnit5.4JUnit5.8.1(因为没有JUnit5.4),即Alt + 回车后会有选择,选择加哪个

  4. Junit常用注解

    1. Junit 4.xxxx版本

      注解 说明
      @Test 测试方法
      @Before 用来修饰实例方法,该方法会在每一个测试方法执行之前执行一次
      @After 用来修饰实例方法,该方法会在每一个测试方法执行之后执行一次
      @BeforeClass 用来静态修饰方法,该方法会在所有测试方法之前只执行一次
      @AfterClass 用来静态修饰方法,该方法会在所有测试方法之后只执行一次
      • 开始执行的方法:初始化资源。
      • 执行完之后的方法:释放资源。
    2. Junit 5.xxxx版本

      注解 说明
      @Test 测试方法
      @BeforeEach 用来修饰实例方法,该方法会在每一个测试方法执行之前执行一次
      @AfterEach 用来修饰实例方法,该方法会在每一个测试方法执行之后执行一次
      @BeforeAll 用来静态修饰方法,该方法会在所有测试方法之前只执行一次
      @AfterAll 用来静态修饰方法,该方法会在所有测试方法之后只执行一次
      • 开始执行的方法:初始化资源。
      • 执行完之后的方法:释放资源。
    3. 举例说明

      java 复制代码
      public class TestUserService {
      
          // 修饰实例方法的
          @Before
          public void before(){
              System.out.println("===before方法执行一次===");
          }
      
          @After
          public void after(){
              System.out.println("===after方法执行一次===");
          }
      
          // 修饰静态方法
          @BeforeClass
          public static void beforeClass(){
              System.out.println("===beforeClass方法执行一次===");
          }
      
          @AfterClass
          public static void afterClass(){
              System.out.println("===afterClass方法执行一次===");
          }
      
      
          /**
             测试方法
             注意点:
                  1、必须是公开的。通常是无参数 无返回值的方法
                  2、测试方法必须使用@Test注解标记。
           */
          @Test
          public void testSelectNames(){
          }
      
      }
相关推荐
小蒜学长2 小时前
汽车专卖店管理系统的设计与实现(代码+数据库+LW)
java·数据库·spring boot·后端·汽车
老华带你飞5 小时前
社区互助|基于SSM+vue的社区互助平台的设计与实现(源码+数据库+文档)
java·前端·数据库·vue.js·小程序·毕设·社区互助平台
007php0076 小时前
Go 错误处理:用 panic 取代 err != nil 的模式
java·linux·服务器·后端·ios·golang·xcode
阿华的代码王国6 小时前
【Android】OkHttp发起GET请求 && POST请求
android·java·okhttp·网络连接
island13146 小时前
【Redis#7】Redis 数据结构 -- Set 类型
java·数据结构·redis
3Cloudream6 小时前
互联网大厂Java面试:从基础到微服务的深度解析
java·spring·微服务·面试·技术解析·电商场景
茯苓gao6 小时前
变频器实习总结14 电子元件中的内部参考电压 Type-c口对于BMS开发的优点
笔记·嵌入式硬件·学习
接着奏乐接着舞。6 小时前
前端RSA加密遇到Java后端解密失败的问题解决
java·开发语言·前端