java反射的优缺点

Ⅰ java反射机制的作用 及其它的好处

反射其实就是程序能够自检查自身信息。就像程序会照镜子反光看自己。

在程序中可以检查某个类中的方法属性等信息，并且能够动态调用。
这样可以写出很灵活的程序。
比如要把一个对象中的数据到另外一个对象中，规则是属性名相同就，
就可以用反射来做，不需要指定每个属性的名字，只要动态从类中取得信息，
再判断属性名是否相同即可。当然应用还有很多。

反射可以结合Java的字节码，使用ASM和cglib等库，还能动态生成类。
hibernate的延迟载入，spring的AOP都是这么实现的

反射给Java带来了一些动态性。不过虽然很好，但毕竟还是有一定局限性的。另外ASM，cglib使用还是不放便。因此一些纯动态语言现在是一个重要发展趋势，比如ruby，python等，程序很容易动态生成。

Ⅱ java 反射有什么用

反射就是把java类中的各种成分映射成为相应的java类。例如：一个java类用一个Class类的对象来表示，一个类中的组成部分:成员变量、方法、构造函数、包等等信息也用一个个java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的java类，表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造函数，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Field、Method、Constructor、Package等等

在平时的编程中，反射基本用不到，但是在编写框架的时候，反射用的就多了，比如你要使用某一个类进行操作，但是这个类是用户通过配置文件配置进来的，你需要先读配置文件，然后拿到这个类的全类名：比如com.onede4..Person,然后在利用反射API来做操作

Ⅲ Java反射的性能为什么比直接调用慢一个数量级左右

反射肯定比直接调用慢

这个毋庸置疑了，我这篇文章也不是证明反射有多高效的。

现在的快递哥很火，那我们就举个快递的例子。如果快递员就在你住的小区，那么你报一个地址：xx栋xx号，那么快递员就可以马上知道你在哪里，直接就去到你家门口；但是，如果快递员是第一次来你们这里，他是不是首先得查查网络地图，看看怎么开车过去，然后到了小区是不是得先问问物管xx栋怎么找，然后，有可能转在楼下转了两个圈才到了你的门前。

我们看上面这个场景，如果快递员不熟悉你的小区，是不是会慢点，他的时间主要花费在了查找网络地图，询问物业管理。OK，反射也是一样，因为我事先什么都不知道，所以我得花时间查询一些其他资料，然后我才能找到你。大家有兴趣可以查看反射的实现原理，以及MetaData的相关概念。

反射到底比直接调用慢多少?

好了，我们知道反射肯定慢的，那么是不是反射就不能用了呢？有些人一听到慢，就非常着急的下结论，反射怎样怎样不行，怎样怎样不能用。但是，同学，反射到底比直接调用慢多少，你造吗，能给我个实际的数据吗？很多人其实对性能只有个模糊的概念，而没有数值支撑。之前我给同事找了一个动态解析表达式的类库，他觉得不太好用，他很聪明，很快的找到了用DataTale.Compute可以实现公式的动态解析。我问他，这个方法和我给的类库性能上有什么区别？他跟我说，这个已经很快了，执行1秒都不到。我一听，就觉得不对劲，你的思想还停留在秒级，跟我谈什么性能?

怎么去判断一个函数的性能?因为函数的执行太快太快了，你需要一个放慢镜，这样才能捕捉到他的速度。怎么做？把一个函数执行一百万遍或者一千万遍，你才能真正了解一个函数的性能。也就是，你如果想判断性能，你就不能还停留在秒级，毫秒级的概念，你必须用另外一个概念替代，才能知道真正的性能。结果我同事把这两种方法执行了100w遍，确实，我提供的类库比他的快了8秒。

好了，现在拿我早两天提供的工厂方法来做测试，其中CodeTimer的实现参考赵大神的文章《一个简单的性能计数器：CodeTimer》：

测试方法如下：

代码如下
复制代码

[Test]
public void TestReflector()
{
CodeTimer.Time("Direct", 100 * 10000,
() =>
{
var instance = new ConnectionTest();
});

CodeTimer.Time("Reflect", 100 * 10000,
() =>
{
this.GetType().Assembly.CreateInstance("TestPropertyGrid.ConnectionTest");
});
}

测试结果如下：

Direct
Time Elapsed: 25ms
CPU Cycles: 57,582,163
Gen 0: 14
Gen 1: 0

