工厂设计模式

工厂设计模式

简单(静态)工厂模式

基本介绍

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

案例代码

1. /**
2. * 抽象的披萨类
3. * @author 长名06
4. * @version 1.0
5. */
6. public abstract class Pizza {
8.     private String name;
10.     public abstract void prepare();
12.     public void bake(){
13.         System.out.println(name + "烘烤完成");
14.     }
16.     public void cut(){
17.         System.out.println(name + "切割完成");
18.     }
20.     public void box(){
21.         System.out.println(name + "打包完成");
22.     }
24.     public void setName(String name) {
25.         this.name = name;
26.     }
27. }
29. //具体披萨类
30. public class PepperPizza extends Pizza{
31.     @Override
32.     public void prepare() {
33.         System.out.println("胡椒披萨准备原材料");
34.     }
35. }
37. public class GreekPizza extends Pizza{
38.     @Override
39.     public void prepare() {
40.         System.out.println("希腊披萨准备原材料");
41.     }
42. }
43. public class CheesePizza extends Pizza{
44.     @Override
45.     public void prepare() {
46.         System.out.println( "芝士披萨" + "准备原材料");
47.     }
48. }
49. //简单工厂类
50. public class SimpleFactory {
52.     public static Pizza createPizza(String pizzaType){
53.         Pizza pizza = null;
54.         System.out.println("使用简单工厂模式");
55.         if(pizzaType.equals("greek")){
56.             pizza = new GreekPizza();
57.             pizza.setName("希腊披萨");
58.         }else if(pizzaType.equals("cheese")){
59.             pizza = new CheesePizza();
60.             pizza.setName("奶酪披萨");
61.         }else if(pizzaType.equals("pepper")){
62.             pizza = new PepperPizza();
63.             pizza.setName("胡椒披萨");
64.         }
65.         return pizza;
66.     }
67. }
69. import java.io.BufferedReader;
70. import java.io.IOException;
71. import java.io.InputStreamReader;
73. /**
74. * @author 长名06
75. * @version 1.0
76. */
77. public class OrderPizza {
79.     private BufferedReader br;
81.     public OrderPizza() {
82.         Pizza pizza = null;
83.         do {
84.             String pizzaType = this.getType();
85.             pizza = SimpleFactory.createPizza(pizzaType);
86.             if(pizza != null) {
87.                 pizza.prepare();
88.                 pizza.bake();
89.                 pizza.cut();
90.                 pizza.box();
91.             } else {
92.                 if(br != null){
93.                     try {
94.                         br.close();
95.                     } catch (IOException e) {
96.                         e.printStackTrace();
97.                     }
98.                 }
99.                 break;
100.             }
101.         }while (true);
102.     }
104.     public String getType() {
105.         br = new BufferedReader(new InputStreamReader(System.in));
106.         System.out.println("input pizza type:");
107.         String type = "";
108.         try {
109.             type = br.readLine();
110.         }catch (IOException e){
111.             e.printStackTrace();
112.         }
113.         return type;
114.     }
116. }
118. public class PizzaStore {
119.     public static void main(String[] args) {
120.         new OrderPizza();
121.     }
122. }

复制代码

工厂方法模式

披萨案例新需求

客户在点披萨的时候，可以点不同地区的披萨，比如北京的奶酪披萨，北京的胡椒披萨或者时伦敦的奶酪披萨，伦敦的胡椒披萨。
思路分析，使用简答工厂模式，创建不同的简单工厂类，比如BJPizzaSimpleFactory，LDPizzaSimpleFactory等，从当前的案例，来说可以使用，但是考虑到项目的规模，及软件的可维护性，扩展性不是很好。
使用工厂方法模式
基本介绍

工厂方法模式设计方案，将披萨项目的实例化功能抽象成抽象方法，在不同的口味点餐子类中实现。
工厂方法模式：定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类实现。
UML类图


案例代码

1. public abstract class Pizza {
3.     private String name;
5.     public abstract void prepare();
7.     public void bake(){
8.         System.out.println(name + "烘烤完成");
9.     }
11.     public void cut(){
12.         System.out.println(name + "切割完成");
13.     }
15.     public void box(){
16.         System.out.println(name + "打包完成");
17.     }
19.     public void setName(String name) {
20.         this.name = name;
21.     }
23. }
25. public class LDPepperPizza extends Pizza{
26.     @Override
27.     public void prepare() {
28.         System.out.println("伦敦胡椒披萨准备原材料");
29.     }
30. }
32. public class LDCheesePizza extends Pizza{
33.     @Override
34.     public void prepare() {
35.         System.out.println("伦敦芝士披萨准备原材料");
36.     }
37. }
39. public class BJPepperPizza extends Pizza{
40.     @Override
41.     public void prepare() {
42.         System.out.println("北京胡椒披萨准备原材料");
43.     }
44. }
46. public class BJCheesePizza extends Pizza{
47.     @Override
48.     public void prepare() {
49.         System.out.println("北京芝士披萨准备原材料");
50.     }
51. }
53. public abstract class OrderPizza {
54.     private BufferedReader br;
56.     public abstract Pizza createPizza(String type);
58.     public OrderPizza() {
59.         Pizza pizza = null;
60.         do {
61.             String pizzaType = this.getType();
62.             pizza = createPizza(pizzaType);
63.             if(pizza != null) {
64.                 pizza.prepare();
65.                 pizza.bake();
66.                 pizza.cut();
67.                 pizza.box();
68.             } else {
69.                 if(br != null){
70.                     try {
71.                         br.close();
72.                     } catch (IOException e) {
73.                         e.printStackTrace();
74.                     }
75.                 }
76.                 break;
77.             }
78.         }while (true);
79.     }
81.     public String getType() {
82.         br = new BufferedReader(new InputStreamReader(System.in));
83.         System.out.println("input pizza type:");
84.         String type = "";
85.         try {
86.             type = br.readLine();
87.         }catch (IOException e){
88.             e.printStackTrace();
89.         }
90.         return type;
91.     }
92. }
94. public class LDOrderPizza extends OrderPizza{
95.     @Override
96.     public Pizza createPizza(String type) {
97.         Pizza pizza = null;
98.         if(type.equals("cheese")){
99.             pizza = new BJCheesePizza();
100.             pizza.setName("北京伦敦披萨");
101.         }else if(type.equals("pepper")){
102.             pizza = new BJPepperPizza();
103.             pizza.setName("北京胡椒披萨");
104.         }
105.         return pizza;
106.     }
107. }
109. public class BJOrderPizza extends OrderPizza{
111.     @Override
112.     public Pizza createPizza(String type) {
113.         Pizza pizza = null;
114.         if(type.equals("cheese")){
115.             pizza = new BJCheesePizza();
116.             pizza.setName("北京伦敦披萨");
117.         }else if(type.equals("pepper")){
118.             pizza = new BJPepperPizza();
119.             pizza.setName("北京胡椒披萨");
120.         }
121.         return pizza;
122.     }
123. }
125. //测试类
126. public class PizzaStore {
127.     public static void main(String[] args) {
128.         new LDOrderPizza();
129.     }
130. }

