类加载+注解

最新推荐文章于 2024-03-22 23:27:21 发布

淘气包海鸟

最新推荐文章于 2024-03-22 23:27:21 发布

阅读量654

点赞数

分类专栏： Java 文章标签： java 缓存 android

本文链接：https://blog.csdn.net/weixin_42229564/article/details/124902394

版权

Java 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

文章目录

类加载器
- 类加载器工作机制
- JVM的类加载机制
反射
注解

类加载器

类加载：当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过类的加载，类的连接，类的初始化这三个步骤来对类进行初始化。
类加载器的作用：负责将.class文件加载到内存中，并为之生成对应的 java.lang.Class 对象。

类加载器工作机制

类加载过程（生命周期）：加载，验证，准备，解析，初始化

类的加载
- 指将class文件读入内存，并为之创建一个 java.lang.Class 对象
- 任何类被使用时，系统都会为之建立一个 java.lang.Class 对象
- 简称：将Java二进制代码导入jvm中，生成Class文件
类的连接
- 验证阶段：用于检验被加载的类是否有正确的内部结构，并和其他类协调一致
  - 简称：检查载入Class文件数据的正确性
- 准备阶段：负责为类的类变量分配内存，并设置默认初始化值
  - 简称：给类的静态变量分配存储空间
- 解析阶段：将类的二进制数据中的符号引用替换为直接引用
  - 简称：将符号引用转成直接引用
类的初始化
- 假如类还未被加载和连接，则程序先加载并连接该类
- 假如该类的直接父类还未被初始化，则先初始化其直接父类
- 假如类中有初始化语句，则系统依次执行这些初始化语句

JVM的类加载机制

全盘负责：就是当一个类加载器负责加载某个Class时，该Class所依赖的和引用的其他Class也将由该类加载器负责载入，除非显示使用另外一个类加载器来载入
父类委托：就是当一个类加载器负责加载某个Class时，先让父类加载器试图加载该Class，只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类
缓存机制：保证所有加载过的Class都会被缓存，当程序需要使用某个Class对象时，类加载器先从缓存区中搜索该Class，只有当缓存区中不存在该Class对象时，系统才会读取该类对应的二进制数据，并将其转换成Class对象，存储到缓存区

反射

反射是指对于任何一个Class类，在"运行的时候"都可以直接得到这个类全部成分。
- 在运行时,可以直接得到这个类的构造器对象：Constructor
- 在运行时,可以直接得到这个类的成员变量对象：Field
- 在运行时,可以直接得到这个类的成员方法对象：Method
反射的关键：
反射的第一步都是先得到编译后的Class类对象，然后就可以得到Class的全部成分。

Java获取反射的三种方法

使用类的class属性来获取该类对应的Class对像。举例：Student·class会返回Student类对应的Class对像
类名.class属性
调用对象的getClass（）方法，返回该对像所属类对应的Class对像
该方法是0bject类中的方法，所有的java对象都可以调用该方法
对象名.getClass()方法
使用Class类中的静态方法forName(String className)，该方法需要传入字符串参数，该字符串参数的值是某个类的全路径，也新是完整包名的路径
Class.forName( 全类名 ) 方法

public class Student {
    private int id;
    String name;
    protected boolean sex;
    public float score;
}

public class Get {
    //获取反射机制三种方式
    public static void main(String[] args) throws ClassNotFoundException {
        //调用对象的getClass()方法，返回该对象所属类对应的Class对象
        Student stu = new Student();
        Class classobj1 = stu.getClass();
        System.out.println(classobj1.getName());
        //使用Class类中的静态方法forName(String className)
        //获得字符串所标识的类的class对象
        Class classobj2 = Class.forName("fanshe.Student");
        System.out.println(classobj2.getName());
        //使用类的class属性来获取该类对应的Class对象
        Class classobj3 = Student.class;
        System.out.println(classobj3.getName());
    }
}

反射机制优缺点

优点：运行期类型的判断，动态加载类，提高代码灵活度。
缺点：性能瓶颈：反射相当于一系列解释操作，通知 JVM 要做的事情，性能比直接的java代码要慢很多。

反射机制的应用场景有哪些？

反射是框架设计的灵魂。
模块化的开发，通过反射去调用对应的字节码；
动态代理设计模式也采用了反射机制;
JDBC连接数据库时使用Class.forName()通过反射加载数据库的驱动程序；
Spring／Hibernate 等框架也大量使用到了反射机制。
- xml的配置模式。Spring 通过 XML 配置模式装载 Bean 的过程：
  - 将程序内所有 XML 或 Properties 配置文件加载入内存中;
  - Java类里面解析xml或properties里面的内容，得到对应实体类的字节码字符串以及相关的属性信息;
  - 使用反射机制，根据这个字符串获得某个类的Class实例;
  - 动态配置实例的属性

反射为何可以给约定了泛型的集合存入其他类型的元素？

编译成Class文件进入运行阶段的时候，泛型会自动擦除。
反射是作用在运行时的技术，此时已经不存在泛型了。

反射的作用