Reflect
Time Elapsed: 3,231ms
CPU Cycles: 8,001,720,795
Gen 0: 269
Gen 1: 1

看到没，我们的放大镜起作用了，现在我们大概可以下这么一个结论：在执行100万遍的时候，反射大概把直接调用慢50~100倍。100倍，咋一看，是相差很大的，但是，我前文说了，别着急下结论，你要看看前提条件。自古我们就喜欢断章取义，比如“以德报怨”这个成语，好像古人说让我们遇到不好的，你不能怨恨，要更好的对待他人，别人打你左脸一巴掌，你应该把右脸伸过去让他再打一下。但实际这个成语是怎样的呢？

或曰：“以德报怨，何如？”
子曰：“何以报德？以直报怨，以德报德”

老孔的意思其实是如果别人对你好，那么你就对他好，要是他招你惹你了，你就干他娘的！你看，傻眼了吧？
有多少情况下需要考虑反射带来的影响?

我认为这个情况是非常非常少的，绝大多数的我们根本就无需考虑这个。就上我上一篇文章提到的工厂，你程序有多少个实体，有100万个吗？如果你只是在弹出窗口的时候new一下，这个百万分之十秒的影响对你很重要吗？

另外，有些人讲，我要是真有这种需求，要把一个对象new一百万遍，那不还是慢吗？这种情况有没有，有！比如我有100w条记录，需要取出来，然后通过反射赋值到一个Model类中。

但是对于这种情况，如果你真是这么想的话，我只能说，你坐办公室坐久了，脑袋生锈了，该去爬爬山，泡泡妞了。如果你需要对一个对象反射一百万遍，那么你就应该缓存这个对象了。拿我们上面那个例子来说，如果这个快递员给小区的人送一百万遍的快递还认不得路，每次都还得网络地图，然后问物业管理，你丫的你还没把他开掉了，那你脑袋不是秀逗了，要不就是任性的有钱人。

上面代码如果缓存之后执行一百万遍，跟直接调用有多大的区别？我这里就不贴代码了，免得你们直接看结果没有意思，自己把代码敲一遍，印象更深刻。

那么，还有没有更快的办法，有。比如你的快递员开始用的是IPHONE4，现在可以考虑给他买个6+。在.net中，提供了Emit的相关方法来让你更快的反射。这里送你一个通过反射快速给Model赋值的轮子“Dapper”，自己回家造去。
编程中是否应该使用反射？

其实看完上面的文字，我相信你们都有了一个初步的判断，而我的看法是：绝大多数的情况下你都可以用反射。

如果你觉得是因为反射导致你程序慢的话，那么，请先用放慢镜好好观察一下，到底是不是反射的问题。如果你确定是反射的问题，那么你再好好的考虑下是不是你没有用对反射，是不是像上面那个走了一百万遍都不认识路的快递员一样。最后，如果你觉得性能上还是不够，那么我建议你升级下硬件吧，把硬件性能上升个3%总好过你请个牛逼的工程师来帮你做这种极限的优化，有一句话我觉得很对“工程师比服务器要昂贵的多”。如果你还非得跟我较劲，那么，没办法了，你程序对性能的要求已经超出了本文讨论的范畴，如果你真有这种需求了，我觉得你也没有必要看我这篇文章了，因为你已经足够牛逼到对系统语言都有深入了解了。

大多时候，我们会把程序的性能归结于编程语言，或者使用了反射等技术，而甚少去关心自己的代码，这种心态会导致你技术的发展越来越缓慢，因为你已经失去了求知的欲望，以及一颗追求技术进步的心。请你记住，更多的时候，影响我们程序性能的，是你编程的思想，你对待编码的态度！
总结

好吧，说了这么多，估计很多人直接就拖到文章末尾然后因为文章码了这么多字而默默点了个赞，那么，我在最后给大家奉献一下本文的精华：

反射大概比直接调用慢50~100倍，但是需要你在执行100万遍的时候才会有所感觉
判断一个函数的性能，你需要把这个函数执行100万遍甚至1000万遍
如果你只是偶尔调用一下反射，请忘记反射带来的性能影响
如果你需要大量调用反射，请考虑缓存。
你的编程的思想才是限制你程序性能的最主要的因素

Ⅳ JAVA中的反射和反射机制到底是什么啊

