乐趣区

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

前言

面试被发问到三种工厂模式 答复得非常含糊 于是花了一上午工夫梳理并总结 , 为了不便大家实际, 我把代码都编写在 一个.java 外面, 复制即可食用. 写完总结了一下, 三种工厂设计模式产品和工厂对应关系相似, 多对一, 一对一, 以及一对多

简略工厂模式

首先介绍简略工厂模式,它的次要特点是须要在工厂类中做判断,从而发明相应的产品。当减少新的产品时,就须要批改工厂类。

举个例子。有一家生产处理器核的厂家,它只有一个工厂,可能生产两种型号的处理器核。客户须要什么样的处理器核,肯定要显示地通知生产工厂。上面给出一种实现计划。

流程图:

测试表代码

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 使一个类的实例化提早到其子类。

流程图:

测试表代码

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 型号的单核多核处理器

流程图:

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

补一句, 明天周六, 大家留神劳动????????????

要是能为您提供帮忙,请给予反对 (关注、 点赞、分享),虫虫蟹蟹大家了!

退出移动版