1. Junit单元测试

测试分类：
1. 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。
2. 白盒测试：需要写代码的。关注程序具体的执行流程。

Junit使用：白盒测试
- 步骤：
  1. 定义一个测试类(测试用例)
    - 建议：
      - 测试类名：被测试的类名Test CalculatorTest
      - 包名：xxx.xxx.xx.test cn.itcast.test
  2. 定义测试方法：可以独立运行
    - 建议：
      - 方法名：test测试的方法名 testAdd()
      - 返回值：void
      - 参数列表：空参
  3. 给方法加@Test
  4. 导入junit依赖环境
- 判定结果：
  - 红色：失败
  - 绿色：成功
  - 一般我们会使用断言操作来处理结果
    - Assert.assertEquals(期望的结果,运算的结果);
- 补充：
  - @Before:
    - 修饰的方法会在测试方法之前被自动执行
  - @After:
    - 修饰的方法会在测试方法执行之后自动被执行

代码

被测试类Calculator.java

package cn.itcast.junit;/*** 计算器类*/
public class Calculator {/*** 加法** @param a* @param b* @return*/public int add(int a, int b) {//int i = 3/0;return a + b;}/*** 减法** @param a* @param b* @return*/public int sub(int a, int b) {return a - b;}}

测试类CalculatorText.java

package cn.itcast.test;import cn.itcast.junit.Calculator;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;public class CalculatorTest {/*** 初始化方法：*  用于资源申请，所有测试方法在执行之前都会先执行该方法*/@Beforepublic void init(){System.out.println("init...");}/*** 释放资源方法：*  在所有测试方法执行完后，都会自动执行该方法*/@Afterpublic void close(){System.out.println("close...");}/*** 测试add方法*/@Testpublic void testAdd(){// System.out.println("我被执行了");//1.创建计算器对象System.out.println("testAdd...");Calculator c  = new Calculator();//2.调用add方法int result = c.add(1, 2);//System.out.println(result);//3.断言  我断言这个结果是3Assert.assertEquals(3,result);}@Testpublic void testSub(){//1.创建计算器对象Calculator c  = new Calculator();int result = c.sub(1, 2);System.out.println("testSub....");Assert.assertEquals(-1,result);}
}

2. 反射：框架设计的灵魂

框架：半成品软件。可以在框架的基础上进行软件开发，简化编码
反射：将类的各个组成部分封装为其他对象，这就是反射机制
- 好处：
  1. 可以在程序运行过程中，操作这些对象。（比如调用String中的方法时，其实是调用内存中的Class类对象的Method成员方法数组中的方法）
  2. 可以解耦，提高程序的可扩展性。
获取Class对象的方式：
1. Class.forName(“全类名”)：将字节码文件加载进内存，返回Class对象(对应Source源代码阶段，代码仍在硬盘中)
  - 多用于配置文件，将类名定义在配置文件中。读取文件，加载类
2. 类名.class：通过类名的属性class获取>(对应Class类对象阶段，代码已经在内存中了)
  - 多用于参数的传递
3. 对象.getClass()：getClass()方法在Object类中定义着。(对应Runtime运行时阶段，已经产生具体对象了)
  - 多用于对象的获取字节码的方式
- 结论：
  同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。
Class对象功能：
- 获取功能：
  1. 获取成员变量们
    - Field[] getFields() ：获取所有public修饰的成员变量
    - Field getField(String name) 获取指定名称的public修饰的成员变量
    - Field[] getDeclaredFields() 获取所有的成员变量，不考虑修饰符
    - Field getDeclaredField(String name)
  2. 获取构造方法们
    - Constructor<?>[] getConstructors()
    - Constructor getConstructor(类<?>… parameterTypes)
    - Constructor getDeclaredConstructor(类<?>… parameterTypes)
    - Constructor<?>[] getDeclaredConstructors()
  3. 获取成员方法们：
    - Method[] getMethods()
    - Method getMethod(String name, 类<?>… parameterTypes)
    - Method[] getDeclaredMethods()
    - Method getDeclaredMethod(String name, 类<?>… parameterTypes)
  4. 获取全类名
    - String getName()

Field：成员变量

操作：

设置值
- void set(Object obj, Object value)
获取值
- get(Object obj)
忽略访问权限修饰符的安全检查
- setAccessible(true):暴力反射

package cn.itcast.reflect;import cn.itcast.domain.Person;import java.lang.reflect.Field;public class ReflectDemo2 {/**Class对象功能：* 获取功能：1. 获取成员变量们* Field[] getFields()* Field getField(String name)* Field[] getDeclaredFields()* Field getDeclaredField(String name)*/public static void main(String[] args) throws Exception {//0.获取Person的Class对象Class personClass = Person.class;/*1. 获取成员变量们* Field[] getFields()* Field getField(String name)* Field[] getDeclaredFields()* Field getDeclaredField(String name)*///1.Field[] getFields()获取所有public修饰的成员变量Field[] fields = personClass.getFields();for (Field field : fields) {System.out.println(field);}System.out.println("------------");//2.Field getField(String name)Field a = personClass.getField("a");//获取成员变量a 的值Person p = new Person();Object value = a.get(p);System.out.println(value);//设置a的值a.set(p,"张三");System.out.println(p);System.out.println("===================");//Field[] getDeclaredFields()：获取所有的成员变量，不考虑修饰符Field[] declaredFields = personClass.getDeclaredFields();for (Field declaredField : declaredFields) {System.out.println(declaredField);}//Field getDeclaredField(String name)Field d = personClass.getDeclaredField("d");//忽略访问权限修饰符的安全检查d.setAccessible(true);//暴力反射Object value2 = d.get(p);System.out.println(value2);}
}

Constructor:构造方法

创建对象：

T newInstance(Object… initargs)
如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法

package cn.itcast.reflect;import cn.itcast.domain.Person;import java.lang.reflect.Constructor;
import java.lang.reflect.Field;public class ReflectDemo3 {/**Class对象功能：* 获取功能：2. 获取构造方法们* Constructor<?>[] getConstructors()* Constructor<T> getConstructor(类<?>... parameterTypes)* Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)* Constructor<?>[] getDeclaredConstructors()*/public static void main(String[] args) throws Exception {//0.获取Person的Class对象Class personClass = Person.class;/*2. 获取构造方法们* Constructor<?>[] getConstructors()* Constructor<T> getConstructor(类<?>... parameterTypes)* Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)* Constructor<?>[] getDeclaredConstructors()*///Constructor<T> getConstructor(类<?>... parameterTypes)Constructor constructor = personClass.getConstructor(String.class, int.class);System.out.println(constructor);//创建对象Object person = constructor.newInstance("张三", 23);System.out.println(person);System.out.println("----------");Constructor constructor1 = personClass.getConstructor();System.out.println(constructor1);//创建对象Object person1 = constructor1.newInstance();System.out.println(person1);Object o = personClass.newInstance();System.out.println(o);//constructor1.setAccessible(true);}
}

Method：方法对象

执行方法：
- Object invoke(Object obj, Object… args)

获取方法名称：

String getName:获取方法名

package cn.itcast.reflect;import cn.itcast.domain.Person;import java.lang.reflect.Constructor;
import java.lang.reflect.Method;public class ReflectDemo4 {/**Class对象功能：* 获取功能：3. 获取成员方法们：* Method[] getMethods()* Method getMethod(String name, 类<?>... parameterTypes)* Method[] getDeclaredMethods()* Method getDeclaredMethod(String name, 类<?>... parameterTypes)4. 获取类名* String getName()*/public static void main(String[] args) throws Exception {//0.获取Person的Class对象Class personClass = Person.class;/*3. 获取成员方法们：* Method[] getMethods()* Method getMethod(String name, 类<?>... parameterTypes)* Method[] getDeclaredMethods()* Method getDeclaredMethod(String name, 类<?>... parameterTypes)*///获取指定名称的方法Method eat_method = personClass.getMethod("eat");Person p = new Person();//执行方法eat_method.invoke(p);// 获取带参数的方法,传递函数名以及指定参数的classMethod eat_method2 = personClass.getMethod("eat", String.class);//执行方法eat_method2.invoke(p,"饭");System.out.println("-----------------");//获取所有public修饰的方法Method[] methods = personClass.getMethods();for (Method method : methods) {System.out.println(method);String name = method.getName();System.out.println(name);//method.setAccessible(true);}//获取类名String className = personClass.getName();System.out.println(className);//cn.itcast.domain.Person}
}

案例：

需求：写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法

实现：
1. 配置文件
2. 反射
步骤：
1. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
2. 在程序中加载读取配置文件
3. 使用反射技术来加载类文件进内存
4. 创建对象
5. 执行方法

实现

配置文件pro.properties
后续如果要更改，只需要更改配置文件，即可执行对应文件

className=cn.itcast.domain.Student
methodName=sleep

className=cn.itcast.domain.Person
methodName=eat

Person类Person.class

package cn.itcast.domain;public class Person {private String name;private int age;public String a;protected String b;String c;private String d;public Person() {}public Person(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;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +", a='" + a + '\'' +", b='" + b + '\'' +", c='" + c + '\'' +", d='" + d + '\'' +'}';}public void eat() {System.out.println("eat...");}public void eat(String food) {System.out.println("eat..." + food);}
}

Studelt类Student.java

package cn.itcast.domain;public class Student {public void sleep(){System.out.println("sleep...");}
}

实现类ReflectText.java

package cn.itcast.reflect;import cn.itcast.domain.Person;
import cn.itcast.domain.Student;import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;/*** 框架类*/
public class ReflectTest {public static void main(String[] args) throws Exception {//可以创建任意类的对象，可以执行任意方法/*前提：不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法*//*  Person p = new Person();p.eat();*/
/*Student stu = new Student();stu.sleep();*///1.加载配置文件//1.1创建Properties对象Properties pro = new Properties();//1.2加载配置文件，转换为一个集合//1.2.1获取class目录下的配置文件ClassLoader classLoader = ReflectTest.class.getClassLoader();InputStream is = classLoader.getResourceAsStream("pro.properties");pro.load(is);//2.获取配置文件中定义的数据String className = pro.getProperty("className");String methodName = pro.getProperty("methodName");//3.加载该类进内存Class cls = Class.forName(className);//4.创建对象Object obj = cls.newInstance();//5.获取方法对象Method method = cls.getMethod(methodName);//6.执行方法method.invoke(obj);}
}

3. 注解

概念：说明程序的。给计算机看的
注释：用文字描述程序的。给程序员看的
定义：注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。
概念描述：
- JDK1.5之后的新特性
- 说明程序的
- 使用注解：@注解名称
作用分类：
①编写文档：通过代码里标识的注解生成文档【生成文档doc文档】
②代码分析：通过代码里标识的注解对代码进行分析【使用反射】
③编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【Override】
JDK中预定义的一些注解
- @Override ：检测被该注解标注的方法是否是继承自父类(接口)的
- @Deprecated：该注解标注的内容，表示已过时
- @SuppressWarnings：压制警告
  - 一般传递参数all @SuppressWarnings(“all”)
自定义注解
- 格式：
  元注解
  public @interface 注解名称{
  属性列表;
  }
- 本质：注解本质上就是一个接口，该接口默认继承Annotation接口
  public interface MyAnno extends java.lang.annotation.Annotation {}
- 属性：接口中的抽象方法
  - 要求：
    1. 属性的返回值类型有下列取值
      - 基本数据类型
      - String
      - 枚举
      - 注解
      - 以上类型的数组
        
        package cn.itcast.annotation;//import com.sun.corba.se.spi.orbutil.threadpool.Work;public @interface MyAnno {int value();Person per();MyAnno2 anno2();String[] strs();/*String name() default "张三";*//*String show2();Person per();MyAnno2 anno2();String[] strs();*/}
    2. 定义了属性，在使用时需要给属性赋值
      1. 如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时，可以不进行属性的赋值。
      2. 如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接定义值即可。
      3. 数组赋值时，值使用{}包裹。如果数组中只有一个值，则{}可以省略
        
        package cn.itcast.annotation;@MyAnno(value = 12, per = Person.P1, anno2 = @MyAnno2, strs = "bbb") @MyAnno3 public class Worker {@MyAnno3public String name = "aaa";@MyAnno3public void show() {} }
- 元注解：用于描述注解的注解
  - @Target：描述注解能够作用的位置
    - ElementType取值：
      - TYPE：可以作用于类上
      - METHOD：可以作用于方法上
      - FIELD：可以作用于成员变量上
  - @Retention：描述注解被保留的阶段
    - @Retention(RetentionPolicy.RUNTIME)：当前被描述的注解，会保留到class字节码文件中，并被JVM读取到
  - @Documented：描述注解是否被抽取到api文档中
  - @Inherited：描述注解是否被子类继承
```
package cn.itcast.annotation;import java.lang.annotation.*;/**元注解：用于描述注解的注解* @Target：描述注解能够作用的位置* @Retention：描述注解被保留的阶段* @Documented：描述注解是否被抽取到api文档中* @Inherited：描述注解是否被子类继承**/@Target({ElementType.TYPE,ElementType.METHOD,ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface MyAnno3 {}
```

在程序使用(解析)注解：获取注解中定义的属性值

获取注解定义的位置的对象（Class，Method,Field）

//1.解析注解
//1.1获取该类的字节码文件对象
Class<ReflectTest> reflectTestClass = ReflectTest.class;

获取指定的注解

getAnnotation(Class)
//其实就是在内存中生成了一个该注解接口的子类实现对象

public class ProImpl implements Pro{public String className(){return "cn.itcast.annotation.Demo1";}public String methodName(){return "show";}
}

调用注解中的抽象方法获取配置的属性值

package cn.itcast.annotation;import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;/*** 框架类*/@Pro(className = "cn.itcast.annotation.Demo1",methodName = "show")
public class ReflectTest {public static void main(String[] args) throws Exception {/*前提：不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法*///1.解析注解//1.1获取该类的字节码文件对象Class<ReflectTest> reflectTestClass = ReflectTest.class;//2.获取上边的注解对象Pro an = reflectTestClass.getAnnotation(Pro.class);//3.调用注解对象中定义的抽象方法，获取返回值String className = an.className();String methodName = an.methodName();System.out.println(className);System.out.println(methodName);//3.加载该类进内存Class cls = Class.forName(className);//4.创建对象Object obj = cls.newInstance();//5.获取方法对象Method method = cls.getMethod(methodName);//6.执行方法method.invoke(obj);}
}

案例：简单的测试框架

Calculator.java

package cn.itcast.annotation.demo;/*** 小明定义的计算器类*/
public class Calculator {//加法@Checkpublic void add(){String str = null;str.toString();System.out.println("1 + 0 =" + (1 + 0));}//减法@Checkpublic void sub(){System.out.println("1 - 0 =" + (1 - 0));}//乘法@Checkpublic void mul(){System.out.println("1 * 0 =" + (1 * 0));}//除法@Checkpublic void div(){System.out.println("1 / 0 =" + (1 / 0));}public void show(){System.out.println("永无bug...");}}

Check注解

package cn.itcast.annotation.demo;import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Check {}

TestCheck.java

package cn.itcast.annotation.demo;import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;/*** 简单的测试框架** 当主方法执行后，会自动自行被检测的所有方法(加了Check注解的方法)，判断方法是否有异常，记录到文件中*/
public class TestCheck {public static void main(String[] args) throws IOException {//1.创建计算器对象Calculator c = new Calculator();//2.获取字节码文件对象Class cls = c.getClass();//3.获取所有方法Method[] methods = cls.getMethods();int number = 0;//出现异常的次数BufferedWriter bw = new BufferedWriter(new FileWriter("bug.txt"));for (Method method : methods) {//4.判断方法上是否有Check注解if(method.isAnnotationPresent(Check.class)){//5.有，执行try {method.invoke(c);} catch (Exception e) {//6.捕获异常//记录到文件中number ++;bw.write(method.getName()+ " 方法出异常了");bw.newLine();bw.write("异常的名称:" + e.getCause().getClass().getSimpleName());bw.newLine();bw.write("异常的原因:"+e.getCause().getMessage());bw.newLine();bw.write("--------------------------");bw.newLine();}}}bw.write("本次测试一共出现 "+number+" 次异常");bw.flush();bw.close();}}

小结：
1. 以后大多数时候，我们会使用注解，而不是自定义注解
2. 注解给谁用？
  1. 编译器
  2. 给解析程序用
3. 注解不是程序的一部分，可以理解为注解就是一个标签

Java基础：基础加强巩固相关推荐

java入门慕路径,Java入门基础知识总结学习教程大全【必看经典】
类型的表达式,是循环条件,表达式3是党执行了一遍循环之后,修改控制循环的变量值. ??? for语句的执行过程是这样的:首先计算表达式1,完成必要的初始化工作:然后判断表达式2的值,如果表达式的值为t ...
java mybatis基础
java mybatis基础 1.1 什么是mybatis? mybatis是一个优秀的持久层框架. 避免几乎所有的JDBC代码和手动设置参数以及获取结果集的过程. 可以使用简单的xml或者注解来配置 ...
java负数右移_收入囊中篇---Java程序基础（二）
前言: 本篇是接着上一篇更新的,如果没有阅读上一篇的话,可以查阅或回顾一下. 1.收入囊中篇---Java基础必备知识(一) 2.收入囊中篇---Java程序基础(二) Java程序基础目录 1.Ja ...
java基础入门传智播客源码_Java-_2020年版Java零基础视频教程（Java 0基础，Java初学入门）魔鬼讲师老杜出品...
不会闲聊!!!不会扯淡!!!小UP只会分享与Java相关的学习资源还记得那年带你Java入门的一声"吼"吗? B站目前播放量已经快到450多万播放量的Java零基础教程的创作者& ...
【JAVA零基础入门系列】Day2 Java集成开发环境IDEA
[JAVA零基础入门系列](已完结)导航目录 Day1 开发环境搭建 Day2 Java集成开发环境IDEA Day3 Java基本数据类型 Day4 变量与常量 Day5 Java中的运算符 Day ...
Java零基础学习难吗
java编程是入行互联网的小伙伴们大多数的选择,那么对于零基础的小伙伴来说Java零基础学习难吗?如果你是初学者,你可以很好的理解java编程语言.并不困难.如果你的学习能力比较高,那么你对Java的 ...
java培训基础知识都学哪些
很多人都开始学习java技术,觉得java语言在未来的发展前景空间非常大,事实却是如此,那么针对于零基础的同学, 学习java技术需要学哪些呢?下面我们就来看看java培训基础知识都学哪些? java ...
cmd 将文件夹下文件剪切到另外一个文件_总结java中文件拷贝剪切的5种方式-JAVA IO基础总结第五篇...
本文是Java IO总结系列篇的第5篇,前篇的访问地址如下: 总结java中创建并写文件的5种方式-JAVA IO基础总结第一篇总结java从文件中读取数据的6种方法-JAVA IO基础总结第二篇 ...
第三章 Java Servlet基础
第三章 Java Servlet基础 3.6.2 转发 1．获得RequestDispatcher对象 2．RequestDispatcher对象调用forward()方法实现转发请求转发工作原理 ...
java泛型简书_一文带你认识Java泛型基础
Java泛型基础 1. 认识泛型泛型是在JDK1.5之后增加的新功能. 泛型可以解决数据的安全性问题, 主要的原理是在类声明的时候通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型. ...

Java基础：基础加强巩固

1. Junit单元测试

2. 反射：框架设计的灵魂

3. 注解

Java基础：基础加强巩固相关推荐

最新文章

热门文章