Java Day25

最新推荐文章于 2024-07-24 17:27:32 发布

哈哈哈捧场王

最新推荐文章于 2024-07-24 17:27:32 发布

阅读量96

点赞数

分类专栏： java学习文章标签： java

本文链接：https://blog.csdn.net/qq_38689352/article/details/108015306

版权

java学习专栏收录该内容

25 篇文章 1 订阅

订阅专栏

第一章 Junit单元测试

1.1 测试的分类

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

1.2 Junit使用

1.2.1 使用步骤

定义一个测试类（测试用例）
- 建议
  - 测试类名：被测试的类名Test
  - 包名：xxx.xxx.xx.test
定义测试方法：可以独立运行
- 建议
  - 方法名：test测试方法的名字
  - 返回值：void
  - 参数列表：空参
给方法添加@Test
倒入junit依赖环境
判定结果：
- 红色：失败
- 绿色：成功
- 一般我们使用断言来处理结果
  - Assert.assertEquals(期望的结果, 运算的结果);
补充
- @Before：修饰的方法会在测试方法之前自动执行
- @After：修饰的方法会在测试方法之后自动执行

1.2.2 代码演示

定义一个Calculator类

package com.it.day14code.Junit;

/*
* 计算器类
*
* */

public class Calculator {
    /*
    * 加法
    * */
    public int add(int a, int b) {
        return a + b;
    }

    /*
    * 减法
    * */
    public int sub (int a, int b) {
        return a - b;
    }

}

定义一个测试类

package com.it.day14code.test;

/*
* Junit 使用步骤
* 1、定义一个测试类（测试用例）
*   *建议：
*       * 测试类名：被测试类名Test
*       * 包名：xxx.xxx.xx.test
* 2、定义测试方法：可以独立运行
*   * 建议：
*       * 方法名：test测试方法名
*       * 返回值：void
*       * 参数列表：空参
* 3、给方法加@Test注解
* 4、倒入Junit依赖环境
* 判定结果：
*   * 红色：成功
*   * 绿色：失败
*   * 一般我们会使用断言操作来处理结果
*       * Assert.assertEquals(期望的结果, 程序得到的结果)
*
* 补充：
*   @Before
*       修饰的方法会在测试方法之前被自动执行
*   @After
*       修饰的方法会在测试方法执行之后自动被执行
* */


import com.it.day14code.Junit.Calculator;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

public class CalculatorTest {

    /*
    * 初始化方法：
    * 用于资源申请，所有测试方法在执行之前都会先执行该方法
    *
    * */
    @Before
    public void init() {
        System.out.println("init...");
    }

    /*
    * 释放资源的方法：
    * 在所有测试方法执行完成后，都会自动执行该方法
    *
    * */
    @After
    public void close() {
        System.out.println("close...");
    }

    /*
    * 测试add方法
    *
    * */
    @Test
    public void testAdd() {
        // System.out.println("我被执行了");
        // 1.创建计算器对象
        Calculator c = new Calculator();
        // 2、调用add方法
        int result = c.add(1, 3);
        // System.out.println(result);

        // 3、断言 我断言这个结果是3
        Assert.assertEquals(3,result);
    }

    @Test
    public void testSub() {
        // 1.创建计算器对象
        Calculator c = new Calculator();
        // 2、调用sub方法
        int result = c.sub(1, 1);
        System.out.println("testsub...");

        // 3、断言 我断言这个结果是0
        Assert.assertEquals(0,result);
    }
}

第二章反射

2.1 反射概述

反射：将类的各个组成部分封装为其他对象，这就是反射机制。
好处
- 可以在程序运行过程中，操作这些对象
- 可以解耦，提高程序的可扩展性

2.2 获取class对象的方式

Class.forName("全类名")：将字节码文件加载进内存，返回class对象。
- 该方式多用于配置文件，将类名定义在配置文件中。读取文件，加载类
类名.class：通过类名的属性class获取
- 该方法多用于参数的传递
对象.getClass()：getClass()方法在Object类中定义着。
- 该方式多用于对象获取字节码的方式
结论
- 统一个字节码文件(*.class)在一次运行过程中只会被加载一次，不论是通过哪种方式获取的Class对象都是同一个。
代码演示：

