Java进阶知识笔记14--【junit、反射、注解】

最新推荐文章于 2024-07-27 13:31:57 发布
最新推荐文章于 2024-07-27 13:31:57 发布
阅读量334 收藏 1
点赞数 1
分类专栏： Java 文章标签： java 反射 单元测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43215322/article/details/109004907
版权

今日内容

  1. Junit单元测试
  2. 反射
  3. 注解

Junit单元测试：

测试分类：

  1. 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。
  2. 白盒测试：需要写代码的。关注程序具体的执行流程。

Junit使用：白盒测试

步骤：

  1. 定义一个测试类(测试用例)

    • 建议：
      • 测试类名：被测试的类名Test CalculatorTest
      • 包名：xxx.xxx.xx.test cn.itcast.test

  2. 定义测试方法：可以独立运行

    • 建议：
      • 方法名：test测试的方法名 testAdd()
      • 返回值：void
      • 参数列表：空参

  3. 给方法加@Test

  4. 导入junit依赖环境

判定结果：

  • 红色：失败
  • 绿色：成功
  • 一般我们会使用断言操作来处理结果
    • Assert.assertEquals(期望的结果,运算的结果);

补充：

  • @Before:
    • 修饰的方法会在测试方法之前被自动执行
  • @After:
    • 修饰的方法会在测试方法执行之后自动被执行

反射：框架设计的灵魂

框架

半成品软件。可以在框架的基础上进行软件开发，简化编码

反射

将类的各个组成部分封装为其他对象，这就是反射机制

好处
  1. 可以在程序运行过程中，操作这些对象。
  2. 可以解耦，提高程序的可扩展性。
获取Class对象的方式

Class.forName(“全类名”)：将字节码文件加载进内存，返回Class对象

  • 多用于配置文件，将类名定义在配置文件中。读取文件，加载类

类名.class：通过类名的属性class获取

  • 多用于参数的传递

对象.getClass()：getClass()方法在Object类中定义着。

  • 多用于对象的获取字节码的方式

结论：
同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。

Class对象功能

获取功能：

  1. 获取成员变量们

    • Field[] getFields() ：获取所有public修饰的成员变量

    • Field getField(String name) 获取指定名称的 public修饰的成员变量

    • Field[] getDeclaredFields() 获取所有的成员变量，不考虑修饰符

    • Field getDeclaredField(String name)

  2. 获取构造方法们

    • Constructor<?>[] getConstructors()

    • Constructor getConstructor(类<?>… parameterTypes)

    • Constructor getDeclaredConstructor(类<?>… parameterTypes)

    • Constructor<?>[] getDeclaredConstructors()

  3. 获取成员方法们：

    • Method[] getMethods()

    • Method getMethod(String name, 类<?>… parameterTypes)

    • Method[] getDeclaredMethods()

    • Method getDeclaredMethod(String name, 类<?>… parameterTypes)

  4. 获取全类名

    • String getName()
Field：成员变量

操作：

  1. 设置值

    • void set(Object obj, Object value)

  2. 获取值

    • get(Object obj)

  3. 忽略访问权限修饰符的安全检查

    • setAccessible(true):暴力反射
Constructor:构造方法

创建对象：

  • T newInstance(Object… initargs)

  • 如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法

Method：方法对象

执行方法：Object invoke(Object obj, Object... args)

获取方法名称：String getName:获取方法名

获取成员变量案例

public class ReflectDemo01 {

    public static void main(String[] args) throws Exception {

        Class personClass = Person.class;
        /*1. 获取成员变量们
         * Field[] getFields() ：获取所有public修饰的成员变量
         * Field getField(String name)   获取指定名称的 public修饰的成员变量

         * Field[] getDeclaredFields()  获取所有的成员变量，不考虑修饰符
         * Field getDeclaredField(String name)  */
        Field[] fields = personClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }

        Person person1 = new Person();
        Field name = personClass.getField("name");
        name.set(person1,"古力娜扎");
        Object value1 = name.get(person1);
        System.out.println(person1);

        System.out.println("======================");

