反射机制

反射机制允许程序在执行期助于ReflectionAPI取得任何类的内部信息比如成员变量、构造器、成员方法等等，并能操作对象的属性及方法，反射在设计模式和框架底层都会用到
加载完类之后，在堆中就产生了一个Class类型的对象一个类只要一个Class对象，这个对象包含了类的完整结构信息，通过这个对象得到了类的结构这个对象就像一面镜子,透过者个镜子看到类的结构，所有，形象的称之为反射
优点：可以动态的创建和是使用对象也是框架底层的核心。使用灵活，没有反射机制，框架技术就失去底层的支撑
缺点：使用反射基本时解释执行，堆执行速度有影响

反射机制优化

Method和field、Constructor对象都有setAccessible()方法
setAccessible作用时启动和禁用访问安全检查的开关
参数值为true表示反射的对象在使用时取消访问检查，提高反射的效率参数值为false则表示反射对象执行访问检查

package com.qiu.reflection1;

import java.lang.reflect.Method;
@SuppressWarnings({"all"})
public class Demo2 {
    final static int NUM=900000000;
    //普通调用hi方法
    public void m1(){
        Cat cat=new Cat();
        long start = System.currentTimeMillis();
        for (int i = 0; i < NUM; i++) {
            cat.hi();
        }
        long end = System.currentTimeMillis();
        System.out.println("m1() 耗时-->"+(end-start)+"ms");
    }
    //反射机制调用hi方法
    public void m2() throws Exception {
        Class c1 = Class.forName("com.qiu.reflection1.Cat");
        Object o = c1.newInstance();
        Method hi = c1.getDeclaredMethod("hi");
        long start = System.currentTimeMillis();
        for (int i = 0; i < NUM; i++) {
           hi.invoke(o);//方法对象.invoke(对象)
        }
        long end = System.currentTimeMillis();
        System.out.println("m2() 耗时-->"+(end-start)+"ms");

    }
    //优化后反射机制调用hi方法
    public void m3() throws Exception {
        Class c1 = Class.forName("com.qiu.reflection1.Cat");
        Object o = c1.newInstance();
        Method hi = c1.getDeclaredMethod("hi");
        hi.setAccessible(true);//取消访问检查
        long start = System.currentTimeMillis();
        for (int i = 0; i < NUM; i++) {
            hi.invoke(o);//方法对象.invoke(对象)
        }
        long end = System.currentTimeMillis();
        System.out.println("m3() 耗时-->"+(end-start)+"ms");

    }

    public static void main(String[] args) throws Exception{
        Demo2 d = new Demo2();
        d.m1();
        d.m2();
        d.m3();
    }
}

Class类

Class也是类，因此也继承了Object类
Class类对象不是new出来的，而是系统创建的
对于某个类的Class类对象，在内存中只有一份，因为类只加载一次
每个类的实例都会记得自己是由那个Class实例所生成
通过Class对象可以完整地得到一个类的完成结构，通过一系列的API
Class对象是存放在堆的
类的字节码二进制数据，是放在方法区的，有的地方称为类的元数据(包括方法代码、变量名、方法名、访问权限等等…)

常用方法

package com.qiu.reflection1;

import java.io.FileReader;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Properties;

public class Demo1 {
    public static void main(String[] args) throws Exception{
        //创建读取Properties类型文件的对象
        Properties p=new Properties();
        //读取路径
        p.load(new FileReader("src/com/qiu/reflection1/configure.Properties"));
        //获取数据
        String objectdemo = p.getProperty("objectdemo");
        String methoddemo = p.getProperty("methoddemo");
        //打印数据
        System.out.println("对象："+objectdemo);
        System.out.println("方法："+methoddemo);

        //通过反射调用方法
        //加载类 返回Class对象
        Class cls = Class.forName(objectdemo);
        //通过cls加载的类 获取Cat的实例对象
        Object o = cls.newInstance();

        Class cls1 = o.getClass();//运行类型
        System.out.println(cls1);

        //获取方法
        //通过cls加载的类 获取获取Cat类的方法对象 在反射中把方法视为对象
        Method declaredMethod = cls.getDeclaredMethod(methoddemo);
        //通过方法的对象调用实例对象的方法
        declaredMethod.invoke(o);//反射机制 方法对象.invoke(对象);

        //获取字段
        Field name = cls.getField("name");
        System.out.println(name.get(o));//get方法获取字段值

        //获取构造器
        Constructor constructor = cls.getConstructor(String.class);
        Cat o1 = (Cat)constructor.newInstance("旺财");
        System.out.println(o1);
    }
}

