反射

反射【框架设计的灵魂】：将类的各个组成部分封装为其他对象，这就是反射机制

好处：1.可以在程序运行过程中，操作这些对象

2. 可以解耦，提高程序的可拓展性

获取class对象的3种方式：

1.Class.forname（“全类名”）;将字节码文件加载进内存，返回Class对象【多用于配置文件，将类名定义在配置文件中。读取对象，加载类】

2.类名.class：通过类名的属性class获取【多用于参数的传递】

3.对象.getClass:该方法在object中定义【多用于对象获取字节码的方式】

同一字节码文件（*.class）在一次程序运行中，只会被加载一次，不论通过哪一种 方式获取到的Class对象都是同一个

 

 

Class对象功能

获取功能：

1.获取成员变量们

Field getField(String name)

Field[] getFields() 获取所有public修饰的成员变量

Field getDeclaredField(String name)

Field[] getDeclaredFields() 获取所有成员变量

 

Field方法

Object get(Object obj)  【获取值】

void set(Object obj, Object value) 【设置传入对象值】

 

setAccessible（true）【暴力反射】 忽略访问权限修饰符的安全检查

 

2.获取构造方法们

Constructor<T> getConstructor(类<?>... parameterTypes)

Constructor con=personClass. getConstructor(String.class,int.class)

Constructor<?>[] getConstructors()

Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)  

Constructor<?>[] getDeclaredConstructors()  

 

Constructor

【创建对象】

1.T newInstance(Object... initargs)  

con.newInstance(“张三”，”23”)

2.如果使用空参构造方法创建对象，操作可以简化：Class对象的 newInstance方法

personClass.newInstance()

3.获取成员方法们

Method getMethod(String name, 类<?>... parameterTypes)   

Method[] getMethods()  

Method getDeclaredMethod(String name, 类<?>... parameterTypes)

Method[] getDeclaredMethods()

 

Method

执行方法

Object invoke(Object obj, Object... args)  【第一个参数是类对象】

4.获取全类名

String getName()

返回单位名称（类，接口，数组类，原始类型，或无效）的 类对象表示，作为一个 String。

  

创建一个配置文件pro.properties 

className=cn.itcast.domin.Person

methodName=eat

1.加载配置文件

(1) 创建Properties对象   Properties p= new Properties()；

(2)  加载配置文件，转换为一个集合  

　　获取class目录下的配置文件

ClassLoder classloader=ReflectTest.class.getClassLoader();[获得该字节码文件的类加载器]

IntputSteam is=Classloader.getResourceAsStream(“pro.properties”);[获取资源所对应的字节流]

pro.load(i);

2.获取配置文件中定义的数据

String  className = pro.getProperty(“className”);

String  className = pro.getProperty(“methodName”);

3.加载该类进内存

Class  cls = Class.forName(className);

4.创建对象

Object obj=cls.newInstance()；

5.获取方法对象

Method method=cls.getMethod(methodName);

6.执行方法

method.invoke(obj);

 

【jvm记载类顺序测试】

package edu.xupt.reflect;

public class Demo1 {
    static {
        System.out.println("main方法将被执行");
    }

    public static void main(String[] args) throws ClassNotFoundException {
        System.out.println(Son.z);


    }
}
class Father{
    static {
        System.out.println("父类静态代码块");
    }
    public Father() {
        System.out.println("父类初始化");
    }
    static int f=100;
}
class Son extends Father{
    static {
        System.out.println("子类静态代码块");
        z=200;
    }
    static int z=100;
    static final int N=1000;
    public Son() {
        System.out.println("子类初始化");
    }
}

package edu.xupt.reflect;

