java的单元测试和反射

单元测试

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

junit单元测试框架：
可以用来对方法进行测试

有点：

可以灵活的编写测试代码，可以针对某个方法进行测试，也支持一键完成对全部方法的自动发测试，且各自独立

步骤：

反射：
反射就是加载类，并允许以编程的方式解剖类中的各种成分

获取类class对象的三种方法：

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 constructor<?>[] getdeclaredconstructors()

public constructor<t> getconstructor(class<?>... parametertypes)

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)

 //获取对象
       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 field getfield(string name)

 public field[] getdeclaredfields()

public field getdeclaredfield(string name)

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)

 //赋值
        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()

public method getmethod(string name, class<?>... parametertypes)

public method[] getdeclaredmethods()

public method getdeclaredmethod(string name, class<?>... parametertypes)

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)

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

    }
}