关于工厂设计模式的问题（反射机制）

首先来写一个传统的工厂：

interface IFruit{
    public void eat();
}
class Apple1 implements IFruit{
    @Override
    public void eat() {
        System.out.println("吃苹果");
    }
}
class Orange implements IFruit{

    @Override
    public void eat() {
        System.out.println("吃橘子");
    }

}
class Factory{
    private Factory(){}
    @SuppressWarnings("unchecked")
    public static IFruit getInstance(String classname){
        if("apple".equals(classname)){
            return new Apple();
        }else if("orange".equals(classname)){
            return new Orange();
        }
        return null;
    } 
}
public class Test30 {
    public static void main(String[] args) {
        IFruit apple = Factory.getInstance("apple");
        apple.eat();
        IFruit orange = Factory.getInstance("orange");
        orange.eat();
    }
}

如上述例子，利用传入的类名来得到相应的实例化对象，但这里是有厂类进行改造，例如个很重的问题：如果IFruit有十个乃至上百个实现类，我们就需要对工厂进行改造，例如上述例子中的orange。有多少个实现类就需要新多少对象，这在实际开发中是不现实的。
我们可以用反射来解决这个问题。

interface IFruit{
    public void eat();
}
interface IMessage{
    public void print();
}
class Apple implements IFruit{
    @Override
    public void eat() {
        System.out.println("吃苹果");
    }
}
class MessageImpl implements IMessage{
    @Override
    public void print() {
        System.out.println("message");
    }
}
class Factory<T>{
    private Factory(){}
    @SuppressWarnings("unchecked")
    public static <T> T getInstance(String classname){
        T obj = null;
        try {
            obj = (T)Class.forName(classname).newInstance();
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return obj;
    } 
}
public class Test29 {
    public static void main(String[] args) {
        IFruit apple = Factory.getInstance("java1_1.Apple");
        apple.eat();
        IMessage im = Factory.getInstance("java1_1.MessageImpl");
        im.print();
    }
}

如上述代码，可以通过传入类名来动态的实例化对象，而不需要再加代码，还可以加入泛型来实现多个接口或抽象类的实例化。