大家好,小豆豆来为大家解答以上的问题。java反射面试题，java 反射这个很多人还不知道,现在让我们一起来看看吧！

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

2、Java反射就是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；并且能改变它的属性。

3、而这也是Java被视为动态语言的一个关键性质。

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

5、扩展资料：JAVA中反射实例：Class superClass=clazz.getSuperclass();//获取父类。

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

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

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

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

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

11、参考资料来源：百度百科： JAVA反射机制JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。

12、JAVA反射（放射）机制：“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。

13、从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言。

14、但是JAVA有着一个非常突出的动态相关机制：Reflection，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。

15、换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods。

16、拓展资料：Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。

17、Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。

18、Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。

19、Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等 。

20、参考资料：JAVA反射机制－百度百科JAVA中的反射是运行中的程序检查自己和软件运行环境的能力，它可以根据它发现的进行改变。

21、通俗的讲就是反射可以在运行时根据指定的类名获得类的信息。

22、首先我们先明确两个概念，静态编译和动态编译。

23、静态编译：在编译时确定类型，绑定对象,即通过。

24、 动态编译：运行时确定类型，绑定对象。

25、动态编译最大限度发挥了java的灵活性，体现了多    态的应用，有以降低类之间的藕合性。

26、   我们可以明确的看出动态编译的好处，而反射就是运用了动态编译创建对象。

27、往往对比能更加直观的向我们展示两者的不同。

28、若是不用反射，它是这样的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 fruitName){          fruit f=null;          if("Apple".equals(fruitName)){              f=new Apple();          }          if("Orange".equals(fruitName)){              f=new Orange();          }          return f;      }  } class hello{      public static void main(String[] a){          fruit f=Factory.getInstance("Orange");          f.eat();      }      } 可以发现，每当我们要添加一种新的水果的时候，我们将不得不改变Factory中的源码，而往往改变原有正确代码是一种十分危险的行为。

29、而且随着水果种类的增加，你会发现你的factory类会越来越臃肿，不得不说这是一种十分--的做法。

30、（初学者可能会问，我们为什么不直接在main方法中new水果那，我们可能会需要getInstance方法做一些别的事情。

31、所以不直接new）；而反射无疑是一种聪明的办法，看代码。

32、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;}  }  class hello{  public static void main(String[] a){fruit f=Factory.getInstance("Reflect.Apple");if(f!=null){f.eat();}}  }  在出现新品种水果的时候，你完全不用去修改原有代码。

33、从上面的案例中，我们可以清楚的体会到反射的优越性。

34、那么有的人又会问，这个例子能完全明白，但是如果放到实际的编程，应用中，我们又会在什么情况下用到反射那？举一个看到过的例子，在实际开发中，我们需要把一个包中的class new出来，但是这个包中的类总是需要变动，那么怎么办，难道总是修改main方法中xxx=new xxx()吗。

35、这样无疑是麻烦的。

36、而运用反射。

37、我们可以相应的增加一个配置文件，在里面记录包中所有的类名，包中类增加时就加一个类名，删除时就删除一个类名。

38、让main方法去读取这个配置文件中的类名，通过反射获得实例，完全不用我们去修改main方法中的代码。

39、他甚至可以修改其他类中的私有属性。

40、android开发中，我们需要改变一个私有标志位的时候，android源码并没有提供set方法，我们又不能改变源码，怎么办，反射可以完美解决这个问题。

41、说了这么多，那么我们的开发中，为什么不全部都用反射那？一个原因，开销，它的开销是什么昂贵的，随意尽量在最需要的地方使用反射。

42、说完是什么，为什么，我们必然需要掌握如何使用反射，先看反射中涉及了那些方法。

43、Class c=Class.forName("className");注明：className必须为全名，也就是得包含包名，比如，cn.netjava.pojo.UserInfo; Object obj=c.newInstance();//创建对象的实例 OK，有了对象就什么都好办了，想要什么信息就有什么信息了。

