使用反射机制可以解决每次增加一个产品时，都需要增加一个对象实现工厂的缺点

public class ShapeFactory {
    public static Object getClass(Class<?extends Shape> clazz) {
        Object obj = null;

        try {
            obj = Class.forName(clazz.getName()).newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

        return obj;
    }
}

使用的使用采用强制转换

Rectangle rect = (Rectangle) ShapeFactory.getClass(Rectangle.class);
rect.draw();
Square square = (Square) ShapeFactory.getClass(Square.class);
square.draw();

这样就只需要一个对象实现工厂

在上面的基础上进一步扩展，针对多个接口实现一个公共的工厂类：

public class ObjectFactory {
    public <T> Object getObject(Class<T> clazz) {
       if (clazz == null ) {
           return null;
    }    
        Object obj  = null;
        try {
            obj = Class.forName(clazz.getName()).newInstance();
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return obj;
    }
}

public class ShapeFactory {
    
   //使用 getShape 方法获取形状类型的对象
   public Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }        
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();
      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();
      } else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }
      return null;
   }
}

创建的这个工厂，这个创建函数，没能看出有什么特别的，还特别繁琐，如果IShape类太多，那么if else语句也将增加太多，不好维护，与其这样写，还不如改成如下：

public class ShapeFactory {
    
   //使用 getShape 方法获取形状类型的对象
  public Shape getShape(Class<?> clazz){
        try {
            return (IShape) clazz.getConstructor().newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        }
        return null;
    }
}

这样写在创建时也不用知道具体的类别，易于管理维护。

使用枚举优化

public enum Factory {
    CIRCLE(new Circle(),"CIRCLE"),
    RECTANGLE(new Rectangle(),"RECTANGLE"),
    SQUARE(new Square(),"SQUARE");
    
    // 成员变量  
    private Shape shape;  
    private String name;  
    
    // 普通方法  
    public static Shape getShape(String name) {  
        for (Factory c : Factory.values()) {  
            if (c.name == name) {  
                return c.shape;  
            }  
        }  
        return null;  
    } 
    // 构造方法  
    private Factory(Shape shape, String name) {  
        this.shape = shape;  
        this.name = name;  
    } 
    public String getName() {
        return name;
    }
    public Shape getShape() {
        return shape;
    }


    public void setShape(Shape shape) {
        this.shape = shape;
    }


    public void setName(String name) {
        this.name = name;
    } 
    
}


/*使用枚举类*/
Factory.getShape("CIRCLE").draw();
Factory.getShape("RECTANGLE").draw();
Factory.getShape("SQUARE").draw();

@kusirp21 讲得很好，使用枚举类优化。

增加枚举类

public enum ShapeType{
    CIRCLE,
    RECTANGLE,
    SQUARE
}

修改工厂类的工厂方法，个人建议工厂方法应该是静态方法或者采用单例模式：

public class ShapeFactory{
    public static Shape getShape(ShapeType type){
        switch(type){
            case CIRCLE:
                return new Circle();
            case RECTANGLE:
                return new Rectangle();
            case SQUARE:
                return new Square();
            default:
                throw new UnknownTypeException();
        }
    }
}

上面用到的类和接口与课程中的一样。

最后是使用示例：

public class FactoryPatternDemo {
    public static void main(String[] args) {
        //获取 Circle 的对象，并调用它的 draw 方法
        Shape shape1 = ShapeFactory.getShape(ShapeType.CIRCLE);

        //调用 Circle 的 draw 方法
        shape1.draw();

        //获取 Rectangle 的对象，并调用它的 draw 方法
        Shape shape2 = ShapeFactory.getShape(ShapeType.RECTANGLE);

        //调用 Rectangle 的 draw 方法
        shape2.draw();

        //获取 Square 的对象，并调用它的 draw 方法
        Shape shape3 = ShapeFactory.getShape(ShapeType.SQUARE);

        //调用 Square 的 draw 方法
        shape3.draw();
    }
}

