大三java学习笔记之注解与反射

大三java学习笔记之注解与反射

前言

注解与反射是框架(mybatis,spring boot)底层实现机制。
注解与注释：注解(Annotation)不但能给人看还能给程序看，甚至还能被其他程序读取(通过反射读取)。
Annotation 可以附加在package , class , method , field 等上面,相当于给他们添加了额外的辅助信息,我们可以通过反射机制编程实现对这些元数据的访问。

内置注解

@Overide :定义在java.lang.Override中,此注释只适用于修饰方法，表示一个方法声明打算重写超类中的另一个方法声明。
@Deprecated :定义在java.lang.Deprecated中,此注释可以用于修饰方法, 属性,类,表示不鼓励程序员使用这样的元素,通常是因为它很危险或者存在更好的选择。
@SuppressWarnings :定义在java.lang.SuppressWarnings中,用来抑制编译时的警告信息，你需要添加一个参数才能正确使用，如@SuppressWarnings(“all”),@SuppressWarnings(“unchecked”)

元注解

元注解的作用就是负责注解其他注解，Java定义了4个标准的meta-annotation(元注解)类型,他们被用来提供对其他annotation类型作说明。
➢@Target :用于描述注解的使用范围(即:被描述的注解可以用在什么地方)
➢@Retention :表示需要在什么级别保存该注释信息,用于描述注解的生命周期(RUNTIME)
➢@Document:说明该注解将被包含在javadoc中
➢@Inherited:说明子类可以继承父类中的该注解

自定义注解

public class Test02 {
     
    //注解可以显示赋值，如果没有默认值，我们就必须给注解赋值
    @MyAnnotation(name="test")
    public void test(){
     }
    @MyAnnotation2("myname") //用value命名并只有一个参数时可以省略
    public void test2(){
     }
}

//定义一个注解
@Target(value = {
     ElementType.METHOD,ElementType.TYPE})  //Target 表示我们的注解可以用在哪些地方
@Retention(value = RetentionPolicy.RUNTIME)      //Retention 表示我们的注解生命周期
        // RUNTIME都有效，SOURCE源码有效，CLASS编译成class文件有效
@Documented  //是否将我们的注解生成在JAVAdoc中
@Inherited     //子类可以继承父类的注解
@interface MyAnnotation{
     
    //注解的参数：参数类型+参数名();
    String name();
    int age() default 2;
    String[] schools() default {
     "清华大学","北京大学"};
}

@Target(value = {
     ElementType.METHOD,ElementType.TYPE})
@Retention(value = RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
     
    //如果只有一个参数建议用value命名;
    String value();
}

反射机制

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

Class C = Class.forName( java.lang.String )

加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象(一个类只有一个Class对象)， 这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像- -面镜子， 透过这个镜子看到类的结构，所以,我们形象的称之为:反射

优点：
➢可以实现动态创建对象和编译，体现出很大的灵活性

缺点：
➢对性能有影响。使用反射基本上是一种解释操作,我们可以告诉JVM,我们希望
做什么并且它满足我们的要求。这类操作总是慢于直接执行相同的操作。

Class类

public final Class getClass() 此类在Object类中定义，返回值的类型是一个Class类，此类是Java反射的源头。
获取实例的方法：

public class Test02 {
     
    public static void main(String[] args) throws ClassNotFoundException {
     
        Person person=new Student();
        System.out.println("这个人是："+person.name);

        //方式一: 通过类名.class获得(该方法最为安全可靠，程序性能最高)
        Class c1=Student.class;
        System.out.println(c1.hashCode());

        //方式二: 通过对象加载
        Class c2=person.getClass();
        System.out.println(c2.hashCode());

        //方式三: 通过forname获得
        Class c3=Class.forName("Reflection.Demo01.Student");
        System.out.println(c3.hashCode());

        //方式四: 基本内置类型的包装类都有一 个Type属性
        Class c4=Integer.TYPE;
        System.out.println(c4);

        //获得父类类型
        Class c5=c1.getSuperclass();
        System.out.println(c5);
    }
}

class Person{
     
    public String name;

    public Person() {
     
    }

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

