Day29-C:\Users\Lenovo\Desktop\note\code\JavaSE\Basic\src\com\reflect

单元测试

Junit单元测试框架

package Basic.src.com.Junit;

public class StringUtil {
    public static void printNumber(String name) {
        if (name == null) {
            System.out.println(0);
            return;//停掉方法
        }
        System.out.println("名字的长度是："+name.length());
    }
    /**
     * 求字符串最大索引
     */
    public static int getMaxIndex(String data){
        if(data==null||data.length()==0){
            return -1;
        }
        return data.length()-1;
    }
}

package Basic.src.com.Junit;

import org.junit.Assert;
import org.junit.Test;

/**
 * 测试类
 */
public class StringUtilTest {
    @Test //测试方法，要先导入框架才不会报错
    public void testPrintNumber(){//测试方法一定是公开无返回值无参数
        StringUtil.printNumber("admin");
        StringUtil.printNumber(null);
    }
    @Test
    public void testGetMaxIndex(){
        int index1 = StringUtil.getMaxIndex(null);
        System.out.println(index1);

        int index2 = StringUtil.getMaxIndex("admin");
        System.out.println(index2);

        //断言机制：程序员可以通过预测业务方法的结果
        Assert.assertEquals("wrong",4,index2);
    }
}

package Basic.src.com.Junit;

import org.junit.*;

import java.net.Socket;

/**
 * 测试类
 */
public class StringUtilTest {
    //private Socket socket;
    private static Socket socket;

    @BeforeClass//初始化资源
    public static void setUpBeforeClass() throws Exception {
        System.out.println("---------setUpBeforeClass 执行了----------------");
        socket = new Socket("127.0.0.1", 9999);
    }

    @AfterClass//释放资源
    public static void tearDownAfterClass() throws Exception {
        System.out.println("---------tearDownAfterClass 执行了----------------");
        socket.close();
    }

    @Before//可以用来写环境准备的代码
    public void test1(){
        System.out.println("------->test1 before 执行了---------------");
        //socket = new Socket();//连接
    }

    @After
    public void test2(){
        System.out.println("------->test2 before 执行了---------------");
        //socket.close();
    }

    @Test //测试方法，要先导入框架才不会报错
    public void testPrintNumber(){//测试方法一定是公开无返回值无参数
        StringUtil.printNumber("admin");
        StringUtil.printNumber(null);
    }
    @Test
    public void testGetMaxIndex(){
        int index1 = StringUtil.getMaxIndex(null);
        System.out.println(index1);

        int index2 = StringUtil.getMaxIndex("admin");
        System.out.println(index2);

        //断言机制：程序员可以通过预测业务方法的结果
        Assert.assertEquals("wrong",4,index2);
    }
}

反射

package Basic.src.com.reflect;

public class Test1Class {
    public static void main(String[] args) throws Exception {
        Class<Student> c1 = Student.class;
        System.out.println(c1.getName());//全类名
        System.out.println(c1.getSimpleName());//简名 Student

        //Class.forName(c1.getName());
        Class<?> c2 = Class.forName("Basic.src.com.reflect.Student");
        System.out.println(c1 == c2);

        Student s = new Student();
        Class<? extends Student> c3 = s.getClass();
        System.out.println(c2 == c3);

    }
}

package Basic.src.com.reflect;

import org.junit.Test;

import java.lang.reflect.Constructor;

