@value注解_Java注解和反射1

最新推荐文章于 2024-06-21 11:30:55 发布

weixin_39981624

最新推荐文章于 2024-06-21 11:30:55 发布

阅读量383

点赞数

文章标签： @value注解 java interface作用是什么 java 动态添加注解 java 注解 java函数默认值 java注解

Java注解和反射

注解: Annotation

作用

不是程序本身，可以对程序作出解释
可以被其他程序读取

格式

“@注释名”, 还可以添加一些参数值，例如:@SuppressWarnings(value = "unchecked").

哪里使用

可以在package，class，method, field上面使用

内置注解

@Override 重写超类中另一个方法的声明
@Deprecated 表示不鼓励使用, 表示使用后果危险或存在更好的选择
@SuppressWarnings 用来抑制编译时的警告信息，需要添加参数才能使用
@SupressWarnings("all")
@SupressWarnings("unchecked")
@SupressWarnings(value ={"unckecked","deprecation"})
等等

元注解

负责解释其他注解的注解
这些类型和它们支持的类可以在java.lang.annotation包中找到(@Target, @Retention, @Documented, @Inherited)
@Target: 描述注解使用范围java public @interface Target { ElementType[] value(); }

public enum ElementType {
    /** Class, interface (including annotation type), or enum declaration */
    TYPE,

    /** Field declaration (includes enum constants) */
    FIELD,

    /** Method declaration */
    METHOD,

    /** Formal parameter declaration */
    PARAMETER,

    /** Constructor declaration */
    CONSTRUCTOR,

    /** Local variable declaration */
    LOCAL_VARIABLE,

    /** Annotation type declaration */
    ANNOTATION_TYPE,

    /** Package declaration */
    PACKAGE,

    /**
     * Type parameter declaration
     *
     * @since 1.8
     */
    TYPE_PARAMETER,

    /**
     * Use of a type
     *
     * @since 1.8
     */
    TYPE_USE
}

@Retention: 表示需要在什么级别保存该注释信息, 用于描述注释的生命周期(Source < Class < Runtime)
自定义注解一般写Runtimejava public @interface Retention { RetentionPolicy value(); }

public enum RetentionPolicy {
    /**
     * Annotations are to be discarded by the compiler.
     */
    SOURCE,

    /**
     * Annotations are to be recorded in the class file by the compiler
     * but need not be retained by the VM at run time.  This is the default
     * behavior.
     */
    CLASS,

    /**
     * Annotations are to be recorded in the class file by the compiler and
     * retained by the VM at run time, so they may be read reflectively.
     *
     * @see java.lang.reflect.AnnotatedElement
     */
    RUNTIME
}

@Documented: 说明该注解将被包含在javadoc中
@Inherited: 说明子类可以继承父类中的该注解
举例:

public class Test02 {

    @MyAnnotation
    public void test(){

    }
}

//@Target 表示注解可以用在哪些地方
@Target(value = {ElementType.METHOD, ElementType.TYPE})

//@Retention表示注解在哪里还有效
//runtime > class > source
@Retention(value = RetentionPolicy.RUNTIME)

//@Documented表示注解是否生成在Javadoc中
@Documented

//@Inherited 子类可以继承父类的注解
@Inherited
@interface MyAnnotation{

}

自定义注解

使用@interface自定义注解,自定义注解继承了java.lang.annotation.Annotaiton接口, 格式:

java public @interface 注解名 { 定义内容 }

若在类中定义注解, 去掉public

每一个方法实际上是声明了一个配置参数

java RetentionPolicy value();

java ElementType[] value();

方法的名称就是参数的名称(如上文中的Target, Retention等等)
返回的类型就是参数的类型(只能是基本类型, Class, String, enum)
可以通过default来声明参数的默认值
如果只有一个参数成员, 一般参数名为value, 且此时可忽略参数名

java @SuppressWarnings("all")

java @SuppressWarnings(value = "all")

两者皆可

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

public class Test02 {
    //注解可以显示赋值,没有默认值则必须赋值
    @MyAnnotation(name = "Bo Peng", schools = {"NYU"})
    public void test(){

    }
}

