java反射

导读：反射是一项在java中很重要的技术，其他的语言没有反射,此篇作为实践篇来运行一下代码,主要运行以下oracle官方的demo

参考文章讲解，讲的挺好的

oracle有关反射文章的讲解

https://www.oracle.com/technical-resources/articles/java/javareflection.html

网站很简洁明了

Reflection is a feature in the Java programming language. It allows an executing Java program to examine or "introspect" upon itself, and manipulate internal properties of the program. For example, it's possible for a Java class to obtain the names of all its members and display them.

翻译如下

A Simple Example-一个简单的例子

实操代码，为了让他能执行，我这里稍微做了小修改

public static void main(String args[])
    {
        try {
            Class c = Stack.class;
            Method m[] = c.getDeclaredMethods();
            for (int i = 0; i < m.length; i++)
                System.out.println(m[i].toString());
        }
        catch (Throwable e) {
            System.err.println(e);
        }
    }

执行后可以看到

public synchronized java.lang.Object java.util.Stack.pop()
public java.lang.Object java.util.Stack.push(java.lang.Object)
public synchronized java.lang.Object java.util.Stack.peek()
public boolean java.util.Stack.empty()
public synchronized int java.util.Stack.search(java.lang.Object)

里面的方法打印了。

Simulating the instanceof Operator-判断是不是当前实例

package com.base.javabase.reflection.oracle;

class A {}

public class instance1 {
    public static void main(String args[])
    {
        try {
            Class cls = Class.forName("com.base.javabase.reflection.oracle.A");
            boolean b1
                    = cls.isInstance(new Integer(37));
            System.out.println(b1);
            boolean b2 = cls.isInstance(new A());
            System.out.println(b2);
        }
        catch (Throwable e) {
            System.err.println(e);
        }
    }
}

输出结果

false
true

Finding Out About Methods of a Class-找出有关类方法

package com.base.javabase.reflection.oracle;

import java.lang.reflect.Method;

/**
 * 找出有关类的方法
 */
public class method1 {
    private int f1(Object p, int x) throws NullPointerException {
        if (p == null) throw new NullPointerException();
        return x;
    }