工厂模式实例：

package 工厂设计模式;

public class Factory_pattern {
    public static void main(String[] args) {
        Factory facortoy = new Factory();
        Person zgr = facortoy.getInstance("zgr");
        zgr.eat();
    }
}

//人类都具有吃方法
interface  Person{
    public void eat();
}

//中国人
class zgr implements Person{

    @Override
        public void eat() {
        System.out.println("中国人吃饭用筷子");
    }
}

//印度人
class ydr implements Person{

    @Override
    public void eat() {
        System.out.println("印度人用手吃饭");
    }
}

//美国人
class mgr implements Person{

    @Override
    public void eat() {
        System.out.println("美国人用刀和叉子吃饭");
    }
}

interface Instance{
    public Person getInstance(String str);
}

class Factory implements Instance{
    @Override
    public Person getInstance(String str) {
        if(str.equals("zgr")) {
            return new zgr();
        }else if(str.equals("ydr")) {
            return new ydr();
        }else if(str.equals("mgr")) {
            return new mgr();
        }else {
            return null;
        }
    }
}

接口定义实现类的规范，通过反射工厂类进行生产，完整的一个过程就是。

接口类：

public interface Shape {
   void draw();
}

实现类：

public class Rectangle implements Shape{
   @Override   public void draw() {
      System.out.println("Rectangle");  
   }
}

public class Square implements Shape{
   @Override   public void draw() {
      System.out.println("Square");  
   }
}

工厂类:

public class ShapeFactory{
   public static Shape getClass(Class<?extends Shape> clazz) {
       Shape o = null;     
        try {
          o = (Shape) Class.forName(clazz.getName()).newInstance();       
        } catch (InstantiationException e) {
          e.printStackTrace();       
        } catch (IllegalAccessException e) {
          e.printStackTrace();       
        } catch (ClassNotFoundException e) {
          e.printStackTrace();       
        }
       return o;    
     }
  }
}

给定条件产出：

public class FactoryModeImpl {
   public static void main(String[] args) {
      Shape shape = ShapeFactory.getClass(Square.class);      
      shape.draw();  
   }
}

python 代码实现示例：

class Shape(object):
    def draw(self):
        pass
    
class RectangleImplementsShape(Shape):
    def __init__(self):
        print("this relalize Interface")
    def draw(self):
        print("Inside Rectangle::draw() method.")
        
class SquareImplementsShape(Shape):
    def __init__(self):
        print("this relalize Interface")
    def draw(self):
        print("Inside Square::draw() method.")
        
        
class CircleImplementsShape(Shape):
    def __init__(self):
        print("this relalize Interface")
    def draw(self):
        print("Inside Circle::draw() method.")
        
class ShapeFactory(object):
    def __init__(self):
        print("ShapeFactory init")
    def getShape(self,method):
        if method.lower() == 'rectangle':
            return RectangleImplementsShape()
        if method.lower() == 'square':
            return SquareImplementsShape()
        if method.lower() == 'circle':
            return CircleImplementsShape()

            
        
shapeFactory = ShapeFactory()        
        
shap1 = shapeFactory.getShape('Rectangle')
shap2 = shapeFactory.getShape('Square')
shap3 = shapeFactory.getShape('Circle')

shap1.draw()
shap2.draw()
shap3.draw()

看了大家的笔记，差点误入歧途，感谢 @kusirp21 的当头棒喝。取长补短，将工厂方法中的判断，提取到枚举中， 工厂方法使用反射创建对象。

以下是代码：