44、   获得构造函数的方法 Constructor getConstructor(Class[] params)//根据指定参数获得public构造器Constructor[] getConstructors()//获得public的所有构造器Constructor getDeclaredConstructor(Class[] params)//根据指定参数获得public和非public的构造器Constructor[] getDeclaredConstructors()//获得public的所有构造器 获得类方法的方法 Method getMethod(String name, Class[] params),根据方法名，参数类型获得方法Method[] getMethods()//获得所有的public方法Method getDeclaredMethod(String name, Class[] params)//根据方法名和参数类型，获得public和非public的方法Method[] getDeclaredMethods()//获得所以的public和非public方法 获得类中属性的方法 Field getField(String name)//根据变量名得到相应的public变量Field[] getFields()//获得类中所以public的方法Field getDeclaredField(String name)//根据方法名获得public和非public变量Field[] getDeclaredFields()//获得类中所有的public和非public方法看到这些方法，你就可以明白，反射是多么的强大了，当你正确使用这些方法的时候，基本上是掌握了反射的技巧。

45、还有 反射操作数组：String[] str = (String[]) Array.newInstance(String.class, 5);//反射调用sleep方法Object invoke = method.invoke(obj, 5);//obj.sleep(5);System.out.println(invoke);扩展资料:如果不知道某个对象的确切类型，RTTI可以告诉你，但是有一个前提：这个类型在编译时必须已知，这样才能使用RTTI来识别它。

46、Class类与java.lang.reflect类库一起对反射进行了支持，该类库包含Field、Method和Constructor类，这些类的对象由JVM在启动时创建，用以表示未知类里对应的成员。

47、这样的话就可以使用Contructor创建新的对象，用get()和set()方法获取和修改类中与Field对象关联的字段，用invoke()方法调用与Method对象关联的方法。

48、另外，还可以调用getFields()、getMethods()和getConstructors()等许多便利的方法，以返回表示字段、方法、以及构造器对象的数组，这样，对象信息可以在运行时被完全确定下来，而在编译时不需要知道关于类的任何事情。

49、反射机制并没有什么神奇之处，当通过反射与一个未知类型的对象打交道时，JVM只是简单地检查这个对象，看它属于哪个特定的类。

50、因此，那个类的.class对于JVM来说必须是可获取的，要么在本地机器上，要么从网络获取。

51、所以对于RTTI和反射之间的真正区别只在于：RTTI，编译器在编译时打开和检查.class文件反射，运行时打开和检查.class文件参考资料:JAVA反射机制-百度百科一、反射的概述JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

52、要想解剖一个类,必须先要获取到该类的字节码文件对象。

53、而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.以上的总结就是什么是反射反射就是把java类中的各种成分映射成一个个的Java对象例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把个个组成部分映射成一个个对象。

54、（其实：一个类中这些成员方法、构造方法、在加入类中都有一个类来描述）如图是类的正常加载过程：反射的原理在与class对象。

55、熟悉一下加载的时候：Class对象的由来是将class文件读入内存，并为之创建一个Class对象。

56、二、Java中为什么需要反射？反射要解决什么问题？Java中编译类型有两种：静态编译：在编译时确定类型，绑定对象即通过。

57、动态编译：运行时确定类型，绑定对象。

58、动态编译最大限度地发挥了Java的灵活性，体现了多态的应用，可以减低类之间的耦合性。

59、Java反射是Java被视为动态（或准动态）语言的一个关键性质。

60、这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public、static等）、superclass（例如Object）、实现之interfaces（例如Cloneable），也包括fields和methods的所有信息，并可于运行时改变fields内容或唤起methods。

61、Reflection可以在运行时加载、探知、使用编译期间完全未知的classes。

62、即Java程序可以加载一个运行时才得知名称的class，获取其完整构造，并生成其对象实体、或对其fields设值、或唤起其methods。

63、反射（reflection）允许静态语言在运行时（runtime）检查、修改程序的结构与行为。

64、在静态语言中，使用一个变量时，必须知道它的类型。

65、在Java中，变量的类型信息在编译时都保存到了class文件中，这样在运行时才能保证准确无误；换句话说，程序在运行时的行为都是固定的。

66、如果想在运行时改变，就需要反射这东西了。

67、实现Java反射机制的类都位于java.lang.reflect包中：Class类：代表一个类Field类：代表类的成员变量（类的属性）Method类：代表类的方法Constructor类：代表类的构造方法Array类：提供了动态创建数组，以及访问数组的元素的静态方法一句话概括就是使用反射可以赋予jvm动态编译的能力，否则类的元数据信息只能用静态编译的方式实现，例如热加载，Tomcat的classloader等等都没法支持。

68、三、使用获取Class对象的三种方式1.1 Object ——> getClass();1.2 任何数据类型（包括基本数据类型）都有一个“静态”的class属性1.3 通过Class类的静态方法：forName（String  className）(常用)希望对您有所帮助！~反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。

