概要

本文主要是总结Java注解反射的相关知识,加深自己对Java类动态语言的理解,同时为日后学习Spring打下基础。

注解:

什么是注解

  • Annotation的作用

    • 不是程序本身,但是可以对程序作出解释。
    • 可以被其他程序(比如:编译器等)读取。
  • Annotation的格式:

    • 注解是以“@注释名”在代码中存在的,还可以添加一些参数值,例如:@SuppressWarnings(value=”unchecked”)。
  • Annotation使用范围:

    • 附加在package、class、method、field等上面,相当于给他们添加了额外的辅助信息,然后通过反射机制编程实现对这些元数据的访问。

内置注解

  • Override:

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

  • Deprecated:

    定义在java.lang.Deprecated中,此注释可以用于修辞方法、属性、类,表示不鼓励程序员使用这样的元素,通常是因为它很危险或者有更好的选择。

  • SuppressWarnings:

    定义在java.lang.SuppressWarnings中,用来抑制编译时警告信息,与前两个注释不同,此注解需要添加一个参数才可正常使用:

    ➢SuppressWarnings(“all”)

    ➢SuppressWarnings(“unchecked”)

    ➢SuppressWarnings(value={“deprecation”,”unchecked”})

    ➢……

元注解

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

  • 这些类型和他们所支持的类在java.lang.annotation包可以找到:

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

    @Retention:表示需要在什么级别保存该注释信息,用于描述注解的生命周期(SOURCE<CLASS<RUNTIME)。

    @Document:说明该注解将被包含在javadoc中。

    @Inherited:说明子类可以继承父类中的该注解。

