Java基础笔记之注解与反射

注解

注解是从JDK1.5之后引入使用的，注解可以作用在类、方法、成员变量等上面，用于给编译器看的

内置注解

内置注解是JDK自带的注解，常用的有：
1、@Override，修饰方法，表示该方法将要重写父类中的另一个同名方法
2、@Deprecated，修饰方法，表示该方法已经过时，或者有更好的替代方法，不鼓励使用，但是使用程序也是不会报错的（特征是，该方法中间会有一条横线）
3、@SuppressWarning()，该注解需要传入参数，修饰类、成员方法等，抑制警告信息

public class Dog extends Animal {

    //该方法重写了父类的method方法
    @Override
    public void method() {
        System.out.println("狗吃肉");
    }
}

public class Demo01AnnotationTest {

    @Deprecated
    public static void test01(){
        System.out.println("deprecated");
    }
    //使用SuppressWarning可以抑制掉方法test02()未被使用的警告
    @SuppressWarnings("all")
    public static void test02(){
        System.out.println("SuppressWarnings");
    }

    public static void main(String[] args) {
        test01();//在使用被@Deprecated注解过的方法，中间会出现横杠，编译不会报错
    }
}

元注解

元注解是使用在注解上的注解，有以下四种：
1、@Target：用于描述注解的使用范围
ElementType.TYPE 该注解用于类、接口
ElementType.FIFLD 该注解用于成员变量
ElementType.METHOD 该注解用于成员方法
ElementType.PARAMETER 该注解用于方法参数
ElementType.CONSTRUCTOR 该注解用于构造器
ElementType.PACHAGE 该注解用于包
ElementType.ANNOTATION 该注解用于注解
例子

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})

2、@Retention：用于描述注解的生命周期
RetentionPolicy.RUNTIME 运行时注解
RetentionPolicy.CLASS class文件
RetentionPolicy.SOURCE 编译时注解
生命周期: RUNTIME>CLASS>SOURCE
3、@Document：说明该注解将被包含于javadoc中
4、@Inherited：说明子类可以继承父类中的该注解

自定义注解

自定义注解，格式：

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

//自定义注解需要有元注解
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation2 {

    String[] name();   //注解中如果设置了参数，那么在使用该注解时，需要给参数赋值
    int age() default 18; //如果参数设置了默认值，则不再需要赋值，也可以再次赋值
    int id() default -1;  //如果默认值设置为-1，则表示不存在
    String value();
}

使用该注解：

public class Test02Annotation {
    @MyAnnotation2(name={"施瓦辛格"},value="10000000")
    public void test02(){
    }
}

如果注解只有一个参数，参数名称可以设置为value，在使用注解给参数赋值时，可以不写参数名称

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation2 {
    String value();
}

使用：

public class Test02Annotation {
    @MyAnnotation2("施瓦辛格")
    public void test02(){
    }
}

反射机制

反射的概念

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

Class c1 = Class.forName("java.lang.String");
// 调用时，调用类需要抛出ClassNotFoundException异常

在加载完类之后，在堆内存的方法区中就会产生一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完成的类结构信息，我们可以通过这个对象得到类的结构

Java反射机制的功能

1、在运行时判断任意一个对象所属的类
2、在运行时构造一个类的对象
3、在运行时获得任意一个类所具有的成员变量和方法
4、在运行时获取泛型信息
5、在运行时调用任意一个对象的成员变量和方法
6、在运行时处理注解
等等，还有其他功能

public class reflectionTest01 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class c1 = Class.forName("com.itheima.demo05.Reflection.User");
        Class c2 = Class.forName("com.itheima.demo05.Reflection.User");
        Class c3 = Class.forName("com.itheima.demo05.Reflection.User");
        Class c4 = Class.forName("java.lang.String");

        System.out.println(c4.hashCode());
        System.out.println(c1.hashCode());
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
    }
}

运行结果：

同一个类反射得到的对象的hashCode的值是一样的，说明一个类只能得到一个Class对象

D:\jdk1.8\bin\java "-javaagent:D:\IDEA\IntelliJ IDEA 2017.2.6\lib\idea_rt.jar=65508:D:\IDEA\IntelliJ IDEA 2017.2.6\bin" -Dfile.encoding=UTF-8 -classpath 
460141958
1163157884
1163157884
1163157884

Class类

1、对于每个类而言，JRE都会给其保留一个不变的Class对象，Class本身也是一个类，Class对象只能由系统建立；
2、一个Class对象对应的是一个加载到JVM中的一个 .class文件；
3、Class类是Reflection的基础，任何动态加载、运行的类，都要先获得相应的Class对象

Class类的常用方法

方法名	说明
static Class.forName(String name)	返回指定类名name的Class对象
Object newInstance()	调用缺省构造函数，返回Class对象的一个实例
GetName()	返回此Class对象所表示的实体的名称
Class getSuperClass()	返回当前Class对象的父类的Class对象
Class[] getInterfaces()	获取当前Class对象的接口
ClassLoader getClassLoader()	返回该类的类加载器

通过反射获取Class对象的几种方式