public interface Shape {    void draw();}
public class Circle implements Shape {
    @Override    public void draw() {
        System.out.println("圆形");
    }
}
public class Rectangle implements Shape {
    @Override    public void draw() {
        System.out.println("矩形");
    }
}
public class Square implements Shape {
    @Override    public void draw() {
        System.out.println("正方形");
    }
}
public enum ShapeTypeEnum {
    CIRCLE("com.example.factorymethods.Circle"),
    SQUARE("com.example.factorymethods.Square"),
    RECTANGLE("com.example.factorymethods.Rectangle");
    private String className;
    ShapeTypeEnum(String className) {
        this.className = className;
    }
    public String getClassName() {
        return className;
    }
}
public class ShapeFactory {
    private ShapeFactory(){}
    /**     
     * 
     * 创建不同的图形实例     
     * @param shapeTypeEnum     
     * @return     
     */
    public static Shape createShape(ShapeTypeEnum shapeTypeEnum){
        Shape shape = null;
        String className = shapeTypeEnum.getClassName();
        try {
            Class clazz = Class.forName(className);
            shape = (Shape)clazz.newInstance();
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return shape;
    }
}
public class FactoryMethodsDemo {
    public static void main(String[] args) {
        ShapeFactory.createShape(ShapeTypeEnum.CIRCLE).draw();
        ShapeFactory.createShape(ShapeTypeEnum.SQUARE).draw();
        ShapeFactory.createShape(ShapeTypeEnum.RECTANGLE).draw();
    }
}

反射很方便。

//示例：
//创建一个Car服务接口
interface CarService{  
  //比如为Car创建一个run()方法
  void run();
}
//创建一个工厂类
public class CarFactory{
    public static void main(String []args){
      try{
          //创建Properties对象      
          Properties properties = new Properties();
          //类加载器读取配置文件
          InputStream is = CarFactory.class.getClassLoader().getResourceAsStream("car.properties");
          properties.load(is);
          is.close();
          //通过Entry遍历<迭代Entry>
          for (Entry<Object, Object> entry : properties.entrySet()) {      
         //动态创建实现类对象,只要在配置文件中的类，都会创建并运行
         CarService cs = (CarService) Class.forName((String) entry.getValue()).newInstance();
         //接口回调
         cs.run();
       }
      }catch(Exception e){
          e.printStackTrace();
      }
  }
}

//创建类实现CarService接口
class BMW implements CarService{
    String name = "BMW";
    public void run(){
      System.out.println(name+"正在路上飞驰。。。");
    }
}
public class Benz implements CarService {
    String name = "Benz";
    public void run(){
    System.out.println(name+"正在路上飞驰。。。");
    }
}

//创建car.properties文件,将实现类的全限定名放在配置文件中
BMW=com.runoob.car.BMW
Bean=com.runoob.Benz

以上这种方法，便于维护，创建对象时，只需要该类实现Service接口，并在配置文件中添加该类的全限定名即可。类似于插件开发。

C++ 的实现方法：

#include <iostream>
using std::string;
using std::cout;
using std::endl;

class Shape{
    public:
        virtual void draw() {
            cout<<"this is virtual fun,cannot do something."<<endl;
        };
        static Shape* getShape(string shapeType);
};
class Rectangle : public Shape{
    public:
        void draw(){
            cout<<"Inside Rectangle::draw() method."<<endl;
        }
};
class Square  : public Shape{
    public:
        void draw(){
            cout<<"Inside Square::draw() method."<<endl;
        }
};
class Circle : public Shape{
    public:
        void draw(){
            cout<<"Inside Circle::draw() method."<<endl;
        }
};
Shape* Shape::getShape(string shapeType){   
      if(shapeType == "CIRCLE"){
         return new Circle();
      } else if(shapeType == "RECTANGLE"){
         return new Rectangle();
      } else if(shapeType == "SQUARE" ){
         return new Square();
      }
      return new Shape();
} 
int main(){
    Shape* shape1=NULL;
    shape1 = Shape::getShape("CIRCLE");
    shape1->draw();
    shape1 = Shape::getShape("RECTANGLE");
    shape1->draw();
    shape1 = Shape::getShape("SQUARE");
    shape1->draw();
    return 0;
}