//创建一个类：Calculator.java
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;
}
}
//创建一个测试类（可以在不同包中）：CalculatorTest.java
import org.junit.Assert;
import org.junit.Test;
import webstudy.day1.junit.Calculator;
public class CalculatorTest {
/**
* 测试add方法
*/
@Test
public void testAdd() { //结果为红色
//System.out.println("我被执行了");
//1. 创建计算器对象
Calculator c = new Calculator();
//2. 调用add方法
int result = c.add(1, 2);
//System.out.println(result);
//3. 断言 我断言这个结束是3
Assert.assertEquals(3, result);
}
/**
* 测试sub方法
*/
@Test
public void testSub() { //结果为绿色
Calculator c = new Calculator();
int result = c.sub(1, 2);
Assert.assertEquals(-1, result);
}
}
package webstudy.day1.Annotation;
/**
* 注解演示
*
* @author Administrator
* @version 1.1
* @since 1.5
*
*/
public class AnnotationDemo1 {
/**
* 计算两数之和
* @param a
* @param b
* @return 两数之和
*/
public int add(int a, int b) {
return a + b;
}
}
/*
* 三个常用注解的学习
* @Override：检查被该注解标注的方法是否是继承自父类（接口）的
* @Deprecated：将该注解标注的内容，表示已过时
* @SuppressWarnings：压制警告（编译器IDE会提示一些警告，当个人不想要这些警告的时候使用该注解）
*/
@SuppressWarnings("all")
public class AnnotationDemo2 {
//@Override：检查被该注解标注的方法是否是继承自父类（接口）的
@Override
public String toString() {
return super.toString();
}
//@Deprecated：将该注解标注的内容，表示已过时
@Deprecated
public void show1() {
//有缺陷，又写了一个show1方法
//但是不能删掉，因为用户的软件可能还用的是show1方法
}
public void show2() {
//替代了show2方法，以后推荐用户使用show2方法
}
public void demo() {
show1();
}
}
3.4 自定义注解_格式&本质&属性（难点）
注解的格式：
元注解
public @interface 注解名称{
属性列表;（其实就是成员方法）
}
注：++元注解，稍后讲解++
注解的本质：(通过反编译自己写的注解代码来生成如下代码)
public interface MyAnno extends java.lang.annotation.Annotation{}
所以：注解本质上就是一个接口，该接口默认继承Annotation接口
继承的Annotation接口是：所有注解类型扩展的公共接口
注解的属性：就是接口中的抽象方法
解释一下就是：（接口中可以定义的内容（常量，方法等））
两点要求如下：
属性的返回值类型有下列取值（其他的比如类，等都不行）
基本数据类型
String
枚举
注解
以上类型的数组
定义了属性，在使用时需要给属性赋值
如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时，可以不进行属性的赋值。
如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接定义值即可。
//自己定义的注解MyAnno
public @Interface MyAnno{
int value();
}
//使用该注解的测试类
public class Test {
@MyAnno(12)
public void show(){
}
}
//如果不是value的时候
public class Test {
@MyAnno(age = 12)
public void show(){
}
}
比如注解：@SuppressWarnings(“all”)，因为省略了所以肯定是一个value
数组赋值时，值使用{}包裹。如果数组中只有一个值，则{}可以省略
//自己定义的注解MyAnno
public @Interface MyAnno{
String[] value();
}
//使用该注解的测试类
public class Test {
@MyAnno(strs={"aaa", "bbb"})
public void show(){
}
}
//如果数组中只有一个值的时候
public class Test {
@MyAnno(strs="aaa")
public void show(){
}
}
比如注解：@SuppressWarnings(“all”)就是一个字符串数组
3.5 元注解：++用于描述注解的注解++
* ==【常用】@Target==：描述注解能够作用的位置
* ElementType的取值如下：
* TYPE：可以作用于类上
* METHOD：可以作用于方法上
* FIELD：可以作用于成员变量上
```
//创建一个注解：MyAnno2
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@Target(value = {ElementType.TYPE}) //表示MyAnno2注解只能作用于类上
public @interface MyAnno2 {
}
//测试该注解的类：Test
@MyAnno2
public class Test {
//@MyAnno2->这里就报错了，因为只能作用于类上
public String name = "aaa";
//@MyAnno2->这里就报错了，因为只能作用于类上
public void show(){
}
}
```
* ==【常用】@Retention==：描述注解被保留的阶段
* @Retention(RetentionPolicy.RUNTIME)：当前被描述的注解，会保留到class字节码文件中，并被JVM读取到
* 还可以是CLASS和SOURCE-->但是==一般都用RUNTIME==
* CLASS：就不会被JVM读取到
* SOURCE：不会被JVM读取到，也不会保留到class字节码文件中
* ==@Documented==：描述注解是否被抽取到api文档中
* ==@Inherited==：描述注解是否被子类继承
注：如何进行反编译
将注解代码放到一个后缀名为.java
运行cmd
javac Anno.java先进行编译（编译后会生成class文件）
javap Anno.java来进行反编译
3.6 在程序中使用（解析）注解的三个步骤：获取注解中定义的属性值
获取注解定义位置的对象（Class，Method,Field）
获取指定的注解
getAnnotation(Class) //其实就是在内存中生成了一个该注解接口的子类实现对象
public class ProImpl implements Pro{
public String className(){
return "cn.javaweb.day01.annotation.Demo1";
}
public String methodName(){
return "show";
}
}
调用注解中的抽象方法获取配置的属性值
反射案例用注解方式改写：(解析注解的案例)
和反射案例一样，只不过这里不需要写配置文件来定义呢两个属性了
而是用注解来描述呢两个属性
///先创建两个测试类：Demo1和Demo2
public class Demo1 {
public void show1(){
System.out.println("demo1...show");
}
}
public class Demo2 {
public void show2(){
System.out.println("demo2...show");
}
}
///创建注解：Pro
/*
* 描述需要执行的类名和方法名
*/
@Target({ElementType.TYPE}) //只能作用在类上
@Retention(RetentionPolicy.RUNTIME) //保留在RUNTIME阶段
public @interface Pro {
String className();
String methodName();
}
///创建案例类：ReflectTest.java
import java.lang.reflect.Method;
/**
* 应用注解来描述配置文件中的属性（替换）-》模拟框架类
*/
@Pro(className = "cn.javaweb.day01.annotation.Demo1", methodName = "show1")
public class ReflectTest {
public static void main(String[] args) throws Exception {
/*
* 前提：不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法
*/
//1. 解析注解：
//1.1 获取该类的字节码文件对象
Class<ReflectTest> reflectTestClass = ReflectTest.class;
//2. 获取上边的注解对象
/*
getAnnotation方法其实相当于如下代码
public class ProImpl implements Pro{
public String className(){
return "cn.javaweb.day01.annotation.Demo1";
}
public String methodName(){
return "show1";
}
}
*/
//其实就是在内存中生成了一个该注解接口的子类实现对象
Pro an = reflectTestClass.getAnnotation(Pro.class);
//3. 调用注解对象中定义的属性（抽象方法），获取返回值
String className = an.className();
String methodName = an.methodName();
System.out.println(className); //cn.javaweb.day01.annotation.Demo1
System.out.println(methodName); //show1
//拿到了属性值后，后面的代码就一样了(复制就行)
//加载该类进内存(返回一个Class对象)
Class cls = Class.forName(className);
//创建对象
Object obj = cls.newInstance(); //使用空参数构造方法创建Class对象的简化写法
//获取对象的方法
Method method = cls.getMethod(methodName);
//6. 执行方法
method.invoke(obj);
}
}
