java基础反射

反射机制是什么

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

反射机制能做什么

反射机制主要提供了以下功能：

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

反射机制的相关api的代码演示

通过一个对象获取完整的包名和类名

package com.sschen.reflect;
public class TestReflect {
    public static void main(String[] args) {
        TestReflect testReflect = new TestReflect();
        System.out.println(testReflect.getClass().getName());
        //执行结果：com.sschen.reflect.TestReflect
    }
}

实例化class对象

package com.sschen.reflect;
public class TestReflect {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> class1 = null;
        Class<?> class2 = null;
        Class<?> class3 = null;

        class1 = Class.forName("com.sschen.reflect.TestReflect");
        class2 = new TestReflect().getClass();
        class3 = TestReflect.class;
        System.out.println("ClassName is : " + class1.getName());
        System.out.println("ClassName is : " + class2.getName());
        System.out.println("ClassName is : " + class3.getName());
    }
}

这三种方式，最终的结果都是一致的，目前编程中使用较多的是Class.forName

获取一个对象的父类和实现的接口

import java.io.Serializable;

public class TestReflect implements Serializable {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> classI = Class.forName("com.sschen.reflect.TestReflect");
        //取得父类
        Class<?> classParent = classI.getSuperclass();
        System.out.println("classI 的父类是 : " + classParent.getName());
        //执行结果：classI 的父类是 : java.lang.Object

        //获取实现的接口
        Class<?>[] iClass = classI.getInterfaces();
        System.out.println("classI 实现的接口有 : ");
        for (int i = 0; i < iClass.length; i++){
            System.out.println((i + 1) + " : " + iClass[i].getName());
        }
        //执行结果：classI 实现的接口有 : 
        //1 : java.io.Serializable
    }
}

获取类中的构造函数，且使用反射机制构造类的实例对象

import java.io.Serializable;
import java.lang.reflect.Constructor;

public class TestReflect implements Serializable {
    public static void main(String[] args) throws Exception {
        Class<?> class1 = null;
        class1 = Class.forName("com.sschen.reflect.User");
        //第一种方法，实例化默认构造函数，使用set赋值
        User user = (User) class1.newInstance();
        user.setAge(20);
        user.setName("ZhangSan");
        System.out.println(user);
        //执行结果：User{age=20, name='ZhangSan'}

        //第二种方法，取得全部的构造函数，使用构造函数赋值
        Constructor<?> cons[] = class1.getConstructors();
        //查看每个构造方法所需要的参数
        for (int i = 0; i < cons.length; i++) {
            Class<?>[] classParam = cons[i].getParameterTypes();
            System.out.print("[ class1 " + i + " ] (");
            for (int j = 0; j < classParam.length; j++) {
                if (j == classParam.length - 1) {
                    System.out.print(classParam[j].getName());
                }
                else {
                    System.out.print(classParam[j].getName() + ",");
                }
            }
            System.out.println(" )");
        }
        /*执行结果
        [ class1 0 ] (java.lang.String )
        [ class1 1 ] (int,java.lang.String )
        [ class1 2 ] ( )*/
        User user1 = (User) cons[0].newInstance("LiSi");
        System.out.println(user1);
        //执行结果：User{age=0, name='LiSi'}
        User user2 = (User) cons[1].newInstance(22, "Wangwu");
        System.out.println(user2);
        //执行结果：User{age=22, name='Wangwu'}
    }
}

获取某个类的全部属性

import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class TestReflect implements Serializable {
    private static final long serialVersionUID = -12423423523423234L;
    public static void main(String[] args) throws Exception {
        Class<?> class1 = null;
        class1 = Class.forName("com.sschen.reflect.TestReflect");
        System.out.println("=======本类属性=======");
        //取得本类的全部属性
        Field[] fields = class1.getDeclaredFields();
        for (int i = 0; i < fields.length; i++) {
            //取得属性的权限修饰符
            int mod = fields[i].getModifiers();
            String priv = Modifier.toString(mod);
            //属性类型
            Class<?> type = fields[i].getType();
            System.out.println(priv + " " + type.getName() + " " + fields[i].getName());
        }
        //执行结果：private static final long serialVersionUID

        System.out.println("=======实现的接口或者父类的属性=======");
        //取得实现的接口或者父类的属性
        Field[] fields1 = class1.getFields();
        for (int i = 0; i < fields1.length; i++) {
            //取得属性的权限修饰符
            int mod = fields1[1].getModifiers();
            String priv = Modifier.toString(mod);
            //属性类型
            Class<?> type = fields1[i].getType();
            System.out.println(priv + " " + type.getName() + " " + fields1[i].getName() + ";");
        }
    }
}