        /*获取所有的成员变量，不考虑修饰符*/
        Field[] declaredFields = personClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }

        System.out.println("======================");

        Field d = personClass.getDeclaredField("d");
        /*忽略访问权限修饰符的安全检查*/
        d.setAccessible(true);//暴力反射
        d.set(person1,25);
        Object value2 = d.get(person1);
        System.out.println(value2);
        System.out.println(person1);
    }
}

执行结果：

在这里插入图片描述

获取构造方法案例

public class ReflectDemo02 {

    public static void main(String[] args) throws Exception {

        Class personClass = Person.class;
        /*2. 获取构造方法们
         * Constructor<?>[] getConstructors()
         * Constructor<T> getConstructor(类<?>... parameterTypes)

         * Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
         * Constructor<?>[] getDeclaredConstructors()*/

        Constructor constructor1 = personClass.getConstructor(String.class, int.class);
        Object person1 = constructor1.newInstance("迪丽热巴", 26);
        System.out.println(person1);

        Constructor constructor2 = personClass.getConstructor();
        Object person2 = constructor2.newInstance();
        System.out.println(person2);

        Object person3 = personClass.newInstance();
        System.out.println(person3);
    }
}

输出结果：

在这里插入图片描述

获取成员方法案例

public class ReflectDemo03 {

    public static void main(String[] args) throws Exception {

        Class personClass = Person.class;
        /*3. 获取成员方法们：
         * Method[] getMethods()
         * Method getMethod(String name, 类<?>... parameterTypes)

         * Method[] getDeclaredMethods()
         * Method getDeclaredMethod(String name, 类<?>... parameterTypes)*/

        Method eat_method1 = personClass.getMethod("eat");
        Person person1 = new Person();
        eat_method1.invoke(person1);

        Method eat_method2 = personClass.getMethod("eat", String.class);
        eat_method2.invoke(person1,"coke");

        //获取所有被public修饰的方法
        Method[] methods = personClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);/*不仅仅有Person定义的一些方法，还有一些隐藏的父类方法*/
            //method.setAccessible(true);同样支持暴力反射，把其他修饰符修饰的方法输出
            System.out.println(method.getName());
        }

        /*获取类名*/
        String className = personClass.getName();
        System.out.println(className);/*全类名*/
    }
}

输出结果：

在这里插入图片描述

简单的反射案例

案例：

需求：写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法

实现：

  1. 配置文件
  2. 反射

步骤：

  1. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
  2. 在程序中加载读取配置文件
  3. 使用反射技术来加载类文件进内存
  4. 创建对象
  5. 执行方法

Properties文件构造：

在这里插入图片描述

代码实现：

public class ReflectTest {

    public static void main(String[] args) throws Exception {
        /*1.加载配置文件
        * 1.1创建Properties对象*/
        Properties pro = new Properties();
        /*1.2加载配置文件，转换为一个集合
        * 1.2.1获取class目录下的配置文件*/
        ClassLoader classLoader = ReflectTest.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("pro.properties");
        pro.load(is);

        /*2.获取配置文件中定义的数据*/
        String className = pro.getProperty("className");
        String methodName = pro.getProperty("methodName");

        /*3.加载该类进内存*/
        Class cls = Class.forName(className);
        /*4.创建对象*/
        Object obj = cls.newInstance();
        /*5.获取方法对象*/
        Method method = cls.getMethod(methodName);
        /*6.执行方法*/
        method.invoke(obj);
    }
}

执行结果：

在这里插入图片描述

注解：

概念

说明程序的。给计算机看的

注释

用文字描述程序的。给程序员看的

定义

注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。

概念描述

  • JDK1.5之后的新特性
  • 说明程序的
  • 使用注解：@注解名称

​

作用分类

①编写文档：通过代码里标识的注解生成文档【生成文档doc文档】
②代码分析：通过代码里标识的注解对代码进行分析【使用反射】
③编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【Override】

JDK中预定义的一些注解

  • @Override ：检测被该注解标注的方法是否是继承自父类(接口)的
  • @Deprecated：该注解标注的内容，表示已过时
  • @SuppressWarnings：压制警告，一般传递参数all @SuppressWarnings(“all”)

自定义注解

格式

元注解

public @interface 注解名称{
	属性列表;   //本质成员方法
}
本质

