工厂模式（五）
简单工厂模式
基本介绍
- 简单工厂模式是创建型模式，是工厂模式的一种，简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例
- 简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为
- 在软件开发中，当我们会用到大量的创建某种，某类或者某批对象时。就会用到工厂模式。
看一个披萨的项目，要便于披萨种类的扩展，要便于维护
- 披萨的种类很多（比如GreekPizz，CheesePizz）
- 披萨的制作有prepare，bake，cut，box
- 完成披萨店订购功能
代码实现
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;
}
}
优点缺点
-
优点是比较好理解，简单易操作
-
缺点是违反了设计模式的ocp原则，即对拓展开放，对修改关闭，即当我们给类增加新功能的时候，尽量不要修改代码，或者尽可能少修改代码。
-
比如我们这时要新增加一个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个要素构成。
结构
- 抽象工厂：提供了创建产品的接口，调用者通过它的访问具体工厂的工厂方法newProduct()来创建产品。
- 具体工厂：主要实现抽象工厂中的抽象方法，完成具体产品的创建。
- 抽象产品：定义了产品的规范，描述了产品的主要特性和功能。
- 具体产品：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应
其结构如图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();
}
}
抽象工厂模式
基本介绍
- 抽象工厂模式，定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类
- 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
- 从设计层面看，抽象工厂模式就是对简单工厂模式的改进（或者称为进一步的抽象）。
- 将工厂抽象成两层，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("北京奶酪披萨准备制作");
}
}
工厂模式的意义
将实例化对象的代码提取出来，放到一个类中统一管理和维护。达到和主项目的依赖关系的解耦，从而提高项目的拓展和维护性
浙公网安备 33010602011771号