获取某个类的全部方法

import java.io.Serializable;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class TestReflect implements Serializable {
    private static final long serialVersionUID = -12423423523423234L;
    public static void main(String[] args) throws Exception {
        Class<?> class1 = null;
        class1 = Class.forName("com.sschen.reflect.TestReflect");
        Method[] methods = class1.getMethods();
        for (int i = 0; i < methods.length; i++) {
            Class<?> returnType = methods[i].getReturnType();
            Class<?>[] params = methods[i].getParameterTypes();
            int temp = methods[i].getModifiers();
            System.out.print(Modifier.toString(temp) + " ");
            System.out.print(returnType.getName() + "  ");
            System.out.print(methods[i].getName() + " ");
            System.out.print("(");
            for (int j = 0; j < params.length; ++j) {
                System.out.print(params[j].getName() + " " + "arg" + j);
                if (j < params.length - 1) {
                    System.out.print(",");
                }
            }
            Class<?> exce[] = methods[i].getExceptionTypes();
            if (exce.length > 0) {
                System.out.print(") throws ");
                for (int k = 0; k < exce.length; ++k) {
                    System.out.print(exce[k].getName() + " ");
                    if (k < exce.length - 1) {
                        System.out.print(",");
                    }
                }
            } else {
                System.out.print(")");
            }
            System.out.println();
        }
        /**
         * 执行结果：
         * public static void  main ([Ljava.lang.String; arg0) throws java.lang.Exception 
         * public final void  wait (long arg0,int arg1) throws java.lang.InterruptedException 
         * public final native void  wait (long arg0) throws java.lang.InterruptedException 
         * public final void  wait () throws java.lang.InterruptedException 
         * public boolean  equals (java.lang.Object arg0)
         * public java.lang.String  toString ()
         * public native int  hashCode ()
         * public final native java.lang.Class  getClass ()
         * public final native void  notify ()
         * public final native void  notifyAll ()
         */
    }
}

通过反射机制操作某个类的属性

import java.lang.reflect.Field;
public class TestReflect {
    private String proprety = null;
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Class.forName("com.sschen.reflect.TestReflect");
        Object obj = clazz.newInstance();
        // 可以直接对 private 的属性赋值，此处也就是我们所说单例模式中失效的反射机制
        //单例模式本身也就是对于自身私有属性的控制，而通过反射，可以直接修改私有属性的值，也就没有单例模式的概念。
        Field field = clazz.getDeclaredField("proprety");
        field.setAccessible(true);
        field.set(obj, "Java反射机制");
        System.out.println(field.get(obj));
        //执行结果：Java反射机制
    }
}

反射机制的动态代理

//定义项目接口
public interface ISubject {
    public String say(String name, int age);
}
//定义真实项目
public class RealSubject implements ISubject {
    public String say(String name, int age) {
        return name + " " + age;
    }
}

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

public class MyInvocationHandler implements InvocationHandler {
    private Object obj = null;
    public Object bind(Object obj){
        this.obj = obj;
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object temp = method.invoke(this.obj, args);
        return temp;
    }
}

public class TestReflect {
    public static void main(String[] args) throws Exception {
        MyInvocationHandler myInvocationHandler = new MyInvocationHandler();
        ISubject subject = (ISubject) myInvocationHandler.bind(new RealSubject());
        String info = subject.say("Sschen", 27);
        System.out.println(info);
    }
}

从上述代码中我们可以看出

//获取类的加载器
类的实例.getClass().getClassLoader()
//获取类所实现的接口
类的实例.getClass().getInterfaces()

而反射实现动态代理就是传入类的实例，反向使用类实现的接口，通过调用接口方法，实现对于具体实例类的调用。
在java中有三种类类加载器。
1）Bootstrap ClassLoader 此加载器采用c++编写，一般开发中很少见。
2）Extension ClassLoader 用来进行扩展类的加载，一般对应的是jrelibext目录中的类
3）AppClassLoader 加载classpath指定的类，是最常用的加载器。同时也是java中默认的加载器。
如果想要完成动态代理，首先需要定义一个InvocationHandler接口的子类，已完成代理的具体操作。