    @Override
    public String toString() {
     
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

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

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

Java内存分析

在JDK1.8中，使用元空间代替永久代来实现方法区，但是方法区并没有改变，变动的只是方法区中内容的物理存放位置。正如上面所说，类型信息（元数据信息）等其他信息被移动到了元空间中；但是运行时常量池和字符串常量池被移动到了堆中

因此JDK1.8中字符串常量池和运行时常量池逻辑上属于方法区，但是实际存放在堆内存中，因此既可以说两者存放在堆中，也可以说两则存在于方法区中。

元空间的本质和永久代类似，都是对JVM规范中方法区的实现。不过元空间与永久代之间最大的区别在于：元空间并不在虚拟机中，而是使用本地内存。因此，默认情况下，元空间的大小仅受本地内存限制，但可以通过以下参数来指定元空间的大小

类的加载：
当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过
如下三个步骤来对该类进行初始化。

加载:将class文件字节码内容加载到内存中(需要用到类加载器)，并将这些静态数据转换成方法区的运行时数据结构,然后生成一个代表这个类的java.lang.Class对象。

链接:将Java类的二进制代码合并到JVM的运行状态之中的过程。
➢验证:确保加载的类信息符合JVM规范，没有安全方面的问题
➢准备:正式为类变量(static) 分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。
➢解析:虚拟机常量池内的符号引用(常量名)替换为直接引用(地址)的过程。

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

重要知识点：class类是在什么时候产生的
java类先加载进方法区，加载完成再立马生成class对象，再指向堆

什么时候会发生类的初始化

➢类的主动引用(一定会发生类的初始化)
➢当虚拟机启动，先初始化main方法所在的类
➢new一个类的对象
➢调用类的静态成员(除了final常量)和静态方法
➢使用java.lang.reflect包的方 法对类进行反射调用
➢当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类

➢类的被动引用(不会发生类的初始化)
➢当访问一个静态域时，只有真正声明这个域的类才会被初始化。如:当通过子类弓|用父类的静 态变量,不会导致子类初始化
➢通过数组定义类引用，不会触发此类的初始化
➢引用常量不会触发此类的初始化(常量在链接阶段就存入调用类的常量池中了)

//测试类什么时候会初始化
public class Test05 {
     

    static{
     
        System.out.println("Main类被加载");
    }

    public static void main(String[] args) {
     
        //1.主动引用
      //  Son son=new Son();

        //反射特惠产生主动引用
        Class c1=Son.class;

        //子类调用父类方法，并不会让子类加载
        System.out.println(Son.b);

        //创建数组没有任何类被加载
        Son[] array=new Son[5];

        //引用常量并不会引起父类与子类的初始化
        System.out.println(Son.M);

    }
}

class Father{
     

    static int b=2;

    static {
     
        System.out.println("父类被加载");
    }
}

class Son extends Father{
     
    static {
     
        System.out.println("子类被加载");
        m=300;
    }

    static int m=100;
    static final int M=1;
}

类加载器

类加载器作用是用来把类(class)装载进内存的。JVM规范定义了如下类型的类的加载器
1.引导类加载器(根加载器)
负责Java平台核心库(在jre的lib目录下的rt.jar中)，用c++编写，用来装载核心类
2.扩展类加载器
负贵jre/ib/ext目录下的jar包，指定目录下的jar包装入工作库
3.系统类加载器
负责java - classpath或-D java.class. path所指的目录下的类与jar包装入工作，是最常用的加载器

获得class对象之后干什么

使用Class.forName( )静态方法的目的是为了动态加载类。
在加载完成后，一般还要调用Class下的newInstance()静态方法来实例化对象以便操作

通过构造器创建对象：

 Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        User user = (User) constructor.newInstance("lmj", 001, 18);
        System.out.println(user);

调用指定方法和属性：

 //通过反射调用普通方法
        User user2 = (User) c1.newInstance();
        //获得方法
        Method setName = c1.getDeclaredMethod("setName", String.class);
        setName.invoke(user2,"lmj2");  //(invoke：激活setName方法)
        System.out.println(user2.getName());

//通过反射操作属性
 User user3 = (User) c1.newInstance();
        Field name = c1.getDeclaredField("name"); //获得属性

        //不能直接操作私有属性，需要关掉安全权限检测
        name.setAccessible(true);  //关掉权限检测，能提高反射效率
        name.set(user3,"lmj3");
        System.out.println(user3.getName());

若原方法声明为private,则需要在调用此invoke()方法前，显式调用方法对象的
setAccessible(true)方法，将可访问private的方法。

反射操作注解

ORM : Object relationship Mapping -->对象关系映射(将java的类映射成数据库里的表)

总结：