注解本质上就是一个接口，该接口默认继承Annotation接口

public interface MyAnno extends java.lang.annotation.Annotation {}
属性

即接口中的抽象方法

要求：

属性的返回值类型有下列取值

  • 基本数据类型
  • String
  • 枚举
  • 注解
  • 以上类型的数组
public @interface MyAnno1 {

    public abstract String show1();/*返回值为String和int类型的抽象方法*/
    int show2();

    Person p();//枚举类型

    MyAnno3 anno2();//注解类型

    String[] strs();

}

定义了属性，在使用时需要给属性赋值

  1. 如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时，可以不进行属性的赋值。
  2. 如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接定义值即可。
  3. 数组赋值时，值使用{}包裹。如果数组中只有一个值，则{}可以省略
public @interface MyAnno1 {

    public abstract String show1();/*返回值为String和int类型的抽象方法*/
    int value();
    int show2();

    Person p();//枚举类型

    MyAnno2 anno2();//注解类型

    String[] strs();

}

@MyAnno1(show1 = "张三", value = 10, show2 = 10,p = Person.p1, anno2 = @MyAnno2, strs = {"aa","bbb"})
public class Worker {

    public String name ="zhangsan";

    public void show(){

    }
}

或者

public @interface MyAnno2 {
    int value();
}

@MyAnno2(10)
public class Worker {

    public String name ="zhangsan";

    public void show(){

    }
}
元注解

用于描述注解的注解（常用前两种）

@Target：描述注解能够作用的位置

ElementType取值：

  • TYPE：可以作用于类上
  • METHOD：可以作用于方法上
  • FIELD：可以作用于成员变量上

@Retention：描述注解被保留的阶段

@Retention(RetentionPolicy.RUNTIME)：当前被描述的注解，会保留到class字节码文件中，并被JVM读取到

@Documented：描述注解是否被抽取到api文档中

@Inherited：描述注解是否被子类继承

在程序使用(解析)注解

获取注解中定义的属性值

  1. 获取注解定义的位置的对象 （Class，Method,Field）

  2. 获取指定的注解

    getAnnotation(Class)
    //其实就是在内存中生成了一个该注解接口的子类实现对象

    ​ public class ProImpl implements Pro{
    ​ public String className(){
    ​ return “cn.itcast.annotation.Demo1”;
    ​ }
    ​ public String methodName(){
    ​ return “show”;
    ​ }
    ​ }

  3. 调用注解中的抽象方法获取配置的属性值

解析注解的案例：

注解代码：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Pro {

    String className();
    String methodName();
}

Demo1代码：

public class Demo1 {

    public void show(){
        System.out.println("show...demo1...");
    }
}

实现案例代码：

@Pro(className = "ncwu.kuber.webdemo.annotation.Demo1",methodName = "show")
public class ReflectTest {

    public static void main(String[] args) throws Exception {
        /*前提：不改变该类的任何代码。*/

        /*1.解析注解*/
        /*1.1获取该类的字节码文件对象*/
        Class<ReflectTest> reflectTestClass = ReflectTest.class;
        Pro anno = reflectTestClass.getAnnotation(Pro.class);

        String className = anno.className();
        String methodName = anno.methodName();

//        System.out.println(className+"==="+methodName);
        Class cls = Class.forName(className);/*加载该类进内存*/
        Object obj = cls.newInstance();/*创建对象*/
        Method method = cls.getMethod(methodName);/*获取方法对象*/
        method.invoke(obj);/*执行方法*/

    }
}

输出结果：

在这里插入图片描述

案例：简单的测试框架

Calculator类：

/**
 * 小明定义的计算器类
 */
public class Calculator {

    //加法
    @Check
    public void add(){
        String str = null;
        str.toString();
        System.out.println("1 + 0 =" + (1 + 0));
    }
    //减法
    @Check
    public void sub(){
        System.out.println("1 - 0 =" + (1 - 0));
    }
    //乘法
    @Check
    public void mul(){
        System.out.println("1 * 0 =" + (1 * 0));
    }
    //除法
    @Check
    public void div(){
        System.out.println("1 / 0 =" + (1 / 0));
    }


    public void show(){
        System.out.println("永无bug...");
    }

}