复制代码

抽象工厂模式

基本介绍

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

uml类图


案例代码

1. Pizza类，及其子类，同上工厂方法模式
2. public interface AbsFactory {
3.     //让子类工厂实现
4.     public Pizza createPizza(String type);
5. }
6. //北京工厂
7. public class BJFactory implements AbsFactory{
8.     @Override
9.     public Pizza createPizza(String type) {
10.         System.out.println("使用的是抽象工厂模式~");
11.         Pizza pizza = null;
12.         if(type.equals("cheese")){
13.             pizza = new BJCheesePizza();
14.             pizza.setName("北京芝士披萨");
15.         }else if(type.equals("pepper")){
16.             pizza = new BJPepperPizza();
17.             pizza.setName("北京胡椒披萨");
18.         }
19.         return pizza;
20.     }
21. }
22. //伦敦工厂
23. public class LDFactory implements AbsFactory{
24.     @Override
25.     public Pizza createPizza(String type) {
26.         System.out.println("使用的是抽象工厂模式~");
27.         Pizza pizza = null;
28.         if(type.equals("cheese")){
29.             pizza = new LDCheesePizza();
30.             pizza.setName("伦敦芝士披萨");
31.         }else if(type.equals("pepper")){
32.             pizza = new LDPepperPizza();
33.             pizza.setName("伦敦胡椒披萨");
34.         }
35.         return pizza;
36.     }
37. }
38. //披萨订单
39. public class OrderPizza {
41.     private BufferedReader br;
43.     private AbsFactory absFactory;
45.     public OrderPizza(AbsFactory absFactory){
46.         setAbsFactory(absFactory);
47.     }
49.     private void setAbsFactory(AbsFactory absFactory) {
50.         Pizza pizza = null;
51.         String pizzaType = "";
52.         this.absFactory = absFactory;
53.         do{
54.             pizzaType = this.getType();
55.             pizza = this.absFactory.createPizza(pizzaType);
56.             if(pizza == null){
57.                 try {
58.                     System.out.println("订购失败");
59.                     br.close();
60.                 } catch (IOException e) {
61.                     e.printStackTrace();
62.                 }
63.                 break;
64.             }else{
65.                 pizza.prepare();
66.                 pizza.bake();
67.                 pizza.cut();
68.                 pizza.box();
69.             }
70.         }while (true);
71.     }
74.     public String getType() {
75.         br = new BufferedReader(new InputStreamReader(System.in));
76.         System.out.println("input pizza type:");
77.         String type = "";
78.         try {
79.             type = br.readLine();
80.         }catch (IOException e){
81.             e.printStackTrace();
82.         }
83.         return type;
84.     }
85. }
86. //测试代码
87. public class PizzaStore {
88.     public static void main(String[] args) {
89. //        new OrderPizza(new BJFactory());
90.         new OrderPizza(new LDFactory());
91.     }
92. }

复制代码

工厂模式在JDK-Calendar中的应用


核心代码

1. if (aLocale.hasExtensions()) {//判断当前时区是否有扩展
2.     String caltype = aLocale.getUnicodeLocaleType("ca");
3.     if (caltype != null) {
4.         switch (caltype) {//采用switch分支创建实例
5.         case "buddhist":
6.         cal = new BuddhistCalendar(zone, aLocale);
7.             break;
8.         case "japanese":
9.             cal = new JapaneseImperialCalendar(zone, aLocale);
10.             break;
11.         case "gregory":
12.             cal = new GregorianCalendar(zone, aLocale);
13.             break;
14.         }
15.     }
16. }

复制代码

工厂模式小结

• 1.工厂模式的作用，将创建对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目解耦的目的。从而提高项目的扩展和维护性。
  
• 2.三种工厂模式(简单工厂模式，工厂方法模式，抽象工厂模式)。
  
• 3.创建对象实例时，不是直接new对象，而是将new对象的动作，放在一个工厂的方法里，并返回创建的对象。
  
• 4.设计模式的依赖倒转原则和里氏替换原则，不要让类继承具体的类，而是继承抽象类和interface，不要覆盖基类中已实现的方法。
  

案例只是为了体现这种设计模式的思想，不具有实际意义
只是为了记录自己的学习历程，且本人水平有限，不对之处，请指正。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！