Modo de fábrica
Veamos primero un requisito específico
Mire un proyecto de pizza: Para facilitar la expansión de tipos de pizza y para facilitar el mantenimiento
1) Hay muchos tipos de pizza (como GreekPizz (griego), CheesePizz (queso), etc.)
2) La pizza se hace con preparar ( material de preparación), hornear (hornear) hornear), cortar (cortar), caja (empaquetar)
3) Completar la función de pedido de pizzería.
Cual es la forma tradicional
Código
Clase abstracta de pizza
/**
* @author 王庆华
* @version 1.0
* @date 2020/12/21 20:06
* @Description TODO
* @pojectname 披萨抽象类 设置为抽象类
*/
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;
}
}
Dos tipos diferentes de pizza.
public class CheesePizza extends Pizza {
@Override
public void prepare() {
System.out.println("准备制作奶酪披萨的原材料");
}
}
public class GreekPizza extends Pizza {
@Override
public void prepare() {
System.out.println("给希腊披萨准备原材料");
}
}
Clase de iniciación de pedidos
/**
* @author 王庆华
* @version 1.0
* @date 2020/12/21 20:14
* @Description TODO
* @pojectname 订购披萨代码
*/
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制作过程
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
}while (true);
}
//获取客户订购的披萨种类
private String getType(){
try {
BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza 种类:");
String str = strin.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
}
Categoría principal: pizzería
/**
* @author 王庆华
* @version 1.0
* @date 2020/12/21 20:22
* @Description TODO
* @pojectname 披萨店客户端，发起订购的类(主类)
*/
public class PizzaStore {
public static void main(String[] args) {
OrderPizza orderPizza = new OrderPizza();
}
}
Ventajas y problemas
La ventaja es que es más fácil de entender y operar.
La desventaja es que viola el principio ocp del patrón de diseño, es decir, está abierto para extensión y cerrado para modificación . Es decir, cuando agregamos nuevas funciones a la clase, intentamos no modificar el código, o modificar el código lo menos posible.
Por ejemplo, si queremos agregar un nuevo tipo de pizza (pizza de pimiento) en este momento, debemos realizar los siguientes cambios:
1. Agregue pizza de pimienta, herede la clase de pizza abstracta
public class PepperPizza extends Pizza {
@Override
public void prepare() {
System.out.println("给胡椒披萨准备原材料");
}
}
2. Debemos agregar la lógica de juzgar si es pizza de pimientos o no en OrderPizza
if (orderType.equals("greek")){
pizza = new GreekPizza();
pizza.setName("希腊披萨");
}else if (orderType.equals("cheese")){
pizza = new CheesePizza();
pizza.setName("奶酪披萨");
}else if (orderType.equals("pepper")){
pizza = new PepperPizza();
pizza.setName("胡椒披萨");
} else {
break;
}
Muchas sucursales se han unido a nosotros, y hay 2,3,4,5,6 ... ¿Qué tal OrderPizza? ¿No hay que cambiarlo todo?
Mejorar
Análisis : Modificar el código es aceptable, pero si también tenemos el código para crear Pizza en otros lugares, significa que también necesitamos modificarlo y, a menudo, hay varios lugares para crear el código para Pizza.
** Idea: ** Encapsular el objeto Pizza creado en una clase, de modo que cuando tengamos un nuevo tipo de Pizza, solo necesitemos modificar la clase, y no sea necesario modificar otros códigos que crean objetos Pizza === = > Modo de fábrica simple
Patrón de fábrica simple
introducción básica
Modo de fábrica estático
1) El modelo de fábrica simple pertenece al modelo de creación , que es una especie de modelo de fábrica. El patrón de fábrica simple es que un objeto de fábrica determina qué instancia de una clase de producto se crea . El modo de fábrica simple es el modo más simple y práctico de la familia de modos de fábrica
2) Patrón de fábrica simple: define una clase para crear objetos, y esta clase encapsula el comportamiento de los objetos instanciados (código)
3) En el desarrollo de software, cuando utilicemos una gran cantidad de objetos para crear un determinado tipo, un determinado tipo o un determinado lote de objetos, se utilizará el modelo de fábrica .
Código
/**
* @author 王庆华
* @version 1.0
* @date 2020/12/21 20:43
* @Description TODO
* @pojectname 简单工厂用来管理Pizza的生产
*/
public class SimpleFactory {
/**
* 根据我们的pizza类型，返回一个该类型的实例对象
* @param orderType pizza类型
* @return
*/
public Pizza createPizza(String orderType){
Pizza pizza = null;
System.out.println("使用简单工厂模式");
if (orderType.equals("greek")){
pizza = new GreekPizza();
pizza.setName("希腊披萨");
}else if (orderType.equals("cheese")){
pizza = new CheesePizza();
pizza.setName("奶酪披萨");
}else if (orderType.equals("pepper")){
pizza = new PepperPizza();
pizza.setName("胡椒披萨");
}
return pizza;
}
}
Cambios en OrderPizza
/**
* @author 王庆华
* @version 1.0
* @date 2020/12/21 20:14
* @Description TODO
* @pojectname 订购披萨代码
*/
public class OrderPizza {
//定义简单工厂对象
SimpleFactory simpleFactory;
Pizza pizza = null;
public void setSimpleFactory(SimpleFactory simpleFactory) {
String orderType = "";//orderType用户输入pizza类型
this.simpleFactory = simpleFactory;//设置一个简单工厂对象
do {
orderType = getType();//获取用户订购的pizza类型
pizza = this.simpleFactory.createPizza(orderType);
//输出制作pizza信息
if (pizza != null){
//订购成功
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
}else {
System.out.println("预定失败，请检查是不是没有这个pizza类型");
break;
}
}while(true);
}
//构造器
public OrderPizza(SimpleFactory simpleFactory){
setSimpleFactory(simpleFactory);
}
//获取客户订购的披萨种类
private String getType(){
try {
BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza 种类:");
String str = strin.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
}
Cambios de cliente
/**
* @author 王庆华
* @version 1.0
* @date 2020/12/21 20:22
* @Description TODO
* @pojectname 披萨店客户端，发起订购的类(主类)
*/
public class PizzaStore {
public static void main(String[] args) {
//使用简单工厂模式订购
new OrderPizza(new SimpleFactory());
System.out.println("退出程序");
}
}
Entendamos: En primer lugar, tenemos nuevos códigos de diferentes tipos de pizza, transferidos de OrderPizza al modelo de fábrica simple, para que cuando necesitemos aumentar los tipos de pizza en el futuro, no tengamos que preocuparnos por tantas. OrderPizza, solo necesita estar en el modelo de fábrica. Solo agregue un juicio lógico, y esta fábrica es una extensión , en línea con nuestro pensamiento OOP
En nuestro OrderPizza, se introduce un objeto de fábrica simple amigo directo. Este objeto de fábrica simple producirá pizza para nosotros. Nuestro OrderPizza solo necesita obtener este objeto, y no necesitamos ir a uno nuevo por nosotros mismos. Se ajusta a la modificación cerrar.
Más conveniente es que podemos establecer el método createPizza en el patrón de fábrica simple como un método estático ¿Qué será de nuestro código?
El cambio del modo de fábrica simple es solo para agregar una modificación estática al método createPizza
OrderPizza cambios
package com.wang.factory.pizza.order;
import com.wang.factory.pizza.Pizza;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
* @author 王庆华
* @version 1.0
* @date 2020/12/21 20:14
* @Description TODO
* @pojectname 订购披萨代码
*/
public class OrderPizza2 {
Pizza pizza = null;
String orderType = "";//orderType用户输入pizza类型
//构造器
public OrderPizza2(){
do {
orderType = getType();//获取用户订购的pizza类型
pizza = SimpleFactory.createPizza(orderType);
//输出制作pizza信息
if (pizza != null){
//订购成功
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
}else {
System.out.println("预定失败，请检查是不是没有这个pizza类型");
break;
}
}while(true);
}
//获取客户订购的披萨种类
private String getType(){
try {
BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza 种类:");
String str = strin.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
}
Debido a que createPizza se ha convertido en modo estático, no necesitamos pasar un objeto de fábrica simple, podemos llamarlo directamente por el nombre de la clase y ya no necesitamos establecer un objeto de fábrica simple.
La diferencia entre los dos no es grande, los detalles son que cuando no es un método estático, es fácil de crear según las necesidades, y el efecto no es muy diferente, según las necesidades del negocio.