//创建一个类: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);
}
}