简单工厂模式

基本介绍

1. 简单工厂模式是创建型模式，是工厂模式的一种，简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例
2. 简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为
3. 在软件开发中，当我们会用到大量的创建某种，某类或者某批对象时。就会用到工厂模式。

看一个披萨的项目，要便于披萨种类的扩展，要便于维护

1. 披萨的种类很多（比如GreekPizz，CheesePizz）
2. 披萨的制作有prepare，bake，cut，box
3. 完成披萨店订购功能

代码实现

Pizza类

package com.itpupil.factory.simplefactory.pizzastore.pizza;
//将pizza类做成抽象类
public abstract class Pizza {
    protected String name;//披萨名字
    //准备原材料，不同的披萨不一样，因此我们做成抽象方法
    public abstract void prepare();
    public void bake(){
        System.out.println(name+=" baking");
    }
    public void cut(){
        System.out.println(name+=" cutting");
    }
    public void box(){
        System.out.println(name+=" boxing");
    }
    public void setName(String name) {
        this.name = name;
    }
}

CheesePizza类

package com.itpupil.factory.simplefactory.pizzastore.pizza;
public class CheesePizza extends Pizza {

    @Override
    public void prepare() {
        System.out.println("给制作奶酪披萨，准备原材料");
    }
}

GreekPizza类

package com.itpupil.factory.simplefactory.pizzastore.pizza;

public class GreekPizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("给希腊披萨准备原材料");
    }
}

PizzaStore类

package com.itpupil.factory.simplefactory.pizzastore;
import com.itpupil.factory.simplefactory.pizzastore.order.OrderPizza;

//相当于一个客户端,发出订购
public class PizzaStore {
    public static void main(String[] args) {
        new OrderPizza();
    }
}

OrderPizza类

package com.itpupil.factory.simplefactory.pizzastore.order;

import com.itpupil.factory.simplefactory.pizzastore.pizza.CheesePizza;
import com.itpupil.factory.simplefactory.pizzastore.pizza.GreekPizza;
import com.itpupil.factory.simplefactory.pizzastore.pizza.Pizza;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class OrderPizza {
    //构造器
    public OrderPizza(){
        Pizza pizza = null;
        String orderType;
        do {
            orderType=getType();
            if (orderType.equals("greek")){
                pizza = new GreekPizza();
                pizza.setName("希腊披萨");
            }else if(orderType.equals("cheese")){
                pizza = new CheesePizza();
                pizza.setName("奶酪披萨");
            }else {
                break;
            }
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }while (true);
    }

    //写一个方法，可以获取客户端希望订购的披萨种类
    private String getType(){
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("input pizza type:");
        String str = null;
        try {
            str = bufferedReader.readLine();
        } catch (IOException e) {
            e.printStackTrace();
            str="";
        }
        return str;
    }
}

优点缺点

1. 优点是比较好理解，简单易操作

2. 缺点是违反了设计模式的ocp原则，即对拓展开放，对修改关闭，即当我们给类增加新功能的时候，尽量不要修改代码，或者尽可能少修改代码。

3. 比如我们这时要新增加一个Pizza的种类（XXXX披萨），我们需要作出如下修改

   //新增类
   public class XPizza extends Pizza{
   	public void prepare(){
   	  System.out.println("给X披萨准备原材料");
   	}
   }
   
   //OrderPizza类新增if条件
   else if(orderType.equals("cheese")){
   	pizza = new XPizza();
       pizza.setName("X披萨");
   }
   

改进思路

分析：修改代码可以接受，但是如果我们在其他的地方也有创建Pizz的代码，就意味着，也需要修改，而创建pizz的代码，往往有多处。

思路：把创建pizza对象封装到一个类中，这样我们有新的pizza种类时，只需要修改该类就可，其他有创建到Pizza对象的代码就不需要修改了----》简单工厂模式

SimpleFactory类

package com.itpupil.factory.simplefactory.pizzastore.order;

import com.itpupil.factory.simplefactory.pizzastore.pizza.CheesePizza;
import com.itpupil.factory.simplefactory.pizzastore.pizza.GreekPizza;
import com.itpupil.factory.simplefactory.pizzastore.pizza.Pizza;

//简单工厂类
public class SimpleFactory {

    Pizza pizza = null;
    public Pizza createPizza(String orderType){
        System.out.println("使用简单工厂模式");
        if (orderType.equals("cheese")){
            pizza = new CheesePizza();
            pizza.setName("奶酪披萨");
        }else if (orderType.equals("greek")){
            pizza= new GreekPizza();
            pizza.setName("希腊披萨");
        }
        return pizza;
    }
}

OrderPizza 类

package com.itpupil.factory.simplefactory.pizzastore.order;

