单元测试
就是针对最小的功能单元，编写测试代码对其进行正确性测试
Junit单元测试框架：
可以用来对方法进行测试
有点：
可以灵活的编写测试代码，可以针对某个方法进行测试，也支持一键完成对全部方法的自动发测试，且各自独立
步骤：
- 测试的方法必须是 公共，无参，无返回值
- 测试方法必须声明@Test注解
反射：
反射就是加载类，并允许以编程的方式解剖类中的各种成分
- 反射第一步：加载类，获取类的字节码：Class对象
- 反射第二步：获取类的构造器：Constructor对象
- 反射第三步：获取类的成员变量：Field对象
- 反射第四步：获取类的成员方法：Method对象
获取类Class对象的三种方法：
- Class c1=类名.class
- 调用Class提供的方法：public static Class forName(String package);
- Object提供的方法：public Class getClass():class c3=对象.getClass();
class Student
{
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
};
public class test1 {
public static void main(String[] args) throws Exception{
Student s=new Student();
Class c1=s.getClass();
System.out.println(c1.getName());//com.he.reflect.Student
System.out.println(c1.getSimpleName());//Student,获取类名
Class c2=Class.forName("com.he.reflect.Student");//跟c1是同一个对象
System.out.println(c1==c2);//地址一样
System.out.println(c2.getName());
Class c3= Student.class;
System.out.println(c1==c3);//true
}
}
获取类的构造器
Class类
public Constructor<?>[] getConstructors()
获取全部构造器（只能获取public修饰的）
public Constructor<?>[] getDeclaredConstructors()
获取全部构造器（包括私有）
public Constructor<T> getConstructor(Class<?>... parameterTypes)
获取某个构造器（只能获取public修饰的） ，参数是构造器里面的类型
public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
获取某个构造器（包括私有）
public class Dog {
private String name;
private int age;
public Dog() {
}
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
private Dog(String name)
{
this.name=name;
}
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;
}
}
public class test2 {
public static void main(String[] args) throws NoSuchMethodException {
//1:反射第一步，获取类的Class对象
Class c=Dog.class;
//2:获取类的全部构造器,构造器对象
Constructor[] constructors = c.getConstructors();//只能获取public修饰的
//3:遍历数组中的每个元素
for(Constructor constructor:constructors)
{
System.out.println(constructor.getName()+"-->"+constructor.getParameterCount());
/*com.he.reflect.Dog-->0
com.he.reflect.Dog-->2*/
}
Constructor[] declaredConstructors = c.getDeclaredConstructors();//可以获取私有的构造器
for (Constructor declaredConstructor : declaredConstructors) {
System.out.println(declaredConstructor.getName()+"-->"+declaredConstructor.getParameterCount());
/* com.he.reflect.Dog-->0
com.he.reflect.Dog-->2
com.he.reflect.Dog-->1*/
}
//4：获取某个构造器
Constructor constructor = c.getConstructor();//获取无参构造器
System.out.println(constructor.getName()+"-->"+constructor.getParameterCount());//com.he.reflect.Dog-->0
Constructor declaredConstructor = c.getDeclaredConstructor(String.class, int.class);
//获取有（string int）类型的构造器
System.out.println(declaredConstructor.getName()+"-->"+declaredConstructor.getParameterCount());
//com.he.reflect.Dog-->2
}
}
获取构造器的作用：初始化对象
Constructor类：
public T newInstance(Object... initargs)
调用此构造器对象表示的构造器，并传入参数，完成对对象的初始化并返回
public void setAccessible(boolean flag)
设置为true，表示禁止检查访问控制，可以访问私有的构造器
//获取对象
Dog dog1 = (Dog)constructor.newInstance();//获取无参构造器的对象
System.out.println(dog1);//Dog{name='null', age=0}
Constructor Dcon = c.getDeclaredConstructor(String.class);//获取私有的有参构造器
Dcon.setAccessible(true);//因为此构造器是私有的，所以设置为禁止检查访问控制
Dog dog2= (Dog) Dcon.newInstance("hhh");//创建一个name=hhh的对象
//Dog{name='null', age=0}获取类的成员变量：
Class类的方法：
public Field[] getFields()
获取类的全部变量（只能是public修饰的）
public Field getField(String name)
获取类的某个变量（只能是public修饰的）
public Field[] getDeclaredFields()
获取类的全部变量（包括private）
public Field getDeclaredField(String name)
获取类的某个变量 （包括private）
public class test3 {
public static void main(String[] args) throws Exception{
//反射第一步，获取类
Class c=Dog.class;
//获取成员变量,只能获得public修饰的
Field[] fields = c.getFields();
//获取成员变量，包括private
Field[] declaredFields = c.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println(declaredField.getName()+"-->"+declaredField.getType());
// name-->class java.lang.String
// age-->int
}
//获取某个成员变量
Field name = c.getDeclaredField("name");//因为是private修饰的，需要在前面加上
System.out.println(name.getName()+"-->"+name.getType());
//name-->class java.lang.String
}
}
获取成员变量的作用：赋值取值
Field类:
public void set(Object obj, Object value)
赋值
public Object get(Object obj)
取值
public void setAccessible(boolean flag)
设置为true，表示禁止检查访问控制，可以访问私有的成员变量
//赋值
Dog d=new Dog();
name.setAccessible(true);
name.set(d,"aaa");//把Dog类型对象d的成员变量name设置为aaa,因为是private修饰的，需要在前面加上
//取值
System.out.println(name.get(d));//aaa获取类的成员方法
Class类：
public Method[] getMethods()
获取类的全部成员方法（只能是publici修饰的）
public Method getMethod(String name, Class<?>... parameterTypes)
获取某个方法(只能是pubilc修饰的)，name是成员方法的名字，第二个参数是方法里面参数的类型，没有参数就不写
public Method[] getDeclaredMethods()
获取类的全部成员方法（包括private）
public Method getDeclaredMethod(String name, Class<?>... parameterTypes)
获取某个方法(包括private)
public class test4 {
public static void main(String[] args) throws Exception{
//反射第一步，获取类
Class c=Dog.class;
//获取方法
Method[] methods = c.getMethods();//只有public修饰的方法
for (Method method : methods) {
System.out.println(method.getName()+"-->"+method.getParameterCount()+"-->"+method.getReturnType());
}
//获取某个方法
Method eat = c.getDeclaredMethod("eat");//private修饰的
System.out.println(eat.getName()+"-->"+eat.getParameterCount()+"-->"+eat.getReturnType());
//eat-->0-->void
}
}获取成员方法的作用：依然是执行
Method类：
public Object invoke(Object obj, Object... args)
触发某个对象的该方法执行 ，第一个参数是对象，第二个可变参数是传给方法的参数
public void setAccessible(boolean flag)
设置为true，表示禁止检查访问控制，可以访问私有的成员方法
Dog d=new Dog();
eat.setAccessible(true);//禁止检查访问权限
eat.invoke(d);//eat方法是private修饰的
//dog is eating例子：对于任意一个对象，把该对象的所有成员变量的名字和对应的值写到文件中
public class test5 {
public static void main(String[] args) throws Exception{
Dog dog=new Dog("hhh",18);
//反射第一步，获取Class
Class c= dog.getClass();
//获取全部成员变量
Field[] declaredFields = c.getDeclaredFields();
try(
OutputStream out=new FileOutputStream("day19-juint-app\\src\\test1.txt");
//包装
PrintStream Pout=new PrintStream(out);
)
{
Pout.println("----"+c.getSimpleName()+"-----");
for (Field declaredField : declaredFields) {
String name=(String)declaredField.getName();//获取变量的名字
declaredField.setAccessible(true);//因为访问的是私有成员
String s= declaredField.get(dog)+"";//获取变量的内容
Pout.println(name+"的内容是"+s);
}
}catch (Exception e)
{
e.printStackTrace();
}
}
}
