设计模式——工厂模式

此博文只用于自学记录。

本文将所有的工厂方法进行记录学习。

简单工厂

简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

缺点：由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。

简单工厂例子：

我们大多数使用点外卖平台有某团平台以及某饿平台，今天使用简单工厂进行模拟。

public interface PlatForm {
    void getName();
}

public class BeautifulPlatForm implements PlatForm{

    @Override
    public void getName() {
        System.out.println("某团平台");
    }
}

public class HungryPlatForm implements PlatForm{

    @Override
    public void getName() {
        System.out.println("某饿平台");
    }
}

public class PlatFormFactory {
    public static final String BEAUTIFUL_PLATFORM = "beautiful";
    public static final String HUNGRY_PLATFORM = "hungry";
    private String name = "";

    public PlatFormFactory(String name) {
        this.name = name;
    }

    public PlatForm createPlatForm() {
        if (Objects.equals(this.name, BEAUTIFUL_PLATFORM)) {
            return new BeautifulPlatForm();
        } else if (Objects.equals(this.name, HUNGRY_PLATFORM)) {
            return new HungryPlatForm();
        } else {
            throw new RuntimeException("sorry");
        }
    }

    public void order() {
        System.out.println("下单");
    }
}

public class Client {
    public static void main(String[] args) {
        String type = "beautiful";
        PlatFormFactory platFormFactory = new PlatFormFactory(type);
        PlatForm platForm = platFormFactory.createPlatForm();
        platForm.getName();
        platFormFactory.order();
        System.out.println("--------------------");
        type = "hungry";
        PlatFormFactory platFormFactory1 = new PlatFormFactory(type);
        PlatForm platForm1 = platFormFactory1.createPlatForm();
        platForm1.getName();
        platFormFactory1.order();
    }
}

 从上面代码可以看到如果想要增加一个平台就需要修改factory类，而且所有对象的创建都在facory类当中，factory类在该模式中承担了比较重的责任。

工厂方法

工厂方法模式(Factory Method Pattern)简称工厂模式，也叫虚拟构造器(Virtual Constructor)模式或者多态工厂(Polymorphic Factory)模式，它属于类创建型模式。

​

在工厂方法模式中，工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象，这样做的目的是将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。

工厂方法模式是简单工厂模式的进一步抽象和推广

工厂方法模式保持了简单工厂模式的优点，并克服了它的缺点

核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给其子类去完成

例子：还是上面点外卖的平台，我们只需要进行修改即可。

 完整代码再次上传

public interface PlatForm {
    void getName();
    default void order(){
        System.out.println("下单成功");
    }
}

public class BeautifulPlatForm implements PlatForm {

    @Override
    public void getName() {
        System.out.println("某团平台");
    }
}

public class HungryPlatForm implements PlatForm {

    @Override
    public void getName() {
        System.out.println("某饿平台");
    }
}

public interface IFactory {
    PlatForm createPlatForm();
}

public class BeautifulPlatFormFactory implements IFactory{
    @Override
    public PlatForm createPlatForm() {
        return new BeautifulPlatForm();
    }
}

public class HungryPlatFormFactory implements IFactory{
    @Override
    public PlatForm createPlatForm() {
        return new HungryPlatForm();
    }
}

public class Client {
    public static void main(String[] args) {
        IFactory beautifulPlatFormFactory = new BeautifulPlatFormFactory();
        PlatForm platForm = beautifulPlatFormFactory.createPlatForm();
        platForm.getName();
        platForm.order();
    }
}

抽象工厂

抽象工厂模式（Abstract Factory Pattern）是设计模式中的创建型模式，用于产品族的构建。抽象工厂是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体情况下，创建多个产品族中的产品对象。
可以简单理解的是工厂方法是抽象工厂的一种例子。

​

例子：

某团和某饿除了可以点外卖之外，假设他们的平台都可以进行打车。 

参考

public interface CarPlatForm {
    void getName();
}

public class BeautifulCarPlatForm implements CarPlatForm{
    @Override
    public void getName() {
        System.out.println("某团打车平台");
    }
}

public class HungryCarPlatForm implements CarPlatForm{
    @Override
    public void getName() {
        System.out.println("某饿打车平台");
    }
}

public interface TakeOutPlatForm {
    void getName();
    default void order(){
        System.out.println("下单成功");
    }
}

public class BeautifulTakeOutPlatForm implements TakeOutPlatForm {

    @Override
    public void getName() {
        System.out.println("某团外卖平台");
    }
}

public class HungryTakeOutPlatForm implements TakeOutPlatForm {

    @Override
    public void getName() {
        System.out.println("某饿外卖平台");
    }
}

public interface AbstractFactory {
    CarPlatForm createConcreteCar();
    TakeOutPlatForm createConcreteTakOut();
}

public class BeautifulFactory implements AbstractFactory{

    @Override
    public CarPlatForm createConcreteCar() {
        return new BeautifulCarPlatForm();
    }

    @Override
    public TakeOutPlatForm createConcreteTakOut() {
        return new BeautifulTakeOutPlatForm();
    }
}

public class HungryFactory implements AbstractFactory{
    @Override
    public CarPlatForm createConcreteCar() {
        return new HungryCarPlatForm();
    }

    @Override
    public TakeOutPlatForm createConcreteTakOut() {
        return new HungryTakeOutPlatForm();
    }
}

public class Client {
    public static void main(String[] args) {
        AbstractFactory abstractFactory = new BeautifulFactory();
        CarPlatForm concreteCar = abstractFactory.createConcreteCar();
        TakeOutPlatForm concreteTakOut = abstractFactory.createConcreteTakOut();
        concreteCar.getName();
        concreteTakOut.getName();
    }
}

 

设计模式-工厂方法模式和抽象工厂模式 - 知乎

Java工厂模式（简单工厂、工厂方法、抽象工厂）详解_java工厂模式三种详解-CSDN博客

抽象工厂模式 java实例 tclhaier_完整案例分析再加知识整合——艾特工厂方法模式，超详细的...-CSDN博客