69、这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。

70、它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。

71、其中LEAD/LEAD++ 、OpenC++ 、MetaXa和OpenJava等就是基于反射机制的语言。

72、最近，反射机制也被应用到了视窗系统、操作系统和文件系统中。

73、 反射本身并不是一个新概念，它可能会使我们联想到光学中的反射概念，尽管计算机科学赋予了反射概念新的含义，但是，从现象上来说，它们确实有某些相通之处，这些有助于我们的理解。

74、在计算机科学领域，反射是指一类应用，它们能够自描述和自控制。

75、也就是说，这类应用通过采用某种机制来实现对自己行为的描述（self-representation）和监测（examination），并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。

76、可以看出，同一般的反射概念相比，计算机科学领域的反射不单单指反射本身，还包括对反射结果所采取的措施。

77、所有采用反射机制的系统（即反射系统）都希望使系统的实现更开放。

78、可以说，实现了反射机制的系统都具有开放性，但具有开放性的系统并不一定采用了反射机制，开放性是反射系统的必要条件。

79、一般来说，反射系统除了满足开放性条件外还必须满足原因连接（Causally-connected）。

80、所谓原因连接是指对反射系统自描述的改变能够立即反映到系统底层的实际状态和行为上的情况，反之亦然。

81、开放性和原因连接是反射系统的两大基本要素。

82、13700863760Java中，反射是一种强大的工具。

83、它使您能够创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代表链接。

84、反射允许我们在编写与执行时，使我们的程序代码能够接入装载到JVM中的类的内部信息，而不是源代码中选定的类协作的代码。

85、这使反射成为构建灵活的应用的主要工具。

86、但需注意的是：如果使用不当，反射的成本很高。

87、二、Java中的类反射：Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。

88、Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。

89、例如，Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。

90、1．检测类：1.1 reflection的工作机制考虑下面这个简单的例子，让我们看看 reflection 是如何工作的。

91、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 类的各方法名以及它们的限制符和返回类型。

92、这个程序使用 Class.forName 载入指定的类，然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。

93、java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。

94、1.2 Java类反射中的主要方法对于以下三类组件中的任何一类来说 -- 构造函数、字段和方法 -- java.lang.Class 提供四种独立的反射调用，以不同的方式来获得信息。

95、调用都遵循一种标准格式。

96、以下是用于查找构造函数的一组反射调用：l Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数，l Constructor[] getConstructors() -- 获得类的所有公共构造函数l Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关)l Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关) 获得字段信息的Class 反射调用不同于那些用于接入构造函数的调用，在参数类型数组中使用了字段名：l Field getField(String name) -- 获得命名的公共字段l Field[] getFields() -- 获得类的所有公共字段l Field getDeclaredField(String name) -- 获得类声明的命名的字段l Field[] getDeclaredFields() -- 获得类声明的所有字段 用于获得方法信息函数：l Method getMethod(String name, Class[] params) -- 使用特定的参数类型，获得命名的公共方法l Method[] getMethods() -- 获得类的所有公共方法l Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型，获得类声明的命名的方法l Method[] getDeclaredMethods() -- 获得类声明的所有方法 1.3开始使用 Reflection：用于 reflection 的类，如 Method，可以在 java.lang.relfect 包中找到。

97、使用这些类的时候必须要遵循三个步骤：第一步是获得你想操作的类的 java.lang.Class 对象。

98、在运行中的 Java 程序中，用 java.lang.Class 类来描述类和接口等。

99、下面就是获得一个 Class 对象的方法之一：Class c = Class.forName("java.lang.String");这条语句得到一个 String 类的类对象。

100、还有另一种方法，如下面的语句：Class c = int.class;或者Class c = Integer.TYPE;它们可获得基本类型的类信息。

101、其中后一种方法中访问的是基本类型的封装类 (如 Integer) 中预先定义好的 TYPE 字段。

102、第二步是调用诸如 getDeclaredMethods 的方法，以取得该类中定义的所有方法的列表。

103、一旦取得这个信息，就可以进行第三步了——使用 reflection API 来操作这些信息，如下面这段代码：Class c = Class.forName("java.lang.String");Method m[] = c.getDeclaredMethods();System.out.println(m[0].toString());它将以文本方式打印出 String 中定义的第一个方法的原型。

