目录

  • 一.注解
  • 1.1.什么是注解
  • 1.2.java的内置注解
  • 1.3.元注解(代码包含了怎么自定义注解)
  • 1.4.自定义注解
  • 二.反射(java.Reflection)
  • 2.1反射概述
  • 2.1.0 反射题外话
  • 2.1.1 反射基本概念
  • 2.1.2 反射优缺点
  • 2.1.3 反射的简单创建
  • 2.1.4 class类
  • 2.1.5 反射能干嘛
  • 2.2类的加载
  • 2.2.1 java运行时内存
  • 2.2.2 类的加载过程
  • 2.2.3 类的初始化(什么时候会发生类的初始化)
  • 2.2.3 类加载器
  • 2.2.4 通过反射获得了class对象后可以做什么?


一.注解

1.1.什么是注解

1.注解从jdk1.5引入
2.可以对程序进行解释和被其他程序读取
3.注解就是以@注释名方式出现的,还能带value参数
4.注解可以在哪使用:注解可以用在package.class,method,field上使用,相当于添加了额外的辅助信息,可以通过反射机制编程实现对元数据的访问

1.2.java的内置注解

  • @Deprecated 已过期,表示方法是不被建议使用的
  • @Override 重写,标识覆盖它的父类的方法
  • @SuppressWarnings 压制警告,抑制警告,就是讲警告解除

1.3.元注解(代码包含了怎么自定义注解)

作用在其他注解的注解(或者说 元注解)是:

  • @Retention - 表示注解在什么地方还有效
  • @Documented - 标记这些注解是否包含在javadoc文档中。
  • @Target - 标记这个注解应该是哪种 Java 成员,描述注解可以用在什么地方,比如用在方法上,用在类上。
  • @Inherited - 标记这个注解可以使得子类继承父类的注解
import java.lang.annotation.*;

public class annotation {

}
//1.表示注解可以用在哪些地方
@Target(value = {ElementType.METHOD,ElementType.TYPE})
//2.Retention表示注解在什么地方还有效,,一般souce<class<runtime
@Retention(value = RetentionPolicy.RUNTIME)
//3.Documented表示是否讲我们的注解生成在javadoc中
@Documented

//4.子类可以继承父类的注解
@Inherited

**//这个就是相当于定义了一个自定义注解MyAnnotation**
@interface MyAnnotation{

}

1.4.自定义注解

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

