[转] Java的反射机制+工厂模式_工厂模式反射强转-CSDN博客

1、什么叫反射
Java.lang.reflect包下
正常情况下我们可以通过类实例化一个对象，那么通过反射实际上就可以通过一个对象得到此类完整的包.类名称。

package org.michael;
class Person{
      private String name;
      private int age;
      public void setName(String name){
            this.name = name;
      }
      public void setAge(int age){
            this.age = age;
      }
      public String getName(){
            return this.name;
      }
      public int getAge(){
            return this.age;
      }
}
public class Demo01{
      public static void main(String args[]){
            Person p = new Person();
            //假设现在不知道p是那个类的对象，则可以通过反射机制找到
            Class c = null;
            c = p.getClass();
            System.out.println(c.getName());
      }
}

看下效果：

除了可以找到对象所在的包.类名称，实际上也可以把所有的方法名称列出来。
package       org.michael;
import java.lang.reflect.*;
class Person{
      private String name;
      private int age;
      public void setName(String name){
            this.name = name;
      }
      public void setAge(int age){
            this.age = age;
      }
      public String getName(){
            return this.name;
      }
      public int getAge(){
            return this.age;
      }
}
public class Demo02{
      public static void main(String args[]){
            Person p = new Person();
            //假设现在不知道p是那个类的对象，则可以通过反射机制找到
            Class c = null;
            c = p.getClass();
            Method m[] = c.getMethods();
            for(int i=0;i<m.length;i++){
            System.out.println(m);
            }
      }
}

2、研究Class类
Class类的构造方法被私有化了，外部无法直接看见，所以其内部必然有一个方法可以取得Class 实例。
public static Class<?> forName(String className) throws ClassNotFoundException
此方法可以返回Class类的实例，此方法接收一个完整的包.类名称。
通过newInstance方法，可以将传入的完整的字符串（包.类名称）实例化。
package       org.michael;
import java.lang.reflect.*;
class Person{
      private String name;
      private int age;
      public void setName(String name){
            this.name = name;
      }
      public void setAge(int age){
            this.age = age;
      }
      public String getName(){
            return this.name;
      }
      public int getAge(){
            return this.age;
      }
}
public class Demo03{
      public static void main(String args[]){
            Person p = null;
            Class c = null;
            try{
                     c = Class.forName("org.michael.Person");
            }catch (Exception e){}
            try{
                     p = (Person)c.newInstance();
            }catch (Exception e){}
            //上面两行代码也可以使用下面一行代码取代哈~
            // p = (Person)Class.forName("org.michael.Person").newInstance();
            p.setName("Michael");
            p.setAge(30);
            System.out.println(p.getName()+"--->"+p.getAge());
      }
}

如果要使用以上的代码去实例化一个对象，则必须有一个前途条件：在对象所在的类中必须有一个无参构造方法，如果没有此无参构造，则肯定会出现错误。
package       org.michael;
import java.lang.reflect.*;
class Person{
      private String name;
      private int age;
      public Person(String name,int age){
            this.name = name;
            this.age = age;
      }
      public void setName(String name){
            this.name = name;
      }
      public void setAge(int age){
            this.age = age;
      }
      public String getName(){
            return this.name;
      }
      public int getAge(){
            return this.age;
      }
}
public class Demo04{
      public static void main(String args[]){
            Person p = null;
            Class c = null;
            try{
                     c = Class.forName("org.michael.Person");
                     p = (Person)c.newInstance();
            }catch (Exception e){
                     System.out.println(e);
            }
            System.out.println(p.getName()+"--->"+p.getAge());
      }
}

在此时如果想继续通过此操作为对象进行实例化，则可以通过构造方法类（Constructor）完成。
package       org.michael;
import java.lang.reflect.*;
class Person{
      private String name;
      private int age;
      public Person(String name,int age){
            this.name = name;
            this.age = age;
      }
      public void setName(String name){
            this.name = name;
      }
      public void setAge(int age){
            this.age = age;
      }
      public String getName(){
            return this.name;
      }
      public int getAge(){
            return this.age;
      }
}
public class Demo05{
      public static void main(String args[]){
            Person p = null;
            Class c = null;
            try{
                     c = Class.forName("org.michael.Person");
                     Constructor[] cs = c.getConstructors();
                     Object obj[] = new Object[]{"Michael",30};
                     //一个类中会有多个构造方法，所以此时返回一个数组
                     p = (Person)cs[0].newInstance(obj);
            }catch (Exception e){
                     System.out.println(e);
            }
            System.out.println(p.getName()+"--->"+p.getAge());
      }
}

反射机制实际上是我们所有框架的一个基础，那么现在就利用反射机制完成一个高可扩展性的工厂设计。

回顾：工厂设计
interface Fruit{
      public void grow();
      public void eat();
}
class Apple implements Fruit{
      public void grow(){
            System.out.println("苹果在生长...");
      }
      public void eat(){
            System.out.println("吃苹果...");
      }
}
class Orange implements Fruit{
      public void grow(){
            System.out.println("橘子在生长...");
      }
      public void eat(){
            System.out.println("吃橘子...");
      }
}
class Factory{
      public static Fruit getFruit(int i){
            Fruit f = null;
            if (i==1){
                     f = new Apple();
            }
            if (i==2){
                     f = new Orange();
            }
            return f;
      }
}
public class Demo06{
      public static void main(String args[]){
            Fruit f = Factory.getFruit(1);
            f.grow();
      }
}