public class Test2Constructor {
    @Test
    public void testGetConstructors(){
        //1.反射第一步，必须要先得到这个类的Class对象
        Class<Cat> c = Cat.class;

        //2.获取类的全部构造器
        //Constructor<?>[] constructors = c.getConstructors();//只能拿到被public修饰的构造器
        Constructor<?>[] declaredConstructors = c.getDeclaredConstructors();//获取全部构造器

        //3.遍历确认
        for (Constructor<?> declaredconstructor : declaredConstructors) {
            System.out.println(declaredconstructor.getName()+"----------"
            +declaredconstructor.getParameterCount());
            //Basic.src.com.reflect.Cat----------0无参
            //Basic.src.com.reflect.Cat----------2
        }
        Student student = new Student();
    }
    @Test
    public void testGetConstructor() throws Exception {
        //1.反射第一步，必须要先得到这个类的Class对象
        Class<Cat> c = Cat.class;

        //2.获取某一个构造器（这里是无参构造器）
        //Constructor<Cat> constructor = c.getConstructor();//只能拿public修饰的
        Constructor<Cat> constructor = c.getDeclaredConstructor();//都能拿

        //3.获取有参构造器
        Constructor<Cat> declaredConstructor = c.getDeclaredConstructor(String.class, int.class);//要写上.class，私有的也可以拿到
        System.out.println(declaredConstructor.getName()+"----------"+declaredConstructor.getParameterCount());
    }
}

package Basic.src.com.reflect;

import org.junit.Test;

import java.lang.reflect.Constructor;

public class Test2Constructor {
    @Test
    public void testGetConstructors(){
        //1.反射第一步，必须要先得到这个类的Class对象
        Class<Cat> c = Cat.class;

        //2.获取类的全部构造器
        //Constructor<?>[] constructors = c.getConstructors();//只能拿到被public修饰的构造器
        Constructor<?>[] declaredConstructors = c.getDeclaredConstructors();//获取全部构造器

        //3.遍历确认
        for (Constructor<?> declaredconstructor : declaredConstructors) {
            System.out.println(declaredconstructor.getName()+"----------"
            +declaredconstructor.getParameterCount());
            //Basic.src.com.reflect.Cat----------0无参
            //Basic.src.com.reflect.Cat----------2
        }
        Student student = new Student();
    }
    @Test
    public void testGetConstructor() throws Exception {
        //1.反射第一步，必须要先得到这个类的Class对象
        Class<Cat> c = Cat.class;

        //2.获取某一个构造器（这里是无参构造器）
        //Constructor<Cat> constructor = c.getConstructor();//只能拿public修饰的
        Constructor<Cat> constructor1 = c.getDeclaredConstructor();//都能拿，<cat>声明一个泛型
        constructor1.setAccessible(true);//禁止检查访问权限
        Cat cat = constructor1.newInstance();//完成对象初始化：有声明之后newInstance()的返回值才可以拿cat类去接收，否则得强转
        System.out.println(cat);


        //3.获取有参构造器
        Constructor<Cat> constructor2 = c.getDeclaredConstructor(String.class, int.class);//要写上.class，私有的也可以拿到
        System.out.println(constructor2.getName()+"----------"+constructor2.getParameterCount());
        constructor2.setAccessible(true);
        Cat cat2 = constructor2.newInstance("哈基滨", 3);
        System.out.println(cat2);
    }
}

package Basic.src.com.reflect;

import org.junit.Test;

import java.lang.reflect.Field;

public class Test3Field {
    @Test
    public void testGetFields() throws Exception {
        //1.反射第一步，必须是得到类的Class对象
        Class<Cat> c = Cat.class;
        //2.获取类的全部成员变量
        Field[] fields = c.getDeclaredFields();
        //3.遍历这个成员变量
        for (Field field : fields) {
            System.out.println(field.getName()+"----------"+field.getType());
        }
        //4.定位某个成员变量
        Field fName = c.getDeclaredField("name");
        System.out.println(fName.getName()+"----------"+fName.getType());

        Field fAge = c.getDeclaredField("age");
        System.out.println(fAge.getName()+"----------"+fAge.getType());

        //赋值
        fName.setAccessible(true);
        fAge.setAccessible(true);
        Cat cat1 = new Cat();//public Cat()
        Cat cat2 = new Cat();
        fName.set(cat1,"咖啡猫");
        System.out.println(cat1);

        //取值
        String name = (String)fName.get(cat2);
        System.out.println(name);
    };
}