设计模式（2）（3）——工厂方法模式 / 抽象工厂模式

今天药忘吃喽~ 2023-07-23 12:54 22阅读 0赞

### 目录 ###

*   *   *  传统方式
         *  简单工厂模式
         *  工厂方法模式
         *  抽象工厂模式
         *  工厂模式在JDK-Calendar应用的源码分析
         *  工厂模式小结
         *   *  工厂模式的意义
             *  三种工厂模式
             *  设计模式的依赖抽象原则

*  案例说明

> 看一个披萨的项目：要便于披萨种类的扩展，要便于维护  
> 披萨的种类很多（比如 GreekPizza、CheesePizza 等）  
> 披萨的制作有prepare，bake，cut，box  
> 完成披萨店订购功能

### 传统方式 ###

*  思路分析  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdW1tbWlu_size_16_color_FFFFFF_t_70]
 *  代码演示

//构造器
    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);
    }

*  传统方式的优缺点
    
     *  优点是比较好理解，简单易操作
     *  缺点是**违反了设计模式的ocp原则**，即对扩展开放，对修改关闭。即当我们给类增加新功能的时候，尽量不修改代码，或者尽量少修改代码。
     *  比如我们这时要新增一个Pizza 的种类（Pepper 披萨），我们需要做如下修改：

//构造器
    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 if (orderType.equals("pepper")) { 
    			pizza = new PepperPizza();
    			pizza.setName("胡椒披萨");
    		} else { 
    			break;
    		}
    		//输出pizza 制作过程
    		pizza.prepare();
    		pizza.bake();
    		pizza.cut();
    		pizza.box();
    	}while(true);
    }

*  改进的思路分析：
    
     *  分析：修改代码可以接受，但是如果我们在其它的地方也有创建 Pizza 的代码，就意味着，也需要修改，而创建 Pizza 的代码，往往有多处。
     *  思路：**把创建 Pizza 对象封装到一个类中，这样我们有新的 Pizza 种类时，只需要修改该类就可**，其它有创建到 Pizza 对象的代码就不需要修改了。 —> 简单工厂模式

### 简单工厂模式 ###

*  基本介绍
    
     *  简单工厂是属于**创建型模式**，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式**是工厂模式家族中最简单实用的**模式。
     *  简单工厂模式：定义了一个创建对象的类，由这个类来**封装实例化对象的行为（代码）**。
     *  在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式。
 *  使用简单工厂模式
    
     *  简单工厂模式的设计方案：定义一个可以实例化 Pizza 对象的类，封装创建对象的代码。  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdW1tbWlu_size_16_color_FFFFFF_t_70 1]
 *  代码演示

package com.lm.factory.simplefactory.pizzstore.order;
    
    import com.lm.factory.simplefactory.pizzstore.pizza.CheesePizza;
    import com.lm.factory.simplefactory.pizzstore.pizza.GreekPizza;
    import com.lm.factory.simplefactory.pizzstore.pizza.PepperPizza;
    import com.lm.factory.simplefactory.pizzstore.pizza.Pizza;
    
    //简单工厂类
    public class SimpelFactory { 
    	
    	//根据orderType 返回对应的Pizza 对象
    	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;
    	}
    	
    	//简单工厂模式 也叫 静态工厂模式
    	public static Pizza createPizza2(String orderType) { 
    		
    		Pizza pizza = null;
    		
    		System.out.println("使用简单工厂模式2");
    		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;
    	}
    
    }