自定义注解

  • 使用@interface自定义注解,格式:public @interface 注解名{定义内容}

  • 自定义注解内部的参数格式:参数类型+参数名();若只有一个参数成员,参数名默认为value

  • 注解的元素必须要有值,我们定义注解元素时,一般默认使用空字符串,0作为默认值。

    //注解可以显式赋值,如果没有默认值,则必须赋值
    @myAnnotation(id = 3)
    public class testAnnotation {
        @myAnnotation(id = 5,school = {"THU","CMU"})
        public void test(){
    
        }
    }
    @Target(value = {ElementType.METHOD,ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @interface myAnnotation{
        //注解的参数:参数类型+参数名()
        String name() default "";
        int id();
        int age() default 0;
        String[] school() default {"HDU"};
    }
    

反射:

什么是反射

  • Reflection是Java被视为动态语言的关键,反射机制允许程序在执行期间借助于Reflection API取得任何类的内部信息,并能直接操作任意对象的内部属性及方法。

  • Java在加载完类之后,在堆内存的方法区中就产生了一个Class类型的对象(一个类只有一个Class对象),这个对象就包含了完整的类的结构信息。我们通过这个对象可以看到类的结构,这种过程称为反射。

    • 正常方式:引入需要的“包类”名称➜通过new实例化➜取得实例化对象
    • 反射方式:实例化对象➜getClass()方法➜取得完整的“包类”名称
  • 反射相关的API

    • java.lang.Class:代表一个类

    • java.lang.reflect.Method:代表类的方法

    • java.lang.reflect.Field:代表类的成员变量

    • java.lang.reflect.Constructor:代表类的构造器

      public class test{
          public static void main(String[] args) throws ClassNotFoundException {
              //通过反射获得类的Class对象
              Class<?> c1 = Class.forName("JavaDoc.User");
              Class<?> c2 = Class.forName("JavaDoc.User");
              Class<?> c3 = Class.forName("JavaDoc.User");
              //一个类在内存中只有一个Class对象
              //一个类被加载后,类的整个结构都会被封装在Class对象中
              System.out.println(c1.hashCode());
              System.out.println(c2.hashCode());
              System.out.println(c3.hashCode());
          }
      }
      //实体类 pojo ,Entity
      class User{...}
      //输出结果:hashCode相同
      1846274136
      1846274136
      1846274136
      

获得Class类的方式

  • 若已知具体的类,通过类的class属性获取。

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

  • 若已知一个类的全类名,且该类在类路径下,可以通过Class类的静态方法forName()方法获取。

    public class test02{
        public static void main(String[] args) throws ClassNotFoundException {
            Student student = new Student();
            //通过forName获得
            Class c1 = Class.forName("JavaDoc.Student");
            //通过对象获得
            Class c2 = student.getClass();
            //通过类名.class获得
            Class c3 = Student.class;
          
            System.out.println(c1.hashCode());
            System.out.println(c2.hashCode());
            System.out.println(c3.hashCode());
            //获得父类类型
            System.out.println(c1.getSuperclass().hashCode());
        }
    }
    //实体类 pojo ,Entity
    class Person{...}
    class Student extends Person{...}
    

Java内存分析

Java内存区域 功能
存放new的对象和数组,可以被所有的线程共享,不会存放别的对象引用
存放基本类型变量(包含具体数值)和引用对象的变量(包含具体地址)
方法区 可以被所有线程共享,包含了所有class和static变量

这里只是浅显列出,详细分析需要参考Java的JVM。

Class类初始化

  • 类的主动引用一定会发生类的初始化

    • 当虚拟机启动时,先初始化main方法所在的类。
    • 调用类的静态成员(除了final常量)和静态方法会发生初始化。
    • 使用java.lang.reflect包反射调用会发生初始化。
  • 类的被动引用不会发生类的初始化

    • 当访问一个静态域时,只有真正声明这个域的类才会被初始化。如当通过子类引用父类的静态变量,不会导致子类初始化。
    • 通过数组定义类的引用,不会触发此类的初始化。
    • 引用常量不会触发此类的初始化。
    public class test03{
        static {
            System.out.println("Main类被加载");
        }
        public static void main(String[] args){
            //主动引用
            Son son = new Son();
          	//final不会初始化父类和子类
            System.out.println(Son.M);
        }
    }
    class Father{
        static int b = 3;
        static {
            System.out.println("父类被加载");
        }
    }
    class Son extends Father{
      static {
            System.out.println("子类被加载");
            m = 200;
        }
        static int m = 100;
        static final int M = 1;
    }
    //输出结果
    Main类被加载
    父类被加载
    子类被加载
    100
    

类加载器

类加载器作用是用来把类装载进内存,JVM规范定义了如下类型的类加载器:

  • 系统类加载器:

    负责java -classpath或- D,导入java.class.path所指定的目录下的类与jar包装入工作,是最常用的加载器。

  • 扩展类加载器:

    负责jre/lib/ext目录下的jar包装入工作库。

  • 引导类加载器:

    采取C++编写,是JVM自带的类加载器,负责Java平台的核心库,用来装载核心类库,无法直接获取。

  • 类加载器采取双亲委派机制,自底向上检查类是否已经装载,自顶向下尝试加载类。

    自定义类加载器⇨System Classloader⇨Extension Classloader⇨Bootstrap Classloader

    public class test04{
        public static void main(String[] args){
            //获取系统类加载器
            ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
            System.out.println(systemClassLoader);
            //获取系统类加载器的父类加载器 --> 扩展类加载器
            ClassLoader parent = systemClassLoader.getParent();
            System.out.println(parent);
            //获取扩展类加载器的父类加载器 --> 根加载器(c/c++)
            ClassLoader parent1 = parent.getParent();
            System.out.println(parent1);
            //获取可加载的系统类加载器
            System.out.println(System.getProperty("java.class.path"));
        }
    }
    

类的运行时结构

  • getName()
  • getFields()
  • getMethods()
  • getConstructors()
  • ……
public class test05{
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> c1 = Class.forName("JavaDoc.User");

        //getFields只能获取public类型信息
        System.out.println("===getFields====");
        Field[] field = c1.getFields();
        for (Field field1 : field) {
            System.out.println(field1);
        }
        //getDeclaredFields可获取所有信息
        System.out.println("===getDeclaredFields====");
        field = c1.getDeclaredFields();
        for (Field field1 : field) {
            System.out.println(field1);
        }
    }
}
class User{
    public double score;
    private String name;
    private int id;
    private int age;
}
//输出结果
===getFields====
public double JavaDoc.User.score
===getDeclaredFields====
public double JavaDoc.User.score
private java.lang.String JavaDoc.User.name
private int JavaDoc.User.id
private int JavaDoc.User.age

动态创建对象执行方法

创建类的对象:

调用Class对象的newInstance()方法

  • 类必须有一个无参构造器。
  • 类的构造器访问权限需要足够。

创建步骤:

  • 通过Class类中的getDeclaredConstructor()取得本类的指定形参类型的构造器。
  • 向构造器的形参中传递一个对象数组进去,里面包含了构造器中所需的各个参数。
  • 通过Constructor实例化对象。
public class test06{
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        Class<?> c1 = Class.forName("JavaDoc.User");
        //newInstance默认调用无参构造
        User user = (User) c1.newInstance();
        System.out.println(user);

        //通过构造器声明含参构造重新调用newInstance
        Constructor<?> constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        User user2 = (User) constructor.newInstance("zhangsan", 001, 20);
        System.out.println(user2);

        //通过反射机制调用User类中的方法
        Method setName = c1.getDeclaredMethod("setId", int.class);
        setName.invoke(user,001);
        System.out.println(user.getId());

        //通过关闭程序权限检测,操作程序的私有属性
        User user4 = (User) c1.newInstance();
        Field name = c1.getDeclaredField("name");
        name.setAccessible(true);
        name.set(user4,"zhangsan2");
        System.out.println(user4.getName());
    }
}
class User{
    ...
    public User() {
    }

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

反射操作注解

public class test07{
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class<?> c1 = Class.forName("JavaDoc.User");
        //通过反射获得注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        //获得注解内部value值
        Table table = c1.getAnnotation(Table.class);
        System.out.println(table.value());
        //获取内部指定字段的注解信息
        Field f1 = c1.getDeclaredField("name");
        fieldStudent field = f1.getAnnotation(fieldStudent.class);
        System.out.println(field.columnName());
        System.out.println(field.type());
        System.out.println(field.length());
    }
}
@Table(value = "db_User")
class User{
    @fieldStudent(columnName = "db_name",type = "varchar",length = 3)
    private String name;
    @fieldStudent(columnName = "db_id",type = "int",length = 10)
    private int id;
    @fieldStudent(columnName = "db_age",type = "int",length = 10)
    private int age;
}

//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Table{
    String value();
}

//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface fieldStudent{
    String columnName();
    String type();
    int length();
}
//程序输出
@JavaDoc.Table(value=db_User)
db_User
db_name
varchar
3
本站资源均源自网络,若涉及您的版权、知识产权或其他利益,请附上版权证明邮件告知。收到您的邮件后,我们将在72小时内删除。
若下载资源地址错误或链接跳转错误请联系站长。站长q:770044133。

» Java注解与反射

发表评论

免登录下载网,提供全网最优质的资源集合!