注解 Annotation

注解 Annotation

一、什么是注解

1.Annotation是从JDK5.0开始引入的新技术

2.Annotation的作用

A.不是程序本身 , 可以对程序作出解释.(这一点和注释(comment)没什么区别)

B.可以被其他程序(比如:编译器等)读取

3.Annotation的格式

注解是以"@注释名"在代码中存在的 , 还可以添加一些参数值 ,

例如:@SuppressWarnings(value=“unchecked”)

4.Annotation的使用场合

可以附加在package（包） , class（类） , method（方法） , field（字段） 等上面 , 相当于给它们添加

了额外的辅助信息,我们可以通过反射机制编程实现对这些元数据的访问

二、内置注解

1.@Override

定义在 java.lang.Override 中 , 此注释只适用于修辞方法 , 表示一个方法声明打算
重写超类中的另一个方法声明。

2.@Deprecated

定义在java.lang.Deprecated中 , 此注释可以用于修辞方法 , 属性 , 类 ,

不鼓励程序员使用这样的元素 , 通常是因为它很危险或者存在更好的选择 .

3.@SuppressWarnings

定义在java.lang.SuppressWarnings中,用来抑制编译时的警告信息

与前两个注释有所不同,你需要添加一个参数才能正确使用,这些参数都是已经定义好了的,

我们选择性的使用就好了 。如下所示：

A.@SuppressWarnings(“all”)
B.@SuppressWarnings(“unchecked”)
C.@SuppressWarnings(value={“unchecked”,“deprecation”})
D…

4.例子

//注解 ： 给人看的，编译器可以识别，有一定功能
//注释 ： 给人看的，编译器无法识别
//Annotation
public class Test1{

    public static void main(String[] args) {
        // new Thread().start();
        // private native void start0();  本地方法，java已经没办法做了，调用了底层C的类库！
        int year = new Date().getYear();
        System.out.println(year);
    }

    //标注这个方法，过时的，或者危险的，不建议使用，但是可以使用！
    @Deprecated
    public int test(){  //不建议使用
        System.out.println("aaaaaa");
        return 1;
    }

    public String hello(){ //没有被使用
       List list = new ArrayList<>();
       return "hello,world!";
    }

    @Override //标注了这个注解，就代表子类重写了父类的方法，而且必须保持一致
    public String toString() {
        return "Test1{}";
    }
}

三、元注解

1.元注解的作用就是负责注解其他注解 , Java定义了4个标准的meta-annotation类型,他们被用来提供对其他annotation类型作说明

2.这些类型和它们所支持的类在java.lang.annotation包中可以找到 ( @Target , @Retention ,@Documented , @Inherited )

A.@Target : 用于描述注解的使用范围(即:被描述的注解可以用在什么地方)

B.@Retention : 表示需要在什么级别保存该注释信息 , 用于描述注解的生命周期

(SOURCE < CLASS < RUNTIME)

C.@Document：说明该注解将被包含在javadoc中

D.@Inherited：说明子类可以继承父类中的该注解

四、自定义注解

使用 @interface自定义注解时 , 自动继承了java.lang.annotation.Annotation接口

分析

1.@ interface用来声明一个注解 , 格式 : public @ interface 注解名 { 定义内容 }

2.其中的每一个方法实际上是声明了一个配置参数

3.方法的名称就是参数的名称

4.返回值类型就是参数的类型 ( 返回值只能是基本类型,Class , String , enum )

5.可以通过default来声明参数的默认值

6.如果只有一个参数成员 , 一般参数名为value

7.注解元素必须要有值 , 我们定义注解元素时 , 经常使用空字符串,0作为默认值

例1

public class Test2 {

    private int age;

    @MyAnnotation
    public int getAge() {
        return age;
    }

}
//自定义注解： @interface 注解名，注意和 interface的区别

//除了这四个注解之外的所有注解，都叫做自定义注解！

@Target(ElementType.METHOD) //表示某个注解，能够注解的对象！  方法，字段，类
@Retention(RetentionPolicy.RUNTIME) //自定义注解我们都会使用 RetentionPolicy.RUNTIME 在运行时生效
@Documented //表示L可以在Javadoc中生成信息，没什么用！
@Inherited //表示子类可以继承父类的注解，一般也不用！
@interface MyAnnotation{


}

例2

//自定义注解

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

public class Test3 {

    private int age;

    @MyAnnotation3("aaa")
    public int getAge() {
        return age;
    }

}


@Target(value={ElementType.METHOD})
@Retention(value = RetentionPolicy.RUNTIME)
@interface MyAnnotation3{

    String[] value(); //只有一个参数的一般名字叫做value， 可以省略！

}

@Target(value={ElementType.METHOD})
@Retention(value = RetentionPolicy.RUNTIME)
@interface MyAnnotation2{

    String name() default "";//通过default来声明参数的默认值
    int age() default 0;
    int id() default -1; // String indexOf("abc")   -1, 找不到，不存在

    String[] schools();

}

例3

import java.util.Arrays;
import java.util.List;

/*
    1. 编号全部满足偶数
    2. 年龄全部大于24
    3. 用户名转换为大写
    4. 用户名 倒排序
    5. 只输出一个用户名！
*/

// JDK8新特性： Stream流  lambda表达式

public class Test {
    public static void main(String[] args) {
        User u1 = new User(11, "a", 23);
        User u2 = new User(12, "b", 24);
        User u3 = new User(13, "c", 22);
        User u4 = new User(14, "d", 28);
        User u5 = new User(16, "e", 26);

        // list 集合---数据
        // stream 流---计算
        List<User> list = Arrays.asList(u1,u2,u3,u4,u5);
		
		//筛选
        list.stream()
                .filter(u->{return u.getId()%2==0;})//编号全部满足偶数
                .filter(u->{return u.getAge()>24;})//年龄全部大于24
                .map(u->{return u.getUserName().toUpperCase();})//用户名转换为大写
                .sorted((o1,o2)->{return o2.compareTo(o1);})//用户名 倒排序
                .limit(1)//只输出一个用户名
                .forEach(System.out::println);

    }
}


class User{
    private int id;
    private String userName;
    private int age;

    public User() {
    }

    public User(int id, String userName, int age) {
        this.id = id;
        this.userName = userName;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", age=" + age +
                '}';
    }

}