Check注解：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Check {
}

实现案例：

/**
 * 简单的测试框架
 *
 * 当主方法执行后，会自动执行被检测的所有方法(加了Check注解的方法)，判断方法是否有异常，记录到文件中
 */
public class TestCheck {

    public static void main(String[] args) throws IOException {
        Calculator calculator = new Calculator();//创建计算器对象

        Class cls = calculator.getClass();//过去字节码文件对象

        Method[] methods = cls.getMethods();//获取所有方法对象
        int counter = 0;
        BufferedWriter bw = new BufferedWriter(new FileWriter("bug.txt"));
        for (Method method : methods) {
            /*判断方法上是否有Check注解*/
            if(method.isAnnotationPresent(Check.class)){
                /*有，执行方法*/
                try {
                    method.invoke(calculator);
                } catch (Exception e) {
                    /*捕获异常，并记录到文件中*/
                    counter++;
                    bw.write(method.getName()+"方法出异常了");
                    bw.newLine();
                    bw.write("异常的名称："+e.getCause().getClass().getSimpleName());
                    bw.newLine();
                    bw.write("异常的原因："+e.getCause().getMessage());
                    bw.newLine();
                    bw.write("-------------------------------");
                    bw.newLine();

                }
            }
        }
        bw.write("本次一共出现了"+counter+"次异常");

        bw.flush();
        bw.close();

    }

}

执行结果：

控制台输出情况

在这里插入图片描述

生成的文本情况

在这里插入图片描述

小结

  1. 以后大多数时候，我们会使用注解，而不是自定义注解
  2. 注解给谁用？
    1. 编译器
    2. 给解析程序用
  3. 注解不是程序的一部分，可以理解为注解就是一个标签
