java----反射

《为什么要反射》

 明显是不能的：

虽然我们可以通过properties来获取到String形态下的classfullpath和method是什么，但是如果直接new 和 使用绝对会如下一样报错

 《反射机制与原理》

 class类型对象在讲static时说过，其中堆中，而且在new（实例化）对象之前就产生了

 

 

 

在javac编译过后通过类加载器ClassLoader生成Class类，完成后可得到Cat对象

在Class类中，原来的

　　成员变量被封装到了Field数组中，变成了Field类

　　构造器封装到了Constructor数组中，变成了Constructor类

　　成员方法封装到了Method数组中，变成了Method类

 

 

 

《反射主要类》

知道这些后可以解决上面的问题了：

注意一下：获取成员变量只有在变量时公开的情况下才能够获取到

《反射调用优化》

 

 

 

 

 

 

 

 《关于Class类》

1.

 

 2.

 

 

 系统通过loadClass方法来创建Class类对象

 

 

 在当 new 这个对象 或者 用反射 Class cls= Class.forName(classFullPath);

都会引起系统调用loadClass方法创建Class类对象

　　普通的new：

 

 

 　　用反射：

 3.

 

 

 

《Class类常用方法》

 

 

 

 

 

 《获取Class类对象的方式》

 

 

 

 

 

 

 《有Class类的类型》

 

 《静态加载和动态加载》

 

 对1的解释:

 假如我有如上代码，而且我没有写（或引入）Dog包：毫无疑问会报错，编译不会通过，这个用new的为静态加载：

 但是如果我有如下代码：

 我用反射动态加载，则编译不会报错，只有在我输入2,进入到case "2"运行了加载类的语句时才会报错

1,2，3都是静态加载，4是动态加载

 

 《类加载的过程》

 

 也就是如上的过程：

 

 加载阶段：

 也就是这个阶段了：

 

 验证阶段：

 

 准备阶段：

 解析阶段：

 

 

 即将两个类之间虚拟的关系，在有了实际的内存地址后转化为了真正的实际关系

初始化阶段：

 如：

 

 执行的顺序是：

 

 

 正因为有上面的保证才有：

 《调用API获取类结构信息》

《Class类》

 

 注意像getFields，getDeclaredFields是以数组形式的，而且类为Field

 

 返回的样子

 

 

 《Field类》

 

 getType的返回值：

 

 

 《Method类》

 

 对于第四点的解释：

 

 

 输出(如果无参,则不会有任何输出)：

 

 《Constructor类》

 

 《通过反射创建对象实例》

 

 

 这里说明一点：因为在指定了访问修饰符与参数的情况下，不可能出现相同构造器，因此上面的方法可以精确地拿出我们想要的构造器

 《通过反射访问类中的成员属性》

 这个与上面介绍的cls.getFields,cls.getDeclare不同的是，其是可以通过属性名精确拿到成员变量

 

 

 对于第四点的解释：static变量其与类有关，与对象无关

 《通过反射调用类的成员方法》

 

 《日后学习对反射的理解》

《简单工厂设计模式》

package com.cilinmengye.Reflect;

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

interface Operator {
    double compute();
}

class Add implements Operator {
    private double a, b;

    public Add(double a, double b) {
        this.a = a;
        this.b = b;
    }

    public double compute() {
        return a + b;
    }
}

class Dec implements Operator {
    private double a, b;

    public Dec(double a, double b) {
        this.a = a;
        this.b = b;
    }

    public double compute() {
        return a - b;
    }
}

class Mul implements Operator {
    private double a, b;

    public Mul(double a, double b) {
        this.a = a;
        this.b = b;
    }

    public double compute() {
        return a * b;
    }
}

class Div implements Operator {
    private double a, b;

    public Div(double a, double b) {
        this.a = a;
        this.b = b;
    }

    public double compute() {
        if (b == 0) {
            System.out.println("除0错误");
            return 0;
        } else return a / b;
    }
}

class OperatorFactory {
    public static Operator creatOperator(String opName, double a, double b) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class c = Class.forName(opName);
        Constructor con = c.getConstructor(double.class, double.class);
        return (Operator) con.newInstance(a, b);
    }
}


public class SimplyFactory {
    public static void main(String []args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        Operator op=null;
           //注意这里是全类名
        op=OperatorFactory.creatOperator("com.cilinmengye.Reflect.Add",1,2);
       //注意这里op.compute能够知道调用Add中的compute是因为java中的动态绑定机制
        System.out.println(op.compute());
    }
}

《用反射将类还原出来》

 

 

 

 

package com.cilinmengye.Reflect;

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

class Test {
    private static final int c = 10;

    public static void a() {
        ;
    }

    public static void a1(int x, int y) {
        ;
    }

    private int b1(double x, int y) {
        return 0;
    }

    protected Test(int x, int y) {
        ;
    }

    Test(int x) {
        ;
    }

    class Text {
        private int bb = 0;

        private int Add() {
            return 0;
        }
    }
}