//@Target 表示注解可以用在哪些地方
@Target(value = {ElementType.METHOD, ElementType.TYPE})

//@Retention表示注解在哪里还有效
//runtime > class > source
@Retention(value = RetentionPolicy.RUNTIME)

//@Documented表示注解是否生成在Javadoc中
@Documented

//@Inherited 子类可以继承父类的注解
@Inherited
@interface MyAnnotation{
    //注解的参数 : 参数类型 + 参数名();
    String name() default "";
    int age() default 18;
    int id() default -1; //如果默认值为-1, 代表不存在, 类似indexof
    String[] schools() default {"Rose-Hulman", "NYU"};
}

反射: Reflection

动态语言

运行时可以改变结构的语言, 比如新的函数, 新的对象, 甚至代码可以被引进, 已有的函数可以被删除或是其他结构上的变化. 通俗说就是运行时代码可以根据某些条件改变自身结构
主要动态语言: Objective-C, C#, JavaScript, PHP, Python

function f(){
    var x = "var a = 3; var b = 5; alert(a + b)";
    eval(x);
}

静态语言

运行时结构不可变, 如Java, C, C++
Java虽然不是动态语言, 但是可以称之为"准动态语言". 即Java有一定的动态性, 我们可以灵活利用反射机制获得类似动态语言的特性. Java的动态性让编程的时候更灵活.

反射提供的动态性质

反射是Java被视为动态语言的关键, 反射机制允许程序在执行期间借助Reflection API取得任何类的内部信息, 并能直接操作任意对象的内部属性及方法
加载完类后, 在堆内存的方法区中产生了一个Class类型的对象(一个类只有一个Class对象), 这个对象就包含了完整的类的结构信息. 我们可以通过这个对象看到类的结构, 如同照镜子一般. 所以我们称之为: 反射

正常方式: 引入需要的"包类"名称 -> 通过new实例化 -> 取得实例化对象

反射方式: 实例化对象 -> getClass()方法 -> 得到完整的"包类"名称

作用

运行时判断任意一个对象的所属类
运行时构造任意一个类的对象
运行时判断任意一个类所具有的成员变量和方法
运行时获取泛型的信息
运行时调用任意一个对象的成员变量和方法
运行时处理注释
生成动态代理(AOP相关)
......

优点

可以实现动态创建对象和编译,体现很大的灵活性

缺点

对于性能有影响, 使用反射基本上是一种解释操作,我们可以告诉JVM,我们希望做什么并且满足我们的要求. 这类操作总是慢于直接执行相同的操作. 运行效率可有数十倍之差.

获得反射对象

范例:

注意因为一个类只有一个Class对象, 所以此处c1, c2和c3的hashcode相同

package com.peng.reflection;

public class Test03 extends Object{
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的Class对象
        Class c1 = Class.forName("com.peng.reflection.User");
        Class c2 = Class.forName("com.peng.reflection.User");
        Class c3 = Class.forName("com.peng.reflection.User");

        //一个类在内存中只有一个Class对象
        //一个类被加载后,类的整个结构都会被封装在Class对象中
        System.out.println(c1);
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
    }
}


//实体类:pojo entity
class User{
    private String name;
    private int id;
    private  int age;

