java的单元测试和反射

单元测试

就是针对最小的功能单元，编写测试代码对其进行正确性测试

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();
        }

    }
}