Java Reflection (JAVA反射) 详解
Java语言反射提供一种动态链接程序组件的多功能方法。它允许程序创建和控制任何类的对象(根据安全性限制)，无需提前硬编码目标类。这些特性使得反射特别适用于创建以非常普通的方式与对象协作的库。例如，反射经常在持续存储对象为数据库、XML或其它外部格式的框架中使用。Java reflection 非常有用，它使类和数据结构能按名称动态检索相关信息，并允许在运行着的程序中操作这些信息。Java 的这一特性非常强大，并且是其它一些常用语言，如 C、C++、Fortran 或者 Pascal 等都不具备的。
但反射有两个缺点。第一个是性能问题。用于字段和方法接入时反射要远慢于直接代码。性能问题的程度取决于程序中是如何使用反射的。如果它作为程序运行中相对很少涉及的部分，缓慢的性能将不会是一个问题。即使测试中最坏情况下的计时图显示的反射操作只耗用几微秒。仅反射在性能关键的应用的核心逻辑中使用时性能问题才变得至关重要。
许多应用中更严重的一个缺点是使用反射会模糊程序内部实际要发生的事情。程序人员希望在源代码中看到程序的逻辑，反射等绕过了源代码的技术会带来维护问题。反射代码比相应的直接代码更复杂，正如性能比较的代码实例中看到的一样。解决这些问题的最佳方案是保守地使用反射——仅在它可以真正增加灵活性的地方——记录其在目标类中的使用。 Reflection是Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说"自审"，并能直接操作程序的内部属性。例如，使用它能获得 Java 类中各成员的名称并显示出来。Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。JavaBean 是 reflection 的实际应用之一，它能让一些工具可视化的操作软件组件。这些工具通过 reflection 动态的载入并取得 Java 组件(类) 的属性。1. 一个简单的例子考虑下面这个简单的例子，让我们看看 reflection 是如何工作的。import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName(args[0]);
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);
}
}
}
按如下语句执行：java DumpMethods java.util.Stack
它的结果输出为：public java.lang.Object java.util.Stack.push(java.lang.Object)public synchronized java.lang.Object java.util.Stack.pop()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)
这样就列出了java.util.Stack 类的各方法名以及它们的限制符和返回类型。这个程序使用 Class.forName 载入指定的类，然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。
2.开始使用 Reflection用于 reflection 的类，如 Method，可以在 java.lang.relfect 包中找到。使用这些类的时候必须要遵循三个步骤：第一步是获得你想操作的类的 java.lang.Class 对象。在运行中的 Java 程序中，用 java.lang.Class 类来描述类和接口等。
下面就是获得一个 Class 对象的方法之一：Class c = Class.forName("java.lang.String");
这条语句得到一个 String 类的类对象。还有另一种方法，如下面的语句：Class c = int.class;
或者Class c = Integer.TYPE;
它们可获得基本类型的类信息。其中后一种方法中访问的是基本类型的封装类 (如 Integer) 中预先定义好的 TYPE 字段。第二步是调用诸如 getDeclaredMethods 的方法，以取得该类中定义的所有方法的列表。一旦取得这个信息，就可以进行第三步了——使用 reflection API 来操作这些信息，如下面这段代码：Class c = Class.forName("java.lang.String");Method m[] = c.getDeclaredMethods();System.out.println(m[0].toString());
它将以文本方式打印出 String 中定义的第一个方法的原型。在下面的例子中，这三个步骤将为使用 reflection 处理特殊应用程序提供例证。模拟 instanceof 操作符得到类信息之后，通常下一个步骤就是解决关于 Class 对象的一些基本的问题。例如，Class.isInstance 方法可以用于模拟 instanceof 操作符：class A {
}public class instance1 {
public static void main(String args[]) {
try {
Class cls = Class.forName("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);
}
}
}
在这个例子中创建了一个 A 类的 Class 对象，然后检查一些对象是否是 A 的实例。Integer(37) 不是，但 new A()是。
3.找出类的方法找出一个类中定义了些什么方法，这是一个非常有价值也非常基础的 reflection 用法。下面的代码就实现了这一用法：import java.lang.reflect.*;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("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);
}
}
}
这个程序首先取得 method1 类的描述，然后调用 getDeclaredMethods 来获取一系列的 Method 对象，它们分别描述了定义在类中的每一个方法，包括 public 方法、protected 方法、package 方法和 private 方法等。如果你在程序中使用 getMethods 来代替 getDeclaredMethods，你还能获得继承来的各个方法的信息。
取得了 Method 对象列表之后，要显示这些方法的参数类型、异常类型和返回值类型等就不难了。这些类型是基本类型还是类类型，都可以由描述类的对象按顺序给出。输出的结果如下：name = f1decl class = class method1param #0 class java.lang.Objectparam #1 intexc #0 class java.lang.NullPointerExceptionreturn type = int-----
name = maindecl class = class method1param #0 class [Ljava.lang.String;return type = void4.获取构造器信息获取类构造器的用法与上述获取方法的用法类似，如：import java.lang.reflect.*;public class constructor1 {
public constructor1() {
}protected constructor1(int i, double d) {
}public static void main(String args[]) {
try {
Class cls = Class.forName("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());
Class pvec[] = ct.getParameterTypes();
for (int j = 0; j < pvec.length; j++)
System.out.println("param #" + j + " " + pvec[j]);
Class evec[] = ct.getExceptionTypes();
for (int j = 0; j < evec.length; j++)
System.out.println("exc #" + j + " " + evec[j]);
System.out.println("-----");
}
} catch (Throwable e) {
System.err.println(e);
}
}
}
这个例子中没能获得返回类型的相关信息，那是因为构造器没有返回类型。这个程序运行的结果是：name = constructor1decl class = class constructor1-----
name = constructor1decl class = class constructor1param #0 intparam #1 double5.获取类的字段(域)
找出一个类中定义了哪些数据字段也是可能的，下面的代码就在干这个事情：import java.lang.reflect.*;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("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);
}
}
}
这个例子和前面那个例子非常相似。例中使用了一个新东西 Modifier，它也是一个 reflection 类，用来描述字段成员的修饰语，如“private int”。这些修饰语自身由整数描述，而且使用 Modifier.toString 来返回以“官方”顺序排列的字符串描述 (如“static”在“final”之前)。这个程序的输出是：name = ddecl class = class field1type = doublemodifiers = private-----
name = idecl class = class field1type = intmodifiers = public static final-----
name = sdecl class = class field1type = class java.lang.Stringmodifiers =
和获取方法的情况一下，获取字段的时候也可以只取得在当前类中申明了的字段信息 (getDeclaredFields)，或者也可以取得父类中定义的字段 (getFields) 。
6.根据方法的名称来执行方法文本到这里，所举的例子无一例外都与如何获取类的信息有关。我们也可以用 reflection 来做一些其它的事情，比如执行一个指定了名称的方法。下面的示例演示了这一操作：import java.lang.reflect.*;
public class method2 {
public int add(int a, int b) {
return a + b;
}
public static void main(String args[]) {
try {
Class cls = Class.forName("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);
}
}
}
假如一个程序在执行的某处的时候才知道需要执行某个方法，这个方法的名称是在程序的运行过程中指定的 (例如，JavaBean 开发环境中就会做这样的事)，那么上面的程序演示了如何做到。上例中，getMethod用于查找一个具有两个整型参数且名为 add 的方法。找到该方法并创建了相应的Method 对象之后，在正确的对象实例中执行它。执行该方法的时候，需要提供一个参数列表，这在上例中是分别包装了整数 37 和 47 的两个 Integer 对象。执行方法的返回的同样是一个 Integer 对象，它封装了返回值 84。
7.创建新的对象对于构造器，则不能像执行方法那样进行，因为执行一个构造器就意味着创建了一个新的对象 (准确的说，创建一个对象的过程包括分配内存和构造对象)。所以，与上例最相似的例子如下：import java.lang.reflect.*;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("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);
}
}
}
根据指定的参数类型找到相应的构造函数并执行它，以创建一个新的对象实例。使用这种方法可以在程序运行时动态地创建对象，而不是在编译的时候创建对象，这一点非常有价值。
8.改变字段(域)的值reflection 的还有一个用处就是改变对象数据字段的值。reflection 可以从正在运行的程序中根据名称找到对象的字段并改变它，下面的例子可以说明这一点：import java.lang.reflect.*;public class field2 {
public double d;public static void main(String args[]) {
try {
Class cls = Class.forName("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 的值被变为了 12.34。
9.使用数组本文介绍的 reflection 的最后一种用法是创建的操作数组。数组在 Java 语言中是一种特殊的类类型，一个数组的引用可以赋给 Object 引用。观察下面的例子看看数组是怎么工作的：import java.lang.reflect.*;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);
}
}
}
例中创建了 10 个单位长度的 String 数组，为第 5 个位置的字符串赋了值，最后将这个字符串从数组中取得并打印了出来。