    public User(){

    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

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

    public int getAge() {
        return age;
    }

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

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

Class类

Class类的性质与Reflection的关系

对于每个类, JRE保留一个不变的Class类型对象. 一个Class对象包含了特定某个结构(class/interface/enum/annotation/primitive type/void/[])的有关信息
Class本身也是一个类
Class对象只能由系统建立对象
一个加载的类在JVM中只有一个Class实例, 一个Class对象对应一个加载到JVM中的class文件
每个类的实例都会记得自己是由哪个Class实例生成
通过Class可以完整地得到一个类中的所有被加载的结构
Class类是Reflection的根源, 针对任何你想动态加载, 运行的类, 唯有先获得相应的Class对象

Class类的常用方法

返回指定类名name的Class对象, 可能抛出ClassNotFoundException:

static Class forName(String name)
Class c1 = Class.forName("com.peng.reflection.User");

调用默认构造函数,返回Class对象的一个实例:

Object newInstance()

返回此Class对象所表示的实体(类,接口, 数组或void)的名称:

getName()

返回当前Class对象的父类的Class对象:

Class getSuperClass()

获取当前Class对象的接口:

Class[] getinterfaces()

返回该类的类加载器:

ClassLoader getClassLoader()

返回一个包含某些Constructor对象的数组:

Constructor[] getConstructors()

返回一个Method对象,此对象的形参类型为paramType:

Method getMethod(String name, Class.. T)

返回Field对象的一个数组:

Field[] getDeclaredFields()

获取Class类的实例

已知具体的类, 通过类的class属性获取, 该方法最安全可靠, 且性能高:

Class c1 = Person.class;

已知某个类的实例, 调用该实例的getClass()方法获取Class对象

Class c2 = person.getClass();

已知一个类的全类名, 且该类在类路径下, 可通过Class类的静态方法forName获取, 可能抛出ClassNotFoundException:

Class c3 = Class.forName("com.peng.reflection.User");

内置数据类型可以直接用类名.Type:

Class c4 = Integer.TYPE

利用ClassLoader:

所有类型的Class对象

class, interface, [], enum, annotation, primitive type 以及 void都有Class对象

java Class c1 = Object.class; //类 Class c2 = Comparable.class; //接口 Class c3 = String[].class; //一维数组 Class c4 = int[][].class; //二维数组 Class c5 = Override.class; //注解 Class c6 = ElementType.class; //枚举enum Class c7 = Integer.class; //基本数据类型 Class c8 = void.class; //void Class c9 = Class.class; //Class

小技巧: IDEA中按住alt可多行间部分复制, 能够复制c1-c9

只要元素类型与维度一样, 就是同一个Class:

int[] a = new int[10];
int[] b = new int[100];
//a 和 b的class相同

Java内存分析

Java内存

堆: Heap

存放new的对象和数组
可以被所有线程共享, 不会存放别的对象引用

栈: Stack

存放基本变量类型 (会包含这个基本类型的具体数值)
引用对象的变量 (会存放这个引用在堆里面的地址)

方法区(特殊的堆): Method Area

可以被所有线程共享
包含了所有的class和static变量

Java类的加载过程

类的加载(Load)

通过将class文件字节码加载到内存, 并且将这些静态数据转换成方法区的运行时数据结构, 然后为之创建一个代表该类的java.lang.Class对象. 此过程由类加载器完成

类的链接(Link)

将类的二进制数据合并到JRE中

验证: 确保加载的类信息JVM规范, 没有安全方面的问题
准备: 正式为类变量(static)分配内存
解析:虚拟机常量池内的符号应用(常量名)替换为直接引用(地址)的过程

类的初始化(Initialize)

JVM负责对类进行初始化.

执行类构造器()方法的过程. 类构造器()方法是由编译器自动收集类中所有类变量的赋值操作和静态代码块中的语句合并产生的. (类构造器是构造类信息的, 不是构造该类对象的构造器).
当初始化一个类的时候, 如果发现其父类还没初始化, 则需要先触发其父类的初始化.
虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步

例子分析(此处存疑,需要看周志明的"深入理解java虚拟机")

package com.peng.reflection;
public class Test05 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(A.m);
    }
}

class A{
    static{
        System.out.println("A类静态代码块初始化");
        m = 300;
    }
    static int m = 100;
    public A(){
        System.out.println("A的无参构造函数初始化");
    }
}
A类静态代码块初始化
A的无参构造函数初始化
100

Process finished with exit code 0

weixin_39981624

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
@value注解_Java注解和反射1

Java注解和反射注解: Annotation作用不是程序本身，可以对程序作出解释可以被其他程序读取格式“@注释名”, 还可以添加一些参数值，例如:@SuppressWarnings(value = "unchecked").哪里使用可以在package，class，method, field上面使用内置注解@Override 重写超类中另一个方法的声明@Deprecated 表示不鼓励使用, ...
复制链接

扫一扫