JavaSE从头再来（四）
从头再来第四弹，主要是Junit单元测试和反射的内容
文章目录
一、Junit单元测试
case1 测试的分类
-
黑盒测试
不需要写代码，给输入值，看程序是否能够输出期望的值
-
白盒测试
需要写代码的。关注程序具体的执行流程
case2 传统测试方法
-
编写一个计算器类
//计算器类 public class Calculator { //加减 public int add(int a,int b){ return a+b; } public int sub(int a,int b){ return a-b; } } -
编写测试类
public class CalculatorTest { public static void main(String[] args) { //创建对象 Calculator c = new Calculator(); //调用方法 int add = c.add(1, 2); int sub = c.sub(1, 2); System.out.println(add); System.out.println(sub); } }
缺点：一个测试类只能运行一个测试，其他测试得注释掉避免干扰。
case3 Junit——白盒测试
-
步骤：
-
定义一个测试类(测试用例)
- 建议：
- 测试类名：被测试的类名Test CalculatorTest
- 包名：xxx.xxx.xx.test cn.itcast.test
- 测试类名：被测试的类名Test CalculatorTest
-
定义测试方法：可以独立运行
- 建议：
- 方法名：test测试的方法名 testAdd()
- 返回值：void
- 参数列表：空参
- 建议：
-
给方法加@Test
-
导入junit依赖环境
<dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test</scope> </dependency>
- 建议：
-
判定结果：
- 红色：失败
- 绿色：成功
- 一般我们会使用断言操作来处理结果
- Assert.assertEquals(期望的结果,运算的结果);
-
补充：
- @Before:
- 修饰的方法会在测试方法之前被自动执行
- 一般用于资源申请
- @After:
- 修饰的方法会在测试方法执行之后自动被执行
- 一般用于释放资源
- @Before:
-
实例代码：
public class CalculatorTest {
/*测试add方法*/
@Test
public void testAdd(){
System.out.println("开始测试");
Calculator c = new Calculator();
int result = c.add(1,2);
//断言 测试者断言这个程序是否成功
//期望值3，实际值result
Assert.assertEquals(3,result);
}
/*初始化方法*/
@Before
public void init(){
System.out.println("测试前调用");
}
@After
public void close(){
System.out.println("测试后调用");
}
}
二、反射
case1 概述
java代码的执行阶段
框架：半成品软件。可以在框架的基础上进行软件开发，简化编码
反射：将类的各个组成部分封装为其他对象，这就是反射机制
- 好处：
- 可以在程序运行过程中，操作这些对象。
- 可以解耦，提高程序的可扩展性。
case2 获取class对象的方式
获取Class对象的方式：
- Class.forName(“全类名”)：将字节码文件加载进内存，返回Class对象
- 多用于配置文件，将类名定义在配置文件中。读取文件，加载类
- 类名.class：通过类名的属性class获取
- 多用于参数的传递
- 对象.getClass()：getClass()方法在Object类中定义着。
- 多用于对象的获取字节码的方式
- 结论：
同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。
代码：
创建person对象
public class Person {
private String name;
private int age;
public String a;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person() {
}
public void eat(){
System.out.println("eat");
}
public void eat(String food){
System.out.println("eat "+food);
}
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 + '\'' +
'}';
}
测试获取class对象
public static void main(String[] args) throws ClassNotFoundException {
//1.Class.forName("全类名")
Class cls = Class.forName("domain.Person");
//2.类名.class
Class<Person> cls2 = Person.class;
//3.对象.getClass()
Person p = new Person();
Class cls3 = p.getClass();
//比较三个对象
System.out.println(cls == cls2);
System.out.println(cls == cls3); //都是true
//同一个字节码文件在一次程序运行中只会加载一次
}
case3 Class对象的常用功能
获取成员变量们
Field[] getFields()：获取所有public修饰的成员变量Field getField(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()
case4 获取成员变量field
Field：成员变量
-
操作：
-
设置值
void set(Object obj, Object value)
-
获取值
get(Object obj)
-
忽略访问权限修饰符的安全检查
setAccessible(true):暴力反射
-
-
代码
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException { //1.获取class对象 Class personClass = Person.class; //2.获取成员变量 Field[] fields = personClass.getFields(); //获取所有public修饰的变量 Field a = personClass.getField( "a"); //获取类里面的成员变量a //获取成员变量a的值 Person person = new Person(); Object o = a.get(person); System.out.println(o); //获取到a的值 现在是null a.set(person,"改了"); //更改person对象中a的值 System.out.println(person); //getDeclaredFields()获取所有的成员变量，不考虑修饰符 Field[] declaredFields = personClass.getDeclaredFields(); for (Field declaredField : declaredFields) { System.out.println(declaredField); } //试图访问private修饰的成员变量name Field nameField = personClass.getDeclaredField("name"); //忽略访问权限修饰符的安全检查 nameField.setAccessible(true); //暴力反射 Object o1 = nameField.get(person); System.out.println(o1); }
case5 获取构造方法 Constructor
-
Constructor:构造方法
- 创建对象：
T newInstance(Object... initargs)
- 创建对象：
-
如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法
-
代码
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { //1.创建class对象 Class<Person> personClass = Person.class; //2.获取构造方法 Constructor<Person> constructor = personClass.getConstructor(String.class, int.class); System.out.println(constructor);// public domain.Person(java.lang.String,int)s //3.使用构造器方法：创造对象 //使用带参构造方法对象 Person person = constructor.newInstance("张三", 18); System.out.println(person);// 张三 18 null //使用空参构造方法对象 Constructor<Person> constructor1 = personClass.getConstructor(); Person person1 = constructor1.newInstance(); System.out.println(person1);// null 0 null //4.直接使用class对象的空参构造方法 Person person2 = personClass.newInstance(); System.out.println(person2);// null 0 null }
case6 Method 方法对象
-
Method：方法对象
-
执行方法：
Object invoke(Object obj, Object... args)
-
获取方法名称：
String getName:获取方法名
-
-
代码
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException { //1.获取clss对象并创建person对象 Class<Person> personClass = Person.class; Person person = personClass.newInstance(); //获取类名 全类名 String personClassName = personClass.getName(); System.out.println(personClassName);//domain.Person //2.获取指定名称的方法对象 //2.1无参方法对象 getMethod("方法名") Method eat = personClass.getMethod("eat"); //2.2有参方法对象 getMethod("方法名"+类型.class) Method eat2 = personClass.getMethod("eat",String.class); //3.执行方法对象 invoke(obj,[args]) System.out.println("----------------------"); eat.invoke(person); //eat eat2.invoke(person,"cola"); //eat cola //4.获取方法名 System.out.println("----------------------"); String name = eat.getName(); System.out.println("method name = " + name); //5.获取所有public修饰的方法 System.out.println("----------------------"); Method[] methods = personClass.getMethods(); for (Method method : methods) { System.out.println(method); //会出来一堆 } /*会出来一些object的一些方法 例如 * public native int java.lang.Object.hashCode() * public boolean java.lang.Object.equals(java.lang.Object) * public final native void java.lang.Object.notify() * */ }
case7 案例
-
需求：写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法
-
实现：
- 配置文件
- 反射
-
步骤：
- 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
- 在程序中加载读取配置文件
- 使用反射技术来加载类文件进内存
- 创建对象
- 执行方法
-
代码
1 创建person类
2 创建properties配置文件
className=domain.Person methodName=eat3 创建框架类RelectTest
public class ReflectTest { public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException { //可以创建任意类的对象，可以执行任意方法 //1.加载配置文件 //1.1创建properties对象 Properties properties = new Properties(); //1.2加载配置文件，转换为集合 //1.2.1获取配置文件 ClassLoader classLoader = ReflectTest.class.getClassLoader(); InputStream rs = classLoader.getResourceAsStream("pro.properties"); properties.load(rs); //2.获取配置文件中定义的数据 String className = properties.getProperty("className"); String methodName = properties.getProperty("methodName"); //3.使用反射 加载该类进内存 Class cla = Class.forName(className); //4.创建对象 Object obj = cla.newInstance(); //5.获取方法 Method method = cla.getMethod(methodName); //6.执行方法 method.invoke(obj); //打印eat } }
扫一扫
522
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
