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

    万次阅读 多人点赞 2017-04-01 20:35:41
    为什么要写这一系列的博客呢?因为在 Android 开发的过程中, 泛型,反射,注解这些知识进场会用到,几乎所有的框架至少都会...java Type 详解java 反射机制详解注解使用入门(一)反射机制什么是反射机制简单来说,

    本篇文章已授权微信公众号 guolin_blog (郭霖)独家发布

    为什么要写这一系列的博客呢?

    因为在 Android 开发的过程中, 泛型,反射,注解这些知识进场会用到,几乎所有的框架至少都会用到上面的一两种知识,如 Gson 就用到泛型,反射,注解,Retrofit 也用到泛型,反射,注解 。学好这些知识对我们进阶非常重要,尤其是阅读开源框架源码或者自己开发开源框架。

    java Type 详解

    java 反射机制详解

    注解使用入门(一)

    Android 自定义编译时注解1 - 简单的例子

    Android 编译时注解 —— 语法详解

    带你读懂 ButterKnife 的源码

    反射机制

    什么是反射机制

    简单来说,反射可以帮助我们在动态运行的时候,对于任意一个类,可以获得其所有的方法(包括 public protected private 默认状态的),所有的变量 (包括 public protected private 默认状态的)。是不是很强大呢。

    反射机制有什么作用呢?

    • 获取某些类的一些变量,调用某些类的私有方法。(例如在Android开发中我们可以用来开启 WiFi 热点,调用 WifiManager 中的 setWifiApEnabled() 方法 )
    • 增加代码的灵活性。很多主流框架都使用了反射技术.像ssh框架都采用两种技术 xml做配置文件+反射技术.

    假如有这样一个类 Person,它拥有多个成员变量,country,city,name,province,height,age 等,同时它拥有多个 构造方法,多个方法,这些变量,方法的访问权限既有 public 也有 private 的。下面我们以这个为例子,一起看怎样使用反射获得相应的 Filed,Constructor,Method。

    /**
     * 博客地址:http://blog.csdn.net/gdutxiaoxu
     * @author xujun
     * @time 2017/3/29 22:19.
     */
    public class Person {
        public String country;
        public String city;
        private String name;
        private String province;
        private Integer height;
        private Integer age;
    
    
        public Person() {
            System.out.println("调用Person的无参构造方法");
        }
    
        private Person(String country, String city, String name) {
            this.country = country;
            this.city = city;
            this.name = name;
        }
    
        public Person(String country, Integer age) {
            this.country = country;
            this.age = age;
        }
    
        private String getMobile(String number) {
            String mobile = "010-110" + "-" + number;
            return mobile;
        }
    
    
        private void setCountry(String country) {
            this.country=country;
    
        }
    
        public void getGenericHelper(HashMap<String, Integer> hashMap) {
        }
    
        public Class getGenericType() {
            try {
                HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
                Method method = getClass().getDeclaredMethod("getGenericHelper",HashMap.class);
                Type[] genericParameterTypes = method.getGenericParameterTypes();
                if (null == genericParameterTypes || genericParameterTypes.length < 1) {
                    return null;
                }
    
                ParameterizedType parameterizedType=(ParameterizedType)genericParameterTypes[0];
                Type rawType = parameterizedType.getRawType();
                System.out.println("----> rawType=" + rawType);
                Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
                if (actualTypeArguments==genericParameterTypes || actualTypeArguments.length<1) {
                    return null;
                }
    
                for (int i = 0; i < actualTypeArguments.length; i++) {
                    Type type = actualTypeArguments[i];
                    System.out.println("----> type=" + type);
                }
            } catch (Exception e) {
    
            }
            return null;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "country='" + country + '\'' +
                    ", city='" + city + '\'' +
                    ", name='" + name + '\'' +
                    ", province='" + province + '\'' +
                    ", height=" + height +
                    '}';
        }
    }
    

    使用反射获得所有构造方法(包括私有的,非私有的)

    默认权限的指的是没有修饰符修饰的

    几个重要的方法讲解

    方法描述
    public Constructor getConstructor(Class<?>… parameterTypes)获得指定的构造方法,注意只能获得 public 权限的构造方法,其他访问权限的获取不到
    public Constructor getDeclaredConstructor(Class<?>… parameterTypes)获得指定的构造方法,注意可以获取到任何访问权限的构造方法。
    public Constructor<?>[] getConstructors() throws SecurityException获得所有 public 访问权限的构造方法
    public Constructor<?>[] getDeclaredConstructors() throws SecurityException获得所有的构造方法,包括(public, private,protected,默认权限的)

    看了上面的几个方法,其实很好区分

    • 后缀带 s 的返回对象时数组类型,是可以获得相应权限的所有方法的,如 Constructor getConstructor() 方法 和 Constructor<?>[] getConstructors() 方法。几乎可以这样说,java 99% 的代码风格是这样的。 同时这里也引申出一个问题,平时你在开发中有没有遵循一定的开发规范
    • getConstructor() 方法和 getDeclaredConstructor 中间只相差一个单词 Declared ,区别在与是获得 public 权限的方法还是所有权限的方法。

    这里为什么要强调这一点呢?因为以下要讲解的 getMethod(), getMethods(),getDeclaredMethod(),getDelcaredMethods() 等方法与这个类似,下面不再阐述。

    获得所有的构造方法

    public static void printConstructor(String className) {
        try {
            Class<?> aClass = Class.forName(className);
            Constructor<?>[] constructors = aClass.getConstructors();
            print(constructors);
            Constructor<?>[] declaredConstructors = aClass.getDeclaredConstructors();
            print(declaredConstructors);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    
    }
    

    print: private com.example.reflectdemo.Person(java.lang.String,java.lang.String,java.lang.String)

    print: public com.example.reflectdemo.Person()

    print:public com.example.reflectdemo.Person(java.lang.String,java.lang.Integer)

    print:public com.example.reflectdemo.Person(java.lang.String,java.lang.Integer)

    对比 Person 里面所有的构造方法,可以知道我们代码的逻辑是正确的

    获得指定的构造方法

    public static Constructor getConstructor(String className, Class<?>... clzs) {
        try {
            Class<?> aClass = Class.forName(className);
            Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(clzs);
            print(declaredConstructor);
            //   if Constructor is not public,you should call this
            declaredConstructor.setAccessible(true);
            return declaredConstructor;
    
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        return null;
    
    }
    
    public class TestHelper {
    
        public static  final String TAG="xujun";
        public static final String CLASS_NAME = "com.example.reflectdemo.Person";
        public static final String CHINA = "China";
    
        public static void testConstructor(){
            ReflectHelper.printConstructor(CLASS_NAME);
            Constructor constructor = ReflectHelper.getConstructor(CLASS_NAME, String.class, Integer.class);
            try {
                Object meinv = constructor.newInstance(CHINA, 12);
                Person person = (Person) meinv;
                Log.i(TAG, "testConstructor: =" + person.toString());
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
    
        }
    }
    

    我们将可以看到以下的输出结果

    testConstructor: =Person [country=China, city=null, name=null, province=null, height=null, age=12]

    可以看到 country=China,age=12 这说明我们成功通过反射调用 Person 带两个参数的沟改造方法。

    注意事项

    如果该方法,或者该变量不是 public 访问权限的,我们应该调用相应的 setAccessible(true) 方法,才能访问得到

    //if Constructor is not public,you should call this
    declaredConstructor.setAccessible(true);
    

    使用反射获得所有的 Field 变量

    获得所有的 Field 变量

    public static void printField(String className) {
        try {
            Class<?> aClass = Class.forName(className);
            Field[] fields = aClass.getFields();
            PrintUtils.print(fields);
            Field[] declaredFields = aClass.getDeclaredFields();
            PrintUtils.print(declaredFields);
    
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    

    获得指定的成员变量

    现在假如我们要获得 Person 中的私有变量 age ,我们可以通过以下的代码获得,同时并打印出所有的成员变量。

    public static Field getFiled(String className, String filedName) {
        Object o = null;
        try {
            Class<?> aClass = Class.forName(className);
    
            Field declaredField = aClass.getDeclaredField(filedName);
            //   if not public,you should call this
            declaredField.setAccessible(true);
            return declaredField;
    
    
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
        return null;
    
    }
    
    public  static void testFiled(){
        ReflectHelper.printFileds(CLASS_NAME);
        Person person = new Person(CHINA, 12);
        Field field = ReflectHelper.getFiled(CLASS_NAME, "age");
        try {
            Integer integer = (Integer) field.get(person);
            PrintUtils.print("integer="+integer);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    
    }
    
    
    

    我们可以看到以下的输出结果

    print: public java.lang.String com.example.reflectdemo.Person.country

    print: public java.lang.String com.example.reflectdemo.Person.city

    print: public java.lang.String com.example.reflectdemo.Person.country

    print: public java.lang.String com.example.reflectdemo.Person.city

    print: private java.lang.String com.example.reflectdemo.Person.name

    print: private java.lang.String com.example.reflectdemo.Person.province

    print: private java.lang.Integer com.example.reflectdemo.Person.height

    print: private java.lang.Integer com.example.reflectdemo.Person.age

    print:integer=12

    使用反射执行相应的 Method

    主要有以下几个方法,

    • public Method[] getDeclaredMethods()
    • public Method[] getMethods() throws SecurityException
    • public Method getDeclaredMethod()
    • public Method getMethod(String name, Class<?>… parameterTypes)

    几个方法的作用我就不一一阐述了,因为上面在讲解 使用反射获得所有构造方法(包括私有的,非私有的) 的时候已经提到过了。

    获取所有的 Method

        public static void printMethods(String className) {
            try {
                Class<?> aClass = Class.forName(className);
                Method[] declaredMethods = aClass.getDeclaredMethods();
                PrintUtils.print(declaredMethods);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
    
        }
    

    print: public java.lang.String com.example.reflectdemo.Person.toString()

    print: public java.lang.Class com.example.reflectdemo.Person.getGenericType()

    print: private void com.example.reflectdemo.Person.setCountry(java.lang.String)

    print: public void com.example.reflectdemo.Person.getGenericHelper(java.util.HashMap)

    print: private java.lang.String com.example.reflectdemo.Person.getMobile(java.lang.String)

    对比 Person 里面的所有方法,毫无疑问我们的代码逻辑是正确的。

    获取指定的 Method

    我们可以使用 getDeclaredMethod(String name, Class<?>... parameterTypes) 或者 getMethod(String name, Class<?>… parameterTypes) 获得指定的方法,只不过 getMethod 方法只能获得 public 访问权限的方法,getDeclaredMethod 可以获得任何访问权限的方法。

    注意一下方法参数, name 代表的是方法的名称,Class<?>… parameterTypes 代表的是方法参数的类型,至于为什么是 … 数组类型的,因为我们参数可能是一个也可能是多个的。

    这里我们以 Person 类 里面的 private void setCountry(String country) 方法为例子讲解,可以看到方法名称为 setCountry ,方法参数的类型为 String ,所以我们在传递参数的时候 name 为 setCountry ,parameterTypes 为 String.class 。如果有多个参数,在加上该参数的 Class 类型即可。

       public static void testMethod(){
        	ReflectHelper.printMethods(CLASS_NAME);
            Person person=new Person();
            Method method = ReflectHelper.getMethod(CLASS_NAME,
                    "setCountry", String.class);
            try {
               // 执行方法,结果保存在 person 中
                Object o = method.invoke(person, CHINA);
               // 拿到我们传递进取的参数 country 的值 China          
                String country=person.country;
                PrintUtils.print(country);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
    
        }
        
        
    public class ReflectHelper {
    
        private static final String TAG = "ReflectHelper";
    
        public static Method getMethod(String className, String methodName, Class<?>... clzs) {
            try {
                Class<?> aClass = Class.forName(className);
                Method declaredMethod = aClass.getDeclaredMethod(methodName, clzs);
                declaredMethod.setAccessible(true);
                return declaredMethod;
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            }
            return null;
        }
    }
    

    执行上面的函数,将可以看到下面的结果

    print:China

    即我们成功利用反射调用 Person 的 setCountry 方法,并将值成功改变。


    使用反射操作数组

    /**
         * 利用反射操作数组
         * 1 利用反射修改数组中的元素
         * 2 利用反射获取数组中的每个元素
         */
        public static void testArrayClass() {
            String[] strArray = new String[]{"5","7","暑期","美女","女生","女神"};
            Array.set(strArray,0,"帅哥");
            Class clazz = strArray.getClass();
            if (clazz.isArray()) {
                int length = Array.getLength(strArray);
                for (int i = 0; i < length; i++) {
                    Object object = Array.get(strArray, i);
                    String className=object.getClass().getName();
                    System.out.println("----> object=" + object+",className="+className);
                }
            }
        }
    

    ----> object=帅哥,className=java.lang.String

    ----> object=7,className=java.lang.String

    ----> object=暑期,className=java.lang.String

    ----> object=美女,className=java.lang.String

    ----> object=女生,className=java.lang.String

    ----> object=女神,className=java.lang.String

    从结果可以说明,我们成功通过 Array.set(strArray,0,“帅哥”) 改变数组的值。

    使用反射获得泛型类型

    public static void getGenericHelper(HashMap<String, Person> map) {
    
        }
    

    现在假设我们有这样一个方法,那我们要怎样获得 HashMap 里面的 String,Person 的类型呢?

    对于 Java Type还不熟悉的可以先读这一篇博客 java Type 详解

    public static  void getGenericType() {
            try {
                Method method =TestHelper.class.getDeclaredMethod("getGenericHelper",HashMap.class);
                Type[] genericParameterTypes = method.getGenericParameterTypes();
                // 检验是否为空
                if (null == genericParameterTypes || genericParameterTypes.length < 1) {
                    return ;
                }
                // 取 getGenericHelper 方法的第一个参数
                
                ParameterizedType parameterizedType=(ParameterizedType)genericParameterTypes[0];
                Type rawType = parameterizedType.getRawType();
                System.out.println("----> rawType=" + rawType);
                Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
                if (actualTypeArguments==genericParameterTypes || actualTypeArguments.length<1) {
                    return ;
                }
                //  打印出每一个类型          
                for (int i = 0; i < actualTypeArguments.length; i++) {
                    Type type = actualTypeArguments[i];
                    System.out.println("----> type=" + type);
                }
            } catch (Exception e) {
    
            }
    
        }
    

    执行上面的代码,输出结果

    ----> rawType=class java.util.HashMap

    ----> type=class java.lang.String

    ----> type=class com.example.reflectdemo.Person


    怎样获得 Metho,Field,Constructor 的访问权限 ( public,private,ptotected 等)

    其实很简单,我们阅读文档可以发现他们都有 getModifiers() 方法,该方法放回 int 数字, 我们在利用 Modifier.toString() 就可以得到他们的访问权限

    int modifiers = method.getModifiers();
    Modifier.toString(modifiers);
    

    demo 下载地址

    好了,今天就写这么多了,明天准备回一下家,接着回一下学校。下一篇准备写 关于怎样编写自定义注解(基于编译时期的),敬且期待。

    推荐阅读

    一步步拆解 LeakCanary

    Android 面试必备 - http 与 https 协议

    Android 面试必备 - 计算机网络基本知识(TCP,UDP,Http,https)

    Android 面试必备 - 线程

    Android_interview github 地址

    扫一扫,欢迎关注我的微信公众号 stormjun94, 目前专注于 Android 开发,主要分享 Android开发相关知识和技术人成长历程,包括个人总结,职场经验,面试经验等。

    展开全文
  • Java反射机制详解

    2020-09-03 01:54:51
    主要介绍了Java反射机制,首先简单介绍了反射机制的预备知识,进一步分析了Java反射机制的原理、实现技巧与应用方法,需要的朋友可以参考下
  • java反射机制详解

    2009-07-16 09:17:53
    java反射机制详解,其中罗列了,反射机制的所有内容
  • JAVA反射机制详解

    2011-05-13 21:32:42
    详细讲解的JAVA的反射机制JAVA反射的工作原理详细讲解的JAVA的反射机制JAVA反射的工作原理详细讲解的JAVA的反射机制JAVA反射的工作原理
  • Java反射机制 详解

    千次阅读 2016-10-03 23:39:46
    一、什么是反射机制JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为...

    一、什么是反射机制

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

    “程序运行时,允许改变程序结构或变量类型,这种语言称为动态语言”。Java不是动态语言。但是Java有着一个非常突出的动态相关机制:Reflection,用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说,Java程序可以加载一个运行时才得知名称的class,获悉其完整构造(但不包括methods定义),并生成其对象实体、或对其fields设值、或唤起其methods。

    二、初识Java反射机制

    反射之中包含了一个“反”的概念,要解释反射就必须先从“正”开始解释,一般而言,一定是先有类再产生实例化对象。如下:

    package com.wz.reflectdemo;
    
    import java.util.Date;//先有类
    
    public class ReflectTest {
    
        public static void main(String[] args) {
            Date date = new Date();//再产对象
            System.out.println(date);
        }
    }
    

    而所谓的“反”,是通过对象找到类。在Object类里面提供有一个方法,
    取得class对象:

    public final Class<?> getClass()

    注:反射之中的所有泛型都定义为?,返回值都是Object。

    实例如下:

    package com.wz.reflectdemo;
    
    import java.util.Date;//先有类
    
    public class ReflectTest {
    
        public static void main(String[] args) {
            Date date = new Date();//再产对象
            System.out.println(date.getClass());
        }
    }
    

    执行结果:

    class java.util.Date

    我们发现,调用getClass()后,得到了类的完整名称。也就找到了对象的出处。

    三、Class类对象实例化

    java.lang.Class是一个类,它和一般类一样继承自Objec。这个类是反射操作的源头,即所有的反射都要从此类开始进行,这个类有三种实例化方式:

    方式一:调用Object类的getClass()方法(很少用到):

    package com.wz.reflectdemo;
    
    import java.util.Date;
    
    public class ReflectTest {
    
        public static void main(String[] args) {
            Date date = new Date();
            Class<?> cls = date.getClass();
            System.out.println(cls);
        }
    }
    

    运行结果:

    class java.util.Date
    

    方式二:使用“类.class”取得:

    package com.wz.reflectdemo;
    
    import java.util.Date;
    
    public class ReflectTest {
    
        public static void main(String[] args) {
            //Date date = new Date();
            Class<?> cls = Date.class;
            System.out.println(cls);
        }
    }
    

    运行结果:

    class java.util.Date
    

    注意:先前取得Class类对象之前需要实例化,但此时并没有进行实例化。

    方式三:调用Class类提供的一个方法:

    public static Class<?> forName(String className) throws ClassNotFoundException

    实例如下:

    package com.wz.reflectdemo;
    
    //import java.util.Date;
    
    public class ReflectTest {
    
        public static void main(String[] args) throws Exception {
            Class<?> cls = Class.forName("java.util.Date");
            System.out.println(cls);
        }
    }
    

    运行结果:

    class java.util.Date
    

    此时,无需使用import语句导入一个明确的类,而类名称是采用字符串的形式进行描述的。

    四、反射实例化对象

    一般情况下,对象的实例化操作需要依靠构造方法和关键字new完成。可是有了Class类对象之后,可以利用反射来实现对象的实例化。
    通过反射实例化对象:

    public T newInstance() throws InstantiationException, IllegalAccessException

    实例:

    package com.wz.reflectdemo;
    
    class Book{
    
        public Book(){
            System.out.println("Book类的无参构造方法");
        }
    
        @Override
        public String toString() {
    
            return "This a book !";
        }
    }
    
    public class TestDemo {
    
        public static void main(String[] args) throws Exception {
    
            Class<?> cls = Class.forName("com.wz.reflectdemo.Book");
            Object obj = cls.newInstance();//相当于使用new调用无参构造实例化对象
    
            Book book = (Book)obj;
            System.out.println(book);
        }
    
    }
    

    运行结果:

    Book类的无参构造方法
    This a book !

    如上,有了反射之后,进行实例化的操作不再只有依靠关键字new来完成了。但这个操作要比之前使用的new复杂一些,并且并不表示用new来进行实例化被完全取代了。为什么呢?

    对于程序的开发一直强调:尽量减少耦合。而减少耦合的最好做法是使用接口,但是就算使用了接口也逃不出关键字new,所以实际上new是造成耦合的关键元凶。

    先看一个简单的工厂设计模式:

    package com.wz.reflectdemo;
    
    
    interface Fruit{
        public void eat();
    }
    
    class Apple implements Fruit{
        @Override
        public void eat(){
            System.out.println("eat apple");
        }
    }
    
    class Factory{
        public static Fruit getInstance(String className){
            if("apple".equals(className)){
                return new Apple();
            }
            return null;
        }
    }
    
    public class FactoryDemo{
        public static void main(String[] args){
            Fruit f = Factory.getInstance("apple");
            f.eat();
        }
    }
    

    运行结果:

    eat apple

    以上是一个简单的工厂设计模式,但是在这个工厂设计模式之中有一个问题:如果增加了Fruit接口子类,那么就需要修改工厂类。

    增加了Fruit接口子类Orange :

    class Orange implements Fruit {
        public void eat() {
            System.out.println("eat orange");
        };
    }

    需要修改工厂类:

    class Factory{
        public static Fruit getInstance(String className){
            if("apple".equals(className)){
                return new Apple();
            }else if("orange".equals(className)){
                return new Orange();
            }
            return null;
    
        }
    }

    问题来了,每增加一个接口子类,就需要去修改工厂类,那么若随时可能增加多个子类呢?那么就要一直对工厂类进行修改!

    根本原因:工厂类中的对象都是通过关键字new直接实例化的。那么如果说现在不使用关键字new了,变为了反射机制呢?

    反射机制实例化对象的时候实际上只需要“包.类”就可以,于是根据此操作,修改工厂设计模式如下:

    package com.wz.reflectdemo;
    
    
    interface Fruit{
        public void eat();
    }
    
    class Apple implements Fruit{
        @Override
        public void eat(){
            System.out.println("eat apple");
        }
    }
    
    class Orange implements Fruit{
        @Override
        public void eat(){
            System.out.println("eat orange");
        }
    }
    
    class Factory{
        public static Fruit getInstance(String className){
            /*if("apple".equals(className)){
                return new Apple();
            }else if("orange".equals(className)){
                return new Orange();
            }
            return null;*/
            Fruit f = null;
            try {
                f = (Fruit)Class.forName(className).newInstance();
    
            } catch (Exception e) {
                e.printStackTrace();
            }
            return f;
    
        }
    }
    
    public class FactoryDemo{
        public static void main(String[] args){
            /*Fruit f = Factory.getInstance("apple");
            f.eat();
    
            Fruit f1 = Factory.getInstance("orange");
            f1.eat();*/
    
            Fruit f1= Factory.getInstance("com.wz.reflectdemo.Apple");
            f1.eat();
    
            Fruit f2 = Factory.getInstance("com.wz.reflectdemo.Orange");
            f2.eat();
    
        }
    }
    

    运行结果:

    eat apple
    eat orange

    这个时候即使增加了接口的子类,工厂类照样可以完成对象的实例化操作,这个才是真正的工厂类,可以应对于所有的变化。这就完成了解耦合的目的,而且扩展性非常强。

    五、反射调用构造方法

    之前我们通过反射实例化对象都是这么写的:

    Class<?> cls = Class.forName(“*****className*****”);
    Object  obj =  cls.newInstance();

    这只能调用默认的无参构造方法,那么,问题来了:若类中不提供无参构造方法呢?怎么解决?

    看一个范例:

    先写一个Book类:

    package com.wz.reflectdemo;
    
    public class Book {
    
        private String title;
        private double price;
    
        public Book(String title, double price) {
            this.title = title;
            this.price = price;
        }
    
        @Override
        public String toString() {
    
            return "图书名称:"+this.title + " ,价格:"+this.price;
        }
    
    }
    

    然后实例化对象:

    package com.wz.reflectdemo;
    
    public class ReflectTest {
    
        public static void main(String[] args) throws Exception {
    
            Class<?> cls = Class.forName("com.wz.reflectdemo.Book");
            Object obj = cls.newInstance();//相当于使用new调用无参构造实例化对象
    
            Book book = (Book)obj;
            System.out.println(book);
    
        }
    }
    

    执行结果:

    Exception in thread "main" java.lang.InstantiationException: com.wz.reflectdemo.Book
        at java.lang.Class.newInstance(Unknown Source)
        at com.wz.reflectdemo.ReflectTest.main(ReflectTest.java:8)
    Caused by: java.lang.NoSuchMethodException: com.wz.reflectdemo.Book.<init>()
        at java.lang.Class.getConstructor0(Unknown Source)
        ... 2 more
    

    由此可见,由于此时Book类没有提供无参构造方法,而cls.newInstance()的时候又调用了无参构造方法,所以无法进行对象实例化。那么,怎么解决?只能明确的调用有参构造方法。

    在Class类里面,提供了方法来取得构造:
    (1)取得全部构造:

    public Constructor<?>[] getConstructors() throws SecurityException

    (2)取得一个指定参数顺序的构造:

    public Constructor<T> getConstructor(Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException

    以上两个方法返回的都是”java.lang.reflect.Constructor”类的对象。在这个类中提供有一个明确传递有参构造内容的实例化对象方法:

    public T newInstance(Object... initargs) throws InstantiationException, IllegalAccessException,
    IllegalArgumentException, InvocationTargetException

    改写上面范例的实例化对象方法,明确调用有参构造方法:

    package com.wz.reflectdemo;
    
    import java.lang.reflect.Constructor;
    
    public class ReflectTest {
    
        public static void main(String[] args) throws Exception {
    
            Class<?> cls = Class.forName("com.wz.reflectdemo.Book");
            /*Object obj = cls.newInstance();//相当于使用new调用无参构造实例化对象
            Book book = (Book)obj;
            System.out.println(book);*/
    
            Constructor<?> con = cls.getConstructor(String.class,double.class);
            Object obj = con.newInstance("Java开发",79.8);//实例化对象
    
            System.out.println(obj);
    
        }
    }
    

    执行结果:

    图书名称:Java开发 ,价格:79.8

    很明显,调用无参构造方法实例化对象要比调用有参构造的更加简单、方便。so,简单的Java开发中不过提供有多少个构造方法,请至少保留有无参构造。

    六、反射调用普通方法

    我们都知道:类中的普通方法只有在一个类产生实例化对象之后才可以调用。

    先看一个例子。我们先定义一个类:

    package com.wz.reflectdemo;
    
    public class Book {
    
        private String title;
    
        public String getTitle() {
            return title;
        }
    
        public void setTitle(String title) {
            this.title = title;
        }
    
    }
    

    这个类有无参构造方法,所有实例化对象的时候可以直接利用Class类提供的newInstance()方法。

    在Class类里面提供以下取得类在Method的操作:
    (1)取得一个类中的全部方法:

    public Method[] getMethods() throws SecurityException

    (2)取得指定方法:

    public Method getMethod(String name, Class<?>... parameterTypes) throws
    NoSuchMethodException, SecurityException

    以上的方法返回的都是”java.lang.reflect.Method”类的对象,在这个类中有一个调用方法:

    public Object invoke(Object obj, Object... args) throws IllegalAccessException,
    IllegalArgumentException, InvocationTargetException

    我们接着上面的例子来看反射调用方法:

    package com.wz.reflectdemo;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Method;
    
    public class ReflectTest {
    
        public static void main(String[] args) throws Exception {
    
            Class<?> cls = Class.forName("com.wz.reflectdemo.Book");
            Object obj = cls.newInstance();
    
            Method setMet = cls.getMethod("setTitle", String.class);
            setMet.invoke(obj, "Java开发");//等价于Book类的setTitle("Java开发")
    
            Method getMet = cls.getMethod("getTitle");
            System.out.println(getMet.invoke(obj));//等价于Book类的getTitle()
        }
    }
    

    执行结果:

    Java开发

    此时,我们完全看不见具体的操作类型,也就是说,利用反射可以实现任意类的指定方法的调用。

    七、反射调用成员

    我们都知道,类中的属性一定要在本类实例化对象之后才可以分配内存空间。在Class类里面提供有取得成员的方法:

    (1)取得全部成员:

    public Field[] getDeclaredFields() throws SecurityException

    (2)取得指定成员:

    public Field getDeclaredField(String name) throws NoSuchFieldException, SecurityException

    这两个方法的返回值类型是”java.lang.reflect.Field”类的对象。在这个类里面有两个重要的方法:

    (1)取得属性内容(类似于:对象.属性):

    public Object get(Object obj)
    throws IllegalArgumentException, IllegalAccessException

    (2)设置属性内容(类似于:对象.属性=内容):

    public void set(Object obj, Object value)
    throws IllegalArgumentException, IllegalAccessException

    接着看一个例子:
    先定义一个类:

    package com.wz.reflectdemo;
    
    public class Book {
    
        private String title;
    
    }
    

    这个类只定义了一个私有属性,按照之前的做法,它一定无法被外部所使用。但是,可以反射调用:

    package com.wz.reflectdemo;
    
    import java.lang.reflect.Field;
    
    public class ReflectTest {
    
        public static void main(String[] args) throws Exception {
    
            Class<?> cls = Class.forName("com.wz.reflectdemo.Book");
            Object obj = cls.newInstance();
    
            Field titleField = cls.getDeclaredField("title");
            titleField.setAccessible(true);//解除封装
            titleField.set(obj, "Java开发");//相当于Book类对象.title = "Java开发"
            System.out.println(titleField.get(obj));//相当于Book类对象的.title
        }
    }
    

    执行结果:

    Java开发

    注:构造方法和普通方法一样可以解除封装,只是很少这么去做。而对于属性的访问还是建议使用setter和getter方法完成。

    展开全文
  • 主要介绍了Java 反射机制详解及实例的相关资料,需要的朋友可以参考下
  • Java 反射机制 详解

    2020-04-10 15:31:18
    JAVA反射机制是在运行状态中,对于任意一个类,都能知道这个类的所有属性和方法       对于任意一个对象,都能调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的...

    java基础(jdk1.8)

    **

    反射

    **

    JAVA反射机制是在运行状态中,对于任意一个类,都能知道这个类的所有属性和方法

          对于任意一个对象,都能调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

    常用于在不改变原有代码基础上增加功能
    /**
     * 加载器加载类后会有一个类对象
     * 拿到这个类的文件对象(反射)
     * 然后用这个对象实现功能的增加
     */
    

    获取文件对象

    1.对象获取

    
        Demo d = new Demo();
        Class c = d.getClass();
        //c为class文件对象
    
    

    2.类名获取

    
        Class c = Demo.class;
        //c为class文件对象
    
    

    3.Class类静态方法获取

    
        Class c = Class.forName("package.Demo");//包名.类名
        //c为class文件对象
    
    

    三者获取的class文件对象相等

    运行构造方法

    1.获取class文件对象

    2.从class文件对象中,获取构造方法

    
        Class c = Class.forName("package.Demo");//包名.类名
        //获得所有公共构造方法
        Constructor[] cons = c.getConstructors();
    
        //获取指定构造方法(传参则获取指定构造方法,无参为无参构造)
        Constructor con = c.getConstructor();
        Constructor con1 = c.getConstructor(int.class);
    
        //运行构造方法
        Object o = con.newInstance();
        Object o1 = con.newInstance(1);
        
        //使用泛型可直接获取需要类的类对象
    

    扩展:

    如果被反射的类具有 空参构造方法 并且为public,即可如下操作

    
        Class c = Class.forName("package.Demo");
    
        Object object = c.newInstance();
    
    

    注意:

    以上只能执行public修饰的构造方法

    执行private修饰则应该使用getDeclaredConstructor()方法(暴力反射)

    成员变量

    1.获取class文件对象

    2.从class文件对象中,获取成员变量

    
        Class c = Class.forName("package.Demo");//包名.类名
        //获取所有公共成员变量
        Field[] fields = c.getFields();
    
        //获取指定成员变量(id)
        Field id = c.getField("id");
    
        //修改参数值
        Object obj = c.newInstance();
        id.set(obj,2);//需要传入指定类(无泛型则Object)
    
    

    同样private修饰应该使用Declared

    方法

    1.获取class文件对象

    2.从class文件对象中,获取方法

    
        Class c = Class.forName("package.Demo");//包名.类名
        //获取所有public方法
        Method[] methods = c.getMethods();
    
        //获取指定方法
        Method method = c.getMethod("eat");
        Method method1 = c.getMethod("eat", int.class);
    
        //运行方法
        Object obj = c.newInstance();
        method.invoke(obj);
        method1.invoke(obj,1);
    
    

    上一篇 》类加载过程

    下一篇 》Java集合

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,401
精华内容 7,360
关键字:

java反射机制详解

java 订阅