可以在运行时得到一个类的全部成分然后操作。
可以破坏封装性。（很突出）
也可以破坏泛型的约束性。（很突出）
更重要的用途是适合：做Java高级框架
基本上主流框架都会基于反射设计一些通用技术功能。

获取构造器

Constructor getConstructor(Class… parameterTypes)
根据参数匹配获取某个构造器，只能拿public修饰的构造器
Constructor getDeclaredConstructor(Class… parameterTypes)
根据参数匹配获取某个构造器，只要申明就可以定位，不关心权限修饰符
Constructor[] getConstructors()
获取所有的构造器，只能拿public修饰的构造器
Constructor[] getDeclaredConstructors()
获取所有申明的构造器，只要你写我就能拿到，无所谓权限

package 反射.构造方法;

import org.junit.Test;
import 反射.Student;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class ReflectDemo01 {
    // 1. getConstructors:
    // 获取全部的构造器：只能获取public修饰的构造器。
    // Constructor[] getConstructors()
    @Test
    public void getConstructors(){
        // a.第一步：获取类对象
        Class c = Student.class;
        // b.提取类中的全部的构造器对象(这里只能拿public修饰)
        Constructor[] constructors = c.getConstructors();
        // c.遍历构造器
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + "===>" + constructor.getParameterCount());
        }
    }


    // 2.getDeclaredConstructors():
    // 获取全部的构造器
    @Test
    public void getDeclaredConstructors(){
        // a.第一步：获取类对象
        Class c = Student.class;
        // b.提取类中的全部的构造器对象
        Constructor[] constructors = c.getDeclaredConstructors();
        // c.遍历构造器
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + "===>" + constructor.getParameterCount());
        }
    }

    // 3.getConstructor(Class... parameterTypes)
    // 获取某个构造器：只能拿public修饰的某个构造器
    @Test
    public void getConstructor() throws Exception {
        // a.第一步：获取类对象
        Class c = Student.class;
        // b.定位单个构造器对象 (按照参数定位无参数构造器 只能拿public修饰的某个构造器)
        Constructor cons = c.getConstructor();
        System.out.println(cons.getName() + "===>" + cons.getParameterCount());
    }


    // 4.getConstructor(Class... parameterTypes)
    // 获取某个构造器
    @Test
    public void getDeclaredConstructor() throws Exception {
        // a.第一步：获取类对象
        Class c = Student.class;
        // b.定位单个构造器对象 (按照参数定位无参数构造器)
        Constructor cons = c.getDeclaredConstructor();
        System.out.println(cons.getName() + "===>" + cons.getParameterCount());

        // c.定位某个有参构造器
        Constructor cons1 = c.getDeclaredConstructor(String.class, int.class);
        System.out.println(cons1.getName() + "===>" + cons1.getParameterCount());

    }

}

创建对象

Constructor类中用于创建对象的方法
- T newInstance(Object… initargs) 根据指定的构造方法创建对象
- public void setAccessible(boolean flag) 设置为true,表示取消访问检查，进行暴力反射

public class ReflectDemo011 {
    // 1.调用构造器得到一个类的对象返回。
    @Test
    public void getDeclaredConstructor() throws Exception {
        // a.第一步：获取类对象
        Class c = Student.class;
        // b.定位单个构造器对象 (按照参数定位无参数构造器)
        Constructor cons = c.getDeclaredConstructor();
        System.out.println(cons.getName() + "===>" + cons.getParameterCount());

        // 如果遇到了私有的构造器，可以暴力反射
        cons.setAccessible(true); // 权限被打开

        Student s = (Student) cons.newInstance();
        System.out.println(s);

        System.out.println("-------------------");

        // c.定位某个有参构造器
        Constructor cons1 = c.getDeclaredConstructor(String.class, int.class);
        System.out.println(cons1.getName() + "===>" + cons1.getParameterCount());

        Student s1 = (Student) cons1.newInstance("哈哈", 10);
        System.out.println(s1);
    }

}

获取方法

Method getMethod(String name,Class…args);
根据方法名和参数类型获得对应的方法对象，只能获得public的
Method getDeclaredMethod(String name,Class…args);
根据方法名和参数类型获得对应的方法对象，包括private的
Method[] getMethods();
获得类中的所有成员方法对象，返回数组，只能获得public修饰的且包含父类的
Method[] getDeclaredMethods();
获得类中的所有成员方法对象，返回数组,只获得本类申明的方法。
Method的方法执行：
- Object invoke(Object obj, Object… args)
- 参数一：触发的是哪个对象的方法执行。
  参数二： args：调用方法时传递的实际参数

package 反射.成员方法;

import org.junit.Test;