获得Class对象的方式有几种：可以通过类的对象获得，可以通过Class类的方法获得，可以通过类名.class获得，下面用一个例子说明一下

public class Test03 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println("我是一名"+person.name);
        //通过类名.class获得，因为通过类名获得的对象，类型已经确认为Student，所以这种方式效率是最高的
        Class c1 = Student.class;
        System.out.println(c1.hashCode());
        //通过对象调用getClass方法获得
        Class c2 = person.getClass();
        System.out.println(c2.hashCode());
        //通过Class类方法获得
        Class c3 = Class.forName("包路径.Student");
        System.out.println(c3.hashCode());

        //一个类只有一个Class对象，所以上面三种方法获得的对象的hashCode值会是一样的
    }
}


class Person{
    public String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }
}

class Student extends Person{
    public Student(){
        this.name = "学生";
    }
}

class Teacher extends Person{
    public Teacher(){
        this.name = "老师";
    }
}

基本的内置类型的包装类都有一个Type属性可以获取类的Class对象

//获取包装类的Class对象
        Class int1 = Integer.TYPE;

还可以通过子类的Class对象获得父类的Class对象

//可以通过子类的Class对象获得父类的Class对象
        Class c1Superclass = c1.getSuperclass();

类加载器内存分析

类加载过程：类加载（Load) → 类的链接（Link）→ 类的初始化（Initialize）
类会先初始化静态代码块，再初始化构造函数

1、加载到内存，会产生一个类对应的Class对象
2、链接，链接结束后 m = 0
3、初始化
(){
System.out.println(“初始化静态代码块”);
m = 300;
m = 100;
}

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

}
    class A{
    static {
        System.out.println("初始化静态代码块");
        int m = 300;
    }

    static int m = 100;

    public A(){
        System.out.println("初始化构造方法");
    }

}

运行结果

注意事项：1、通过子类调用父类的静态方法、成员变量，不会初始化子类
2、用子类来定义一个数组类型，该类不会被初始化
3、调用类中被final修饰的常量，该类不会被初始化
4、Method和Field、Constructor对象都有setAccessible()方法，作用是启动（false）和禁用（true）访问安全检查的开关，使得使用反射也可以访问private修饰的方法和属性

类加载器的作用

类加载的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口
类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。最后通过JVM的垃圾回收机制清除

类加载会使用双亲委派机制，保证类加载的安全性

使用反射对性能的影响

public class Test10 {
    public static void main(String[] args) throws InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
        test01();
        test02();
        test03();
    }

    public static void test01(){
        User user = new User();
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            user.getName();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("普通方式执行10亿次："+(endTime - startTime));
    }

    public static void test02() throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Class<User> c1 = User.class;
        User user = c1.newInstance();
        Method getName = c1.getDeclaredMethod("getName", null);
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            getName.invoke(user,null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("通过反射方式执行10亿次："+(endTime - startTime));
    }

    public static void test03() throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Class<User> c1 = User.class;
        User user = c1.newInstance();
        Method getName = c1.getDeclaredMethod("getName", null);
        getName.setAccessible(true);
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            getName.invoke(user,null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("通过反射方式,关闭检测执行10亿次："+(endTime - startTime));
    }
}

运行结果：

通过反射获取注解信息

分别定义作用类和属性的注解
1、TableAnnotation.java

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

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TableAnnotation {
    String value();
}

2、FieldAnnotation.java

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

/**
 * @author hfr
 * @date 2021/3/20 - 19:15
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface FieldAnnotation {
    String columnName();
    String type();
    int length();
}

定义一个类StudentOne.java，用以上两个注解进行修饰

@TableAnnotation("db_student")
public class StudentOne {

    @FieldAnnotation(columnName = "姓名",type = "String",length = 20)
    private String name;
    @FieldAnnotation(columnName = "年龄",type = "String",length = 2)
    private int age;
    @FieldAnnotation(columnName = "编号",type = "Int",length = 10)
    private int id;

    public StudentOne() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public int getId() {
        return id;
    }

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

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

使用反射将类和属性的注解的值打印出来

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;

public class Test12 {
    public static void main(String[] args) throws NoSuchFieldException {
        Class<StudentOne> c1 = StudentOne.class;

        //通过反射获取注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        //获取类的注解的value值
        TableAnnotation tableAnnotation = (TableAnnotation)c1.getAnnotation(TableAnnotation.class);
        String value = tableAnnotation.value();
        System.out.println(value);
        //获取属性的注解的值
        Field name = c1.getDeclaredField("name");
        FieldAnnotation fieldAnnotation = name.getAnnotation(FieldAnnotation.class);
        System.out.println(fieldAnnotation.columnName());
        System.out.println(fieldAnnotation.type());
        System.out.println(fieldAnnotation.length());
    }

}

运行结果

总结

断断续续利用业余时间把注解和反射的知识学习完了，其中有很多的地方看一遍不懂，需要看几次才能理解，总的来说还是需要愿意花费时间和心思，多思考，还要把所有的代码都敲一遍。
学习程序，需要付出极多的时间和耐心，不能浮躁。