精华内容
下载资源
问答
  • Java反射机制

    2021-01-02 18:50:03
    Java反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够动态调用它的任意一个方法和属性;这个动态获取信息以及动态调用对象的方法的功能称为Java语言的反射机制...

    反射机制概念

    Java反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够动态调用它的任意一个方法和属性;这个动态获取信息以及动态调用对象的方法的功能称为Java语言的反射机制

    在Java的设计模式和流行框架中,反射机制被大量的使用,如果不深刻理解Java反射机制,是无法理解Java的设计模式或阅读流行框架底层代码的。

    反射机制提供的功能

    • 在运行时判断任意一个对象所属的类
    • 在运行时构造任意一个类的对象
    • 在运行时访问一个类所具有的成员变量
    • 在运行时调用任意一个对象的方法
    • 生成动态代理

    反射实现的类

    在JDK中,主要由以下类来实现Java反射机制,这些类都位于java.lang.reflect包中。

    • Class类:封装了描述方法的Method,描述字段的Field,描述构造器的Constructor等属性。对于每个类,JRE都会为其保留一个不变的Class类型的对象
    • Field类:代表类的成员变量(成员变量也称为类的属性)
    • Method类:代表类的方法
    • Constructor类:代表类的构造方法

    获取类的字节码对象

    要想解剖一个类,必须要获取到该类的字节码文件对象。常用的获取Class对象的3中方式:使用Class类的静态方法、使用类的.class方法、使用对象的getClass()。

    /**
     * 获取Class对象演示
     *
     * @author god-jiang
     * @date 2021/1/2 17:09
     */
    public class Reflect {
        public static void main(String[] args) throws ClassNotFoundException {
            // 获取类的三种方法
            // 第一种 Class.forName("类名")(强烈推荐)
            Class c1 = Class.forName("java.lang.String");
            System.out.println("第一种方法获取的类:" + c1);
    
            // 第二种 类名.class
            Class c2 = String.class;
            System.out.println("第二种方法获取的类:" + c2);
    
            // 第三种 对象.getClass()
            String str = new String();
            Class c3 = str.getClass();
            System.out.println("第三种方法获取的类:" + c3);
        }
    }
    

    在这里插入图片描述

    反射机制的运用

    1、在运行时判断任意一个对象所属的类

    /**
     * 反射的运用
     *
     * @author god-jiang
     * @date 2021/1/2 17:33
     */
    public class Reflect {
        public static void main(String[] args) throws ClassNotFoundException {
            // 1、在运行时判断任意一个对象所属的类
            Class c1 = Class.forName("java.lang.String");
            String str = new String("god-jiang");
            Integer itr = 666;
            // 同一个类则返回true,否则返回false
            boolean instance1 = c1.isInstance(str);
            boolean instance2 = c1.isInstance(itr);
            System.out.println("运行时获取的对象c1是否属于String类:" + instance1);
            System.out.println("运行时获取的对象c1是否属于Integer类:" + instance2);
        }
    }
    

    在这里插入图片描述

    2、在运行时构造任意一个类的对象

    /**
     * 反射的运用
     *
     * @author god-jiang
     * @date 2021/1/2 17:33
     */
    public class Reflect {
        public static void main(String[] args) throws Exception {
            // 2、在运行时构造任意一个类的对象
            Class c1 = Class.forName("java.lang.String");
            // 调用无参的构造器
            Object str1 = c1.newInstance();
            System.out.println(str1.hashCode());
    
            // 调用有参的构造器
            // 获取String类带一个String参数的构造器
            Constructor constructor = c1.getConstructor(String.class);
            Object str2 = constructor.newInstance("god-jiang");
            System.out.println(str2);
        }
    }
    

    在这里插入图片描述

    3、在运行时访问类所具有的成员变量

    
    package god.jiang;
    
    /**
     * 演示的POJO
     *
     * @author god-jiang
     * @date 2020/1/2 18:31
     */
    @Data
    public class User {
        private String name;
        private Integer age;
        private String tag;
    }
    

    演示反射机制获取成员变量并且修改变量

    /**
     * 反射的运用
     *
     * @author god-jiang
     * @date 2021/1/2 17:33
     */
    public class Reflect {
        public static void main(String[] args) throws Exception {
            // 3、在运行时访问类所具有的成员变量
            Class c1 = Class.forName("god.jiang.User");
    
            // 实例化对象
            User user = (User) c1.newInstance();
            user.setName("god-jiang");
            user.setAge(18);
            user.setTag("god-jiang演示反射的运用");
    
            Field[] fields = c1.getDeclaredFields();
            for (Field field : fields) {
                // 获取private变量的访问权
                field.setAccessible(true);
                System.out.println("成员变量" + field.getName() + "的值为:" + field.get(user));
            }
    
            System.out.println("=====================================================");
            // 动态修改对象的值
            Field field = c1.getDeclaredField("name");
            field.setAccessible(true);
            field.set(user, "wuxijiang666");
            System.out.println("name的值修改后为:" + user.getName());
        }
    }
    

    在这里插入图片描述

    4、在运行时调用对象所具有的方法

    /**
     * 反射的运用
     *
     * @author god-jiang
     * @date 2021/1/2 17:33
     */
    public class Reflect {
        public static void main(String[] args) throws Exception {
            // 4、在运行时调用对象所具有的方法
            Class c1 = Class.forName("java.lang.String");
            Object str = c1.getConstructor(String.class).newInstance("god-jiang");
    
            // 通过反射获取String类的indexOf方法
            Method indexOf = c1.getDeclaredMethod("indexOf", String.class);
            // 获取private的访问权
            indexOf.setAccessible(true);
            // 调用方法,获取'-'在“god-jiang”的位置
            Object invoke = indexOf.invoke(str, "-");
            System.out.println("获取'-'在“god-jiang”的位置为:" + invoke);
        }
    }
    

    在这里插入图片描述

    反射的缺点

    • 反射会额外消耗一些系统资源,因此如果不需要动态创建一个对象那就不要使用反射
    • 反射调用方法可以忽略权限检查,因此可能会破坏封装性而导致安全问题

    总结

    反射是每个Java程序员都必定要掌握的一个知识点,只会CRUD的只能是初级程序员,而初级往中高级的途径中,必有反射机制这个门槛,希望每位Java程序员都能够迈过去,一步步成长和升级。

    希望以上这篇Java反射机制对正在学习Java或者已经工作的程序猿有所帮助。

    展开全文
  • Java 反射机制

    万次阅读 2019-10-17 17:37:24
    JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制...

    一、总体介绍

    1、什么是反射机制。
        JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制(注意关键词:运行状态)换句话说,Java程序可以加载一个运行时才得知名称的class,获悉其完整构造(但不包括methods定义),并生成其对象实体、或对其fields设值、或唤起其methods。

    2、反射机制主要提供的功能。
        在运行时判断任意一个对象所属的类;
        在运行时构造任意一个类的对象;
        在运行时判断任意一个类所具有的成员变量和方法;
        在运行时调用任意一个对象的方法;
        
    3、java Reflection API简介。
        Class类:代表一个类,位于java.lang包下
        Field类:代表类的成员变量(成员变量也称为类的属性)
        Method类:代表类的方法
        Constructor类:代表类的构造方法
        Array类:提供了动态创建数组,以及访问数组的元素的静态方法

    二、Reflection API详细简介

    1、Class代表类的实体,在运行的Java应用程序中表示类和接口。在这个类中提供了很多有用的方法,这里对他们简单的分类介绍。
      获得类相关的方法。
        方法    用途
        asSubclass(Class<U> clazz)    把传递的类的对象转换成代表其子类的对象
        Cast    把对象转换成代表类或是接口的对象
        getClassLoader()    获得类的加载器
        getClasses()    返回一个数组,数组中包含该类中所有公共类和接口类的对象
        getDeclaredClasses()    返回一个数组,数组中包含该类中所有类和接口类的对象
        forName(String className)    根据类名返回类的对象
        getName()    获得类的完整路径名字
        newInstance()    创建类的实例
        getPackage()    获得类的包
        getSimpleName()    获得类的名字
        getSuperclass()    获得当前类继承的父类的名字
        getInterfaces()    获得当前类实现的类或是接口
      获得类中属性相关的方法。
        方法    用途
        getField(String name)    获得某个公有的属性对象
        getFields()    获得所有公有的属性对象
        getDeclaredField(String name)    获得某个属性对象
        getDeclaredFields()    获得所有属性对象
      获得类中注解相关的方法。
        方法    用途
        getAnnotation(Class<A> annotationClass)    返回该类中与参数类型匹配的公有注解对象
        getAnnotations()    返回该类所有的公有注解对象
        getDeclaredAnnotation(Class<A> annotationClass)    返回该类中与参数类型匹配的所有注解对象
        getDeclaredAnnotations()    返回该类所有的注解对象
      获得类中构造器相关的方法。
        方法    用途
        getConstructor(Class...<?> parameterTypes)    获得该类中与参数类型匹配的公有构造方法
        getConstructors()    获得该类的所有公有构造方法
        getDeclaredConstructor(Class...<?> parameterTypes)    获得该类中与参数类型匹配的构造方法
        getDeclaredConstructors()    获得该类所有构造方法
      获得类中方法相关的方法。
        方法    用途
        getMethod(String name, Class...<?> parameterTypes)    获得该类某个公有的方法
        getMethods()    获得该类所有公有的方法
        getDeclaredMethod(String name, Class...<?> parameterTypes)    获得该类某个方法
        getDeclaredMethods()    获得该类所有方法
      类中其他重要的方法。
        方法    用途
        isAnnotation()    如果是注解类型则返回true
        isAnnotationPresent(Class<? extends Annotation> annotationClass)    如果是指定类型注解类型则返回true
        isAnonymousClass()    如果是匿名类则返回true
        isArray()    如果是一个数组类则返回true
        isEnum()    如果是枚举类则返回true
        isInstance(Object obj)    如果obj是该类的实例则返回true
        isInterface()    如果是接口类则返回true
        isLocalClass()    如果是局部类则返回true
        isMemberClass()    如果是内部类则返回true

    2、Field代表类的成员变量(成员变量也称为类的属性)。
        方法    用途
        equals(Object obj)    属性与obj相等则返回true
        get(Object obj)    获得obj中对应的属性值
        set(Object obj, Object value)    设置obj中对应属性值

    3、Method代表类的方法。
       方法    用途
       invoke(Object obj, Object... args)    传递object对象及参数调用该对象对应的方法

    4、Constructor代表类的构造方法。
        方法    用途
        newInstance(Object... initargs)    根据传递的参数创建类的对象

    三、实例。

    1、新建一个测试类User。

    package com.zxj.reptile.api.test;
    
    public class User {
        private String id;
        private String username;
        private String password;
    
        public int age = 11;
    
        public User() {
        }
    
        public User(String id) {
            this.id = id;
        }
    
        public User(String username, String password) {
            this.username = username;
            this.password = password;
        }
    
        public User(String id, String username, String password) {
            this.id = id;
            this.username = username;
            this.password = password;
        }
    
        public String getId() {
            return id;
        }
    
        public void setId(String id) {
            this.id = id;
        }
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "id='" + id + '\'' +
                    ", username='" + username + '\'' +
                    ", password='" + password + '\'' +
                    '}';
        }
    
        private String write(String password) {
            return String.format("%s您的密码是:%s", getUsername(), password);
        }
    }
    

    2、Class的三种获取方式。

    //Class三种获取方式
    User userTest1 =new User();
    Class<?> userClazz1 = userTest1.getClass();//用对象调用getClass()方法
    Class<?> userClazz2 = Class.forName("com.zxj.reptile.api.test.User"); //用Class类的静态方法forName()
    Class<?> userClazz3 = User.class;//用.class的方式
    System.out.println("userClazz1: " + userClazz1);
    System.out.println("userClazz2: " + userClazz2);
    System.out.println("userClazz3: " + userClazz3);

    3、创建对象实例

    //用Class创建对象实例
    Class<?> userClass = Class.forName("com.zxj.reptile.api.test.User");
    User user = (User) userClass.newInstance();
    user.setUsername("xiaojie");
    user.setPassword("111");
    System.out.println("user: " + user.toString());
    //用Constructor创建对象实例
    Constructor<?>[] constructorArray = userClass.getConstructors();
    for (Constructor<?> constructor : constructorArray) {
        Type[] typeArray = constructor.getGenericParameterTypes();
        if (typeArray.length == 2) {
            User user2 = (User) constructor.newInstance("xiaojie2", "222");
            System.out.println("user2: " + user2.toString());
        } else if (typeArray.length == 0) {
            User user3 = (User) constructor.newInstance();
            System.out.println("user3: " + user3.toString());
        }
    }

    4、属性的获取。

    //调用属性
    Class<?> userClass = Class.forName("com.zxj.reptile.api.test.User");
    Object userObject = userClass.newInstance();
    Field usernameField = userClass.getDeclaredField("username");
    usernameField.setAccessible(true);//取消java的权限控制检查,private和public默认都是true
    usernameField.set(userObject, "xiaojie");
    System.out.println("user 属性调用: " + userObject);
    //调用方法
    Method method = userClass.getMethod("toString");
    String str= (String) method.invoke(userClass.newInstance());
    System.out.println("user 方法调用: " + str);

    四、总结

        在阅读Class类文档时发现一个特点,以通过反射获得Method对象为例,一般会提供四种方法,getMethod(parameterTypes)、getMethods()、getDeclaredMethod(parameterTypes)和getDeclaredMethods()。getMethod(parameterTypes)用来获取某个公有的方法的对象,getMethods()获得该类所有公有的方法,getDeclaredMethod(parameterTypes)获得该类某个方法,getDeclaredMethods()获得该类所有方法。带有Declared修饰的方法可以反射到私有的方法,没有Declared修饰的只能用来反射公有的方法。其他的Annotation、Field、Constructor也是如此。

     

     

    展开全文
  • java反射机制

    万次阅读 多人点赞 2019-07-02 21:26:19
    编译期和运行期,编译期就是编译器帮你把源代码翻译成机器能识别的代码,比如编译器把java代码编译成jvm识别的字节码文件,而运行期指的是将可执行文件交给操作系统去执行,JAVA反射机制是在运行状态中,对于任意一...

    🌱1. 什么是反射机制?
    首先大家应该先了解两个概念,编译期和运行期,编译期就是编译器帮你把源代码翻译成机器能识别的代码,比如编译器把java代码编译成jvm识别的字节码文件,而运行期指的是将可执行文件交给操作系统去执行,JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意方法和属性;这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制
    简单说,反射机制值得是程序在运行时能够获取自身的信息。在java中,只要给定类的名字,那么就可以通过反射机制来获得类的所有信息。

    🌱2. java反射机制提供了什么功能?

    • 在运行时能够判断任意一个对象所属的类

    • 在运行时构造任意一个类的对象

    • 在运行时判断任意一个类所具有的成员变量和方法

    • 在运行时调用任一对象的方法

    • 在运行时创建新类对象

    🌱3.new和反射创建有什么区别呢?

    new: 静态编译,在编译期就将模块编译进来,执行该字节码文件,所有的模块都被加载;

    反射:动态编译,编译期没有加载,等到模块被调用时才加载;

    注:spring的ioc就用到反射机制,newInstance创建。更加的通用,并且降低耦合,避免了硬编码,只需提供一个字符串就可以动态的创建。

    String className = readfromXMlConfig;//从xml 配置文件中获得字符串
    
    Class c = Class.forName(className);
    
    factory = (AInterface)c.newInstance();
    

    举例

    有自行车🚲,小轿车🚗,

    静态:上班将自行车放车里去上班,一定得带着,一个不能落下,

    动态:将自行车放家里,交通堵塞骑自行车去,车放家里。

    🌱4. 如何通过反射调用私有对象?

    Field[] declaredFields = clazz.getDeclaredFields();
    
    for (Field f : declaredFields) {
    			System.out.println("属性的名称:" + f.getName());
    			System.out.println("属性的类型:" + f.getType().getName());
    			// 给属性赋值
    			f.setAccessible(true);// 设置为私有属性可以访问
    

    🌱5.如何通过反射调用方法?

    		Method m = stuClass.getMethod("show1", String.class);
    		System.out.println(m);
    		//实例化一个Student对象
    		Object obj = stuClass.getConstructor().newInstance();
    		m.invoke(obj, "刘德华");
    

    🌱6. class类一部分常用方法总结

    • 获取公共构造器 getConstructors()
    • 获取所有构造器getDeclaredConstructors
    • 获取包含的方法 getMethod()
    • 获取包含的属性 getField(String name)
    • 获取内部类 getDeclaredClasses()
    • 获取外部类getDeclaringClass()
    • 获取所实现的接口 getInterfaces()
    • 获取修饰符 getModifiers()
    • 获取所在包 getPackage()
    • 获取类名包含包路径 getName()
    • 类名不包含包路径 getSimpleName()

    java反射的简单演示

    
    package com.fjh;
    
    public class Student {
    	private String name;
    	private int age;
    	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 Student(String name, int age) {
    		
    		this.name = name;
    		this.age = age;
    	}
    	public Student() {
    		System.out.println("实例化一个对象!");
    	
    	}
    	@Override
    	public String toString() {
    		return "Student [name=" + name + ", age=" + age + "]";
    	}
    	
    	
    	
    }
    
    
    package com.fjh;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    
    public class ReflectTest {
    
    	public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchFieldException,
    			SecurityException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException {
    		// 普通方法创建一个对象
    		Student stu = new Student();
    		// 利用反射机制创建一个对象
    		Student newInstance = Student.class.newInstance();
    		// 通过字节码获取属性
    		Class clazz = Student.class;
    		// Field field = clazz.getField("name");//指定返回一个公有的属性
    		Field field = clazz.getDeclaredField("name");
    		System.out.println("属性的名称:" + field.getName());
    		System.out.println("属性的类型:" + field.getType().getName());
    
    		System.out.println("---------------------");
    		// 获取一个类中的所有属性
    		Field[] declaredFields = clazz.getDeclaredFields();
    		for (Field f : declaredFields) {
    			System.out.println("属性的名称:" + f.getName());
    			System.out.println("属性的类型:" + f.getType().getName());
    			// 给属性赋值
    			f.setAccessible(true);// 设置为私有属性可以访问
    
    			if (int.class == f.getType()) {
    				f.set(newInstance, 50);
    			} else if (String.class == f.getType()) {
    				f.set(newInstance, "蔡徐坤");
    			}
    		}
    		System.out.println("========通过直接赋值后的结果==========");
    		System.out.println(newInstance);
    		
    		System.out.println("========获取所有方法==========");
    
    		// 获取所有方法 不包括构造方法
    		Method[] methods = clazz.getDeclaredMethods();
    		for (Method method : methods) {
    			String methodName = method.getName();// 参数名称
    			int parameterCount = method.getParameterCount();// 参数个数
    			System.out.println("方法名字:" + methodName);
    			System.out.println("方法参数个数:" + parameterCount);
    			Class<?>[] parameterTypes = method.getParameterTypes();
    			// 获取每个方法的参数类型
    			for (Class<?> class1 : parameterTypes) {
    				System.out.println("参数类型:" + class1.getName());
    			}
    
    			// 获取方法的返回值
    			Class<?> returnType = method.getReturnType();
    			System.out.println("方法的返回值为:" + returnType.getName());
    			System.out.println("-------------------");
    		}
    
    		// 执行获取到的 方法
    		// 如果方法参数有多个,则需要用字节码数组来代替
    		// Method declaredMethod = clazz.getDeclaredMethod("setName", new
    		// Class[]{String.class,int.class});
    		// 执行方法同样使用数组
    		// declaredMethod.invoke(newInstance,Object[]{"mayun",20} );
    		Method declaredMethod = clazz.getDeclaredMethod("setName", String.class);// 返回当前Class对象表示的类或接口的指定已说明的一个方法对象。
    		declaredMethod.invoke(newInstance, "马云");
    		System.out.println("==========设值注入=========");
    		System.out.println(newInstance);
    
    		// 构造函数
    		Constructor constructor = clazz.getConstructor(new Class[] { String.class, int.class });
    		// 如何执行构造函数
    		Object obj = constructor.newInstance(new Object[] { "周杰伦", 46 });
    		System.out.println("==========构造注入=========");
    		System.out.println(obj);
    		
    		System.out.println("==========构造方法=========");
    		//获取所有的构造函数
    		Constructor[] constructors = clazz.getConstructors();
    		for (Constructor c : constructors) {
    			if(c.getParameterCount() != 0){
    				Class[] parameterTypes = c.getParameterTypes();
    				for (Class class1 : parameterTypes) {
    					System.out.println("参数类型:"+class1.getTypeName());
    				}
    				System.out.println("-------------------");
    			}else{
    				System.out.println("无参构造");
    				System.out.println("-------------------");
    			}
    		}
    	}
    
    }
    

    🌱5. 结果
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • JAVA 反射机制

    2014-09-08 23:01:42
    Java 反射机制
    

    JAVA 反射机制

    学习目标:

    1.理解Class

    2.理解Java的类加载机制

    3.学会使用ClassLoader进行加载

    4.理解反射机制

    5.掌握ConstructorMethodField

    6.理解并掌握动态代理

    如何理解Class 

    对象照镜子后可以得到的信息:某个类的数据成员名、方法和构造器、某个类到底实现 了哪些接口。对于每个类而言,JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个类的有关信息。

    Class 对象只能由系统建立对象

    一个类在 JVM 中只会有一个Class实例 

    每个类的实例都会记得自己是由哪个 Class 实例所生成 

     

    Class可以这么理解:它管理所有类的信息,所有的类都对应有一个Class对象。

    想使用反射第一步是获得对应的Class对象

    类加载器:

    1.System ClassLoader 系统类加载器  

                     1.通过ClassLoader静态方法 getSystemClassLoader()获得

                     2.通过this.getClass().getClassLoader()获得

    2.Extension ClassLoader 扩展类加载器

    3.Bootstap ClassLoader  引导类加载器

    最常用的一个方法

    Classloader.getResourceAsStream();

     

     

    获取Class对象的方法:

    1.通过class属性来获得,类.class

    2.通过具体对象的.getClass()方法来获得

    3.通过Class.forName(具体包名类名);        ----->最常使用的方法

     

    Class对象clazz的主要方法:

    1.产生一个具体对象     clazz.newInstance();

    2.获得Method方法(一个方法数组或具体某个方法)     

                      clazz.getMethods()clazz.getMethod(String name,Class...parameterTypes)

                  还有一种是getDeclaredMethod同理

                      Method一个比较重要的方法: invoke(对象名字,可变参数);

    3.获得构造方法Constractor (使用的机会很少)

    4.获取Field      clazz.getFields()clazz.getField(String name) 

            同理有getDeclaredFields

     

    若想获得私有的属性和方法就需要getDeclaredxxx,若想执行私有方法和获得私有属性需要methodfield:setAccessible(true)  暴力解除约束,       

    FieldMethod对应学习,也有私有和公有的区别。


    Java反射机制总结:

    java反射机制被认为是java准动态语言的依据,各种高级应用中都提倡类中存在无参构造方法。在现在的开发设计中大量使用反射处理机制,很多框架都是利用了反射机制才实现的,比如Struts、Spring框架等,理解好反射处理机制对将来学习或自己开发设计框架很有帮助。

    练习:

    自己写一个invoke(StringName,MethodName,Object...args)   有点难度哦(要遍历父类)

    1.要获得args对应的Class类型

    2.要获得父类中的方法

    获得父类  superClass


    备注:反射机制非常重要,尤其是如果你将来自己设计框架的时候



    备注:Java的反射机制是在运行时期获得类的信息的。

    展开全文
  • JAVA反射机制

    2017-11-26 17:57:07
     JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意方法和属性;这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。  ...
  • Java反射机制Java反射机制Java反射机制Java反射机制Java反射机制Java反射机制Java反射机制Java反射机制

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,681
精华内容 13,472
关键字:

java反射机制

java 订阅