定义一个Person类；

public class Person {
    private String name;
    private int age;

    public String a;
    protected String b;
    String c;
    private String d;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                '}';
    }

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

    public void eat(String food) {
        System.out.println("eat food...");
    }
}

定义一个测试类

/*
* 反射；框架设计的灵魂
*   框架：半成品软件，可以在框架的基础上进行软件开发，简化编码
*   反射：将类的各个组成部分封装为其他对象，这就是反射机制
*       好处
*           1、可以在程序的运行过程中操作这些对象
*           2、可以解耦，提高程序的可扩展性
*
* 获取Class对象的几种方式
*   1、source源代码阶段
*       Class.forName("全类名")：将字节码文件加载至内存
*       多用于配置文件，将类名定义在配置文件中。读取文件，加载类
*   2、Class对象阶段
*       类名.class：通过类名的属性class获取
*       多用于参数的传递
*   3、Runtime运行时阶段
*       对象.getClass()：getClass()在Object中定义
*       多用于对象获取字节码的方式
* 结论：
*   同一个字节码文件（*.class）在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取Class对象都是同一个
*
* Class对象功能：
*   获取功能：
*       获取成员变量们
*           Field[] getField() 获取所有的成员变量
*           Field[] gerField(String name)
*
*           Field[] getDeclaredFields()
*           Field getDeclaredField(String name)
*       获取构造方法们
*           Constructor<?>[] getConstructors() 获取所有的构造方法
*           COnstructor<T> getConstructor(类 <?>... parameterTypes) 获取单个成员方法
*
*           Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
*           Constructor<?>[] getDeclaredConstructors()
*
*       获取成员方法们
*           Method[] getMethods()
*           Method getMethod(String name, 类<?>... parameterTypes)
*
*           Method[] getDeclaredMethods()
*           Method getDeclaredMethod(String name, 类<?>... parameterTypes)
*       获取类名
*           String getName()
*
* */

import com.it.day14code.domain.Person;
import com.it.day14code.domain.Student;

public class ReflectDemo01 {
    public static void main(String[] args) throws ClassNotFoundException {
        // Class.forName("全类名")：将字节码文件加载至内存
        Class cls1 = Class.forName("com.it.day14code.domain.Person");
        System.out.println(cls1);

        // 类名.class：通过类名的属性class获取
        Class cls2 = Person.class;
        System.out.println(cls2);

        // 对象.getClass()：getClass()在Object中定义
        Person p = new Person();
        Class cls3 = p.getClass();
        System.out.println(cls3);

        // 用==比较三个对象
        System.out.println(cls1==cls2);
        System.out.println(cls2==cls3);

        Class c = Student.class;
        System.out.println(c == cls1);
    }
}

2.3 Class对象功能

2.3.1 获取功能

获取功能
- 获取成员变量
  - Field[] getFields()：获取所有public修饰的成员变量
  - Field getField()：获取指定名称的public修饰的成员变量
  - Field[] getDeclaredFields()：获取所有的成员变量，不考虑修饰符
  - Field getDeclaredField()：获取某一个成员变量，不考虑修饰符
- 获取构造方法
  - Constructor<?>[] getConstructors()：获取所有构造方法
  - Constructor<T> getConstructor(类<?>... parameterTypes)
  - Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
  - Constructor<?>[] getDeclaredConstructors()
- 获取成员方法
  - Method[] getMethods()
  - Method getMethod(String name, 类<?>...parameterTypes)
  - Method getDeclaredMethods()
  - Method getDeclaredMethod(String name, 类<?>...parameterTypes)
- 获取全类名
  - String getName()

2.3.2 获取后操作

Field：成员变量
- 操作
  - 设置值
    - void set(Object obj, Object value)
  - 获取值
    - get(Object obj)
  - 忽略访问权限修饰符的安全检查
    - setAccessible(true)：暴力反射
- 代码演示：