Ⅳ JAVA中反射是什么

JAVA中反射是动态获取信息以及动态调用对象方法的一种反射机制。

Java反射就是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；并且能改变它的属性。而这也是Java被视为动态语言的一个关键性质。

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

(5)java反射的优缺点扩展阅读：

JAVA中反射实例：

1、Class superClass=clazz.getSuperclass();//获取父类。

System.out.println("getSuperclass："+superClass)。

2、Class[] interfaces=clazz.getInterfaces();//获取实现接口。

System.out.println("getInterfaces:"+interfaces.length)。

3、Constructor[] cons=clazz.getConstructors();//构造方法。

System.out.println("getConstructors:"+cons.length)。

参考资料来源：网络： JAVA反射机制

Ⅵ 怎么理解Java中的反射,作用是什么

反射是审查元数据并收集关于它的类型信息的能力。元数据（编译以后的最基本数据单元）就是一大堆的表，当编译程序集或者模块时，编译器会创建一个类定义表，一个字段定义表，和一个方法定义表等.

反射的主要作用是用来扩展系统和动态调用程序集。
所谓扩展系统就是先把系统写好，系统里面定义接口，后面开发的人去写接口的代码。
此时该系统就要用反射了，系统用反射调用接口，当接口没写，系统利用反射就不会不会出错，此时就等于没实现此功能而已，当接口被人写好了，系统就会自动调用接口的功能展现在系统上。
即反射实现即插即用功能。

