设计模式 — 简单工厂模式（Simple Factory）

定义：定义一个工厂类，它可以根据参数的不同返回不同类型的实例，被创建的实例通常有公共的父类。

模式类型：创建型模型

Factory（工厂角色）：即工厂类，负责实现创建所有产品实例的内部逻辑；工厂类可以直接被外界调用，创建所需的产品对象；在工厂类中提供了静态的工厂方法FactoryMethod（），它的返回类型为抽象产品Product。

Product（抽象产品角色）：它是工厂类所创建的所有对象的父类，封装了各种产品对象的公共方法。提高了系统的灵活性，使得工厂类只需定义一个通用的工厂方法，因为所有创建的具体产品对象都是其子类对象。

ConcreteProduct（具体产品角色）：所有被创建的对象都充当某个具体类的实例。每一个具体产品角色都继承了抽象产品角色，需要实现在抽象产品中声明的抽象方法。

案例：pizza生产简单工厂模式

1 /**
  2  * @author EASON
  3  * @date 2017.1.7  13:23
  4  * @function 工厂模式
  5  */
  6 package com.nju;
  7 
  8 import java.io.BufferedReader;
  9 import java.io.IOException;
 10 import java.io.InputStreamReader;
 11 
 12 public class Test {
 13     public static void main(String[] args) {
 14         PizzaStore ps = new PizzaStore();
 15         ps.orderPizza();
 16     }
 17 }
 18 
 19 //抽象产品类
 20 interface Pizza{
 21     public void prepare();
 22     public void bake();
 23     public void cut();
 24     public void packaged();
 25 }
 26 
 27 //具体产品类-奶酪披萨
 28 class CheesePizza implements Pizza{
 29     //具体产品类需要实现抽象产品类中的方法
 30     public void prepare() {
 31         System.out.println("奶酪披萨开始制作...");
 32     }
 33 
 34     public void bake() {
 35         System.out.println("奶酪披萨开始烘焙...");
 36     }
 37 
 38     public void cut() {
 39         System.out.println("奶酪披萨开始切块...");
 40     }
 41 
 42     public void packaged() {
 43         System.out.println("奶酪披萨包装完毕...");
 44     }
 45     
 46 }
 47 
 48 //具体产品类-洋葱披萨
 49 class PepperoniPizza implements Pizza{
 50 
 51     public void prepare() {
 52         System.out.println("洋葱披萨开始制作...");
 53     }
 54 
 55     public void bake() {
 56         System.out.println("洋葱披萨开始烘焙...");
 57     }
 58 
 59     public void cut() {
 60         System.out.println("洋葱披萨开始切块...");
 61     }
 62 
 63     public void packaged() {
 64         System.out.println("洋葱披萨包装完毕...");
 65     }
 66     
 67 }
 68 
 69 //Pizza工厂类
 70 class PizzaFactory{
 71     public Pizza getPizza(String pizzaType){
 72         switch(pizzaType){
 73         case("cheesePizza"):
 74             return new CheesePizza();
 75         case("pepperonPizza"):
 76             return new PepperoniPizza();
 77         default:
 78             return null;
 79         }
 80     }
 81 }
 82 
 83 //Pizza商店类
 84 class PizzaStore{
 85     public void orderPizza(){
 86         BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
 87         PizzaFactory pf = new PizzaFactory();
 88         System.out.println("欢迎光临！");
 89         System.out.println("请输入你想要购买的Pizza：");
 90         try {
 91             String pizzaType = bf.readLine();
 92             Pizza pizza = pf.getPizza(pizzaType);
 93             pizza.prepare();
 94             pizza.bake();
 95             pizza.cut();
 96             pizza.packaged();
 97             System.out.println("欢迎下次光临！");
 98         } catch (IOException e) {
 99             e.printStackTrace();
100         }
101     }
102 }      

 使用简单工厂模式的好处，可以把复杂的逻辑判断代码从PizzaStore中分离出来，即便需要修改判断逻辑，也不会影响PizzaStore，符合OCP。

转载于:https://www.cnblogs.com/huiAlex/p/6259446.html