当前位置： 代码迷 >> 综合 >> Java Day25
  详细解决方案

Java Day25

热度：1   发布时间：2023-12-25 12:20:37.0

第一章 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 {/** 初始化方法：* 用于资源申请，所有测试方法在执行之前都会先执行该方法** */@Beforepublic void init() {System.out.println("init...");}/** 释放资源的方法：* 在所有测试方法执行完成后，都会自动执行该方法** */@Afterpublic void close() {System.out.println("close...");}/** 测试add方法** */@Testpublic void testAdd() {// System.out.println("我被执行了");// 1.创建计算器对象Calculator c = new Calculator();// 2、调用add方法int result = c.add(1, 3);// System.out.println(result);// 3、断言 我断言这个结果是3Assert.assertEquals(3,result);}@Testpublic void testSub() {// 1.创建计算器对象Calculator c = new Calculator();// 2、调用sub方法int result = c.sub(1, 1);System.out.println("testsub...");// 3、断言 我断言这个结果是0Assert.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;}@Overridepublic 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 {//加法@Checkpublic void add(){String str = null;str.toString();System.out.println("1 + 0 =" + (1 + 0));}//减法@Checkpublic void sub(){System.out.println("1 - 0 =" + (1 - 0));}//乘法@Checkpublic void mul(){System.out.println("1 * 0 =" + (1 * 0));}//除法@Checkpublic 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();}}

 

  相关解决方案

代码迷 - 您身边的软件异常，代码异常，编程异常助手（发现，解决，分享）
Copyright © 2009-2013 DAIMAMI.COM. All rights reserved.