public class ViewClass {
    public static String getPackageStr(Class cls) {
        Package p = cls.getPackage();
        if (p == null) {
            return "";
        }
        return "package " + p.getName();
    }

    public static String getModifyStr(int modifyInt) {
        if (modifyInt == 0) return "";
        return Modifier.toString(modifyInt);
    }

    public static String getClassStr(Class cls) {
        int modifyInt = cls.getModifiers();
        String type = Modifier.isInterface(modifyInt) ? "interface" : "class";
        return getModifyStr(modifyInt) + " " + type + " " + cls.getSimpleName();
    }

    public static String getFieldStr(Class cls) {
        Field[] fields = cls.getDeclaredFields();
        StringBuilder str = new StringBuilder("\t");
        for (Field f : fields) {
            str.append(getModifyStr(f.getModifiers())).
                    append(" ").append(f.getType().getName()).append(" ").append(f.getName()).append(";\n");
        }
        return str.toString();
    }

    public static String getParamStr(Class[] classes) {
        StringBuilder str = new StringBuilder();
        for (Class cls : classes) {
            str.append(cls.getSimpleName()).append(",");
        }
        String ans = str.toString();
        if (ans.length() == 0) return "";
        else return ans.substring(0, ans.length() - 1);
    }

    public static String getConstructorStr(Class cls) {
        Constructor[] constructors = cls.getDeclaredConstructors();
        StringBuilder str = new StringBuilder("\t");
        for (Constructor c : constructors) {
            str.append(getModifyStr(c.getModifiers())).append(" ").append(cls.getSimpleName()).
                    append(" (").append(getParamStr(c.getParameterTypes())).append(");").append("\n").append("\t");
        }
        return str.toString();
    }

    public static String getMethodStr(Class cls) {
        Method[] methods = cls.getDeclaredMethods();
        StringBuilder str = new StringBuilder("\t");
        for (Method method : methods) {
            str.append(getModifyStr(method.getModifiers())).append(" ").
                    append(method.getReturnType()).append(" ").append(method.getName()).append("(").
                    append(getParamStr(method.getParameterTypes())).append(");\n\t");
        }
        return str.toString();
    }

    public static String view(String className) throws ClassNotFoundException {
        Class cls = Class.forName(className);
        StringBuilder str = new StringBuilder(getPackageStr(cls) + "\n"
                + getClassStr(cls) + "{\n"
                + getFieldStr(cls) + "\n"
                + getConstructorStr(cls) + "\n"
                + getMethodStr(cls) + "\n");
        Class[] classes = cls.getDeclaredClasses();
        for (Class c : classes) {
            str.append(view(c.getName()));
        }
        str.append("}\n");
        return str.toString();
    }
}

class App {
    public static void main(String[] args) throws ClassNotFoundException {
        String str = ViewClass.view("com.cilinmengye.Reflect.Test");
        System.out.println(str);
    }
}

 《抽象工厂模式》

抽象工厂模式只是在简单工厂模式上需要产品的组装而已，具体框架思路如下：

 《代理模式》

《静态代理》

专家：

 

 

 代理：

代理实现了专家的接口，即要实现其方法，这样可以在代理类中调用与专家同名的方法，所以可以将代理当专家来用，

同时靠这个能够知道在代理类中的那个方法中调用哪一个专家的真正方法

 

 

 

《动态代理》

好博客连接：https://blog.csdn.net/qq_46494427/article/details/124173617

 

 

动态代理与静态代理相比，其可以实现一个统一的框架处理模式，面对大量需要代理的类其可以统一处理

1. 

 

这个dl是我们上面实现的框架:代理

 

2.

 这个S是专家

 

package com.cilinmengye.Reflect;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface Doctor {
    void care();
}

interface Teacher {
    void talk();

    void think();
}

class Doctor1 implements Doctor {
    public void care() {
        System.out.println("治疗!");
    }
}

class Teacher1 implements Teacher {

    @Override
    public void talk() {
        System.out.println("教授!");
    }

    @Override
    public void think() {
        System.out.println("思考!");
    }
}

class Agent implements InvocationHandler {
    private Object expert;

    public void setExpert(Object expert) {
        this.expert = expert;
    }

    private void do1() {
        System.out.println("小动作开始!");
    }

    private void do2() {
        System.out.println("小动作结束！");
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
        do1();
        Object result = method.invoke(expert, args);
        do2();
        return result;
    }
}

public class Oagent {
    public static void main(String[] args) {
        Agent a1 = new Agent(), a2 = new Agent();
        Doctor1 doctor1 = new Doctor1();
        Teacher1 teacher1 = new Teacher1();
        a1.setExpert(doctor1);
        a2.setExpert(teacher1);
        Doctor e1 = (Doctor) Proxy.newProxyInstance(Doctor.class.getClassLoader()
                , doctor1.getClass().getInterfaces(), a1);
        e1.care();
        Teacher e2 = (Teacher) Proxy.newProxyInstance(Teacher.class.getClassLoader()
                , teacher1.getClass().getInterfaces(), a2);
        e2.talk();
    }
}