package com.lm.factory.simplefactory.pizzstore.order;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    import com.lm.factory.simplefactory.pizzstore.pizza.CheesePizza;
    import com.lm.factory.simplefactory.pizzstore.pizza.GreekPizza;
    import com.lm.factory.simplefactory.pizzstore.pizza.PepperPizza;
    import com.lm.factory.simplefactory.pizzstore.pizza.Pizza;
    
    public class OrderPizza { 
    	
    	//定义一个简单工厂对象
    	SimpelFactory simpelFactory;
    	Pizza pizza = null;
    	
    	//构造器
    	public OrderPizza(SimpelFactory simpelFactory) { 
    		setFactory(simpelFactory);
    	}
    	
    	
    	public void setFactory(SimpelFactory simpelFactory) { 
    		String orderType = ""; //用户输入的
    		
    		this.simpelFactory = simpelFactory; //设置简单工厂对象
    		
    		do { 
    			orderType = getType();
    			pizza = this.simpelFactory.createPizza(orderType);
    			
    			//输出pizza
    			if (pizza != null) {  //订购成功
    				pizza.prepare();
    				pizza.bake();
    				pizza.cut();
    				pizza.box();
    			} else { 
    				System.out.println(" 订购披萨失败 ");
    				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 "";
    		}
    	}
    }

### 工厂方法模式 ###

*  案例说明

> 披萨项目新的需求：客户在点披萨时，可以点**不同口味的披萨**，比如 北京的奶酪 pizza、北京的胡椒 pizza 或者是伦敦的奶酪 pizza、伦敦的胡椒 pizza。

*  思路1：
    
     *  使用简单工厂模式，创建不同的建档工厂类，比如 BJPizzaSimpelFactory、 LDPizzaSimpelFactory 等等。从当前这个案例来说，也是可以的，但是考虑到项目的规模，以及软件的可维护性、可扩展性并不是很好。
 *  思路2：
    
     *  使用工厂方法模式
 *  基本介绍
    
     *  1）工厂方法模式设计方案：将披萨项目的实例化功能抽象成抽象方法，在不同的口味点餐子类中具体实现。
     *  1.  工厂方法模式：**定义了一个创建对象的抽象方法**，**由子类决定要实例化的类**。工厂方法模式将**对象的实例化推迟到子类**。
 *  思路分析  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdW1tbWlu_size_16_color_FFFFFF_t_70 2]
 *  代码演示

package com.lm.factory.factorymethod.pizzstore.order;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    import com.lm.factory.factorymethod.pizzstore.pizza.Pizza;
    
    public abstract class OrderPizza { 
    	
    	//定义一个抽象方法，createPizza，让各个工厂子类自己实现
    	abstract Pizza createPizza(String orderType);
    
    	//构造器
    	public OrderPizza() { 
    		Pizza pizza = null;
    		String orderType; //订购披萨的类型
    		do { 
    			orderType = getType();
    			pizza = createPizza(orderType);	//抽象方法，由子工厂子类完成
    			//输出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 "";
    		}
    	}
    }

package com.lm.factory.factorymethod.pizzstore.order;
    
    import com.lm.factory.factorymethod.pizzstore.pizza.BJCheesePizza;
    import com.lm.factory.factorymethod.pizzstore.pizza.BJPepperPizza;
    import com.lm.factory.factorymethod.pizzstore.pizza.Pizza;
    
    public class BJOrderPizza extends OrderPizza { 
    
    	@Override
    	Pizza createPizza(String orderType) { 
    		
    		Pizza pizza = null;
    		if (orderType.equals("cheese")) { 
    			pizza = new BJCheesePizza();
    		} else if (orderType.equals("pepper")) { 
    			pizza = new BJPepperPizza();
    		}
    		
    		return pizza;
    	}
    
    }

package com.lm.factory.factorymethod.pizzstore.order;
    
    import com.lm.factory.factorymethod.pizzstore.pizza.LDCheesePizza;
    import com.lm.factory.factorymethod.pizzstore.pizza.LDPepperPizza;
    import com.lm.factory.factorymethod.pizzstore.pizza.Pizza;
    
    public class LDOrderPizza extends OrderPizza { 
    
    	@Override
    	Pizza createPizza(String orderType) { 
    		
    		Pizza pizza = null;
    		if (orderType.equals("cheese")) { 
    			pizza = new LDCheesePizza();
    		} else if (orderType.equals("pepper")) { 
    			pizza = new LDPepperPizza();
    		}
    		
    		return pizza;
    	}
    
    }