库北勒神
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA进阶笔记之单元测试，反射，注解(推荐)
王大师企业官方博客
01-02 301
学习目标： 1、一周掌握 JAVA入门知识 2、掌握基础入门C#知识 3、手把手教你vbs脚本制作 4、强大的 IDEA编程利器 5、经典常见的 面试题目技巧 6、家居生活风水一点通 JAVA基础加强笔记（推荐）学习目标：前言主要内容Junit单元测试反射：框架设计的灵魂注解详解总结 前言 希望：2021年，牛年更牛！ 主要内容 1. 单元测试 2. 反射详解 3. 注解详解 Junit单元测试 * 测试分类： 1. 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。 ..
Java进阶笔记.zip
04-13
以上知识点只是“Java进阶笔记”可能涉及的一部分，具体笔记可能还会包含更多主题，如JavaFX（GUI开发）、Swing、网络编程、数据库连接等。通过深入学习这些内容，开发者可以提高解决问题的能力，更好地适应各种复杂...
13天Java进阶笔记-day12-JUnit单元测试、反射、注解、动态代理
qq_36178962的博客
06-11 1242
单元测试是指程序员写的测试代码给自己的类中的方法进行预期正确性的验证。单元测试一旦写好了这些测试代码，就可以一直使用，可以实现一定程度上的自动化测试。单元测试一般要使用框架进行。 什么是框架？ 框架是前人或者一些牛逼的技术公司在实战或者研发中设计的一些优良的设计方案或者成型的 代码功能，作为一个完整的技术体系发行出来称为框架。框架可以让程序员快速拥有一个强大的解决方案，可以快速的开发功能，提高效率并且直接就有了很好的性能。单元测试的经典框架：是什么单元测试概念单元测试框架的作用Junit框架的使用步骤:下载
JavaSE-进阶-学习笔记-Junit单元测试、反射、注解、动态代理
qq_52668773的博客
04-03 1858
javase进阶学习之Junit单元测试、反射、注解、动态代理、Base64编码
Java基础进阶03-注解和单元测试
qq_33627452的博客
01-25 1513
注解是代码里的特殊标记,程序可以读取注解，一般用于替代配置文件可以通过反射技术去得到类里面的注解，来决定怎么去运行类public @interface 注解名称{//属性类型：基本数据类型，String，Class，注解，枚举，以上类型的一维数组//特殊属性值Value，我们在使用注解的时候，如果我们只给注解的value属性赋值，那么value=可省略public 属性类型 属性名() default 默认值描述元注解的注解（写在注解上面的注解）单元测试是对单个代码模块的正确性的测试。
【02】Java进阶：15-Junit单元测试、反射、注解、动态代理、JDK8新特性、
忘尘丶莫负的博客
02-04 383
day15【JUnit单元测试、反射、注解、动态代理、JDK8新特性】 今日内容 JUnit单元测试 反射 注解 动态代理 JDK8新特性 学习目标 能够使用Junit进行单元测试 能够通过反射技术获取Class字节码对象 能够通过反射技术获取构造方法对象，并创建对象。 能够通过反射获取成员方法对象，并且调用方法。 能够通过反射获取属性对象，并且能够给对象的属性赋值和取值。 能够说出注解的作用 能够自定义注解和使用注解 能够说出常用的元注解及其作用 能够解析注解并获取注解中的数据
Java进阶16 单元测试&XML&注解
summer_9823的博客
05-23 1056
单元测试Junit、XML文件编写语法规则、约束、解析、注解、自定义注解
学习笔记：黑马程序员Java-进阶篇（二）（第五部分）
D_boj的博客
08-13 1397
本章介绍，多线程（重要）、网络编程、反射（重要）、动态代理、日志、注解以及算法和补充学习部分。本章内容较为丰富，有待后期复习巩固完善
Java基础进阶（学习笔记）
m0_74016429的博客
01-02 1115
自定义异常的分类1、自定义编译时异常定义一个异常类继承Exception.重写构造器2、自定义运行时异常定义一个异常类继承RuntimeException.重写构造器。try {System.out.println("底层执行成功");System.out.println("底层执行失败");System.out.println("年龄被成功保存："+age);System.out.println("请您输入合法的数字！");
Java进阶笔记（三）：Spring相关
BHSZZY的博客
10-14 204
【总体部分】 Spring框架的目的：让开发者专注于业务，而不是基本实现。 ------------------ Spring的优势： 方便解耦，简化开发 支持AOP编程 支持声明式事务（@Transactional） 方便程序测试（Junit） 方便集成其它优秀框架 降低JavaEE API的使用难度（spring封装了一些jdk中的方法） ------------------ Spring可分为4个模块（开发时只需要引入需要的模块即可）： Web（M...
java-developer-guide-samples:本仓库主要是用来记录Java开发者所需的基础和进阶知识，以及自己平时的思考和学习笔记
03-13
2. **进阶主题**：仓库可能涵盖JVM（Java虚拟机）内部工作原理、垃圾收集机制、性能调优、反射、注解、模块化系统（如Jigsaw）、并发编程高级技术（如Fork/Join框架和CountDownLatch）等。理解JVM对于优化代码和解决...
黑马java教程知识点笔记整理
02-04
【Java编程基础】 ...以上是黑马Java教程知识点笔记的主要内容，涵盖了Java编程的基础到进阶知识，是学习和巩固Java技能的重要参考资料。通过深入理解和实践这些知识点，开发者可以逐步提升Java编程能力。
Java语言程序设计 基础篇-进阶篇源码
12-25
这些知识点构成了Java程序员进阶所必需的基础。通过"Java语言程序设计 基础篇-进阶篇源码"中的实例和练习，学习者可以深入理解和掌握这些概念，并通过实践提高编程技能。"新建文本文档.txt"可能是课程资料或笔记，而...
Java笔记（重点）共55页.pdf.zip
10-28
这份笔记不仅适合初学者入门，也对有经验的开发者具有参考价值，因为它涵盖了Java从基础到进阶的各个重要方面。通过深入学习并实践这些知识点，你可以扎实地掌握Java编程，为实际项目开发打下坚实的基础。
golang 接口
m0_70982551的博客
07-24 958
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 517
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 653
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 595
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
JavaWeb学习笔记：Eclipse、JUnit到反射、注解和XML解析
"传智播客的《30天轻松掌握JavaWeb视频》笔记整理版，涵盖了一系列JavaWeb开发中的核心知识点，包括Eclipse的使用、调试、JUnit测试框架、Java 5的新特性、反射技术、内省技术、泛型、注解、类加载器以及XML解析等。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值