/*
* Class对象功能：
*   获取功能：
*       获取成员变量们
*           Field[] getField() 获取所有public修饰的成员变量
*           Field[] gerField(String name)  获取指定名称的public修饰的成员变量
*
*           Field[] getDeclaredFields() 获取所有的成员变量，不考虑修饰符
*           Field getDeclaredField(String name)  获取指定的成员变量，不考虑修饰符
*       获取构造方法们
*           Constructor<?>[] getConstructors() 获取所有的构造方法
*           COnstructor<T> getConstructor(类 <?>... parameterTypes) 获取单个成员方法
*
*           Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
*           Constructor<?>[] getDeclaredConstructors()
*
*       获取成员方法们
*           Method[] getMethods()
*           Method getMethod(String name, 类<?>... parameterTypes)
*
*           Method[] getDeclaredMethods()
*           Method getDeclaredMethod(String name, 类<?>... parameterTypes)
*       获取类名
*           String getName()
* Field：成员变量
*   操作：
*       1、设置值
*           void set(Object obj, Object value)
*       2、获取值
*           get(Object obj)
*       3、忽略访问权限修饰符的安全检查
*           setAccessible(true)  暴力反射
*
* */

import com.it.day14code.domain.Person;

import java.io.File;
import java.lang.reflect.Field;

public class ReflectDemo02 {
    public static void main(String[] args) throws Exception {
        // 0、获取Person的Class对象
        Class personClass = Person.class;

        /*
        * 获取成员变量们
        * Field[] getField() 获取所有public修饰的成员变量
        * Field[] gerField(String name) 获取指定名称的public修饰的成员变量
        *
        * Field[] getDeclaredFields()
        * Field getDeclaredField(String name)
        *
        *
        * */
        // Field[] getField() 获取所有public修饰的成员变量
        Field[] fields = personClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }

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

        // Field[] gerField(String name) 获取指定名称的public修饰的成员变量
        Field a = personClass.getField("a");

        // 获取成员变量a的值
        Person p = new Person();
        Object value = a.get(p);
        System.out.println(value);

        // 设置a的值
        a.set(p, "张三");
        System.out.println(p);


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

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

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

    }
}

Constructor：构造方法
- 创建对象
  - T newInstance（Object...initargs）
  - 如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法
- 代码演示

/*
*       获取构造方法们
*           Constructor<?>[] getConstructors() 获取所有的构造方法
*           COnstructor<T> getConstructor(类 <?>... parameterTypes) 获取单个成员方法
*
*           Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
*           Constructor<?>[] getDeclaredConstructors()
*
* Constructor：构造方法
*   创建对象：
*       T newInstance(Object... initargs)
*       如果使用空参构造方法创建对象，操作可以简化：Class对象的newInstance方法
*/

import com.it.day14code.domain.Person;

import java.lang.reflect.Constructor;

public class ReflectDemo03 {
    public static void main(String[] args) throws Exception {
        // 获取Person的Class对象
        Class personClass = Person.class;

        // Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
        Constructor constructor = personClass.getConstructor(String.class, int.class);
        System.out.println(constructor);

        // 创建对象
        Object person = constructor.newInstance("张三", 2);
        System.out.println(person);

        System.out.println("=================================");
        // Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
        Constructor constructor1 = personClass.getConstructor();
        System.out.println(constructor1);

        // 创建对象
        Object person1 = constructor1.newInstance();
        System.out.println(person1);

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

Method：方法对象
- 执行方法：
  - Object invoke(Object obj, Object...args)
- 获取方法名称
  - String getName：获取方法名称
- 代码演示

/*
*       获取成员方法们
*           Method[] getMethods()
*           Method getMethod(String name, 类<?>... parameterTypes)
*
*           Method[] getDeclaredMethods()
*           Method getDeclaredMethod(String name, 类<?>... parameterTypes)
*
* Method:方法对象
*   执行方法：
*       Object incoke(Object obj, Object... args)
*   获取方法名称：
*       String getName：获取方法名
*
*
*/

import com.it.day14code.domain.Person;

import java.lang.reflect.Method;

public class ReflectDemo04 {
    public static void main(String[] args) throws Exception {
        // 获取Person的Class对象
        Class personClass = Person.class;

        // 获取指定名称的无参方法
        Method eat_method = personClass.getMethod("eat");
        Person p = new Person();

        // 执行方法
        eat_method.invoke(p);


        // 获取指定名称有参方法
        Method eat2 = personClass.getMethod("eat", String.class);
        // 执行方法
        eat2.invoke(p, "饭");

        System.out.println("=========================================");
        // 获取所有的public修饰的方法
        Method[] methods = personClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
            System.out.println(method.getName());
        }

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


    }
}

2.3.3 案例实现

*
* 框架类
* 可以执行创建任意类的对象，可以执行任意方法
*
* 实现：
*   配置文件
*   反射
*
* 步骤
*   1、将需要创建的对象和全类名和需要执行的方法定义在配置文件中
*   2、在程序中加载读取配置文件
*   3、使用反射技术来加载类文件进内存
*   4、创建对象
*   5、执行方法
* */

import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;

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

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