104、2．处理对象：如果要作一个开发工具像debugger之类的，你必须能发现filed values,以下是三个步骤:a.创建一个Class对象b.通过getField 创建一个Field对象c.调用Field.getXXX(Object)方法(XXX是Int,Float等，如果是对象就省略；Object是指实例).例如：import java.lang.reflect.*;import java.awt.*;class SampleGet { public static void main(String[] args) { Rectangle r = new Rectangle(100, 325); printHeight(r); } static void printHeight(Rectangle r) { Field heightField; Integer heightValue; Class c = r.getClass(); try { heightField = c.getField("height"); heightValue = (Integer) heightField.get(r); System.out.println("Height: " + heightValue.toString()); } catch (NoSuchFieldException e) { System.out.println(e); } catch (SecurityException e) { System.out.println(e); } catch (IllegalAccessException e) { System.out.println(e); } }}三、安全性和反射：在处理反射时安全性是一个较复杂的问题。

105、反射经常由框架型代码使用，由于这一点，我们可能希望框架能够全面接入代码，无需考虑常规的接入限制。

106、但是，在其它情况下，不受控制的接入会带来严重的安全性风险，例如当代码在不值得信任的代码共享的环境中运行时。

107、由于这些互相矛盾的需求，Java编程语言定义一种多级别方法来处理反射的安全性。

108、基本模式是对反射实施与应用于源代码接入相同的限制：n 从任意位置到类公共组件的接入 n 类自身外部无任何到私有组件的接入 n 受保护和打包（缺省接入）组件的有限接入 不过至少有些时候，围绕这些限制还有一种简单的方法。

109、我们可以在我们所写的类中，扩展一个普通的基本类java.lang.reflect.AccessibleObject 类。

110、这个类定义了一种setAccessible方法，使我们能够启动或关闭对这些类中其中一个类的实例的接入检测。

111、唯一的问题在于如果使用了安全性管理器，它将检测正在关闭接入检测的代码是否许可了这样做。

112、如果未许可，安全性管理器抛出一个例外。