获取Class类的六种方法

package com.qiu.classdemo;
//class的六中获取方式
public class Demo3 {
    public static void main(String[] args) throws Exception{
        String path="com.qiu.classdemo.Dog";
        Class cls1 = Class.forName(path);//用于读配置文件 Class.forName(类的路径); 返回与给定字符串名称的类或接口相关联的 类对象。
        System.out.println(cls1.getName());

        Class cls2 = Dog.class;//类名.class 用于传入参数
        System.out.println(cls2);

        Dog dog=new Dog();
        Class cls3 = dog.getClass();//对象名.getClass() 返回此Object的运行时类。
        System.out.println(cls3);
        //这个对象他关联的Class对象 只要你创建一个对象他就知道他是属于那个class对象 class对象就是他加载进来的对象

        //先得到类加载器
        ClassLoader loader = dog.getClass().getClassLoader();
        //通过类加载器获取class对象
        Class cls4 = loader.loadClass(path);
        System.out.println(cls4);

        Class<Integer> cls5 = int.class;
        System.out.println(cls5);

        Class<Integer> cls6 = Integer.TYPE;
        System.out.println(cls6);
        System.out.println(cls1.hashCode());
        System.out.println(cls2.hashCode());
        System.out.println(cls3.hashCode());
        System.out.println(cls4.hashCode());
        System.out.println(cls5.hashCode());
        System.out.println(cls6.hashCode());

    }
}

类加载

静态和动态加载

静态加载：编译时加载相关的类，如果没有就报错，依赖性太强
动态加载：运行时加载需要的类，如果运行时不用该类，即使不存在该类也不会报错，降低了依赖性，运行到该类的时候没有当前类就会报错

public class Classload_01{

    public static void main(String[] args) throws Exception {

        Scanner s=new Scanner(System.in);
        System.out.println("out key");
        String key=s.next();
        switch(key){
            case "1":
                Dog dog =new Dog();//静态加载依赖性很强
				//Dog是静态加载必须有要Dog类
                dog.sleep();
                break;

            case "2":
				//反射动态加载
                Class cls1=Class.forName("Person");//加载Person[动态加载]
				//Person是动态加载 所有 没有编写类也不会报错 只有动态加载该类的时候才会加载
                Object o=cls1.newInstance();
                Method m=cls1.getMethod("hi");
                m.invoke(o);
                break;

            default:
                System.out.println("nonono");
        }

    }
}

在这里插入图片描述

加载：将类的class文件读入内存，并且创建一个java.lang.Class对象此过程由类加载完成
链接：将类的二进制数据合并JRE中，可运行的状态
- 验证：对文件的安全检查
- 准备：静态变量默认初始化，并分配空间
- 解析：符号引用转为直接引用
初始化：jvm负责对类进行初始化，这里主要是指静态成员
加载和链接时jvm控制的，运行时由程序员可以自己控制的
加载阶段：JVM在该阶段的主要目的时将字节码从不同的数据源(可能时class文件、也可能是jar包、甚至网络)转换为二进制字节流加载到内存中，并生成一个代表该类的java.lang.Class对象
验证阶段：目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全，包括：文件格式验证(是否以魔数 oxcafebabe开头)/元数据验证、字节码验证和符号引用验证可以考虑使用-Xverify:none参数来关闭大部分的类验证来措施，缩短虚拟机类加载的时间
准备阶段：JVM会在阶段对静态变量，分配内存并默认初始化(对应数据类型的默认吃初始值，如0、0L、null、false等)。这些变量所使用的内存都将在方法区中进行分配
解析阶段：虚拟机将常量池的符号引用替换为直接引用的过程
初始化阶段：

到初始化阶段，才真正开始执行类中定义的Java程序代码，此阶段是执行 clinit ()方法的过程

clinit()方法是由编译器按语句在源文件中出现的顺序，依次自动收集类中的所有静态变量的赋值动作和静态代码中的语句，并进行合并

虚拟机会保证一个类clinit()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的clinit()方法，其他线程都需要阻塞等待，直到活动线程执行clinit()方法完毕

反射基本知识

反射机制

反射机制优化

Class类

常用方法

获取Class类的六种方法

类加载

静态和动态加载