Java的注解学习总结

Java注解学习总结

一、基本概念
1.注释
1.1单行注释：//…
1.2多行注释：/…/
1.3文档注释：/**…*/
2.注解
2.1注解的写法：@xxx(携带信息)
2.2注解的位置：根据注解创建时的定义，可以在类的上面、属性上面、方法上面、构造方法上面、参数的前面
2.3注解的作用：
用来充当注释作用，仅仅是一个文字的说明，如@Deprecated；
用来做代码的检测和验证，如@Override；
可以携带一些信息，如 @SuppressWarnings(携带的信息)
3.常见的注解
3.1@Deprecated，说明方法是废弃的
3.2@Override，检测方法是否是一个重写方法
3.3@SuppressWarnings(信息)，信息：String类型的数组，如果数组内的元素只有一个长度，可以省略大括号的写法
unused 变量定义未被使用
serial 类实现了序列化接口，但不想添加序列化ID
rawtypes 集合没有定义泛型
deprecation 废弃的方法去除划线
unchecked 出现泛型的问题可以不检测
all 所有问题都不检测
3.注解可以携带的信息
3.1 基础数据类型
3.2String类型
3.3枚举类型
3.4注解类型
3.5数组类型，数组的内部需要时是如上的四种类型

二、如何描述一个注解
1.创建一个注解类型，类似创建类是用Class，接口是interface，注解是@interface
2.写法与接口类似，注解内部的属性是共有的、静态的、最终的，注解内的方法是抽象方法，可以有返回值，返回值必须是3中那5钟类型
3.自己定义注解时，光定义是不足的，我们要利用Java提供好的注解来说明
3.1元注解：元注解也是注解，不过它是用来描述注解的注解
3.2元注解的类型：
@Target 定义注解的位置

@Retention 存在什么作用域中
源代码–编译–字节码文件–加载–内存执行
SOURCE CLASS RUNTIME

@Inherited 当前注解是否能被子类继承

@Document 当前注解能否被文档记录
4.自定义注解实例

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD,ElementType.FIELD,ElementType.CONSTRUCTOR})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {

String[] value() ;

}
5.使用描述好的注解
5.1如果定义的注解只有一个方法，方法名叫value时，在使用的时候可以省略方法名
5.2在注解里描述了一个方法，方法没有参数 ，方法的返回值String[]，使用注解的时候，为何必须让我们传递参数？
理解为：注解的方法将我们传递给他的参数搬运给了别人
三、注解的使用
1.利用反射技术设计一个方法，给定一个String类型的方法名，得到一个被赋值的对象
2.代码如下
Person类
public class Person {

private String name;
private Integer age;
private String sex;

@MyAnnotation({"刘亮亮","18","男"})
public Person(){}
public Person(String name, Integer age, String sex) {
    this.name = name;
    this.age = age;
    this.sex = sex;
}

public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public Integer getAge() {
    return age;
}
public void setAge(Integer age) {
    this.age = age;
}
public String getSex() {
    return sex;
}
public void setSex(String sex) {
    this.sex = sex;
}

}
MySpring类
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class MyString {

public static Object getBean(String className){
    Object obj=null;
    try {
        Class clazz = Class.forName(className);
        Constructor con = clazz.getConstructor();
        obj = con.newInstance();
        //将对象内的属性赋值
        Annotation annotation=con.getAnnotation(MyAnnotation.class);
        Class aclass=annotation.getClass();
        Method method=aclass.getMethod("value");
        String[] s=(String[])method.invoke(annotation);
        Field[] fields=clazz.getDeclaredFields();
        for (int i=0;i<fields.length;i++){
            String fieldname=fields[i].getName();
            String first=fieldname.substring(0,1).toUpperCase();
            String other=fieldname.substring(1);
            StringBuilder builder=new StringBuilder("set");
            builder.append(first);
            builder.append(other);
            Method setMethod=clazz.getMethod(builder.toString(),fields[i].getType());
            setMethod.invoke(obj,fields[i].getType().getConstructor(String.class).newInstance(s[i]));
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return obj;
}

}
测试类
public class Text02 {

public static void main(String[] args) {
    Person p= (Person) MyString.getBean("annotation.Person");
    System.out.println(p.getName()+","+p.getSex()+","+p.getAge());
}

}