import com.itpupil.factory.simplefactory.pizzastore.pizza.CheesePizza;
import com.itpupil.factory.simplefactory.pizzastore.pizza.GreekPizza;
import com.itpupil.factory.simplefactory.pizzastore.pizza.Pizza;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class OrderPizza {
    public OrderPizza(SimpleFactory simpleFactory){
        setSimpleFactory(simpleFactory);
    }
    SimpleFactory simpleFactory;
    Pizza pizza = null;
    public void setSimpleFactory(SimpleFactory simpleFactory){
        String orderType="";
        this.simpleFactory =simpleFactory;
        do {
            orderType=getType();
            pizza = this.simpleFactory.createPizza(orderType);
            if (pizza != null){
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }else {
                System.out.println("订购披萨失败");
                break;
            }
        }while (true);
    }
    //写一个方法，可以获取客户端希望订购的披萨种类
    private String getType(){
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("input pizza type:");
        String str = null;
        try {
            str = bufferedReader.readLine();
        } catch (IOException e) {
            e.printStackTrace();
            str="";
        }
        return str;
    }
}

工厂模式

基本介绍

概述

? 工厂模式是对简单工厂模式的进一步抽象化，其好处的可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则

优点

• 用户只需要知道具体工厂的名称就可以得到所要的产品，无需知道产品的具体创建过程。
• 灵活性增加，对于新产品的创建，只需要多写一个相应的工厂类。
• 满足迪米特法则，依赖倒置和里氏替换原则

缺点

• 类的个数容易过多，增加复杂度
• 增加了系统的抽象性和理解难度
• 抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决。

模式的结构与实现

? 工厂方法模式由抽象工厂、具体工厂、抽象产品和具体产品等4个要素构成。

结构

1. 抽象工厂：提供了创建产品的接口，调用者通过它的访问具体工厂的工厂方法newProduct()来创建产品。
2. 具体工厂：主要实现抽象工厂中的抽象方法，完成具体产品的创建。
3. 抽象产品：定义了产品的规范，描述了产品的主要特性和功能。
4. 具体产品：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应

其结构如图1所示

实现

//抽象工厂：提供了产品的生成方法
public interface AbstractFactory {
    Product createProduct();
}
//产品接口
public interface Product {
    public void show();
}
//具体工厂一
public class ConcreteFactory1 implements AbstractFactory{
    @Override
    public Product createProduct() {
        System.out.println("具体工厂1");
        return new ConcreteProduct1();
    }
}
//具体工厂二
public class ConcreteFactory2 implements  AbstractFactory {
    @Override
    public Product createProduct() {
        System.out.println("具体工厂2");
        return new ConcreteProduct2();
    }
}
//具体产品1
public class ConcreteProduct1 implements Product {
    @Override
    public void show() {
        System.out.println("生成具体产品一");
    }
}
//具体产品2
public class ConcreteProduct2 implements Product{

    @Override
    public void show() {
        System.out.println("生产具体产品2");
    }
}
//调用
public class App {
    public static void main(String[] args) {
        AbstractFactory abstractFactory = new ConcreteFactory1();
        Product product = abstractFactory.createProduct();
        product.show();
    }
}

抽象工厂模式

基本介绍

1. 抽象工厂模式，定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类
2. 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
3. 从设计层面看，抽象工厂模式就是对简单工厂模式的改进（或者称为进一步的抽象）。
4. 将工厂抽象成两层，AbsFactory(抽象工厂)和具体实现的工厂子类，程序员可以根据创建对象类型使用对应的工厂子类，这样将单个的简单工厂变成了工厂簇，更利于代码的维护和拓展。

代码实现

例：pizza

//一个抽象工厂模式的抽象层
public interface AbsFactory {
    Pizza createPizza(String orderType);
}
//具体实现类
public class BjFactory implements AbsFactory{
    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        switch (orderType){
            case "cheese":
                pizza = new BjCheesePizza();
                break;
            case "greek":
                pizza = new BjGreekPizza();
                break;
        }
        return pizza;
    }
}
//将pizza类做成抽象类
public abstract class Pizza {
    protected String name;//披萨名字
    //准备原材料，不同的披萨不一样，因此我们做成抽象方法
    public abstract void prepare();
    public void bake(){
        System.out.println(name+=" baking");
    }
    public void cut(){
        System.out.println(name+=" cutting");
    }
    public void box(){
        System.out.println(name+=" boxing");
    }
    public void setName(String name) {
        this.name = name;
    }
}

public class BjCheesePizza extends Pizza{
    @Override
    public void prepare() {
        setName("北京奶酪披萨");
        System.out.println("北京奶酪披萨准备制作");
    }
}

工厂模式的意义

? 将实例化对象的代码提取出来，放到一个类中统一管理和维护。达到和主项目的依赖关系的解耦，从而提高项目的拓展和维护性

工厂模式（五）

原文：https://www.cnblogs.com/It-smallstudent/p/14835744.html