反射机制的应用实例

在泛型为Integer的ArrayList中放入String类型的对象

public class TestReflect {
    public static void main(String[] args) throws Exception {
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        arrayList.add(23);
        Method method = arrayList.getClass().getMethod("add", Object.class);
        method.invoke(arrayList, "Hello World");
        System.out.println(arrayList.get(1));
    }
}

通过这个例子可以看到，反射机制可以绕过声明泛型实例时对于类型的指定，而直接调用ArrayList的Add方法，放入Object类型的对象，这点是很强大的。

通过反射获取并修改数组的信息

import java.lang.reflect.Array;

public class TestReflect {
    public static void main(String[] args) throws Exception {
        int[] temp = {1, 2, 3, 4, 5};
        Class<?> demo = temp.getClass().getComponentType();
        System.out.println("数组类型为： " + demo.getName());
        System.out.println("数组长度为： " + Array.getLength(temp));
        System.out.println("数组第一个元素为： " + Array.get(temp, 0));
        Array.set(temp, 0, 100);
        System.out.println("修改后的第一个元素为： " + Array.get(temp, 0));
        /**
         * 执行结果为
         * 数组类型为： int
         * 数组长度为： 5
         * 数组第一个元素为： 1
         * 修改后的第一个元素为： 100
         */
    }
}

通过反射机制修改数组的大小

import java.lang.reflect.Array;

public class TestReflect {
    public static void main(String[] args) throws Exception {
        int[] temp = {1, 3, 5, 7, 9};
        int[] newTemp = (int[])arrayInc(temp, 15);
        print(newTemp);
        String[] arrStr = {"aa", "bb", "cc"};
        String[] newStr = (String[])arrayInc(arrStr, 8);
        print(newStr);
        /**
         * 执行结果
         * 数组长度为： 15
         * 1 | 3 | 5 | 7 | 9 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
         * 数组长度为： 8 
         * aa | bb | cc | null | null | null | null | null | 
         */
    }

    /**
     * 修改数据大小
     * @param obj 数组元素
     * @param len 新的长度
     * @return 返回修改后的数组
     */
    public static Object arrayInc(Object obj, int len) {
        //得到数组数据类型
        Class<?> temp = obj.getClass().getComponentType();
        //根据数组类型使用新的长度生成新的数组
        Object newArr = Array.newInstance(temp, len);
        //得到原有数据的长度
        int newCo = Array.getLength(obj);
        //将原有数组的内容拷贝到新的数组上
        System.arraycopy(obj, 0, newArr, 0, newCo);
        return newArr;
    }

    /**
     * 打印输出
     * @param obj
     */
    public static void print(Object obj) {
        Class<?> type = obj.getClass();
        if (!type.isArray()) {
            return;
        }
        System.out.println("数组长度为： " + Array.getLength(obj));
        for (int i = 0; i < Array.getLength(obj); i++) {
            System.out.print(Array.get(obj, i) + " | ");
        }
        System.out.println();
    }
}

使用反射机制实现工厂模式

interface fruit {
    public abstract void eat();
}
class Apple implements fruit {
    public void eat() {
        System.out.println("Apple");
    }
}
class Orange implements fruit {
    public void eat() {
        System.out.println("Orange");
    }
}
class Factory {
    public static fruit getInstance(String ClassName) {
        fruit f = null;
        try {
            f = (fruit) Class.forName(ClassName).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return f;
    }
}
public class TestReflect {
    public static void main(String[] args) throws Exception {
        fruit f = Factory.getInstance("net.xsoftlab.baike.Apple");
        if (f != null) {
            f.eat();
        }
    }
}

参考：
Java反射机制详解

最后编辑于：2017.12.06 07:24:45

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 203,362评论 5赞 477
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 85,330评论 2赞 381
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 150,247评论 0赞 337
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 54,560评论 1赞 273
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 63,580评论 5赞 365
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,569评论 1赞 281
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 37,929评论 3赞 395
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,587评论 0赞 258
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 40,840评论 1赞 297
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,596评论 2赞 321
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,678评论 1赞 329
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,366评论 4赞 318
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 38,945评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,929评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,165评论 1赞 259
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 43,271评论 2赞 349
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,403评论 2赞 342

java基础 反射