Modo de fábrica
Vamos examinar um requisito específico primeiro
Olhe para um projeto de pizza: Para facilitar a expansão dos tipos de pizza e para facilitar a manutenção
1) Existem muitos tipos de pizza (como GreekPizz (grego), CheesePizz (queijo), etc.)
2) Pizza é feita com preparo ( material de preparação), assar (assar) assar), cortar (cortar), caixa (embalar)
3) Complete a função de pedido da pizzaria.
Qual é o jeito tradicional
Código
Classe abstrata 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;
}
}
Dois 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("给希腊披萨准备原材料");
}
}
Aula de iniciação 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 "";
}
}
}
Categoria principal: pizzaria
/**
* @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();
}
}
Vantagens e problemas
A vantagem é que é mais fácil de entender e fácil de operar.
A desvantagem é que ele viola o princípio ocp do padrão de design, ou seja, está aberto para extensão e fechado para modificação . Ou seja, quando adicionamos novas funções à classe, tentamos não modificar o código ou modificar o código o menos possível
Por exemplo, se quisermos adicionar um novo tipo de Pizza (Pizza de Pimenta) neste momento, precisamos fazer as seguintes alterações:
1. Adicione pizza de pimenta, herde a classe abstrata de pizza
public class PepperPizza extends Pizza {
@Override
public void prepare() {
System.out.println("给胡椒披萨准备原材料");
}
}
2. Devemos adicionar a lógica de julgar se é pizza de pimenta ou não em 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;
}
Muitos ramos se juntaram a nós, e há 2,3,4,5,6 ... Que tal OrderPizza? Não é preciso mudar tudo?
Melhorar
Análise : Modificar o código é aceitável, mas se também temos o código para criar Pizza em outros lugares, isso significa que também precisamos modificar, e frequentemente existem vários lugares para criar o código para Pizza.
** Idéia: ** Encapsule o objeto Pizza criado em uma classe, de modo que quando tivermos um novo tipo de Pizza, só precisemos modificar a classe, e outros códigos que criam objetos Pizza não precisam ser modificados === = > Modo Fábrica Simples
Padrão de fábrica simples
introdução básica
Modo de fábrica estático
1) O modelo de fábrica simples pertence ao modelo de criação , que é uma espécie de modelo de fábrica. O padrão de fábrica simples é que um objeto de fábrica determina qual instância de uma classe de produto é criada . O modo de fábrica simples é o modo mais simples e prático na família do modo de fábrica
2) Padrão de fábrica simples: define uma classe para a criação de objetos, e esta classe encapsula o comportamento de objetos instanciados (código)
3) No desenvolvimento de software, quando utilizarmos um grande número de objetos para criar um certo tipo, um certo tipo ou um certo lote de objetos, será utilizado o 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;
}
}
Mudanças em 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 "";
}
}
}
Mudanças de clientes
/**
* @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("退出程序");
}
}
Vamos entender: em primeiro lugar, nós novos códigos de diferentes tipos de Pizza, transferidos de OrderPizza para o modelo de fábrica simples, para que quando precisarmos aumentar os tipos de pizza no futuro, não tenhamos que nos preocupar com tantos OrderPizza, só precisa estar no modelo de fábrica. Basta adicionar um julgamento lógico e essa fábrica é uma extensão , de acordo com nosso pensamento OOP
Em nosso OrderPizza, um objeto de fábrica simples de amigo direto é introduzido. Este objeto de fábrica simples produzirá Pizza para nós. Nosso OrderPizza só precisa obter este objeto, e não precisamos ir para o novo por nós mesmos. Ele está em conformidade com a modificação Fechar.
Mais conveniente é que podemos definir o método createPizza no padrão de fábrica simples como um método estático.O que será do nosso código?
A mudança do modo de fábrica simples é apenas para adicionar modificação estática ao método createPizza
OrderPizza muda
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 "";
}
}
}
Como nosso createPizza se tornou o modo estático, não precisamos passar um objeto de fábrica simples, podemos chamá-lo diretamente pelo nome da classe e não precisamos mais definir um objeto de fábrica simples.
A diferença entre os dois não é grande, os detalhes são que quando não é um método estático, é fácil de criar de acordo com as necessidades, e o efeito não é muito diferente, dependendo das necessidades do negócio