动态调用程序集就是利用反射去调用编译好的dll，当然此时的dll没有被引用到你所建的工程里面。
当你编译你的工程时，不会编译你调用的dll，当你运行到调用dll时，此时才会去调用dll，判断是否有语法语义，等编译，运行的错误。
这样利用反射具有一定灵活性，就是不用从你的工程调用dll，还有就是dll可随时改变（当然接口还是要对应），不需改变你所建的工程。

总之反射最好的好处就是新建工程时后不须一定要写好dll，可新建完工程后，后期写dll也可以。即所谓后期绑定。当然利用反射是耗资源的，损失效率，如果不是在上面的场合利用此技术，可能不会带来好处，反而是坏处。

Ⅶ java反射的性能为什么低

java反射需要将内存中的对象进行解析，涉及到与底层c语言的交互，速度会比较慢。
java反射得到的每一个Method都有一个root，不暴漏给外部，而是每次一个Method。具体的反射调用逻辑是委托给MethodAccessor的，而accessor对象会在第一次invoke的时候才创建，是一种lazy init方式。而且默认Class类会cache method对象。目前MethodAccessor的实现有两种，通过设置inflation，一个native方式，一种生成java bytecode方式。native方式启动快，但运行时间长了不如java方式，个人感觉应该是java方式运行长了,jit compiler可以进行优化。所以JDK6的实现，在native方式中，有一个计数器，当调用次数达到阀值，就会转为使用java方式。默认值是15。java方式的实现，基本和非反射方式相同。

Ⅷ java反射的作用。

1.可以通过反射机制发现对象的类型，发现类型的方法/属性/构造器
2.可以创建对象并访问任意对象方法和属性

Ⅸ 大神解释一下java反射有什么作用

java的反射机制就是增加程序的灵活性，避免将程序写死到代码里，

例如： 实例化一个 person()对象， 不使用反射， new person(); 如果想变成 实例化 其他类， 那么必须修改源代码，并重新编译。
使用反射： class.forName("person").newInstance()； 而且这个类描述可以写到配置文件中，如 *.xml, 这样如果想实例化其他类，只要修改配置文件的"类描述"就可以了，不需要重新修改代码并编译。

像spring，struts等这些开源框架的实现都用到了反射机制。

Ⅹ java的反射技术有什么用

一、反射的概述

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.

以上的总结就是什么是反射
反射就是把java类中的各种成分映射成一个个的Java对象
例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把个个组成部分映射成一个个对象。（其实：一个类中这些成员方法、构造方法、在加入类中都有一个类来描述）
如图是类的正常加载过程：反射的原理在与class对象。
熟悉一下加载的时候：Class对象的由来是将class文件读入内存，并为之创建一个Class对象。

希望对您有所帮助！~