第12章_JAVA反射机制

已于 2023-02-12 14:16:05 修改
阅读量131 收藏
点赞数
分类专栏： java 文章标签： java jvm 开发语言
于 2023-02-11 13:39:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46655235/article/details/128982918
版权

12.JAVA反射机制

12.1 反射的概述

public class Main {
    //反射之前
    @Test
    public void test1(){
        //1.创建Person类的对象
        Person p = new Person("Tom", 12);
        //2.通过对象调用Person类声明的属性和方法
        p.age=10;
        p.show();
        //3.在Person类外部，不可以调用Person类声明的私有结构，比如：私有构造器、属性、方法
    }
    //反射之后
    @Test
    public void test2() throws Exception{
        Class<Person> clazz = Person.class;
        //1.创建Person类的对象
        Constructor<Person> cons = clazz.getConstructor(String.class, int.class);
        Person p = cons.newInstance("Tom", 12);
        System.out.println(p);//Person{name='Tom', age=12}
        //2.通过指定对象调用Person类声明的属性和方法
        //调用属性
        Field age = clazz.getDeclaredField("age");
        age.set(p,10);
        System.out.println(p);//Person{name='Tom', age=10}
        //调用方法
        Method show = clazz.getDeclaredMethod("show");
        show.invoke(p);//你好，我是一个人
        //3.在Person类外部，也可以调用Person类声明的私有结构。比如：私有的构造器、属性、方法
        //调用私有的构造器
        Constructor<Person> cons1 = clazz.getDeclaredConstructor(String.class);
        cons1.setAccessible(true);
        Person p1 = cons1.newInstance("Jerry");
        System.out.println(p1);//Person{name='Jerry', age=0}
        //调用私有的属性
        Field name = clazz.getDeclaredField("name");
        name.setAccessible(true);
        name.set(p1,"Marry");
        System.out.println(p1);//Person{name='Marry', age=0}
        //调用私有的方法
        Method showNation = clazz.getDeclaredMethod("showNation", String.class);
        showNation.setAccessible(true);
        String nation = (String) showNation.invoke(p1, "中国");//相当于String nation = p1.showNation("中国");：我的国籍是：中国
        System.out.println(nation);//中国
    }
	//体会反射的动态性
    @Test
    public void test3(){
        for (int i=0;i<100;i++){
            int num=new Random().nextInt(3);//0,1,2
            String classPath="";
            switch (num){
                case 0:
                    classPath="java.util.Date";
                    break;
                case 1:
                    classPath="java.lang.Object";
                    break;
                case 2:
                    classPath="jiple.Person";
                    break;
            }
            Object instance = null;
            try {
                instance = getInstance(classPath);
                System.out.println(instance);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }
    public Object getInstance(String classPath) throws Exception{
        Class<?> clazz = Class.forName(classPath);
        return clazz.newInstance();
    }
}
class Person{
    private String name;
    public int age;

    private Person(String name){
        this.name=name;
    }

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    private String showNation(String nation){
        System.out.println("我的国籍是："+nation);
        return nation;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void show(){
        System.out.println("你好，我是一个人");
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

12.2 Class类的理解

public class Main {
/*
1.Class类的理解
    1.1 类的加载过程：程序经过javac.exe命令以后，会生成一个或多个字节码文件(.class结尾)，接着我们使用java.exe命令对某个字节码文件进行解释运行，相当于将某个字节码文件加载到内存中，此过程就称为类的加载。加载到内存中的类，我们就称为运行时类，此运行时类就作为Class的一个实例
    1.2 加载到内存中的运行时类会缓存一定的时间。在此时间之内，我们可以通过不同的方式来获取此运行时类
2.实例化Class类的几种方式：（前三种方式需要掌握）
 */
    @Test
    public void test1() throws Exception{
        //方式一：调用运行时类的属性：class
        Class<Person> clazz1 = Person.class;
        System.out.println(clazz1);//class jiple.Person

        //方式二：通过运行时类的对象调用方法：Class<?> getClass()
        Person p1 = new Person();
        Class<? extends Person> clazz2 = p1.getClass();
        System.out.println(clazz2);//class jiple.Person

        //方式三：调用Class类的静态方法：static Class<?> forName(String className)
        Class<?> clazz3 = Class.forName("jiple.Person");
        Class<?> clazz = Class.forName("java.lang.String");
        System.out.println(clazz3);//class jiple.Person
        System.out.println(clazz);//class java.lang.String

        //方式四：使用类的加载器调用方法：Class<?> loadClass(String name)
        ClassLoader classLoader = Main.class.getClassLoader();
        Class<?> clazz4 = classLoader.loadClass("jiple.Person");
        System.out.println(clazz4);//class jiple.Person

        System.out.println(clazz1 == clazz2);//true
        System.out.println(clazz1 == clazz3);//true
        System.out.println(clazz1 == clazz4);//true
    }
/*
3.总结：创建类的对象的方式：
    3.1 方式一：new + 构造器
    3.2 方式二：要创建Xxx类的对象，可以查看Xxx、Xxxs、XxxFactory、XxxBuilder类中是否有静态方法的存在，可以调用其静态方法，创建Xxx对象
    3.3 方式三：通过反射
4.Class类的实例可以是哪些结构：
    4.1 外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类
    4.2 接口
    4.3 数组
    4.4 枚举类
    4.5 注解
    4.6 基本数据类型
    4.7 void
 */
    @Test
    public void test2(){
        Class c1 = Object.class;
        Class c2 = Comparable.class;
        Class c3 = String[].class;
        Class c4 = int[][].class;
        Class c5 = ElementType.class;
        Class c6 = Override.class;
        Class c7 = int.class;
        Class c8 = void.class;
        Class c9 = Class.class;

        int[] a = new int[10];
        int[] b = new int[100];
        Class c10 = a.getClass();
        Class c11 = b.getClass();
        
        System.out.println(c10);//class [I
        System.out.println(c11);//class [I
        System.out.println(c10 == c11);//true
    }
}
class Person{
    private String name;
    public int age;

    private Person(String name){
        this.name=name;
    }

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    private String showNation(String nation){
        System.out.println("我的国籍是："+nation);
        return nation;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void show(){
        System.out.println("你好，我是一个人");
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

12.3 了解ClassLoader

/*
1.类的加载器的作用：
	1.1 类加载的作用：将字节码文件(.class结尾)加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的Class对象，作为方法区中类数据的访问入口。
	1.2 类缓存的作用：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载(缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。
2.类的加载器的分类
 */

image-20230129181156858

public class Main {
    @Test
    public void test1(){
        //对于自定义类，使用系统类加载器进行加载
        ClassLoader classLoader = Main.class.getClassLoader();
        System.out.println(classLoader);//jdk.internal.loader.ClassLoaders$AppClassLoader@63947c6b
        //系统类加载器调用getParent()：获取扩展类加载器
        ClassLoader classLoader1 = classLoader.getParent();
        System.out.println(classLoader1);//jdk.internal.loader.ClassLoaders$PlatformClassLoader@7181ae3f
        //扩展类加载器调用getParent()：无法获取引导类加载器
        //引导类加载器主要负责加载java的核心类库，无法加载自定义类的。
        ClassLoader classLoader2 = classLoader1.getParent();
        System.out.println(classLoader2);//null
        ClassLoader classLoader3 = String.class.getClassLoader();
        System.out.println(classLoader3);//null
    }
/*
3.使用Classloader加载配置文件
    3.1 右击当前的module->new->Resource Bundle->输入jdbc
        在jdbc.properties中添加：name=Tom
                               password=123
    3.2 右击当前module的src->new->Resource Bundle->输入jdbc1
        在jdbc.properties中添加：name=Tom
                               password=123
 */
    @Test
    public void test2(){
        InputStream is= null;
        try {
            Properties pros = new Properties();
            //读取配置文件的方式一：
            //配置文件默认识别为：当前module下
//        FileInputStream fis = new FileInputStream("jdbc.properties");
//        pros.load(fis);

            //读取配置文件的方式二：使用ClassLoader
            //配置文件默认识别为：当前module的src下
            ClassLoader classLoader = Main.class.getClassLoader();
            is = classLoader.getResourceAsStream("jdbc1.properties");
            pros.load(is);

            String name = pros.getProperty("name");
            String password = pros.getProperty("password");
            System.out.println("user = "+name+",password = "+password);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
//        fis.close();
            if(is!=null){
                try {
                    is.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

12.4 反射应用一：创建运行时类的对象

public class Main {
/*
1.T newInstance()：调用此方法，创建对应的运行时类对象。内部调用了运行时类的空参构造器
2.要想此方法正常地创建运行时类对象，要求：
    2.1 运行时类必须提供空参构造器
    2.2 空参构造器的访问权限得够。通常，设置为public
3.在JavaBean中要求提供公共空参构造器的原因：
    3.1 便于通过反射，创建运行时类对象
    3.2 便于子类继承此运行时类时，默认调用super()时，保证父类有此构造器
 */
    @Test
    public void test1() throws Exception {
        Class<Person> clazz = Person.class;
        Person person = clazz.newInstance();
        System.out.println(person);
    }
}
class Person{
    private String name;
    public int age;

    private Person(String name){
        this.name=name;
    }

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    private String showNation(String nation){
        System.out.println("我的国籍是："+nation);
        return nation;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void show(){
        System.out.println("你好，我是一个人");
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

12.5 反射应用二：获取运行时类的完整结构

class Creature<T> implements Serializable{
    private char gender;
    public double weight;

    private void breath(){
        System.out.println("生物呼吸");
    }

    public void eat(){
        System.out.println("生物吃东西");

    }
}
interface MyInterface{
    void info();
}
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@interface MyAnnotation{
    String value() default "hello";

}
@MyAnnotation("hi")
class Person extends Creature<String> implements Comparable<String>,MyInterface{

    private String name;
    int age;
    public int id;

    @MyAnnotation("abc")
    private Person(String name){
        this.name=name;
    }

    Person(String name,int age){
        this.name=name;
        this.age=age;
    }

    public Person(){

    }

    @MyAnnotation
    private String show(String nation){
        System.out.println("我的国籍是:"+nation);
        return nation;
    }

    String display(String interests){
        return interests;
    }

    @Override
    public void info() {
        System.out.println("我是一个人");
    }

    @Override
    public int compareTo(String o) {
        return 0;
    }

}
public class Main {
/*
1.获取当前运行时类的属性
 */
    @Test
    public void test1(){
        Class<Person> clazz = Person.class;
        //Field[] getFields()：获取当前运行时类及其所有父类中声明为public的属性
        Field[] fields = clazz.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        /*输出
        public int jiple.Person.id
        public double jiple.Creature.weight
         */
        System.out.println();
        //Field[] getDeclaredFields()：获取当前运行时类中声明的所有属性。（不包含父类中声明的属性）
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field field : declaredFields) {
            System.out.println(field);
        }
        /*输出
        private java.lang.String jiple.Person.name
        int jiple.Person.age
        public int jiple.Person.id
         */
    }
/*
2.获取属性的：
    权限修饰符  数据类型 变量名
 */
    @Test
    public void test2(){
        Class<Person> clazz = Person.class;
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field field : declaredFields) {
            //int getModifiers()：获取属性的权限修饰符
            int modifiers = field.getModifiers();
            System.out.print(Modifier.toString(modifiers)+"\t");
            //Class<?> getType()：获取属性的数据类型
            Class<?> type = field.getType();
            System.out.print(type.getName()+"\t");
            //String getName()：获取属性的变量名
            String fieldName = field.getName();
            System.out.print(fieldName);
            System.out.println();
        }
        /*输出
        private	java.lang.String	name
	    	int	age
        public	int	id
         */
    }
/*
3.获取运行时类的方法结构
 */
    @Test
    public void test3(){
        Class<Person> clazz = Person.class;
        //Method[] getMethods()：获取当前运行时类及其所有父类中声明为public的方法
        Method[] methods = clazz.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println();
        //Method[] getDeclaredMethods()：获取当前运行时类中声明的所有方法。（不包含父类中声明的方法）
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method method : declaredMethods) {
            System.out.println(method);
        }
        /*输出
        public int jiple.Person.compareTo(java.lang.String)
        public int jiple.Person.compareTo(java.lang.Object)
        public void jiple.Person.info()
        java.lang.String jiple.Person.display(java.lang.String)
        private java.lang.String jiple.Person.show(java.lang.String)
         */
    }
/*
4.获取方法的：
    @Xxxx
    权限修饰符  返回值类型  方法名(参数类型1 形参名1,...) throws XxxException{}
 */
    @Test
    public void test4(){
        Class<Person> clazz = Person.class;
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method method : declaredMethods) {
            //Annotation[] getAnnotations()：获取方法的注解
            Annotation[] annotations = method.getAnnotations();
            for (Annotation annotation : annotations) {
                System.out.println(annotation);
            }
            //int getModifiers()：获取方法的权限修饰符
            int modifiers = method.getModifiers();
            System.out.print(Modifier.toString(modifiers)+"\t");
            //Class<?> getReturnType()：获取方法的返回值类型
            Class<?> returnType = method.getReturnType();
            System.out.print(returnType.getName()+"\t");
            //String getName()：获取方法名
            String name = method.getName();
            System.out.print(name);
            System.out.print("(");
            //Class<?>[] getParameterTypes()：获取形参列表
            Class<?>[] parameterTypes = method.getParameterTypes();
            if(!(parameterTypes==null&&parameterTypes.length==0)){
                for(int i=0;i<parameterTypes.length;i++){
                    if(i==parameterTypes.length-1){
                        System.out.print(parameterTypes[i].getName()+" args_"+i);
                        break;
                    }
                    System.out.print(parameterTypes[i].getName()+" args_"+i+",");
                }
            }
            System.out.print(")");
            //Class<?>[] getExceptionTypes()：获取抛出的异常
            Class<?>[] exceptionTypes = method.getExceptionTypes();
            if(exceptionTypes.length>0){
                System.out.print("throws ");
                for(int i=0;i<exceptionTypes.length;i++){
                    if(i == exceptionTypes.length-1){
                        System.out.println(exceptionTypes[i].getName());
                        break;
                    }
                    System.out.println(exceptionTypes[i].getName()+",");
                }
            }
            System.out.println();
        }
    }
/*
5.获取构造器结构
 */
    @Test
    public void test5(){
        Class<Person> clazz = Person.class;
        //Constructor<?>[] getConstructors()：获取当前运行时类中声明为public的构造器（不包含父类中声明的构造器）
        Constructor<?>[] constructors = clazz.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor);
        }
        /*输出
        public jiple.Person()
         */
        System.out.println();
        //Constructor<?>[] getDeclaredConstructors()：获取当前运行时类中声明的所有的构造器
        Constructor<?>[] declaredConstructors = clazz.getDeclaredConstructors();
        for (Constructor<?> constructor : declaredConstructors) {
            System.out.println(constructor);
        }
        /*输出
        public jiple.Person()
        jiple.Person(java.lang.String,int)
        private jiple.Person(java.lang.String)
         */
    }
/*
6.获取运行时类的父类
 */
    @Test
    public void test6(){
        Class<Person> clazz = Person.class;
        //Class<? super T> getSuperclass()：获取运行时类的父类
        Class<? super Person> superclass = clazz.getSuperclass();
        System.out.println(superclass);//class jiple.Creature
    }
/*
7.获取运行时类的带泛型的父类
 */
    @Test
    public void test7(){
        Class<Person> clazz = Person.class;
        //Type getGenericSuperclass()：获取运行时类的带泛型的父类
        Type genericSuperclass = clazz.getGenericSuperclass();
        System.out.println(genericSuperclass);//jiple.Creature<java.lang.String>
    }
/*
8.获取运行时类的带泛型的父类的泛型
 */
    @Test
    public void test8(){
        Class<Person> clazz = Person.class;
        Type genericSuperclass = clazz.getGenericSuperclass();
        ParameterizedType paramType = (ParameterizedType) genericSuperclass;
        //Type[] getActualTypeArguments()：获取运行时类的带泛型的父类的泛型
        Type[] actualTypeArguments = paramType.getActualTypeArguments();
        System.out.println(actualTypeArguments[0].getTypeName());//java.lang.String
//        System.out.println(((Class)actualTypeArguments[0]).getName());//java.lang.String
    }
/*
9.获取运行时类实现的接口
 */
    @Test
    public void test9(){
        //获取运行时类实现的接口
        Class<Person> clazz = Person.class;
        //Class<?>[] getInterfaces()：获取运行时类实现的接口
        Class<?>[] interfaces = clazz.getInterfaces();
        for (Class<?> anInterface : interfaces) {
            System.out.println(anInterface);
        }
        /*输出
        interface java.lang.Comparable
        interface jiple.MyInterface
         */
        //获取运行时类的父类实现的接口
        System.out.println();
        Class<?>[] interfaces1 = clazz.getSuperclass().getInterfaces();
        for (Class<?> aClass : interfaces1) {
            System.out.println(aClass);
        }
        /*
        interface java.io.Serializable
         */
    }
/*
10.获取运行时类所在的包
 */
    @Test
    public void test10(){
        Class<Person> clazz = Person.class;
        //Package getPackage()：获取运行时类所在的包
        Package pack = clazz.getPackage();
        System.out.println(pack);//package jiple
    }
/*
11.获取运行时类声明的注解
 */
    @Test
    public void test11(){
        Class<Person> clazz = Person.class;
        //Annotation[] getAnnotations()：获取运行时类声明的注解
        Annotation[] annotations = clazz.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        /*输出
        @jiple.MyAnnotation("hi")
         */
    }
}

12.6 反射应用三：调用运行时类的指定结构

class Creature<T> implements Serializable{
    private char gender;
    public double weight;

    private void breath(){
        System.out.println("生物呼吸");
    }

    public void eat(){
        System.out.println("生物吃东西");

    }
}
interface MyInterface{
    void info();
}
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@interface MyAnnotation{
    String value() default "hello";

}
@MyAnnotation("hi")
class Person extends Creature<String> implements Comparable<String>,MyInterface{

    private String name;
    int age;
    public int id;

    @MyAnnotation("abc")
    private Person(String name){
        this.name=name;
    }

    Person(String name,int age){
        this.name=name;
        this.age=age;
    }

    public Person(){

    }

    @MyAnnotation
    private String show(String nation){
        System.out.println("我的国籍是:"+nation);
        return nation;
    }

    String display(String interests){
        return interests;
    }

    @Override
    public void info() {
        System.out.println("我是一个人");
    }

    @Override
    public int compareTo(String o) {
        return 0;
    }

    private static void showDesc(){
        System.out.println("我是一个可爱的人");
    }

}
public class Main {
/*
1.调用运行时类的指定属性
 */
    @Test
    public void test1() throws Exception{
        Class<Person> clazz = Person.class;
        //1.创建运行时类的对象
        Person person = clazz.newInstance();
        //2.Field getDeclaredField(String name)：获取运行时类的指定属性
        Field name = clazz.getDeclaredField("name");
        //3.保证当前属性是可访问的
        name.setAccessible(true);
        //4.设置指定对象的此属性值
        name.set(person,"Tom");
        //5.获取指定对象的此属性值
        System.out.println(name.get(person));//Tom
    }
/*
2.调用运行时类的指定方法
 */
    @Test
    public void test2() throws Exception{
        Class<Person> clazz = Person.class;
        //1.创建运行时类的对象
        Person person = clazz.newInstance();
        //2.Method getDeclaredMethod(String name, Class<?>... parameterTypes)：获取运行时类的指定方法
        Method show = clazz.getDeclaredMethod("show", String.class);
        //3.保证当前方法是可访问的
        show.setAccessible(true);
        //4.利用指定对象调用此方法（非静态方法）
        String returnValue = (String)show.invoke(person, "CHN");//相当于String returnValue = p.show("CHN");：我的国籍是:CHN
        System.out.println(returnValue);//CHN
        System.out.println("*****如何调用静态方法******");
        //5.利用指定类调用此方法（静态方法）
        Method showDesc = clazz.getDeclaredMethod("showDesc");
        showDesc.setAccessible(true);
        //如果方法没有返回值，则invoke()方法返回null
        Object returnVal = showDesc.invoke(Person.class);//相当于String returnVal = Person.showDesc();：我是一个可爱的人
        System.out.println(returnVal);//null
    }
/*
3.调用运行时类的指定构造器：
 */
    @Test
    public void test3() throws Exception{
        Class<Person> clazz = Person.class;
        //1.Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)：获取运行时类的指定构造器
        Constructor<Person> constructor = clazz.getDeclaredConstructor(String.class);
        //2.保证当前构造器是可访问的
        constructor.setAccessible(true);
        //3.调用此构造器创建运行时类的对象
        Person person = constructor.newInstance("Tom");
        System.out.println(person);//Person{name='Tom', age=0, id=0, weight=0.0}
    }
}

12.7 反射应用四：动态代理

/*
1.代理模式的原理：使用一个代理类将被代理类对象包装起来, 然后用该代理类的对象取代被代理类对象，任何对被代理类对象的调用都要通过代理类对象，代理类对象决定是否以及何时将方法调用转移到被代理类对象上
2.静态代理
    2.1 静态代理举例一：
        实现Runnable接口的方法创建多线程：
        Class MyThread implements Runnable{} //相当于被代理类
        Class Thread implements Runnable{} //相当于代理类
        main(){
            MyThread t = new MyThread();
            Thread thread = new Thread(t);
            thread.start();//启动线程；调用线程的run()
        }
    2.2 静态代理的缺点：
        2.2.1 代理类和被代理类都是在编译期间确定下来，不利于程序的扩展
        2.2.2 每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理
    2.3 静态代理举例二：
 */
interface ClothFactory{
    void produceCloth();
}
//被代理类
class NikeClothFactory implements ClothFactory{

    @Override
    public void produceCloth() {
        System.out.println("Nike工厂生产一批运动服");
    }
}
//代理类
class ProxyClothFactory implements ClothFactory{
    private ClothFactory factory;//用被代理类对象进行实例化

    public ProxyClothFactory(ClothFactory factory) {
        this.factory = factory;
    }

    @Override
    public void produceCloth() {
        System.out.println("代理工厂做一些准备工作");
        factory.produceCloth();
        System.out.println("代理工厂做一些后续的收尾工作");
    }
}
public class Main {
    @Test
    public void test1(){
        //创建被代理类的对象
        ClothFactory nike = new NikeClothFactory();
        //创建代理类的对象
        ClothFactory proxyClothFactory = new ProxyClothFactory(nike);
        proxyClothFactory.produceCloth();
        /*输出
        代理工厂做一些准备工作
        Nike工厂生产一批运动服
        代理工厂做一些后续的收尾工作
         */
    }
}

/*
3.动态代理的特点：在程序运行时根据加载到内存中的被代理类，动态地创建代理类及其对象，当通过代理类对象调用方法a时，自动地调用被代理类中的同名方法a
4.动态代理的实现
    4.1 问题一：如何根据加载到内存中的被代理类，动态地创建代理类及其对象 
    4.2 问题二：当通过代理类对象调用方法a时，如何自动地调用被代理类中的同名方法a
 */
interface Human{
    String getBelief();
    void eat(String food);
}
//被代理类
class SuperMan implements Human{

    @Override
    public String getBelief() {
        return "I believe I can fly!";
    }

    @Override
    public void eat(String food) {
        System.out.println("我喜欢吃"+food);
    }
}
class HumanUtil{
    public void method1(){
        System.out.println("通用方法一");
    }
    public void method2(){
        System.out.println("通用方法二");
    }
}
class ProxyFactory{    
    public static Object getProxyInstance(Object obj){
        MyInvocationHandler myInvocationHandler = new MyInvocationHandler(obj);
        //调用此方法，返回一个代理类的对象。解决问题一
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),myInvocationHandler);
    }
}
class MyInvocationHandler implements InvocationHandler{
    private Object object;//需要使用被代理类的对象进行赋值

    public MyInvocationHandler(Object object) {
        this.object = object;
    }

    //当我们通过代理类的对象调用方法a时，就会自动地调用如下的方法：invoke()
    //将调用被代理类中的同名方法a的操作声明在invoke()中。解决问题二
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        HumanUtil util = new HumanUtil();
        util.method1();
        //method：即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
        //obj：被代理类的对象
        Object returnValue = method.invoke(object, args);
        util.method2();
        //上述方法的返回值就作为当前类中的invoke()的返回值
        return returnValue;
    }
}

public class Main {
    @Test
    public void test(){
        SuperMan superMan = new SuperMan();
        //proxyInstance:代理类的对象
        Human proxyInstance = (Human)ProxyFactory.getProxyInstance(superMan);
        //当通过代理类对象调用方法时，会自动地调用被代理类中同名的方法
        String belief = proxyInstance.getBelief();
        System.out.println(belief);
        /*输出
        通用方法一
        通用方法二
        I believe I can fly!
         */
        proxyInstance.eat("四川麻辣烫");
        /*输出
        通用方法一
        我喜欢吃四川麻辣烫
        通用方法二
         */
        System.out.println("*****************");
        NikeClothFactory nikeClothFactory = new NikeClothFactory();
        ClothFactory clothFactory = (ClothFactory)ProxyFactory.getProxyInstance(nikeClothFactory);
        clothFactory.produceCloth();
        /*输出
        通用方法一
        Nike工厂生产一批运动服
        通用方法二
         */
    }
}
interface ClothFactory{
    void produceCloth();
}
class NikeClothFactory implements ClothFactory{

    @Override
    public void produceCloth() {
        System.out.println("Nike工厂生产一批运动服");
    }
}
假装不痛
关注
专栏目录
Java反射使用实例
Javee的博客
08-19 314
Java反射使用实例 ——Javee Java反射机制是指，在Java运行的过程中可以获取到任意一个类的属性和方法；也可以获取任意一个对象的属性或执行对象的方法。 反射方法的简介： package cn.edu.ncu.online.work2; import cn.edu.ncu.online.work1...
Java反射机制
hchhan的博客
08-10 237
反射机制是Java动态性之一。 反射就是为了提高程序的灵活性，例如在使用程序加载数据库驱动时，或者在框架中。 因为很多框架要灵活的适应到很多情况下，比如struts框架中，当请求时，需要struts通过查询配置文件来 找到请求对应的action方法，然后通过反射实例化action，调用method。 如果不使用反射，那就只能写死在代码里了。 一、动态语言 动态语言，是指程序在运行时可以改变其...
Java反射
weixin_49329785的博客
09-02 492
一、Java反射机制概述 //反射之前，对于Person的操作 @Test public void test1(){ //1.创建Person类的对象 Person p1 = new Person("Tom",12); //2.通过对象，调用其内部的属性、方法 p1.age = 10; System.out.println(p1.toString());//Person{name='Tom',..
Java高级之反射详解
weixin_30861797的博客
03-07 168
一，类的加载概述和加载时机　 1.1.1，类的加载概述: 　　当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。　 加载 　就是指将class文件读入内存，并为之创建一个Class对象。任何类被使用时系统都会建立一个Class对象。 连接 　验证 是否有正确的内部结构，并和其他类协调一致 　准备 负责为...
android person类_java反射系列1（反射的概括、Class类的理解与获取Class的实例）
weixin_39831039的博客
10-21 208
反射的概括1.Reflection(反射)是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。框架 = 反射 + 注解 + 设计模式。2.体会反射机制的“动态性”//体会反射的动态性@Testpublic void test2(){ for(int i = 0;i < 100;i++){ int num...
哪些类用来实现java反射机制_JAVA反射机制
weixin_29555609的博客
02-27 2388
运行时类型识别(Run-time Type Identification, RTTI)主要有两种方式，一种是我们在编译时和运行时已经知道了所有的类型，另外一种是功能强大的“反射”机制。要理解RTTI在Java中的工作原理，首先必须知道类型信息在运行时是如何表示的，这项工作是由“Class对象”完成的，它包含了与类有关的信息。类是程序的重要组成部分，每个类都有一个Class对象，每当编写并编译了一个...
java 反射机制详解_java反射机制原理详解
weixin_31669073的博客
03-07 2168
反射机制:所谓的反射机制就是java语言在运行时拥有一项自观的能力。通过这种能力可以彻底的了解自身的情况为下一步的动作做准备。下面具体介绍一下java的反射机制。这里你将颠覆原来对java的理解。Java的反射机制的实现要借助于4个类：class，Constructor，Field，Method；其中class代表的时类对象，Constructor－类的构造器对象，Field－类的属性对象，Met...
java反射机制实际应用_java反射机制实际应用
weixin_42453050的博客
02-25 200
其中 LEAD/LEAD++ 、OpenC++ 、 MetaXa 和 OpenJava 等就是基于反射机制的语言。最近,反射机制也被应用到了视窗系统、操作系统 和文件系统中。 反射本身并不是......以下这个类运用反射机制调用其 add()和 echo()方法,代码如下: Invoketester.java 代码 1. import java.lang.reflect.Method; 2. 3....
java api查询反射_java反射机制API详解
weixin_35834213的博客
03-02 99
之前给大家介绍了一下java反射机制是什么的内容，那么下面要给大家详细的介绍的就是java反射机制API一起来了解一下吧。实现Java反射机制的类都位于java.lang.reflect包中，java.lang.Class类是Java反射机制API中的核心类。java.lang.Class类java.lang.Class类是实现反射的关键所在，Class类的一个实例表示Java的一种数据类型，包括...
java 反射模式_java反射机制模式
weixin_29471541的博客
02-15 351
第十八章：Java Reflection1.JAVA反射机制：JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。JAVA反射(放射)机制：“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。1.1Java反射机制的好处：Java...
MLDN 第十五章 Java反射机制.docx
06-11
Java反射机制是Java编程语言中的一种强大的工具，它允许程序在运行时检查并操作类、接口、字段和方法的信息。这一特性使得Java代码能够在运行时动态地获取类的信息，并能够创建和操作任何类的对象，即使在编译时不...
java-ppt.rar_java .ppt_java ppt_java基础 ppt_java基础 ppt_ppt jav
09-21
13. **反射机制**：动态获取类信息，创建对象，调用方法，修改字段值的能力。 14. **JNI（Java Native Interface）**：让Java代码调用C/C++原生代码，实现性能优化或利用已有库。 15. **JavaFX和Swing**：构建图形...
java 反射 类型转换_Java反射机制( 转)
weixin_39955829的博客
02-20 732
Java反射机制摘要Reflection 是Java被视为动态(或准动态)语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers(诸如public, static 等等)、superclass(例如Object)、实现之interfaces(例如Cloneable)，也包括fields和methods的所有...
工厂模式的介绍及实现
户伟伟的博客
09-25 96
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
基于Hive和Hadoop的哔哩哔哩网站分析系统
最新发布
图南的博客
09-27 165
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
智能BI平台项目
2302_79400545的博客
09-22 223
BI商业智能：数据可视化、报表可视化系统。
Android系统：系统架构
liufeismart2024的博客
09-23 493
Android的系统结构的设计混合了分层设计和分块设计。
Java Alibaba Druid 数据库连接池
miracle的专栏
09-24 718
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
JPA+Thymeleaf增删改查
y050505的博客
09-25 450
在使用JPA（Java Persistence API）和Thymeleaf作为模板引擎进行Web开发时，实现增删改查（CRUD）操作是一个常见的需求。下面，我将简要介绍如何使用Spring Boot框架结合JPA和Thymeleaf来实现这一功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值