简单工厂模式 (Simple Factory Pattern)

模式名称：简单方法模式（Simple Factory Pattern）

问题：想要完成面向对象编程，我们就希望将对象的创建和使用分离。依赖倒置原则告诉我们，要对抽象进行编程，不要对实现进行编程，客户不关心披萨饼是怎样被创建出来的。因此我们只需要为对象封装一个创建型接口，甚至可以隐藏对象的具体类型，客户端程序只需要面向抽象编程即可，而不需要关注实际使用对象的具体类型。简单工厂模式正是抱着这个原则被设计了出来。

解决方案：设计一个工厂类，让所有需要获取的对象都通过工厂类的预留的接口进行获取。

效果：显然它足够简单，但是又违反了开闭原则这个面向对象关键性的原则，如果要引入新的产品，就要对工厂类的内部代码进行修改。

public class Main {
    
    public static void main(String[] args) {
        ShapeFactory shapeFactory = new ShapeFactory();
        
        Shape shape1 = shapeFactory.getShape("CIRCLE");
        shape1.draw();
   
        Shape shape2 = shapeFactory.getShape("RECTANGLE");
        shape2.draw();
   
        Shape shape3 = shapeFactory.getShape("SQUARE");
        shape3.draw();
    }
}

class ShapeFactory {
    
    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;
    }
}

interface Shape {
    void draw();
}

class Rectangle implements Shape {
    
    @Override
    public void draw() {
        System.out.println("Inside Rectangle::draw() method.");
    }
}
class Square implements Shape {
    
    @Override
    public void draw() {
        System.out.println("Inside Square::draw() method.");
    }
}
class Circle implements Shape {
    
    @Override
    public void draw() {
        System.out.println("Inside Circle::draw() method.");
    }
}