Java单元测试、反射、注解
单元测试
Junit
public class UserService { public String login(String loginName, String password) { if ("admin".equals(loginName) && "123456".equals(password)) { return "success"; } return "用户名或密码错误"; } } public class UserServiceTest { /** * 测试方法要求： * 1.必须public修饰 * 2.没有返回值没有参数 * 3.必须使注解@Test修饰 */ @Test public void testLogin() { UserService userService = new UserService(); String rs = userService.login("admin", "123456"); // 断言预期结果的正确性 /** * 参数一：测试失败的提示信息 * 参数二：期望值 * 参数三：实际值 */ Assert.assertEquals("登录业务功能方法有误", "success", rs); } }
Junit常用注解
如Junit4，如5个注解都有，则执行顺序为@BeforeClass、@Before、@Test、@After、@AfterClass
反射
反射获取类对象
public class ReflectDemo01 { public static void main(String[] args) throws ClassNotFoundException { // 反射的第一步永远是先得到类的Class文件对象：字节码文件 // 1.类名.class Class c1 = Student.class; System.out.println(c1); // 2.对象.getClass() Student swk = new Student(); Class c2 = swk.getClass(); System.out.println(c2); // 3.Class.forName("类的全限名") Class c3 = Class.forName("Student"); System.out.println(c3); } }
反射获取构造器对象
public class ReflectDemo01 { public static void main(String[] args) throws ClassNotFoundException { // 反射的第一步永远是先得到类的Class文件对象：字节码文件 // 1.类名.class Class c1 = Student.class; System.out.println(c1); // 2.对象.getClass() Student swk = new Student(); Class c2 = swk.getClass(); System.out.println(c2); // 3.Class.forName("类的全限名") Class c3 = Class.forName("Student"); System.out.println(c3); } @Test public void getConstructors() { // 1.反射第一步得到Class类对象 Class c = Student.class; // 2.定位全部构造器，只能拿public修饰 Constructor[] cons = c.getConstructors(); // 3.遍历构造器 for (Constructor con: cons) { System.out.println(con.getName() + "===>" + con.getParameterCount()); } } @Test public void getDeclaredConstructors() { // 1.反射第一步得到Class类对象 Class c = Student.class; // 2.定位全部构造器，只要申明了就可以拿到 Constructor[] cons = c.getDeclaredConstructors(); // 3.遍历构造器 for (Constructor con: cons) { System.out.println(con.getName() + "===>" + con.getParameterCount()); } } @Test public void getDeclaredConstructor() throws NoSuchMethodException { // 1.反射第一步得到Class类对象 Class c = Student.class; // 2.定位全部构造器，只要申明了就可以拿到 // Constructor con = c.getDeclaredConstructor(); Constructor con = c.getDeclaredConstructor(String.class, int.class); // 3.遍历构造器 System.out.println(con.getName() + "===>" + con.getParameterCount()); } } public class Student { private String name; private int age; public Student() { } private Student(String name, int age) { this.name = name; this.age = age; } 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; } }
反射获取构造器然后通过构造器初始化对象
// 调用无参构造器得到一个类的对象返回 @Test public void createObj01() throws Exception { // a.反射第一步是先得到Class类对象 Class c = Student.class; // b.定位无参数构造器对象 Constructor constructor = c.getDeclaredConstructor(); // c.通过无参数构造器初始化对象返回 constructor.setAccessible(true); // d.通过无参数构造器初始化对象返回 Student swk = (Student) constructor.newInstance(); System.out.println(swk); } // 调用有参构造器得到一个类的对象返回 @Test public void createObj02() throws Exception { // a.反射第一步是先得到Class类对象 Class c = Student.class; // b.定位无参数构造器对象 Constructor constructor = c.getDeclaredConstructor(String.class, int.class); // c.通过有参数构造器初始化对象返回 Student swk = (Student) constructor.newInstance("测试", 100); System.out.println(swk); }
反射获取Field成员变量对象及赋值
/** * 获取全部的成员变量 * @throws Exception */ @Test public void createObj03() throws Exception { // a.反射第一步是先得到Class类对象 Class c = Dog.class; // b.获取全部申明的成员变量对象 Field[] fields = c.getDeclaredFields(); for (Field field: fields) { System.out.println(field.getName()+""); } Field nameF = c.getDeclaredField("name"); // c. 为这个成员变量赋值 Dog taidi = new Dog(); /** * 参数一：被赋值的对象 * 参数二：该成员变量的值 */ nameF.setAccessible(true); nameF.set(taidi, "勇敢的泰迪"); System.out.println(taidi); String value = nameF.get(taidi) + ""; System.out.println(value); }
反射获取Method方法对象
/** * 获取所有方法对象 */ @Test public void getDeclaredMethods() { Class d = Dog.class; Method[] methods = d.getDeclaredMethods(); for (Method method: methods) { System.out.println(method.getName() + "====>" + method.getParameterCount() + "===>" + method.getReturnType()); } } /** * 获取某个方法对象 */ @Test public void getDeclardMethod() throws Exception { // 1.先获取class类对象 Class c = Dog.class; // 2.定位它的某个方法 Method run = c.getDeclaredMethod("run"); // 3.触发方法执行 Dog jinmao = new Dog(); run.invoke(jinmao); // 触发jinMao对象的run()方法执行 /** * 参数一：方法名称 * 参数二：方法的参数个数和类型（可变参数） */ Method eat = c.getDeclaredMethod("eat", String.class); eat.setAccessible(true); /** * 参数一：被触发方法所在的对象 * 参数二：方法需要的入参值 */ eat.invoke(jinmao, "肉"); System.out.println(); } public class Dog { private void eat() { System.out.println("狗吃骨头"); } private void eat(String name) { System.out.println("狗吃" + name); } public void run() { System.out.println("狗在跑"); } }
反射破坏类的封装性与泛型的约束性
@Test public void getDeclardMethod1() throws Exception { // 泛型只能工作在编译阶段，运行阶段泛型就消失了 // 反射工作在运行阶段 List<Double> scores = new ArrayList<>(); scores.add(24.1); scores.add(123.4); // 拓展：通过反射暴力注入一个其它类型数据 Class c = scores.getClass(); // 从ArrayList的class对象中定位add方法 Method add = c.getDeclaredMethod("add", Object.class); // 出发scores集合对象中的add执行（运行阶段，泛型不能约束了） add.invoke(scores, "波仔"); System.out.println(scores); }
反射的作用
public static void main(String[] args) throws ClassNotFoundException { Dog dog = new Dog("haha", 15, "红"); MyBatis.save(dog); } public class Dog { private String name; private int age; private String color; public Dog(String name, int age, String color) { this.name = name; this.age = age; this.color = color; } public Dog() { } 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 String getColor() { return color; } public void setColor(String color) { this.color = color; } } import java.io.FileOutputStream; import java.io.PrintStream; import java.lang.reflect.Field; public class MyBatis { // 提供一个方法：可以保存一切对象数据的字段和具体值 public static void save(Object obj) { try ( PrintStream ps = new PrintStream(new FileOutputStream("反射/src/test.txt", true)); ) { // 1.先得到对象的Class文件对象 Class c = obj.getClass(); // 2.定位它的全部成员变量 Field[] fields = c.getDeclaredFields(); // 3.遍历这些字段并取值 for (Field field: fields) { // 字段名称 String name = field.getName(); // 字段的值 field.setAccessible(true); // 暴力反射 String value = field.get(obj) + ""; ps.println(name + "=" + value); } }catch (Exception e) { e.printStackTrace(); } } }
注解
自定义注解
注解的属性
注解的特殊属性
元注解——是用在自定义注解上的注解
注解的解析
@Book(value="test1", authors = {"1", "2"}, price = 5.1)
public class MyBook {
public static void main(String[] args) throws NoSuchMethodException {
// 1.定位Class类对象
Class c = BookStore.class;
// 2.判断这个类上是否使用了某个注解
if (c.isAnnotationPresent(Book.class)) {
// 3.获取这个注解对象
Book book = (Book) c.getDeclaredAnnotation(Book.class);
System.out.println(book.value());
System.out.println(book.price());
}
Method run = c.getDeclaredMethod("run");
// 2.判断这个方法上是否使用了某个注解
if (run.isAnnotationPresent(Book.class)) {
// 3.获取这个注解对象
Book book = (Book) run.getDeclaredAnnotation(Book.class);
System.out.println(book.value());
System.out.println(book.price());
}
}
}
@Book(value = "Java基础精通", price = 50, authors = {"脖子", "哈哈"})
class BookStore {
@Book(value = "Java基础精通1", price = 500, authors = {"脖1子", "哈2哈"})
public void run() {
}
}
// 自定义一个注解
@Target({ElementType.METHOD, ElementType.FIELD, ElementType.TYPE}) // 申明只能注解方法与成员变量与类
@Retention(RetentionPolicy.RUNTIME)
@interface Book {
String value();
String[] authors();
double price();
String address() default "广州";
}
注解模拟Junit框架的基本使用
@Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @interface MyTest { } MyBook t = new MyBook(); Class d = MyBook.class; // 2.获取类中全部方法对象 Method[] methods = d.getDeclaredMethods(); for (Method method: methods) { if (method.isAnnotationPresent(MyTest.class)) { // 触发此方法执行 method.invoke(t);
}
} @MyTest public void test01() { System.out.println("====test01===="); } @MyTest public void test02() { System.out.println("====test02===="); } @MyTest public void test03() { System.out.println("====test03===="); }