import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectDemo01 {

        /**
         * 1.获得类中的所有成员方法对象
         */
        @Test
        public void getDeclaredMethods(){
            // a.获取类对象
            Class c = Student.class;
            // b.提取全部方法；包括私有的
            Method[] methods = c.getDeclaredMethods();
            // c.遍历全部方法
            for (Method method : methods) {
                System.out.println(method.getName() +" 返回值类型：" + method.getReturnType() + " 参数个数：" + method.getParameterCount());
            }
        }

        /**
         * 2. 获取某个方法对象
         */
        @Test
        public void getDeclardMethod() throws Exception {
            // a.获取类对象
            Class c = Student.class;
            // b.提取单个方法对象
            Method m = c.getDeclaredMethod("method");
            Method m2 = c.getDeclaredMethod("method", String.class);

            // 暴力打开权限了
            m.setAccessible(true);
            m2.setAccessible(true);

            // c.触发方法的执行
            Student d = new Student();
            // 注意：方法如果是没有结果回来的，那么返回的是null.
            Object result = m.invoke(d);
            System.out.println(result);

            Object result2 = m2.invoke(d, "好好学习");
            System.out.println(result2);
        }
    }

获取成员变量

Field getField(String name);
根据成员变量名获得对应Field对象，只能获得public修饰
Field getDeclaredField(String name);
根据成员变量名获得对应Field对象，只要申明了就可以得到
Field[] getFields();
获得所有的成员变量对应的Field对象，只能获得public的
Field[] getDeclaredFields();
获得所有的成员变量对应的Field对象，只要申明了就可以得到

获取全部成员变量：getDeclaredFields
获取某个成员变量：getDeclaredField

package 反射.成员变量;

import org.junit.Test;
import 反射.Student;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;



public class ReflectDemo01 {
       /**
         * 1.获取全部的成员变量。
         * Field[] getDeclaredFields();
         *  获得所有的成员变量对应的Field对象，只要申明了就可以得到
         */
        @Test
        public void getDeclaredFields(){
            // a.定位Class对象
            Class c = Student.class;
            // b.定位全部成员变量
            Field[] fields = c.getDeclaredFields();
            // c.遍历一下
            for (Field field : fields) {
                System.out.println(field.getName() + "==>" + field.getType());
            }
        }

        /**
         2.获取某个成员变量对象 Field getDeclaredField(String name);
         */
        @Test
        public void getDeclaredField() throws Exception {
            // a.定位Class对象
            Class c = Student.class;
            // b.根据名称定位某个成员变量
            Field f = c.getDeclaredField("age");
            System.out.println(f.getName() +"===>" + f.getType());
        }

 }

取值和赋值

void set(Object obj, Object value)：给对象注入某个成员变量数据
Object get(Object obj):获取对象的成员变量的值。
void setAccessible(true);暴力反射，设置为可以直接访问私有类型的属性。
Class getType(); 获取属性的类型，返回Class对象。
String getName(); 获取属性的名称。

package 反射.成员变量;

import org.junit.Test;
import 反射.Student;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;


public class ReflectDemo02 {
	  @Test
	   public void setField() throws Exception {
	       // a.反射第一步，获取类对象
	       Class c = Student.class;
	
	       // b.提取某个成员变量
	       Field ageF = c.getDeclaredField("age");
	
	       ageF.setAccessible(true); // 暴力打开权限
	
	       // c.赋值
	       Student s = new Student();
	       ageF.set(s , 18);  // s.setAge(18);
	       System.out.println(s);
	
	       // d、取值
	       int age = (int) ageF.get(s);
	       System.out.println(age);
	
	   }
 }

注解

注解的作用

对Java中类、方法、成员变量做标记，然后进行特殊处理。
例如：JUnit框架中，标记了注解@Test的方法就可以被当成测试方法执行，而没有标记的就不能当成测试方法执行

自定义注解

就是自己做一个注解来使用

public @interface 注解名称 {    
public 属性类型 属性名() default 默认值 ;
}

元注解：就是注解注解的注解

@Target: t约束自定义注解可以标记的范围，约束自定义注解只能在哪些地方使用
- 可使用的值定义在ElementType枚举类中
@Retention：申明注解的生命周期
- 可使用的值定义在RetentionPolicy枚举类中，常用值如下

SOURCE： 注解只作用在源码阶段，生成的字节码文件中不存在  
CLASS：  注解作用在源码阶段，字节码文件阶段，运行阶段不存在，默认值.  
RUNTIME：注解作用在源码阶段，字节码文件阶段，运行阶段（开发常用）

注解解析

注解的操作中经常需要进行解析，注解的解析就是判断是否存在注解，存在注解就解析出内容。

Annotation: 注解的顶级接口，注解都是Annotation类型的对象
AnnotatedElement:该接口定义了与注解解析相关的解析方法

淘气包海鸟

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
类加载+注解

文章目录类加载器类加载器工作机制JVM的类加载机制反射Java获取反射的三种方法反射机制优缺点反射机制的应用场景有哪些？反射为何可以给约定了泛型的集合存入其他类型的元素？反射的作用获取构造器创建对象获取方法获取成员变量取值和赋值注解注解的作用自定义注解元注解：就是注解注解的注解注解解析类加载器类加载：当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过类的加载，类的连接，类的初始化这三个步骤来对类进行初始化。类加载器的作用：负责将.class文件加载到内存中，并为之生成对应的 java
复制链接

扫一扫