JAVA高级用法 —— 反射（一）

引言：这里结合工厂模式和接口来记录对于反射的理解。代码和文字部分源于网络。对其进行了重新整理。反射机制对于普通开发者而言，意义不大，一般都是作为一些系统的架构设计去使用的，包括以后学习的开源框架，几乎都使用了反射机制。

反射概念

• 反射之后的“反”是针对与“正”来的。那什么是正？就是使用一个类构造一个对象的过程：类——>对象；因此，“反”即是：对象——>类。

package reflection;class Apple{}public class Demo{    public static void main(String[] args) throws Exception    {        Apple a = new Apple(); //正向操作        System.out.println(a.getClass().getName());//反向操作    }}

• 反向操作即通过使用一个getClass()方法，得到对象所在的“package.Class”,返回一个Class类对象，这就是一切反射机制的根源。

获取Class类的三种方法

• 通过Object类的getClass()方法，很少用此方法：

package reflection;class Apple{}public class Demo{    public static void main(String[] args) throws Exception    {        Apple a = new Apple(); //正向操作        System.out.println(a.getClass().getName());//反向操作    }}

• 使用“类.class”获得Class对象：

package reflection;class Apple{}public class Demo{    public static void main(String[] args) throws Exception    {        Class c = Apple.class;        System.out.println(cls.getName());    }}

• 使用Class类内部定义的static方法：

package reflection;class Apple{}public class Demo{    public static void main(String[] args) throws Exception    {        Class cls = Class.forName("reflection.Apple");        System.out.println(cls.getName());    }}

• 通过反射实例化对象：

package reflection;class Apple{    @Override public String toString()    {        return "eating an apple...";    }}public class Demo{    public static void main(String[] args) throws Exception    {        Class cls = Class.forName("reflection.Apple");        Object obj = cls.newInstance(); //实例化对象，此处和关键字new是一样的        Apple a = (Apple) obj;//转换类型        System.out.println(obj);     }}

应用中的反射

• 在“通过反射实例化对象”一部分中，对于对象的实例化操作，除了使用new关键字之外，又多了一个反射机制操作，增加了复杂性，然而有什么用？对于程序的开发模式，一直要求尽量减少耦合，而减少耦合的最好方法就是使用接口，但是就算使用了接口也避不开关键字new。所以new是造成耦合的关键。但是，通过反射机制和接口就可以避免new造成的耦合。
• 原始版工厂设计模式

package reflection;interface Fruit{    public void eat();}class Apple implement Fruit{    public void eat()    {        System.out.println("eating an apple...");    }}class Factory{    public static Fruit getInstance(String className)    {        if("Apple".equals(className))        {            return new Apple();        }        return null;    }}public class FactoryDemo{    public static void main(String[] args)    {        Fruit f = Factory.getInstance("Apple");        f.eat();    }}/**  * 这是最简单的工厂设计模式，但是其中有一个最大的问题：如果现在实现接口的类增加  * 了，那么Factory类肯定需要修改，问题的原因就在与Factory类getInstance方法  * 中的new，如果使用反射机制，就可避免该类问题。  */

• 使用反射机制的工厂类，此处使用第三种获得Class对象的方法。

package reflection;interface Fruit{    public void eat();}class Apple implement Fruit{    public void eat()    {        System.out.println("eating an apple...");    }}class Orange implement Fruit{    public void eat()    {        System.out.println("eating an orange...");    }｝class Factory{    public static Fruit getInstance(String className)    {        Fruit temp = null;        try        {            temp = (Fruit)Class.forName(className).newInstance();        }        catch(Exception e)        {            e.printStackTrace();        }        return temp;    }}public class FactoryDemo{    public static void main(String[] args)    {        Fruit apple = Factory.getInstance("reflection.Apple");        apple.eat();        Fruit orange = Factory.getInstance("reflection.Orange");        orange.eat();    }}/**  * 这样不论实现接口的类有多少，都不需要改动Factory类，降低了耦合性  */