（1）反射机制允许程序在执行期间借助于ReflectionAPI取得任何类的内部信息（比如成员变量，构造器，成员方法等等），并能操作对象的属性及方法。反射在设计模式和框架底层都会用到。
（2）加载完类之后，在堆中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个对象就像是一面镜子，透过这个镜子看到类的结构，所以，形象的称之为反射
java反射机制可以完成：
（1）在运行时判断任意一个对象所属的类
（2）在运行时构造任意一个类的对象
（3）在运行时得到任意一个类所具有的成员变量和方法
（4）在运行时得到个任意一个对象的成员变量和方法
（5）生成动态代理
反射机制
反射优点和缺点
（1）优点：可以动态的创建和使用对象（也是框架底层核心），使用灵活。如果没有反射机制，框架技术就失去底层支撑
（2）缺点：使用反射，基本是解释执行，对执行速度有影响
Class类（1）Class类也是类，因此也继承Object类
（2）Class类对象不是new出来的，而是系统创建的。
（3）对于某个类的Class类对象，在内存中只有一份，因为类只加载一次
（4）每个类的实例都会记得自己是由哪个Class实例所生成
（5）通过Class对象可以完整地得到一个类的完整结构，通过一系列API可以实现
（6）Class对象是存放在堆中的
（7）类的字节码二进制数据是放在方法区的，有点地方称为类的元数据
类加载反射机制 是java实现动态语言的关键，也就是通过反射实现类的动态加载
（1）静态加载：编译时加载相关的类，如果没有则报错，依赖性太强
（2）动态加载：运行时加载需要的类，如果运行时不用该类，则不报错，降低了依赖性
例：
import java.util.*;
import java.lang.reflect.*;
public class Hello{
public static void main(String[] args) throws Exception{
Scanner scanner = new Scanner(System.in);
System.out.println("请输入key：");
String key = scanner.next();
switch(key){
case "1":
Dog dog = new Dog();//静态加载
dog.cry();
break;
case "2":
Class cls = Class.forName("Person");
Object o = cls.newInstance();
Method method = cls.getMethod("hi");
method.invoke(o);
break;
default:
System.out.println("请重新输入");
}
}
}
class Dog{
public void cry(){
System.out.println("小猫喵喵叫");
}
}
class Person{
public void hi(){
System.out.println("你好啊");
}
}
类加载时机：
（1）当创建对象时（new） //静态加载
（2）当子类被加载时 // 静态加载
（3）使用类中的静态成员时 // 静态加载
（4）通过反射 // 动态加载
类加载
加载阶段：JVM在该阶段的主要目的是将字节码从不同的数据源（类，jar包，或者是网络数据）转化为二进制字节流加载到内存中，并生成一个代表该类的java.lang.Class对象
连接阶段--验证：
（1）目的是：为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全
（2）包括：文件格式验证、元数据验证，字节码验证和符号引用验证
（3）可以考虑使用 -Xverify：none参数来关闭大部分的类验证措施，缩短虚拟机类加载的时间
连接阶段--准备
JVM会在该阶段对静态变量，分配内存并默认初始化。这些变量所使用的内存都将在方法区中进行分配
连接阶段--解析
虚拟机将常量池内的符号引用替换为直接引用的过程
初始化：
（1）到初始化阶段，才真正开始执行类中定义的JVA程序代码，此阶段是执行
（2）
（3）虚拟机会保证一个类的
（1）调用类中的public修饰的无参构造器
（2）调用类中的指定构造器
import java.util.*;
import java.lang.reflect.*;
public class Hello{
public static void main(String[] args) throws Exception{
//获取类的class对象
Class cls = Class.forName("User");
//通过public的无参构造器创建实例
Object o = cls.newInstance();
System.out.println(o);
//通过public的有参构造器创建实例
Constructor constructor = cls.getConstructor(String.class);
Object cst = constructor.newInstance("你可真帅");
System.out.println("cst = "+cst);
//通过私有的构造器创建实例
Constructor constructor1 = cls.getDeclaredConstructor(int.class,String.class);
constructor1.setAccessible(true);//使用爆破可以访问private构造器
Object cst1 = constructor1.newInstance(18,"我是最帅的");
System.out.println("cst1 = "+ cst1);
}
}
class User{
private int age = 10;
private String name = "你可真好看";
public User(){//无参构造器
}
public User(String name){
this.name = name;
}
private User(int age,String name){
this.age = age;
this.name = name;
}
public String toString(){
return "User age=" + age + ",name = " + name;
}
}
爆破小练习：
import java.util.*;
import java.lang.reflect.*;
public class Hello{
public static void main(String[] args) throws Exception{
Class stucls = Class.forName("Student");
Object stu = stucls.newInstance();
System.out.println(stu.getClass());
//使用反射得到age属性对象
Field age = stucls.getField("age");
age.set(stu,18);//通过反射操作属性
System.out.println(stu);
//获取私有属性
Field name = stucls.getDeclaredField("name");
//因为name是私有属性，采用爆破机制
name.setAccessible(true);
// name.set(stu,"roy");
name.set(null,"roy~");//因为name是静态属性，所以可以为空
System.out.println(stu);
}
}
class Student{
public int age = 10;
private static String name = "karry";
public Student(){//无参构造器
}
// public Student(String name,int age){
// this.name = name;
// this.age = age;
// }
// private Student(int age,String name){
// this.age = age;
// this.name = name;
// }
public String toString(){
return "User age=" + age + ",name = " + name;
}
}