### 抽象工厂模式 ###

*  基本介绍
    
     *  抽象工厂模式：定义了一个**interface用于创建相关或者有依赖关系的对象簇**，而无需指明具体的类
     *  抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合
     *  从设计层面看，抽象工厂模式就是对简单工厂模式的改进（或者称为进一步的抽象）。
     *  将工厂抽象成两层，**AbsFactory（抽象工厂）和具体实现的子类**。程序员可以根据创建对象类型使用对应的的工厂子类。这样将单个的简单工厂变成了工厂簇，更利于代码的维护和扩展。
     *  类图：  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdW1tbWlu_size_16_color_FFFFFF_t_70 3]
 *  代码演示

package com.lm.factory.absfactory.pizzstore.order;
    
    import com.lm.factory.absfactory.pizzstore.pizza.Pizza;
    
    //一个抽象工厂模式的抽象层（接口）
    public interface AbsFactory { 
    	//让下面的工厂子类来 具体实现
    	public Pizza createPizza(String orderType);
    }

package com.lm.factory.absfactory.pizzstore.order;
    
    import com.lm.factory.absfactory.pizzstore.pizza.BJCheesePizza;
    import com.lm.factory.absfactory.pizzstore.pizza.BJPepperPizza;
    import com.lm.factory.absfactory.pizzstore.pizza.Pizza;
    
    //这是工厂子类
    public class BJFactoty implements AbsFactory { 
    
    	@Override
    	public Pizza createPizza(String orderType) { 
    		System.out.println("~使用的是抽象工厂模式");
    		Pizza pizza = null;
    		if (orderType.equals("cheese")) { 
    			pizza = new BJCheesePizza();
    		} else if (orderType.equals("pepper")) { 
    			pizza = new BJPepperPizza();
    		}
    		return pizza;
    	}
    
    }

package com.lm.factory.absfactory.pizzstore.order;
    
    import com.lm.factory.absfactory.pizzstore.pizza.LDCheesePizza;
    import com.lm.factory.absfactory.pizzstore.pizza.LDPepperPizza;
    import com.lm.factory.absfactory.pizzstore.pizza.Pizza;
    
    //这是工厂子类
    public class LDFactoty implements AbsFactory { 
    
    	@Override
    	public Pizza createPizza(String orderType) { 
    		System.out.println("~使用的是抽象工厂模式");
    		Pizza pizza = null;
    		if (orderType.equals("cheese")) { 
    			pizza = new LDCheesePizza();
    		} else if (orderType.equals("pepper")) { 
    			pizza = new LDPepperPizza();
    		}
    		return pizza;
    	}
    
    }

package com.lm.factory.absfactory.pizzstore.order;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    import com.lm.factory.absfactory.pizzstore.pizza.Pizza;
    
    public class OrderPizza { 
    
    	AbsFactory factory;
    	
    	//构造器
    	public OrderPizza(AbsFactory factory) { 
    		setFactory(factory);
    	}
    	
    	private void setFactory(AbsFactory factory) { 
    		Pizza pizza = null;
    		String orderType = ""; //用户输入
    		this.factory = factory;
    		
    		do { 
    			orderType = getType();
    			//factory 可能是北京的工厂子类，也可能是伦敦的工厂子类
    			pizza = factory.createPizza(orderType);
    			if (pizza != null) { 
    				pizza.prepare();
    				pizza.bake();
    				pizza.cut();
    				pizza.box();
    			} else { 
    				System.out.println("订购失败");
    				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 "";
    		}
    	}
    	
    }

### 工厂模式在JDK-Calendar应用的源码分析 ###

*  JDK中的Calendar类中，就使用了简单工厂模式
 *  源码分析+Debug源码+说明
    
     *  源码部分

package com.lm.jdk;
    
    import java.util.Calendar;
    
    public class Factory { 
    
    	public static void main(String[] args) { 
    		Calendar cal = Calendar.getInstance();
    		System.out.println("年:" + cal.get(Calendar.YEAR));
    		System.out.println("月:" + (cal.get(Calendar.MONTH) + 1));
    		System.out.println("日:" + cal.get(Calendar.DAY_OF_MONTH));
    		System.out.println("时:" + cal.get(Calendar.HOUR_OF_DAY));
    		System.out.println("分:" + cal.get(Calendar.MINUTE));
    		System.out.println("秒:" + cal.get(Calendar.SECOND));
    	}
    
    }

Calendar.java

/** * Gets a calendar using the default time zone and locale. The * <code>Calendar</code> returned is based on the current time * in the default time zone with the default * {@link Locale.Category#FORMAT FORMAT} locale. * * @return a Calendar. */
        public static Calendar getInstance()
        { 
            return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT));
        }

