导读:反射是一项在java中很重要的技术,其他的语言没有反射,此篇作为实践篇来运行一下代码,主要运行以下oracle官方的demo
文章目录
- 参考文章讲解,讲的挺好的
- oracle有关反射文章的讲解
- A Simple Example-一个简单的例子
- Simulating the instanceof Operator-判断是不是当前实例
- Finding Out About Methods of a Class-找出有关类方法
- Obtaining Information About Constructors-获取有关构造函数的信息
- Finding Out About Class Fields-寻找类字段
- Invoking Methods by Name(按名称调用方法)
- Creating New Objects-创建新对象
- Changing Values of Fields-更改字段的值
- Using Arrays-使用数组
- 霸气的总结
- 廖雪峰的官方网站反射讲解
- 神秘的Java反射机制了解一下
参考文章讲解,讲的挺好的
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.