public class annotation2 {
    @MyAnnotation2(name = "xx",age=11)
    public void test1(){

    }
    
    
    @MyAnnotation3("dd")
    public  void test2(){

    }
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
    //注解的参数:参数类型+参数名().default如下
    String name() default "";
    int age();
    int id() default  -1;//默认值是-1代表不存在
    //数组
    String[] schools() default {"清华","北大"};
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation3{
    //当只有一个参数的时候,默认写参数名字就是value;
    String value();

}

二.反射(java.Reflection)

2.1反射概述

2.1.0 反射题外话

利用反射机制可以使得java获得类似动态语言的特性,java的动态性让编程的时候更加灵活。
jdbc就是就是通过使用反射加载驱动,关于为什么jdbc要使用反射加载驱动?
直接import com.mysql.jdbc.Driver其实效果是一样的,但是为啥要反射加载
a.以反射形式加载的一个好处是当驱动jar包不存在时,可以做更多的操作。运行期以反射的方式来检查JDBC驱动的主类com.mysql.jdbc.Driver是否存在,若不存则表示运行环境中没有这个驱动,进入catch段,然后做相应操作,因为不知道它存在不存在,直接引入包的话,就会报错。
b.还有就是解耦,直接引入import com.mysql.jdbc.Driver违反了开闭原则的扩展原则

(1)动态语言(弱类型语言)
动态语言是在运行时确定数据类型的语言。比如python里面变量不需要类型声明,变量的类型就是被赋值的那个值的类型。
如PHP/Ruby/Python/SQL/JavaScript等等。
(2)静态语言(强类型语言)
静态语言是在编译时变量的数据类型即可确定的语言,多数静态类型语言要求在使用变量之前必须声明数据类型。
例如:C,C++、Java。

2.1.1 反射基本概念

1.反射使得java在生成class文件后还能够对对象进行修改、

2.反射机制允许程序在执行期能够借助Reflection API取得任何类的内部信息,并能直接操作对象的内部属性和方法

3.加载类后,在堆内存方法区域中产生了class类型的对象,这个对象包含了完整的类的结构信息。可以通过这个对象去看到类的结构。这个对象就像是镜子,通过这个镜子去看到类内结构,所以形象称之为反射。

4.正常new和反射的差别(引入包类名称就是import包)

java反射获取注解中的指定field重新赋值_java

2.1.2 反射优缺点

优点:可以实现动态创建对象和编译,有很大灵活性。举例子(项目底层有时是用mysql,有时用oracle,需要动态地根据实际情况加载驱动类,这个时候反射就有用)
缺点:对性能有很大影响(反射是动态的对类型、方法进行解析,肯定是会比直接调用慢一点,vm无法进行优化)

2.1.3 反射的简单创建

一个类被加载后,类的整个结构都会被封装在class对象中,一个类的内存中只有一个class对象

package reflection;
//什么叫反射
public class test01 {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的class对象
        Class<?> c1 = Class.forName("reflection.User");
        Class<?> c2 = Class.forName("reflection.User");
        System.out.println(c1.hashCode());
        System.out.println(c2.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 +
                '}';
    }
}

2.1.4 class类

因为在object中定义了一个final方法:public final Class getClass(),所以此方法将被所有的子类继承
Class类是java反射的源头,其实反射就是通过对象去求出类的名称。见2.1.1。

1.是一个类,存在于java.lang包中,它的构造函数是私有的,由JVM(类加载器)创建Class对象,我们可以通过getClass()方法获取到Class对象

2.Class类的作用

(1)获取类中属性的类型

(2)获取类中属性的名称

(3)获取类的方法

(4)获取类的基类等等

(5)综合上述通过表class可以完整得到一个类中的所有被加载的结构,他是反射的根源,可以利用它完成反射

3.class类常用方法

java反射获取注解中的指定field重新赋值_初始化_02


4.反射获得class类的四种方式

1.调用运行时类本身的.class属性

Class clazz = String.class;

2,通过运行时类的对象获取

Person p = new Person();

Class clazz = p.getClass();

3.通过Class的静态方法获取:体现反射的动态性

String className = “java.util.commons”;

Class clazz = Class.forName(className);

4.通过类的加载器

String className = “java.util.commons”;

ClassLoader classLoader = this.getClass().getClassLoader();

Class clazz = classLoader.loadClass(className);

5.哪些类型具有class对象

Class c2 = Comparable.class; // 接口

Class c3 = String[].class; // 一维数组

Class c4 = int[][].class; // 二维数组

Class c5 = Override.class; // 注解

Class c6 = ElementType.class; // 枚举

Class c7 = Integer.class; // 基本数据类型

Class c8 = void.class; // 空类型

Class c9 = Class.class; // Class本身

注意点:如果数组的维度和类型是一样的,就是同一个class

2.1.5 反射能干嘛

java反射获取注解中的指定field重新赋值_java_03


项目底层有时是用mysql,有时用oracle,需要动态地根据实际情况加载驱动类,可以根据反射根据实际情况动态的加载驱动类。

运行时候获取注解的信息等等。

还有比如动态获取注解的信息,注解参数传入的信息。

2.2类的加载

2.2.1 java运行时内存

java反射获取注解中的指定field重新赋值_java_04

2.2.2 类的加载过程

java反射获取注解中的指定field重新赋值_初始化_05


(1)类的加载

java反射获取注解中的指定field重新赋值_初始化_06

(2)类的链接
验证:验证的目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求,并且不会危害虚拟机自身的安全。
准备:正式为类变量(即static变量)分配内存(方法区)并为类变量赋初默认值.
解析:将虚拟机中常量池内的符号引用替换为直接引用(地址)。.

(3)类的初始化
0.执行类构造器(不是普通的类对象的构造器)的()方法,它是讲所有的变量的赋值动作什么的进行合并产生的。就是讲代码进行整合。
1.如果这个类没有被加载、连接,则程序先加载、连接该类;
2.如果该类的直接父类没有被初始化,则先初始化直接父类;
3.如果该类中有初始化语句则先执行初始化语句

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

  • 1.类的主动引用(一定会发生类的初始化)
    (1)当虚拟机启动,先初始化main方法所在的类
    (2)new一个类的对象
    (3)调用类的静态成员(除了final常量)和静态方法
    (4)使用java.lang.reflect包的方法对类进行反射调用。
    (5)当初始化一个类,如果其父类没有被初始化,则先会初始化它的父类
  • 2.类的被动引用(不会发生类的初始化)
    (1)当访问一个静态域时,只有真正声明这个域的类才会被初始化。如:当通过子类引用父类的静态变量,不会导致子类初始化
    (2)通过数组定义类引用,不会触发此类的初始化,就是类是class son{},然后Son[] array = new Son[5],这种类是不会有初始化的
    (3)引用常量不会触发此类的初始化(常量在链接阶段就存入调用类的常量池中)

2.2.3 类加载器

类加载器负责加载 Java 类的字节代码(.class)到 Java 虚拟机中。

java反射获取注解中的指定field重新赋值_加载_07

2.2.4 通过反射获得了class对象后可以做什么?

获得这个类对象后可以对这个对象操作,可以获得对象实例,通过反射获取方法,属性等

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


        //通过这个可以获取一个对象实例,其实就是调用了一个无参构造器
        User user3 = (User)c3.newInstance();
        //通过反射获取普通方法,表示获取setName方法,这个方法的传入参数是String
        Method setName = c3.getDeclaredMethod("setName",String.class);
        //invoke:激活这个方法
        //(对象,"方法的值"),这样就完成了这个方法的调用
        setName.invoke(user3,"xxx");
        //获取反射的属性,属性是private就获取不了
        //除非前面加上setAccessible(true)。
        Field name  = c1.getDeclaredField("name");
        name.setAccessible(true);
        name.set(user3,"fwe");