客户端只与工厂和直接的接口有关了，而与其他的无关，但是有个问题，如果现在要扩展了子类，则工厂也必须同时进行修改。那么有没有一种方法，可以让子类扩充之后不去修改工厂呢？肯定是有的，通过Class.forName 完成。
interface Fruit{
      public void grow();
      public void eat();
}
class Apple implements Fruit{
      public void grow(){
            System.out.println("苹果在生长...");
      }
      public void eat(){
            System.out.println("吃苹果...");
      }
}
class Orange implements Fruit{
      public void grow(){
            System.out.println("橘子在生长...");
      }
      public void eat(){
            System.out.println("吃橘子...");
      }
}
class Banana implements Fruit{
      public void grow(){
            System.out.println("香蕉在生长...");
      }
      public void eat(){
            System.out.println("吃香蕉...");
      }
}
class Factory{
      public static Fruit getFruit(String className){
            Fruit f = null;
            try{
                     f = (Fruit)Class.forName(className).newInstance();
            }catch (Exception e){}
            return f;
      }
}
public class Demo07{
      public static void main(String args[]){
            Fruit f = Factory.getFruit("Banana");
            f.grow();
      }
}

但是此程序依然有一个缺点，现在的输入的包.类名称实际上长度非常的短，如果包.类名称的长度过长了，则在使用的时候就比较麻烦了。所以最好可以找个代号进行替代。
使用Hashtable的子类 —— Properties完成。
import java.util.*;
import java.io.*;
interface Fruit{
      public void grow();
      public void eat();
}
class Apple implements Fruit{
      public void grow(){
            System.out.println("苹果在生长...");
      }
      public void eat(){
            System.out.println("吃苹果...");
      }
}
class Orange implements Fruit{
      public void grow(){
            System.out.println("橘子在生长...");
      }
      public void eat(){
            System.out.println("吃橘子...");
      }
}
class Banana implements Fruit{
      public void grow(){
            System.out.println("香蕉在生长...");
      }
      public void eat(){
            System.out.println("吃香蕉...");
      }
}
class Factory{
      public static Fruit getFruit(String className){
            Fruit f = null;
            try{
                     f = (Fruit)Class.forName(className).newInstance();
            }catch (Exception e){}
            return f;
      }
}
class InputData{
      private BufferedReader buf = null;
      public InputData(){
            this.buf = new BufferedReader(new InputStreamReader(System.in));
      }
      public String getString(){
            String str = null;
            try{
                     str = this.buf.readLine();
            }catch (Exception e){}
            return str;
      }
}
public class Demo08{
      public static void main(String args[]){
            Properties p = new Properties();
            p.setProperty("a","Apple");
            p.setProperty("o","Orange");
            p.setProperty("b","Banana");
            System.out.println(p);
            System.out.print("请选择所需要的类型：");
            String str = new InputData().getString();
            //进一步扩展，现在可以由用户自己输入要使用的类型
            Fruit f = Factory.getFruit(p.getProperty(str));
            f.grow();
      }
}

如果现在再增加子类呢？
属性文件肯定不够了。
所以此时为了达到好的效果，则最好可以将属性保存起来，之后通过修改保存的文件达到属性的扩充。
import java.util.*;
import java.io.*;
interface Fruit{
      public void grow();
      public void eat();
}
class Apple implements Fruit{
      public void grow(){
            System.out.println("苹果在生长...");
      }
      public void eat(){
            System.out.println("吃苹果...");
      }
}
class Orange implements Fruit{
      public void grow(){
            System.out.println("橘子在生长...");
      }
      public void eat(){
            System.out.println("吃橘子...");
      }
}
class Banana implements Fruit{
      public void grow(){
            System.out.println("香蕉在生长...");
      }
      public void eat(){
            System.out.println("吃香蕉...");
      }
}
class Factory{
      public static Fruit getFruit(String className){
            Fruit f = null;
            try{
                     f = (Fruit)Class.forName(className).newInstance();
            }catch (Exception e){}
            return f;
      }
}
class PropertyOperate{
      private Properties pro = null;
      public PropertyOperate(){
            this.pro = new Properties();
            this.load();
      }
      //设置一个返回方法
      public Properties getPro(){
            return this.pro;
      }
      //从文件中读出属性，如果文件不存在，则创建一个默认的
      private void save(){
            pro.setProperty("a","Apple");
            pro.setProperty("o","Orange");
            //保存在文件之中
            try{
                     pro.storeToXML(new FileOutputStream(new File("e://fruit.xml")),"FRUIT FACTORY");
            }catch (Exception e){}
      }
      private void load(){
            File f = new File("e://fruit.xml");
            if(f.exists()){
                     //文件存在则可以读取
                     try{
                              pro.loadFromXML(new FileInputStream(f));
                     }catch (Exception e){}
            }else{
                     //进行创建
                     this.save();
            }
      }
}
class InputData{
      private BufferedReader buf = null;
      public InputData(){
            this.buf = new BufferedReader(new InputStreamReader(System.in));
      }
      public String getString(){
            String str = null;
            try{
                     str = this.buf.readLine();
            }catch(Exception e){}
            return str;
      }
}
public class Demo09{
      public static void main(String args[]){
            Properties p = new PropertyOperate().getPro();
            System.out.println(p);
            System.out.print("请选择所需要的类型：");
            String str = new InputData().getString();
            //进一步扩展，现在可以由用户自己输入要使用的类型
            Fruit f = Factory.getFruit(p.getProperty(str));
            f.grow();
      }
}

如果此时要想新增加可以操作的子类，则就需要配置fruit.xml文件即可。
此种代码是典型的配置与程序相分离，程序直接有配置文件有关。某一个部分的修改不影响其他程序。—— 思想必须建立起来。

总结
对象的产生到底有多少种方法了：
· 直接用new关键字产生：直接，但是代码间会产生严重的耦合性
· 可以通过工厂传递引用：直接，但是必须考虑到代码以后的可维护性
· 通过对象克隆可以完成
· 通过Class.forName()进行反射加载完成。