Java基础拓展

Junit单元测试
白盒测试：关注代码执行过程
Junit使用：白盒测试
步骤：
1.定义一个测试类（测试用例）
*建议：
测试类名：被测试的类名Test CalculatorTest
包名：xxx.xxx.xxx.test
2.定义测试方法：可以独立运行
*建议：
方法名：test测试的方法名 testAdd()
返回值：void
参数列表：空参
3.给方法加@Test注解
4.导入Junit依赖环境

判定结果：
红色：表示失败
绿色：表示成功
一般使用断言处理操作结果
Assert.assert(期望结果，程序结果)

package cn.itcast.junit;

public class Calculate {

    public int add(int a,int b)
    {
        return a+b;
    }

    public int sunb(int a,int b)
    {
        return a-b;
    }
}


package cn.Test.Junit.itcast;

import cn.itcast.junit.Calculate;
import org.junit.Assert;
import org.junit.Test;

public class CalculateTest {

    /**
     * 添加测试方法
     */
    @Test
    public void testAdd()
    {
        Calculate cal=new Calculate();

        int result=cal.add(1,2);

        //设置断言
        Assert.assertEquals(3,result);
    }
}

反射：框架设计灵魂
框架：半成品软件。在框架基础上进行软件开发，简化编码
概念：将类的各个组成部分封装为其他对象,这就是反射机制
创建对象.java文件；

1. 编译成类.class文件（源代码阶段）仍然存储在硬盘上
   .class文件存储：1.成员变量；2.构造方法；3.成员方法以及类名等其他信息

2. 使用类加载器加载.class自解码文件；class类对象（成员变量封装为Filed[]对象，构造方法封装为Constructor[]对象，成员方法封装为Method[]对象）

3. 运行时阶段，使用new方法，将类对象在内存中创建

好处：
1.在程序运行过程中，操纵这些对象
2.可以解耦，提高程序扩展性

获取Class对象的方式：
1.Class.forName(“全类名”):将字节码文件加载进内存，返回Class对象
*多用于配置文件，将类名定义在配置文件中。读取文件，加载类
2.类名.class：通过类名属性class获取
*多用于参数传递
3.对象.getClass():在Object类中定义着
*多用于对象的获取字节码方式

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * Class对象功能
 *      获取功能：
 *          1.获取成员变量
 *          Field[] getFields()
 *          Field[] getField(String name)
 *          Field[] getDeclaredFields()
 *          Field[] getDeclaredField(String name)
 */

public class ReflectDemo2 {
    public static void main(String[] args) throws Exception{

        show03();

    }

    private static void show01()throws Exception
    {
        Class person=Person.class;//获取Person的Class对象

        /**
         * 获取成员变量
         */

        //Field[] getFields()获取所有public修饰的成员变量
        Field[] fields=person.getFields();
        for(Field field:fields)
        {
            System.out.println(field);
        }
        //Field getField(String name),只能获取public修饰成员变量
        Field d=person.getField("d");

        //获取成员变量a的值
        Person per=new Person();
        Object value=d.get(per);
        System.out.println(value);

        //设置d的值
        d.set(per,"zhangmin");

        System.out.println("***************");

        //Field[] getDeclaredFields():获取所有的成员变量，不考虑修饰符

        Field[] declaredFields=person.getDeclaredFields();
        for(Field declaredField:declaredFields)
        {
            System.out.println(declaredField);
        }

        //Field getDeclaredField(String name)
        Field declared=person.getDeclaredField("a");
        //忽略权限修饰符的安全检查
        declared.setAccessible(true);//暴力反射

        Object vlaue2=declared.get(per);
        System.out.println(vlaue2);
    }

    private static void show02()throws Exception
    {
        Class personClass=Person.class;

        /**
         * 获取构造方法
         */
        Constructor constructor=personClass.getConstructor(String.class,int.class);
        System.out.println(constructor);

        //使用构造器创建对象
        Object person=constructor.newInstance("Kobe",38);
        System.out.println(person);

        System.out.println("*************");
        //使用空参创建对象，可以使用Class类中默认的newInstance方法
        Object person1=personClass.newInstance();
        System.out.println(person1);
    }


    private static void show03()throws Exception
    {
        //获取成员方法
        Class personClass=Person.class;

        //获取成员方法，需指定成员方法名以及参数列表
        Method eatMethod=personClass.getMethod("eat",String.class);

        Method eatMethod01=personClass.getMethod("eat");


        //执行方法，需要实例化对象
        Person person=new Person();
        eatMethod.invoke(person,"banana");

        eatMethod01.invoke(person);

        Method[] methods=personClass.getMethods();
        //遍历成员方法列表，会得到Object类的成员方法（继承关系）
        for(Method method:methods)
        {
            System.out.println(method);
        }
    }
}