三种工厂设计模式看这篇就够了

时间 2020-07-12

标签三种工厂设计模式看这够了繁體版

原文原文链接

前言

面试被提问到三种工厂模式回答得十分模糊因而花了一上午时间梳理并总结 ,为了方便你们实践,我把代码都编写在一个.java里面,复制便可食用.写完总结了一下,三种工厂设计模式产品和工厂对应关系相似,多对一,一对一,以及一对多java

简单工厂模式

首先介绍简单工厂模式，它的主要特色是须要在工厂类中作判断，从而创造相应的产品。当增长新的产品时，就须要修改工厂类。面试

举个例子。有一家生产处理器核的厂家，它只有一个工厂，可以生产两种型号的处理器核。客户须要什么样的处理器核，必定要显示地告诉生产工厂。下面给出一种实现方案。设计模式

流程图:ide

测试表代码函数

package sample;

//简单工厂代码demo
public class FactoryDemo {

    interface Product{
        public void saySmoe() ;
    }

    static class ProductA implements Product{
        @Override
        public void saySmoe() {
            System.out.println("say ProductA");
        }
    }
    static class ProductB implements Product{
        @Override
        public void saySmoe() {
            System.out.println("say ProductB");
        }
    }

    static class ProductFactory{
        public static Product getProduct(String name) {
            if("productA".equals(name)) {
                return new ProductA();
            }else if("productB".equals(name)) {
                return new ProductB();
            }else {
                return null;
            }


        }
    }
    public static void main(String[] args) {
        // 使用工厂模式 下降使用者与被使用者之间的耦合
        //Product productA = new productA();
        // 将使用者与被使用者之间的依赖转移到使用者与工厂之间的依赖
        Product productA = ProductFactory.getProduct("productA");
        if(null!=productA) {
            productA.saySmoe();
        }
    }
}

结果:测试

say ProductA

工厂模式

简单工厂模式虽然方便,可是每次添加新的产品就须要修改工厂类。这就违反了开放封闭原则：软件实体（类、模块、函数）能够扩展，可是不可修改。因而，工厂方法模式出现了。所谓工厂方法模式，是指定义一个用于建立对象的接口，让子类决定实例化哪个类。Factory Method使一个类的实例化延迟到其子类。ui

流程图:spa

测试表代码设计

package sample;

//简单工厂代码demo
public class FactoryDemo {

    interface Product{
        public void saySmoe() ;
    }

    interface AbstarctFactory{
        Product getProduct();
    }

    static class ProductA implements Product{
        @Override
        public void saySmoe() {
            System.out.println("say ProductA");
        }
    }
    static class ProductB implements Product{
        @Override
        public void saySmoe() {
            System.out.println("say ProductB");
        }
    }

    static class ProductFactoryA implements  AbstarctFactory{
        @Override
        public Product getProduct() {
            return new ProductA();
        }
    }

    static class ProductFactoryB implements  AbstarctFactory{
        @Override
        public Product getProduct() {
            return new ProductB();
        }
    }
    public static void main(String[] args) {
        AbstarctFactory productFactoryA = new ProductFactoryA();
        AbstarctFactory productFactoryB = new ProductFactoryB();
        productFactoryA.getProduct().saySmoe();
        productFactoryB.getProduct().saySmoe();

    }
}

抽象工厂模式

既然有了简单工厂模式和工厂方法模式，为何还要有抽象工厂模式呢？它到底有什么做用呢？仍是举这个例子，这家公司的技术不断进步，不只能够生产单核处理器，也能生产多核处理器。如今简单工厂模式和工厂方法模式都鞭长莫及。抽象工厂模式登场了。它的定义为提供一个建立一系列相关或相互依赖对象的接口，而无需指定它们具体的类。具体这样应用，这家公司仍是开设两个工厂，一个专门用来生产A型号的单核多核处理器，而另外一个工厂专门用来生产B型号的单核多核处理器code

流程图:

package sample;

//简单工厂代码demo
public class AbstractFactoryDemo {

    interface ProductA{
        public void saySmoe() ;
    }

    interface ProductB{
        public void eatFood() ;
    }

    interface AbstarctFactory{
        ProductA getProductA();
        ProductB getProductB();
    }

    static class ProductA1 implements ProductA{
        @Override
        public void saySmoe() {
            System.out.println("say ProductA1");
        }
    }
    static class ProductA2 implements ProductA{
        @Override
        public void saySmoe() {
            System.out.println("say ProductA2");
        }
    }
    static class ProductB1 implements ProductB{
        @Override
        public void eatFood() {
            System.out.println("say ProductB1");
        }
    }
    static class ProductB2 implements ProductB{
        @Override
        public void eatFood() {
            System.out.println("say ProductB2");
        }
    }

    static class ProductFactory1 implements  AbstarctFactory{

        @Override
        public ProductA getProductA() {
            return new ProductA1();
        }

        @Override
        public ProductB getProductB() {
            return new ProductB1();
        }
    }

    static class ProductFactory2 implements  AbstarctFactory{

        @Override
        public ProductA getProductA() {
            return new ProductA2();
        }

        @Override
        public ProductB getProductB() {
            return new ProductB2();
        }
    }
    public static void main(String[] args) {
        //构造一个制做 产品A1 和 产品B1的的工厂
        AbstarctFactory abstarctFactory1 = new ProductFactory1();
        abstarctFactory1.getProductA().saySmoe();
        abstarctFactory1.getProductB().eatFood();

        System.out.println("===================");
        //构造一个制做 产品A2 和 产品B2的的工厂
        AbstarctFactory abstarctFactory2 = new ProductFactory2();
        abstarctFactory2.getProductA().saySmoe();
        abstarctFactory2.getProductB().eatFood();
    }
}

结果:

say ProductA1
say ProductB1
===================
say ProductA2
say ProductB2

补一句,今天周六,你们注意休息🍻🍻🍻

要是能为您提供帮助，请给予支持(关注、点赞、分享)，虫虫蟹蟹你们了！