Junit单元测试
测试分类
黑盒测试：黑盒测试又叫功能测试、数据驱动测试或给予需求规格说明书的功能测试。这种测试注重于测试软件的功能性需求。
白盒测试：白盒测试又称结构测试、逻辑驱动测试或基于程序代码内部结构的测试。此时，需要深入考察程序代码的内部结构、逻辑设计等等。白盒测试需要测试工程师具备很深的软件开发工地，精通相应的开发语言，一般的软件测试工程师难以胜任该工作。
Junit使用步骤 白盒
1、定义一个测试类（测试用例）
测试类名：被测试类名+Test
包名：xxx.xxx.xx.Test
2、定义测试方法：可以独立运行
方法名：test+测试方法名
返回值：void
参数列表：空参
3、给方法[email protected]
4、导入junit依赖
判定结果：红色代表失败，绿色代表成功
一般使用断言的操作来处理结果
计算器类
public class Calculator {
public int add(int a,int b){
//int i = 3/0;
return a - b;
}
public int sub(int a,int b){
return a - b;
}
}
测试类
import org.junit.Assert;
import org.junit.Test;
public class CalculatorTest {
/*
* 测试add方法
* */
@Test
public void testAdd(){
//1、创建计算器对象
Calculator c = new Calculator();
//2、调用add方法
int result = c.add(1,2);
//3、断言：断言这个结果是3
Assert.assertEquals(3,result);//期望值是3真实值是result
}
}
初始化方法 @Before
/*
* 初始化方法：
* 用于申请资源，所有测试方法在执行之前都会先执行该测试方法*/
@Before
public void init(){
System.out.println("init.....");
}
释放资源方法 @After
/*
* 释放资源方法：
* 在所有测试方法执行完后，都会自动执行该方法*/
@After
public void close(){
System.out.println("close.....");
}
反射
框架设计的灵魂
框架：半成品软件
可以在框架的基础上进行软件开发，简化编码
反射：将类的各个组成部分封装为其他对象，这就是反射机制。
好处：
1、在程序运行过程中，操作这些对象。
2、可以解耦，提高程序的可扩展性。
获取Class字节码对象的方式：
1、Class.forName(“全类名”)：将字节码文件加载进内存，返回Class对象，多用于配置文件，将类名定义在配置文件中，读取文件，加载类
2、类名.class:通过类名的属性class获取
多用于参数的传递
3、对象.getClass（）：getClass（）方法在Object类中定义，所有对象都有这种方法
多用于对象的获取字节码的方式
public class ReflectDemo01 {
public static void main(String[] args) throws Exception {
//1、Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
Class cls1 = Class.forName("cn.day18.domain.Person");
System.out.println(cls1);
//2、类名.class:通过类名的属性class获取
Class<Person> cls2 = Person.class;
System.out.println(cls2);
//3、对象.getClass（）：getClass（）方法在Object类中定义，所有对象都有这种方法
Person p = new Person();
Class<? extends Person> cls3 = p.getClass();
System.out.println(cls3);
//用==比较三个对象
System.out.println(cls1==cls2);//true
System.out.println(cls1==cls3);//true
System.out.println(cls2==cls3);//true
}
}
结论：同一个字节码文件（*.class）在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获得class对象都是同一个。
Class功能
获取功能
获取成员变量们
Field[] getFields() 获取所有public修饰的成员变量
Field getField(string name) 获取指定名称的public修饰的成员变量
Field[] getDeclaredFields() 获取所有的成员变量，不考虑访问权限修饰符
Field getDeclaredField(string name) 获取指定名称的成员变量
public static void main(String[] args) throws Exception {
//0、获取Person的class对象
Class personClass = Person.class;
//1、获取成员变量们
//Field[] getFields() 获取所有public修饰的成员变量
Field[] fields = personClass.getFields();
for (Field field : fields) {
System.out.println(field);//public java.lang.String cn.day18.domain.Person.a
}
//Field getField(string name) 获取指定名称的public修饰的成员变量
Field a = personClass.getField("a");
System.out.println(a);//public java.lang.String cn.day18.domain.Person.a
//获取到成员变量可以设置值void set(Object obj,Object value)，获取值get(Object obj)
//获取成员变量a的值
Person p = new Person();
Object value = a.get(p);
System.out.println(value);//null
//设置a的值
a.set(p,"张三");
System.out.println(p);//Person{name='null', age=0, a='张三', b='null', c='null', d='null'}
//Field[] getDeclaredFields()获取所有的成员变量，不考虑访问权限修饰符
Field[] declaredFields = personClass.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println(declaredField);//获取所有的成员变量
//private java.lang.String cn.day18.domain.Person.name
//private int cn.day18.domain.Person.age
//public java.lang.String cn.day18.domain.Person.a
//protected java.lang.String cn.day18.domain.Person.b
//java.lang.String cn.day18.domain.Person.c
//private java.lang.String cn.day18.domain.Person.d
}
//Field getDeclaredField(string name) 获取指定名称的成员变量
Field d = personClass.getDeclaredField("d");
//在访问有访问权限修饰符时，忽略访问权限的安全检查
d.setAccessible(true);//暴力反射
Object value1 = d.get(p);
System.out.println(value1);//null
d.set(p,"李四");
System.out.println(p);//Person{name='null', age=0, a='张三', b='null', c='null', d='李四'}
}
}
获取构造方法们
Constructor<?>[]getConstructors()
constructor getConstructor(类<?>… parameterTypes)
constructor getDeclaredConstructor(类<?>… parameterTypes)
Constructor<?>[] getDeclaredConstructors()
public class ReflectDemo03 {
public static void main(String[] args) throws Exception {
//0、获取Person的class对象
Class personClass = Person.class;
//constructor<T> getConstructor(类<?>... parameterTypes)
Constructor constructor = personClass.getConstructor(String.class, int.class);
System.out.println(constructor);//public cn.day18.domain.Person(java.lang.String,int)
//创建对象newInstance
Object o = constructor.newInstance("张三", 23);
System.out.println(o);//Person{name='张三', age=23, a='null', b='null', c='null', d='null'}
//使用空参构造器
Constructor constructor1 = personClass.getConstructor();
System.out.println(constructor1);//public cn.day18.domain.Person(java.lang.String,int)
//创建对象newInstance
Object o1 = constructor1.newInstance();
System.out.println(o1);//Person{name='null', age=0, a='null', b='null', c='null', d='null'}
//如果使用空参构造方法创建对象，操作是可以简化的
Object o2 = personClass.newInstance();
System.out.println(o2);//Person{name='null', age=0, a='null', b='null', c='null', d='null'}
}
}
获取成员方法们
Method[] getMethods()
Method getMethod(string name,类<?>… parameterTypes)
Method[] getDeclaredMethods()
Method getDeclaredMethod(String name，类<?>… parameterTypes)
public class ReflectDemo04 {
public static void main(String[] args) throws Exception {
//0、获取Person的class对象
Class personClass = Person.class;
//获取指定名称的方法
Method eat = personClass.getMethod("eat");
Person p = new Person();
//执行方法，Object invoke(Object obj,Object... args)
//因为对象p没有参数对象，所以实参对象传递p就行
eat.invoke(p);//eat...
//获取指定带有参数的方法
Method eat1 = personClass.getMethod("eat", String.class);
//执行方法
eat1.invoke(p,"馒头");//eat...馒头
//Method[] getMethods() 获取所有public修饰的方法
Method[] methods = personClass.getMethods();
for (Method method : methods) {
System.out.println(method);
String name = method.getName();
//获取方法名：String getName
System.out.println(name);
//public java.lang.String cn.day18.domain.Person.getName()
//getName
//public java.lang.String cn.day18.domain.Person.toString()
//toString
//public void cn.day18.domain.Person.setName(java.lang.String)
//setName
//public void cn.itcast.day18.domain.Person.eat()
//eat
//public void cn.day18.domain.Person.eat(java.lang.String)
//eat
//public int cn.day18.domain.Person.getAge()
//getAge
//public void cn.day18.domain.Person.setAge(int)
//setAge
//public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
//wait
//public final void java.lang.Object.wait() throws java.lang.InterruptedException
//wait
//public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
//wait
//public boolean java.lang.Object.equals(java.lang.Object)
//equals
//public native int java.lang.Object.hashCode()
//hashCode
//public final native java.lang.Class java.lang.Object.getClass()
//getClass
//public final native void java.lang.Object.notify()
//notify
//public final native void java.lang.Object.notifyAll()
//notifyAll
}
}
获取类名
String getName()
//获取类名
String name = personClass.getName();
System.out.println(name);//cn.day18.domain.Person
案例
需求：写一个类“框架”,可以帮我们创建任意类的对象，并且执行其中的任意方法
我们之前使用的创建类，创建对象方法的弊端是：既然创建的类是一个框架，即为一个半成品，不允许修改的，所以不能改变该类任何代码，可以执行创建任意类的对象，可以执行任意方法。所以我们就需要使用反射完成这样的需求
框架类
实现：配置文件、反射
步骤：1、将需要创建的对象的全类名和需要执行的方法定义在配置文件中
2、在程序中加载读取配置文件，使用反射技术来加载类文件进内存
3、创建对象
4、执行方法
定义类
package cn.day18.domain;
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);
}
}
配置文件
className = cn.day18.domain.Person
methodName = eat
测试类
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.getDeclaredConstructor().newInstance();
//5、获取方法对象
Method method = cls.getMethod(methodName);
//6、执行方法
method.invoke(obj);
}
}
注解
概念：说明程序的，给计算机看的
注释：用文字表述程序。给程序员看的
注解（Annotation）,也叫元数据，一种代码级别的说明，他是JDK1.5及以后版本引入的一个特性，与类、接口、枚举、是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。
作用：
1、编写文档：通过代码里标识的注解生成文档【生成文档doc】
2、代码分析：通过代码里标识的注解对代码进行分析【使用反射】
3、编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【Override】
JDK中预定义的一些注解
@Override：检测被该注解标注的方法是否是继承自父类（接口）的
@Deprecated：将该注解标注的内容以过时
@SuppressWarnings：压制警告
public class AnnoDemo2 {
@Override
public String toString() {
return super.toString();
}
@Deprecated
public void show1(){
//有缺陷
}
@SuppressWarnings("all")
public void show2(){
//替代show2方法
}
public void demo(){
show1();
}
}
自定义注解
格式：元注解 public @interface MyAnno {}
本质：注解本质上就是一个接口，该接口默认继承Annotation接口
public interface MyAnno extends iava.lang.annotation.Annotation{}
属性：接口中的抽象方法
1、属性的返回值类型：基本数据类型，String，枚举，注解，以上类型的注解
2、定义了属性，在使用时需要给属性赋值。如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时可以不进行属性赋值；如果只有一个属性需要赋值，并且属性的名称时value，则value可以省略，直接定义值即可。
3、数组赋值需要使用{}包裹值，如果只有一个值，则大括号可以省略
![Java小案例——随机数猜测随机数猜测[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)