设计模式（1）-工厂模式

工厂模式可以将其分为三种。
1.简单工厂模式。
2.工厂方法模式。
3.抽象工厂模式。

下面我们一个一个来说。

一、简单工厂模式

简单工厂模式，或称静态工厂方法模式，是类的创建模式。

简单工厂模式是由一个 工厂对象根据收到的消息决定要创建哪一个类的对象实例。工厂类负责创建的对象比较少，客户只需要传入工厂类参数，对于如何创建对象（逻辑）不关心。简单工厂模式很容易违反高内聚低耦合的原则，因此一般只在很简单的情况下使用。

public interface Shape {

public void draw();

}


public class Circle implements Shape {

    @Override
    public void draw() {
        System.out.println("Inside Circle::draw() method.");
    }

}

public class Rectangle implements Shape {

    @Override
    public void draw() {
        System.out.println("Inside Rectangle::draw() method.");
    }

}

public class Square implements Shape {

    @Override
    public void draw() {
        System.out.println("Inside Square::draw() method.");
    }

}

工厂类，根据要求创建不同的对象。

public class ShapeFactory {

    public Shape getShape(String type) {
        if ("circle".equals(type)) {
            return new Circle();
        } else if ("rectangle".equals(type)) {
            return new Rectangle();
        } else if ("square".equals(type)) {
            return new Square();
        } else {
            return null;
        }
    }

}

在使用时，调用ShapeFactory的getShape方法就行。

public class FactoryPatternDemo {

    public static void main(String[] args) {
        ShapeFactory shapeFactory = new ShapeFactory();
        shapeFactory.getShape("circle").draw();
        shapeFactory.getShape("rectangle").draw();
        shapeFactory.getShape("square").draw();
    }

}

但简单工厂模式对“开-闭“原则的支持不够。如果有新的产品加入，就需要修改工厂类，加入必要的逻辑。

二、工厂方法模式

工厂方法模式，又叫虚拟构造子模式，或多态性工厂模式。工厂方法模式的用意是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类中。
工厂方法是简单工厂的进一步抽象和推广。
优点：创建对象的接口，让子类决定具体实例化的对象，把简单的内部逻辑判断移到了客户端。工厂方法模式克服了简单工厂所违背的开闭原则的缺点，又保持了封装对象创建过程的优点。扩展性高，想要增加一个产品，只要扩展一个工厂类就可以。

 public interface ShapeFactory {

    public Shape getShape();

}

public class CircleFactory implements ShapeFactory {

    @Override
    public Shape getShape() {
        return new Circle();
    }

}

public class RectangleFactory implements ShapeFactory {
    @Override
    public Shape getShape() {
        return new Rectangle();
    }

}

public class FactoryMethodDemo {
    public static void main(String[] args) {
        ShapeFactory circleFactory = new CircleFactory();
        circleFactory.getShape().draw();
        ShapeFactory rectangleFactory = new RectangleFactory();
        rectangleFactory.getShape().draw();
        ShapeFactory squareFactory = new SquareFactory();
            }

}

三、抽象工厂模式

抽象工厂是围绕一个超级工厂创建其他工厂，该超级工厂又称为其他工厂的工厂。提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。
举例：

 public interface Button {
    public void processEvent();

}

public interface Text {
    public void getWholeText();

}

public class LinuxButton implements Button {
    @Override
    public void processEvent() {
        System.out.println("Inside LinuxButton::processEvent() method.");
    }

}

public class WindowsButton implements Button {
    @Override
    public void processEvent() {
        System.out.println("Inside WindowsButton::processEvent() method.");
    }

}

public class LinuxText implements Text {
    @Override
    public void getWholeText() {
        System.out.println("Inside LinuxText::getWholeText() method.");
    }

}

public class WindowsText implements Text {
    @Override
    public void getWholeText() {
        System.out.println("Inside WindowsText::getWholeText() method.");
    }

}

public interface AbstractFactory {
    public Button createButton();
    public Text createText();

}

public class LinuxFactory implements AbstractFactory {
    @Override
    public Button createButton() {
        return new LinuxButton();
    }
    @Override
    public Text createText() {
        return new LinuxText();
    }

}

public class WindowsFactory implements AbstractFactory {

    @Override
    public Button createButton() {
        return new WindowsButton();
    }

    @Override
    public Text createText() {
        return new WindowsText();
    }

}

public class AbstractFactoryDemo {

    public static void main(String[] args) {
        AbstractFactory linuxFactory = new LinuxFactory();
        linuxFactory.createButton().processEvent();
        linuxFactory.createText().getWholeText();
        AbstractFactory windowsFactory = new WindowsFactory();
        windowsFactory.createButton().processEvent();
        windowsFactory.createText().getWholeText();
    }

}