113、下面是一段程序，在TwoString 类的一个实例上使用反射来显示安全性正在运行：public class ReflectSecurity { public static void main(String[] args) { try { TwoString ts = new TwoString("a", "b"); Field field = clas.getDeclaredField("m_s1");// field.setAccessible(true); System.out.println("Retrieved value is " + field.get(inst)); } catch (Exception ex) { ex.printStackTrace(System.out); } }}如果我们编译这一程序时，不使用任何特定参数直接从命令行运行，它将在field .get(inst)调用中抛出一个IllegalAccessException异常。

114、如果我们不注释field.setAccessible(true)代码行，那么重新编译并重新运行该代码，它将编译成功。

115、最后，如果我们在命令行添加了JVM参数-Djava.security.manager以实现安全性管理器，它仍然将不能通过编译，除非我们定义了ReflectSecurity类的许可权限。

116、四、反射性能：反射是一种强大的工具，但也存在一些不足。

117、一个主要的缺点是对性能有影响。

118、使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。

119、这类操作总是慢于只直接执行相同的操作。

120、下面的程序是字段接入性能测试的一个例子，包括基本的测试方法。

121、每种方法测试字段接入的一种形式 -- accessSame 与同一对象的成员字段协作，accessOther 使用可直接接入的另一对象的字段，accessReflection 使用可通过反射接入的另一对象的字段。

122、在每种情况下，方法执行相同的计算 -- 循环中简单的加/乘顺序。

123、程序如下：public int accessSame(int loops) { m_value = 0; for (int index = 0; index < loops; index++) { m_value = (m_value + ADDITIVE_VALUE) * MULTIPLIER_VALUE; } return m_value;}public int accessReference(int loops) { TimingClass timing = new TimingClass(); for (int index = 0; index < loops; index++) { timing.m_value = (timing.m_value + ADDITIVE_VALUE) * MULTIPLIER_VALUE; } return timing.m_value;}public int accessReflection(int loops) throws Exception { TimingClass timing = new TimingClass(); try { Field field = TimingClass.class. getDeclaredField("m_value"); for (int index = 0; index < loops; index++) { int value = (field.getInt(timing) + ADDITIVE_VALUE) * MULTIPLIER_VALUE; field.setInt(timing, value); } return timing.m_value; } catch (Exception ex) { System.out.println("Error using reflection"); throw ex; }}在上面的例子中，测试程序重复调用每种方法，使用一个大循环数，从而平均多次调用的时间衡量结果。

124、平均值中不包括每种方法第一次调用的时间，因此初始化时间不是结果中的一个因素。

125、下面的图清楚的向我们展示了每种方法字段接入的时间：图 1：字段接入时间 ：我们可以看出：在前两副图中(Sun JVM)，使用反射的执行时间超过使用直接接入的1000倍以上。

126、通过比较，IBM JVM可能稍好一些，但反射方法仍旧需要比其它方法长700倍以上的时间。

127、任何JVM上其它两种方法之间时间方面无任何显著差异，但IBM JVM几乎比Sun JVM快一倍。

128、最有可能的是这种差异反映了Sun Hot Spot JVM的专业优化，它在简单基准方面表现得很糟糕。

129、反射性能是Sun开发1.4 JVM时关注的一个方面，它在反射方法调用结果中显示。

130、在这类操作的性能方面，Sun 1.4.1 JVM显示了比1.3.1版本很大的改进。

131、如果为为创建使用反射的对象编写了类似的计时测试程序，我们会发现这种情况下的差异不象字段和方法调用情况下那么显著。

132、使用newInstance()调用创建一个简单的java.lang.Object实例耗用的时间大约是在Sun 1.3.1 JVM上使用new Object()的12倍，是在IBM 1.4.0 JVM的四倍，只是Sun 1.4.1 JVM上的两部。

133、使用Array.newInstance(type, size)创建一个数组耗用的时间是任何测试的JVM上使用new type[size]的两倍，随着数组大小的增加，差异逐步缩小。

134、结束语：Java语言反射提供一种动态链接程序组件的多功能方法。

135、它允许程序创建和控制任何类的对象(根据安全性限制)，无需提前硬编码目标类。

136、这些特性使得反射特别适用于创建以非常普通的方式与对象协作的库。

137、例如，反射经常在持续存储对象为数据库、XML或其它外部格式的框架中使用。

138、Java reflection 非常有用，它使类和数据结构能按名称动态检索相关信息，并允许在运行着的程序中操作这些信息。

139、Java 的这一特性非常强大，并且是其它一些常用语言，如 C、C++、Fortran 或者 Pascal 等都不具备的。

140、但反射有两个缺点。

141、第一个是性能问题。

142、用于字段和方法接入时反射要远慢于直接代码。

143、性能问题的程度取决于程序中是如何使用反射的。

144、如果它作为程序运行中相对很少涉及的部分，缓慢的性能将不会是一个问题。

145、即使测试中最坏情况下的计时图显示的反射操作只耗用几微秒。

146、仅反射在性能关键的应用的核心逻辑中使用时性能问题才变得至关重要。

147、许多应用中更严重的一个缺点是使用反射会模糊程序内部实际要发生的事情。

148、程序人员希望在源代码中看到程序的逻辑，反射等绕过了源代码的技术会带来维护问题。

149、反射代码比相应的直接代码更复杂，正如性能比较的代码实例中看到的一样。

150、解决这些问题的最佳方案是保守地使用反射——仅在它可以真正增加灵活性的地方——记录其在目标类中的使用。

151、利用反射实现类的动态加载Bromon原创 请尊重版权最近在成都写一个移动增值项目，俺负责后台server端。

152、功能很简单，手机用户通过GPRS打开Socket与服务器连接，我则根据用户传过来的数据做出响应。

153、做过类似项目的兄弟一定都知道，首先需要定义一个类似于MSNP的通讯协议，不过今天的话题是如何把这个系统设计得具有高度的扩展性。

154、由于这个项目本身没有进行过较为完善的客户沟通和需求分析，所以以后肯定会有很多功能上的扩展，通讯协议肯定会越来越庞大，而我作为一个不那么勤快的人，当然不想以后再去修改写好的程序，所以这个项目是实践面向对象设计的好机会。

155、首先定义一个接口来隔离类：package org.bromon.reflect;public interface Operator{public java.util.List act(java.util.List params)}根据设计模式的原理，我们可以为不同的功能编写不同的类，每个类都继承Operator接口，客户端只需要针对Operator接口编程就可以避免很多麻烦。

156、比如这个类：package org.bromon.reflect.*;public class Success implements Operator{public java.util.List act(java.util.List params){List result=new ArrayList();。

本文到此分享完毕，希望对大家有所帮助。

版权说明： 本文版权归原作者所有，转载文章仅为传播更多信息之目的，如作者信息标记有误，请第一时间联系我们修改或删除，多谢。

标签：