public class Demo2 {
    public static void main(String[] args) throws ClassNotFoundException {
        System.out.println("获取系统类的加载器");
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);
        System.out.println("获取系统类加载器的父加载器-->拓展加载器");
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);
        System.out.println("获取拓展类加载器的父加载器-->根加载器");
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);
        System.out.println(Demo2.class.getClassLoader());
        Class<?> aClass = Class.forName("edu.xupt.reflect.Demo2");
        System.out.println(aClass.getClassLoader());

        System.out.println("检测JDK内置类是谁加载的");
        System.out.println(Object.class.getClassLoader());
        System.out.println(Class.forName("java.lang.ClassLoader" /*Object*/).getClassLoader());

        System.out.println("获得系统类加载器可以加载的路径");
        System.out.println(System.getProperty("java.class.path"));
        /*
        D:\Java\jdk1.8.0_212\jre\lib\charsets.jar;
        D:\Java\jdk1.8.0_212\jre\lib\deploy.jar;
        D:\Java\jdk1.8.0_212\jre\lib\ext\access-bridge-64.jar;
        D:\Java\jdk1.8.0_212\jre\lib\ext\cldrdata.jar;
        D:\Java\jdk1.8.0_212\jre\lib\ext\dnsns.jar;
        D:\Java\jdk1.8.0_212\jre\lib\ext\jaccess.jar;
        D:\Java\jdk1.8.0_212\jre\lib\ext\jfxrt.jar;
        D:\Java\jdk1.8.0_212\jre\lib\ext\localedata.jar;
        D:\Java\jdk1.8.0_212\jre\lib\ext\nashorn.jar;
        D:\Java\jdk1.8.0_212\jre\lib\ext\sunec.jar;
        D:\Java\jdk1.8.0_212\jre\lib\ext\sunjce_provider.jar;
        D:\Java\jdk1.8.0_212\jre\lib\ext\sunmscapi.jar;
        D:\Java\jdk1.8.0_212\jre\lib\ext\sunpkcs11.jar;
        D:\Java\jdk1.8.0_212\jre\lib\ext\zipfs.jar;
        D:\Java\jdk1.8.0_212\jre\lib\javaws.jar;
        D:\Java\jdk1.8.0_212\jre\lib\jce.jar;
        D:\Java\jdk1.8.0_212\jre\lib\jfr.jar;
        D:\Java\jdk1.8.0_212\jre\lib\jfxswt.jar;
        D:\Java\jdk1.8.0_212\jre\lib\jsse.jar;
        D:\Java\jdk1.8.0_212\jre\lib\management-agent.jar;
        D:\Java\jdk1.8.0_212\jre\lib\plugin.jar;
        D:\Java\jdk1.8.0_212\jre\lib\resources.jar;
        D:\Java\jdk1.8.0_212\jre\lib\rt.jar;
        D:\Java\zhang\2019.11.23—注解\out\production\2019.11.23—注解;
        D:\IntelliJ IDEA 2019.2.3\lib\idea_rt.jar

        */

    }
}



【反射基本方法测试】

package edu.xupt.reflect;

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

public class Demo3 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        Class<?> c1 = Class.forName("edu.xupt.reflect.Student");

        System.out.println("类名");
        System.out.println(c1.getName());
        System.out.println(c1.getSimpleName());
        System.out.println("======================");
        System.out.println("获得成员变量");
        Field[] fields = c1.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        fields = c1.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("======================");
        Method[] methods = c1.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println(">>>>>>>>>>>>>>>>>>>>");
        methods = c1.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("======================");
        Constructor<?> constructor = c1.getConstructor(int.class, String.class, boolean.class);
        System.out.println(constructor);
        Class<String> stringClass = String.class;
        System.out.println(stringClass);
    }
}

class Student{
    private int id;
    private String name;
    private boolean sex;
//    public String name1;

    public Student() {
    }

    public Student(int id, String name, boolean sex) {
        this.id = id;
        this.name = name;
        this.sex = sex;
    }

    public Student(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public String setName(String name) {
        return this.name = name;
    }
    private void show(){
        System.out.println("show被调用");
    }
    public void show1(){
        System.out.println("show1被调用");
    }

    public boolean isSex() {
        return sex;
    }

    public void setSex(boolean sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Student{"  
                "id="   id  
                ", name='"   name   '\''  
                ", sex="   sex  
                '}';
    }
}


【单例模式的反射破坏】

package edu.xupt.desidn.singleton;

import java.awt.geom.FlatteningPathIterator;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

public class Demo6 {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
/*        test1 test = new test1();
        for (int i = 0; i < 100; i  ) {
            new Thread(test).start();
        }*/
        Constructor<Singleton6> Constructor = Singleton6.class.getDeclaredConstructor(null);
        Constructor.setAccessible(true);
        Singleton6 singleton6 = Constructor.newInstance();
        Field flag = Singleton6.class.getDeclaredField("flag");
        flag.setAccessible(true);
        flag.set(singleton6,false);
        Singleton6 singleton61 = Constructor.newInstance();
        System.out.println(singleton6 == singleton61);
    }
}
class Singleton6{
    private static boolean flag= false;
    private volatile static Singleton6 singleton6;

    private Singleton6() {//[可以考虑直接抛异常，不允许进构造]
        if (flag==false){
            flag=true;
            System.out.println("第一次进构造");}
            else {throw new RuntimeException("不要想着用反射破坏我的单例");
        }
    }

    public static Singleton6 getSingleton6() {
        if (singleton6==null){
            synchronized (Singleton6.class){
                if (singleton6==null){
                    System.out.println("实例化");
                    singleton6 = new Singleton6();
                }
            }
        }
        return singleton6;
    }
}
class test6 implements Runnable{
    @Override
    public void run() {
        Singleton6.getSingleton6();
    }
}

 

来源：https://www./content-4-596151.html