根据 TimeZone zone, Locale aLocale 创建对应的实例  
里面还会根据不同条件 aLocale.getUnicodeLocaleType(“ca”) 来创建不同实例（BuddhistCalendar、JapaneseImperialCalendar、GregorianCalendar）

private static Calendar createCalendar(TimeZone zone,
                                               Locale aLocale)
        { 
            CalendarProvider provider =
                LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale)
                                     .getCalendarProvider();
            if (provider != null) { 
                try { 
                    return provider.getInstance(zone, aLocale);
                } catch (IllegalArgumentException iae) { 
                    // fall back to the default instantiation
                }
            }
    
            Calendar cal = null;
    
            if (aLocale.hasExtensions()) { 
                String caltype = aLocale.getUnicodeLocaleType("ca");
                if (caltype != null) { 
                    switch (caltype) { 
                    case "buddhist":
                    cal = new BuddhistCalendar(zone, aLocale);
                        break;
                    case "japanese":
                        cal = new JapaneseImperialCalendar(zone, aLocale);
                        break;
                    case "gregory":
                        cal = new GregorianCalendar(zone, aLocale);
                        break;
                    }
                }
            }
            if (cal == null) { 
                // If no known calendar type is explicitly specified,
                // perform the traditional way to create a Calendar:
                // create a BuddhistCalendar for th_TH locale,
                // a JapaneseImperialCalendar for ja_JP_JP locale, or
                // a GregorianCalendar for any other locales.
                // NOTE: The language, country and variant strings are interned.
                if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") { 
                    cal = new BuddhistCalendar(zone, aLocale);
                } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"
                           && aLocale.getCountry() == "JP") { 
                    cal = new JapaneseImperialCalendar(zone, aLocale);
                } else { 
                    cal = new GregorianCalendar(zone, aLocale);
                }
            }
            return cal;
        }

### 工厂模式小结 ###

#### 工厂模式的意义 ####

将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。

#### 三种工厂模式 ####

*  1、简单工厂模式
 *  2、工厂方法模式
 *  3、抽象工厂模式

#### 设计模式的依赖抽象原则 ####

*  创建对象实例时，不要直接 new 类，而是把这个 new 类的动作放在一个工厂的方法中，并返回。有的书上说，变量不要直接持有具体类的引用。
 *  不要让类继承具体类，而是继承抽象类或者是实现interface（接口）
 *  不要覆盖基类中已经实现的方法

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdW1tbWlu_size_16_color_FFFFFF_t_70]: /images/20230528/1aabb238191d4d77a375e220d5710258.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdW1tbWlu_size_16_color_FFFFFF_t_70 1]: /images/20230528/85ab2e03dd8844f2859af54034df423d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdW1tbWlu_size_16_color_FFFFFF_t_70 2]: /images/20230528/3f7c7416a08741fdb825170a95dd170a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdW1tbWlu_size_16_color_FFFFFF_t_70 3]: /images/20230528/883b4366069048aabcab03ee027c7ba6.png