设计模式--三种工厂模式

工厂模式

把对类的创建初始化全都交给一个工厂来执行，而用户不需要去关心创建的过程是什么样的，只用告诉工厂我想要什么就行了。而这种方法的缺点也很明显，违背了设计模式的开闭原则，因为如果你要增加工厂可以初始化的类的时候，你必须对工厂进行改建。
示例：
定义一个接口代表形状，然后创建形状接口的实现类，有长方形正方形和圆形。

public interface Shape {
    void draw();
}

public class Ractangle  implements Shape{
    @Override
    public void draw() {
        System.out.println("inside Ractangle::draw() method");
    }
}

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

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

工厂模式核心是一个Factory类，基于传递给getShape()的对象决定创建的对象类型。

public class ShapeFactory {
    public Shape getShape(String shapeType){
        if (shapeType == null) {
           return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")){
            return  new Circle();
        }
        if (shapeType.equalsIgnoreCase("SQUARE")){
            return  new Square();
        }
        if (shapeType.equalsIgnoreCase("RACTANGLE")){
            return  new Ractangle();
        }
        return null;
    }
}

工厂方法模式

设计一个工厂的接口，你想要什么东西，就写个类继承于这个工厂，这样就不用修改什么，直接添加就行了。就相当于，这个工厂是用来生形状的，而要什么形状要具体分到了每个车间，如果新多了一种形状，直接新增一个形状工厂就行了。
示例：
工厂方法模式给每个类都创建了一个自己的工厂，有新增的时候，新增后再添加对应的工厂即可。（基础形状类省略）

public interface ShapeFactory {
    public Shape getShapeFactory();
}

public class RactangleFactory implements ShapeFactory {
    @Override
    public Shape getShapeFactory() {
        return new Ractangle();
    }
}

public class SquareFactory implements ShapeFactory {
    @Override
    public Shape getShapeFactory() {
        return new Square();
    }
}

public class CircleFactory implements ShapeFactory {
    @Override
    public Shape getShapeFactory() {
        return new Circle();
    }
}

//新增梯形
public class TrapeziumFactory implements ShapeFactory {
    @Override
    public Shape getShapeFactory() {
        return new Trapezium();
    }
}

main方法验证：

public class FactoryMain {
    public static void main(String[] args) {
        Shape circle = new CircleFactory().getShapeFactory();
        circle.draw();
        Shape square = new SquareFactory().getShapeFactory();
        square.draw();
        Shape ractangle = new RactangleFactory().getShapeFactory();
        ractangle.draw();
        Shape trapezium = new TrapeziumFactory().getShapeFactory();
        trapezium.draw();
    }
}

inside Circle::draw() method
inside Square::draw() method
inside Ractangle::draw() method
inside Trapezium::draw() method

抽象工厂模式

抽象工厂模式可以理解为工厂的工厂，用来创建其他工厂。当使用抽象工程模式时，我们首先使用超级工厂创建出工厂然后使用创建出的工厂去创建对象。抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构。在编程中，通常一个产品结构，表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。
示例：
我们上述例子有形状，包含正方形长方形圆形等等，现在我们要创建打印机，包含纸张打印机，网络打印机和屏幕打印机。
形状相关代码不变。

public interface Printer {
    void print();
}

public class PaperPrinter implements Printer {
    @Override
    public void print() {
        System.out.println("PaperPrinter");
    }
}

public class WebPrinter implements Printer {
    @Override
    public void print() {
        System.out.println("WebPrinter");
    }
}

public class ScreenPrinter implements Printer {
    @Override
    public void print() {
        System.out.println("ScreenPrinter");
    }
}

分别创建抽象工厂和对象工厂。

abstract interface AbstractFactory {
    abstract Shape getShape(String shape);
    abstract Printer getPrinter(String type);
}

public class ShapeFactory implements AbstractFactory {
    @Override
    public Shape getShape(String share) {
        if (share == null) {
            return null;
        }
        if (share.equalsIgnoreCase("CIRCLE")){
            return new Circle();
        }
        if (share.equalsIgnoreCase("SQUARE")){
            return new Square();
        }
        if (share.equalsIgnoreCase("RACTANGLE")){
            return new Ractangle();
        }
        return null;
    }

    @Override
    public Printer getPrinter(String type) {
        return null;
    }
}

public class PrinterFactory implements AbstractFactory{
    @Override
    public Shape getShape(String shape) {
        return null;
    }

    @Override
    public Printer getPrinter(String type) {
        if (type == null) {
            return null;
        }
        if (type.equalsIgnoreCase("WEBPRINTER")){
            return new WebPrinter();
        }
        if (type.equalsIgnoreCase("SCREENPRINTER")){
            return new ScreenPrinter();
        }
        if (type.equalsIgnoreCase("PAPERPRINTER")){
            return new PaperPrinter();
        }
        return null;
    }
}

main方法验证：

public class FactoryMain {
    public static void main(String[] args) {
        AbstractFactory abstractFactory = Factorys.getFactory("printer");
        Printer printer1 = abstractFactory.getPrinter("webprinter");
        printer1.print();

        AbstractFactory abstractFactory1 = Factorys.getFactory("shape");
        Shape shape1 = abstractFactory1.getShape("circle");
        shape1.draw();
    }
}