    public static void main(String args[]) {
        try {
            Class cls = Class.forName("com.base.javabase.reflection.oracle.method1");
            Method methlist[] = cls.getDeclaredMethods();
            for (int i = 0; i < methlist.length; i++) {
                Method m = methlist[i];
                System.out.println("name = " + m.getName());
                System.out.println("decl class = " + m.getDeclaringClass());
                //方法的参数有类型
                Class pvec[] = m.getParameterTypes();
                for (int j = 0; j < pvec.length; j++) System.out.println(" param #" + j + "" + pvec[j]);
                //判处异常类型
                Class evec[] = m.getExceptionTypes();
                for (int j = 0; j < evec.length; j++) System.out.println("exc #" + j + " " + evec[j]);
                //方法返回的类型
                System.out.println("return type = " + m.getReturnType());
                System.out.println("-----");
            }
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

输出结果

name = main
decl class = class com.base.javabase.reflection.oracle.method1
 param #0class [Ljava.lang.String;
return type = void
-----
name = f1
decl class = class com.base.javabase.reflection.oracle.method1
 param #0class java.lang.Object
 param #1int
exc #0 class java.lang.NullPointerException
return type = int
-----

Obtaining Information About Constructors-获取有关构造函数的信息

package com.base.javabase.reflection.oracle;

import java.lang.reflect.Constructor;

/**
 * 获取有关构造函数的信息
 */
public class constructor1 {
    public constructor1() {
    }

    protected constructor1(int i, double d) {
    }

    public static void main(String args[]) {
        try {
            Class cls = Class.forName("com.base.javabase.reflection.oracle.constructor1");
            Constructor ctorlist[] = cls.getDeclaredConstructors();
            for (int i = 0; i < ctorlist.length; i++) {
                Constructor ct = ctorlist[i];
                System.out.println("name = " + ct.getName());
                System.out.println("decl class = " + ct.getDeclaringClass());
            }
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

结果输出

name = com.base.javabase.reflection.oracle.constructor1
decl class = class com.base.javabase.reflection.oracle.constructor1
-----
name = com.base.javabase.reflection.oracle.constructor1
decl class = class com.base.javabase.reflection.oracle.constructor1
param #0 int
param #1 double
-----

Finding Out About Class Fields-寻找类字段

package com.base.javabase.reflection.oracle;

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

/**
 * Finding Out About Class Fields
 */
public class field1 {
    private double d;
    public static final int i = 37;
    String s = "testing";

    public static void main(String args[]) {
        try {
            Class cls = Class.forName("com.base.javabase.reflection.oracle.field1");
            Field fieldlist[] = cls.getDeclaredFields();
            for (int i = 0; i < fieldlist.length; i++) {
                Field fld = fieldlist[i];
                System.out.println("name = " + fld.getName());
                System.out.println("decl class = " + fld.getDeclaringClass());
                System.out.println("type = " + fld.getType());
                int mod = fld.getModifiers();
                System.out.println("modifiers = " + Modifier.toString(mod));
                System.out.println("-----");
            }
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

输出结果

name = d
decl class = class com.base.javabase.reflection.oracle.field1
type = double
modifiers = private
-----
name = i
decl class = class com.base.javabase.reflection.oracle.field1
type = int
modifiers = public static final
-----
name = s
decl class = class com.base.javabase.reflection.oracle.field1
type = class java.lang.String
modifiers = 
-----

Invoking Methods by Name(按名称调用方法)

package com.base.javabase.reflection.oracle;
import java.lang.reflect.Method;
/**
 * Invoking Methods by Name(按名称调用方法)
 */
public class method2 {
    public int add(int a, int b) {
        return a + b;
    }
    public static void main(String args[]) {
        try {
            Class cls = Class.forName("com.base.javabase.reflection.oracle.method2");
            Class partypes[] = new Class[2];
            partypes[0] = Integer.TYPE;
            partypes[1] = Integer.TYPE;
            Method meth = cls.getMethod("add", partypes);
            method2 methobj = new method2();
            Object arglist[] = new Object[2];
            arglist[0] = new Integer(37);
            arglist[1] = new Integer(47);
            Object retobj = meth.invoke(methobj, arglist);
            Integer retval = (Integer) retobj;
            System.out.println(retval.intValue());
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

输出结果

84

Creating New Objects-创建新对象

package com.base.javabase.reflection.oracle;

import java.lang.reflect.Constructor;

/**
 * Creating New Objects-创建新对象
 */
public class constructor2 {
    public constructor2() {
    }
    public constructor2(int a, int b) {
        System.out.println("a = " + a + " b = " + b);
    }
    public static void main(String args[]) {
        try {
            Class cls = Class.forName("com.base.javabase.reflection.oracle.constructor2");
            Class partypes[] = new Class[2];
            partypes[0] = Integer.TYPE;
            partypes[1] = Integer.TYPE;
            Constructor ct = cls.getConstructor(partypes);
            Object arglist[] = new Object[2];
            arglist[0] = new Integer(37);
            arglist[1] = new Integer(47);
            Object retobj = ct.newInstance(arglist);
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

输出结果

a = 37 b = 47

Changing Values of Fields-更改字段的值

package com.base.javabase.reflection.oracle;

import java.lang.reflect.Field;

/**
 * Changing Values of Fields-更改字段的值
 */
public class field2 {
    public double d;

    public static void main(String args[]) {
        try {
            Class cls = Class.forName("com.base.javabase.reflection.oracle.field2");
            Field fld = cls.getField("d");
            field2 f2obj = new field2();
            System.out.println("d = " + f2obj.d);
            fld.setDouble(f2obj, 12.34);
            System.out.println("d = " + f2obj.d);
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

输出结果

d = 0.0
d = 12.34

Using Arrays-使用数组

package com.base.javabase.reflection.oracle;
import java.lang.reflect.Array;
/**
 * Using Arrays-使用数组
 */
public class array1 {
    public static void main(String args[]) {
        try {
            Class cls = Class.forName("java.lang.String");
            Object arr = Array.newInstance(cls, 10);
            Array.set(arr, 5, "this is a test");
            String s = (String) Array.get(arr, 5);
            System.out.println(s);
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

输出结果

this is a test

package com.base.javabase.reflection.oracle;

import java.lang.reflect.Array;

public class array2 {
    public static void main(String args[]) {
        int dims[] = new int[]{5, 10, 15};
        Object arr = Array.newInstance(Integer.TYPE, dims);
        Object arrobj = Array.get(arr, 3);
        Class cls = arrobj.getClass().getComponentType();
        System.out.println(cls);
        arrobj = Array.get(arrobj, 5);
        Array.setInt(arrobj, 10, 37);
        int arrcast[][][] = (int[][][]) arr;
        System.out.println(arrcast[3][5][10]);
    }
}

输出结果

class [I
37

github demo下载

https://github.com/sky5cai/javabase

霸气的总结

Java reflection is useful because it supports dynamic retrieval of information about classes and data structures by name, and allows for their manipulation within an executing Java program. This feature is extremely powerful and has no equivalent in other conventional languages such as C, C++, Fortran, or Pascal.

大致的意思是java的反射是非常用的，在运行class类时可以获取相关方法，其他的编程语言没有反射。

---

廖雪峰的官方网站反射讲解

https://www.liaoxuefeng.com/wiki/1252599548343744/1264803678201760

文章讲的很好，通俗易懂，这里放一下在oracle没提到的

获取继承关系

https://www.liaoxuefeng.com/wiki/1252599548343744/1264804244564000

动态代理

https://www.liaoxuefeng.com/wiki/1252599548343744/1264804593397984

---

神秘的Java反射机制了解一下

以思维导图的形式来讲解，且内容很详细充实，加上有场景的应用讲解，very nice.