        // 加载该类进内存
        Class<?> cls = Class.forName(className);

        // 创建对象
        Object obj = cls.newInstance();

        // 获取方法对象
        Method method = cls.getMethod(methodName);

        // 执行方法
        method.invoke(obj);

    }
}

第三章注解

3.1 注解概述

注解：说明程序的，给计算机看
- JDK1.5之后的新特性
- 说明程序的
- 使用注解：@注解名称
作用：
- 编写文档：通过代码里标识注解生成文档【生成文档doc文档】
- 代码分析：通过代码里标识的注解对代码进行分析【使用反射】
- 编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查
JDK中定义的一些注解
- @Override：检测被该注解标注的方法是否是继承父类(接口)de
- @Deprecated：该注解标注的内容，表示已过时
- @suppressWarnings：压制警告
  - 一般传递all参数

3.2 自定义注解

格式

元注解
public @interface 注解名称 {
    属性列表;
}

注解的本质：接口中的抽象方法
要求
- 属性的返回值类型有下列取值
  - 基本数据类型
  - String
  - 枚举
  - 注解
  - 以上类型的数组
- 定义属性在使用的时候需要给属性赋值
  - 如果定义属性时，使用default关键字给属性默认初始化，则使用注解时，可以不进行属性赋值
  - 如果只有一个属性需要赋值，并且属性名称是value，则value可以省略，直接定义值即可
  - 数组赋值时，使用过{]包裹，如果数组中只有一个值，则{}可以省略
元注解：用于描述注解的注解
- @Target：描述注解能够作用的位置
  - ElementType取值：
    - TYPE：可以作用于类上
    - METHOD：可以作用域方法上
    - FIELD：可以作用于成员变量上
- @Retention(RetentionPolicy.RUNTIME)：当前被描述的注解，会保留到class字节码文件中，并被JVM读取到
- @Documented：描述注解是否被抽取到api文档中
- @Inherited：描述注解是否被子类继承
在程序使用注解：获取注解定义的属性值
- 获取注解定义的位置的对象(Class、Method、Field)
- 获取指定的注解
  - getAnnotation(Class)：本质就是在内存中生成了一个该注解接口的子类实现对象
- 调用注解中的抽象方法获取配置的属性值

3.3 案例：简单的测试框架

定义一个计算器类

/**
 * 定义的计算器类
 */
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...");
    }

}

定义一个检查注解

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

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

定义一个测试类

/*
* 简单的测试框架
*
* 当主方法执行后，会执行被检测的所有方法（加了check注解的方法）判断方法是否有异常，记录到文献中
*
* */

import com.it.day13code.MethodReference.ObjectMethodReference.MethodRerObject;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

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

        // 2、获取字节码文件对象
        Class cls = c.getClass();

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

        bw.write("本次测试一共出现" + num + "次异常");
        bw.flush();
        bw.close();

    }

}

哈哈哈捧场王

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java Day25

第一章 Junit单元测试1.1 测试的分类黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望值。白盒测试：需要写代码。关注程序的具体执行流程。1.2 Junit使用1.2.1 使用步骤定义一个测试类（测试用例）建议测试类名：被测试的类名Test 包名：xxx.xxx.xx.test 定义测试方法：可以独立运行建议方法名：test测试方法的名字返回值：void 参数列表：空参给方法添加@Test 倒入junit依
复制链接

扫一扫