设计模式（二）（装饰者模式、工厂方法模式、抽象工厂模式）

墨蓝 2022-05-10 12:34 213阅读 0赞

# 三：装饰者模式 #

***装饰者模式动态地将责任附加到对象上。若要扩展功能，装饰者提供了比继承更有弹性的替代方案。***

**意图：**动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。

**主要解决：**一般的，我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。

**何时使用：**在不想增加很多子类的情况下扩展类。

**如何解决：**将具体功能职责划分，同时继承装饰者模式。

**关键代码：** 1、Component 类充当抽象角色，不应该具体实现。 2、修饰类引用和继承 Component 类，具体扩展类重写父类方法。

**应用实例：** 1、孙悟空有 72 变，当他变成"庙宇"后，他的根本还是一只猴子，但是他又有了庙宇的功能。 2、不论一幅画有没有画框都可以挂在墙上，但是通常都是有画框的，并且实际上是画框被挂在墙上。在挂在墙上之前，画可以被蒙上玻璃，装到框子里；这时画、玻璃和画框形成了一个物体。

**优点：**装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。

**缺点：**多层装饰比较复杂。

**使用场景：** 1、扩展一个类的功能。 2、动态增加功能，动态撤销。

**注意事项：**可代替继承。

**实现**

首先定义个抽象类做基类，这个类是饮料类：

/* 
     * 抽象类（饮料）
    * @author zzf 
    * @date 2018年10月18日 下午2:29:23 
    */
    public abstract class Beverage {
    
    	/**
    	 * 描述
    	 */
    	String description="未知";
    	
    	public String getDescription() {
    		return description;
    	}
    	
    	/**
    	 * 价格
    	 * @return
    	 */
    	public abstract BigDecimal cost();
    }

下面做调料抽象类(装饰者类)：

/* 
     * 调料装饰者
    * @author zzf 
    * @date 2018年10月18日 下午2:35:39 
    */
    public abstract class CondimentDecorator extends Beverage{
    	
    	/**
    	 * 所有调料装饰者都需要重新实现这个方法
    	 */
    	public abstract String getDescription();
    }

现在已经有基类了，现在做饮料的具体实现，并且实现cost()方法：

/* 
     * 意大利浓咖啡类
    * @author zzf 
    * @date 2018年10月18日 下午2:37:47 
    */
    public class Espresso extends Beverage{
    
    	public Espresso() {
    		description="意大利浓咖啡";
    	}
    	
    	/**
    	 * 重新定义Espresso的价格
    	 */
    	@Override
    	public BigDecimal cost() {
    		// TODO Auto-generated method stub
    		return new BigDecimal("9.99");
    	}
    
    }

/* 
     * 混合咖啡
    * @author zzf 
    * @date 2018年10月18日 下午2:40:12 
    */
    public class HouseBlend extends Beverage{
    
    	public HouseBlend() {
    		description="混合咖啡";
    	}
    	
    	@Override
    	public BigDecimal cost() {
    		// TODO Auto-generated method stub
    		return new BigDecimal("2.1");
    	}
    
    }

现在已经有抽象组件（Beverage），具体组件（HouseBlend），抽象装饰类（CondimentDecorator），现在实现具体的装饰者：

/* 
     * 装饰类：摩卡
    * @author zzf 
    * @date 2018年10月18日 下午2:48:13 
    */
    public class Mocha extends CondimentDecorator{
    
    	/**
    	 * 该实例变量记录饮料(被装饰者)
    	 */
    	Beverage beverage;
    	
    	/**
    	 * 被装饰类记录到实例变量
    	 * 把饮料当作构造器的参数，再由构造器将此饮料记录在实例变量中。
    	 * @param beverage
    	 */
    	public Mocha(Beverage beverage) {
    		this.beverage=beverage;
    	}
    	
    	/**
    	 * 叙述
    	 */
    	@Override
    	public String getDescription() {
    		// TODO Auto-generated method stub
    		return beverage.getDescription()+"->摩卡";
    	}
    
    	/**
    	 * 计算价钱
    	 */
    	@Override
    	public BigDecimal cost() {
    		// TODO Auto-generated method stub
    		return new BigDecimal("0.20").add(beverage.cost());
    	}
    
    }

/* 
     * 牛奶
    * @author zzf 
    * @date 2018年10月18日 下午2:55:30 
    */
    public class Milk extends CondimentDecorator{
    
    	/**
    	 * 该实例变量记录饮料(被装饰者)
    	 */
    	Beverage beverage;
    	
    	/**
    	 * 被装饰类记录到实例变量
    	 * 把饮料当作构造器的参数，再由构造器将此饮料记录在实例变量中。
    	 * @param beverage
    	 */
    	public Milk(Beverage beverage) {
    		this.beverage=beverage;
    	}
    	
    	/**
    	 * 叙述
    	 */
    	@Override
    	public String getDescription() {
    		// TODO Auto-generated method stub
    		return beverage.getDescription()+"->牛奶";
    	}
    
    	/**
    	 * 计算价钱
    	 */
    	@Override
    	public BigDecimal cost() {
    		// TODO Auto-generated method stub
    		return new BigDecimal("0.50").add(beverage.cost());
    	}
    
    }

测试类：

/* 
    * @author zzf 
    * @date 2018年10月18日 下午2:59:47 
    */
    public class Coffee {
    
    	public static void main(String[] args) {
    		Beverage beverage=new Espresso();
    		//首先打印一个意大利浓咖啡
    		System.out.println(beverage.getDescription()+":$"+beverage.cost());
    		
    		//创建一个综合咖啡
    		Beverage beverage2=new HouseBlend();
    		//用摩卡装饰:2.1+0.2+0.5
    		beverage2=new Mocha(beverage2);
    		beverage2=new Milk(beverage2);
    		System.out.println(beverage2.getDescription()+":$"+beverage2.cost());
    		
    		Beverage beverage3=new Espresso();
    		beverage3=new Milk(beverage3);
    		beverage3=new Milk(beverage3);
    		//意大利浓咖啡：9.99+0.50+0.50
    		System.out.println(beverage3.getDescription()+":$"+beverage3.cost());
    	}
    }

![70][]

在JDK中装饰者模式广泛应用于I/O中，下面简单展示一个将大写字符输入流转为小写字符串：

/* 
    * @author zzf 
    * @date 2018年10月18日 下午4:09:17 
    */
    public class LowerCaseInputStream extends FilterInputStream {
    
    	protected LowerCaseInputStream(InputStream in) {
    		super(in);
    	}
    
    	public int read() throws IOException {
    		int c=in.read();
    		return c==-1?c:Character.toLowerCase(c);
    	}
    }

![70 1][]

**要点：**

**1、继承属于扩展形式之一，但不一定是达到弹性设计的最佳方式。**

**2、在类的设计中，应该允许行为可以被扩展，而无须修改现有代码。**

**3、组合和委托可用于在运动时动态地加上新的行为。**

**4、除了继承，装饰者模式可以让我们扩展行为。**

**5、装饰者模式意味着一群装饰者类，这些类用来包装具体组件。**

**6、装饰者类反映出被装饰的组件类型。**

**7、装饰者可以在被装饰者的行为前面与/或后面加上自己的行为，甚至将被装饰者的行为取代，从而达到特定目的。**

**8、可以用无数个装饰者包装一个组件。**

**9、装饰者模式一般对组件的客户是透明的，除非客户程序依赖于组件的具体类型。**

**10、装饰者会导致设计中出现许多小对象，如果过度使用会让程序复杂化。**

# 四：工厂方法模式 #

***工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类实例化推迟到子类。***

**意图：**定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

**主要解决：**主要解决接口选择的问题。

**何时使用：**我们明确地计划不同条件下创建不同实例时。

**如何解决：**让其子类实现工厂接口，返回的也是一个抽象的产品。

**关键代码：**创建过程在其子类执行。

**应用实例：** 1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。 2、Hibernate 换数据库只需换方言和驱动就可以。

**优点：** 1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。

**缺点：**每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

**使用场景：** 1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。 2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。 3、设计一个连接服务器的框架，需要三个协议，"POP3"、"IMAP"、"HTTP"，可以把这三个作为产品类，共同实现一个接口。

**注意事项：**作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

**实现：**

首先定义一个Color接口并创建两个实现类：

/* 
    * @author zzf 
    * @date 2018年10月19日 下午4:05:17 
    */
    public interface Color {
    	void colour();
    }

public class Red implements Color{
    
    	@Override
    	public void colour() {
    		// TODO Auto-generated method stub
    		System.out.println("Red");
    	}
    
    }

public class Yello implements Color{
    
    	@Override
    	public void colour() {
    		// TODO Auto-generated method stub
    		System.out.println("Yello");
    	}
    
    }

然后创建抽象工厂类，里面有个抽象方法：

public abstract class Factory {
    
    	abstract public Color getColor();
    	
    }

下面分别创建两个类用于返回创建真实的Color对象：

/* 
    * @author zzf 
    * @date 2018年10月19日 下午4:45:38 
    */
    public class RedFactory extends Factory{
    
    	@Override
    	public Color getColor() {
    		// TODO Auto-generated method stub
    		return new Red();
    	}
    
    }

/* 
    * @author zzf 
    * @date 2018年10月19日 下午4:46:49 
    */
    public class YelloFactory extends Factory{
    
    	@Override
    	public Color getColor() {
    		// TODO Auto-generated method stub
    		return new Yello();
    	}
    
    }

最后创建测试类：

/* 
    * @author zzf 
    * @date 2018年10月19日 下午4:10:13 
    */
    public class ColorDemo {
    
    	public static void main(String[] args) {
    		Factory factory=new RedFactory();
    		factory.getColor().colour();
    		
    		factory=new YelloFactory();
    		factory.getColor().colour();
    		
    		
    	}
    }

![70 2][]

# 五：抽象工厂模式 #

***抽象工厂模式提供一个接口用于创建相关或依赖对象的家族，而不需要指定具体类。***

**意图：**提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

**主要解决：**主要解决接口选择的问题。

**何时使用：**系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

**如何解决：**在一个产品族里面，定义多个产品。

**关键代码：**在一个工厂里聚合多个同类产品。

**应用实例：**工作了，为了参加一些聚会，肯定有两套或多套衣服吧，比如说有商务装（成套，一系列具体产品）、时尚装（成套，一系列具体产品），甚至对于一个家庭来说，可能有商务女装、商务男装、时尚女装、时尚男装，这些也都是成套的，即一系列具体产品。假设一种情况（现实中是不存在的，要不然，没法进入共产主义了，但有利于说明抽象工厂模式），在您的家中，某一个衣柜（具体工厂）只能存放某一种这样的衣服（成套，一系列具体产品），每次拿这种成套的衣服时也自然要从这个衣柜中取出了。用 OO 的思想去理解，所有的衣柜（具体工厂）都是衣柜类的（抽象工厂）某一个，而每一件成套的衣服又包括具体的上衣（某一具体产品），裤子（某一具体产品），这些具体的上衣其实也都是上衣（抽象产品），具体的裤子也都是裤子（另一个抽象产品）。

**优点：**当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

**缺点：**产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

**使用场景：** 1、QQ 换皮肤，一整套一起换。 2、生成不同操作系统的程序。

**注意事项：**产品族难扩展，产品等级易扩展。

**实现：**

首先定义两个接口分别是Color和Shape:

/* 
    * @author zzf 
    * @date 2018年10月19日 下午4:05:17 
    */
    public interface Color {
    	void colour();
    }

/* 
    * @author zzf 
    * @date 2018年10月19日 下午5:03:33 
    */
    public interface Shape {
    
    	public void draw();
    }

然后实现这两个类：

/* 
    * @author zzf 
    * @date 2018年10月19日 下午4:06:25 
    */
    public class Red implements Color{
    
    	@Override
    	public void colour() {
    		// TODO Auto-generated method stub
    		System.out.println("Red");
    	}
    
    }

/* 
    * @author zzf 
    * @date 2018年10月19日 下午4:07:09 
    */
    public class Yello implements Color{
    
    	@Override
    	public void colour() {
    		// TODO Auto-generated method stub
    		System.out.println("Yello");
    	}
    
    }

/* 
    * @author zzf 
    * @date 2018年10月19日 下午5:11:45 
    */
    public class Square implements Shape{
    
    	@Override
    	public void draw() {
    		// TODO Auto-generated method stub
    		System.out.println("正方形");
    	}
    
    }

/* 
    * @author zzf 
    * @date 2018年10月19日 下午5:10:29 
    */
    public class Rotundity implements Shape{
    
    	@Override
    	public void draw() {
    		// TODO Auto-generated method stub
    		System.out.println("圆形");
    	}
    
    }

然后创建抽象工厂模式类:

/* 
    * @author zzf 
    * @date 2018年10月19日 下午4:08:15 
    */
    public abstract class Factory {
    
    	abstract public Color getColor(String type);
    	abstract public Shape getShape(String type);
    	
    }

分别实现：

/* 
    * @author zzf 
    * @date 2018年10月19日 下午5:05:13 
    */
    public class ShapeFactory extends Factory{
    
    	@Override
    	public Color getColor(String type) {
    		// TODO Auto-generated method stub
    		return null;
    	}
    
    	@Override
    	public Shape getShape(String type) {
    		if("rotundity".equals(type)) {
    			return new Rotundity();
    		}else if("square".equals(type)){
    			return new Square();
    		}
    		return null;
    	}
    
    }

/* 
    * @author zzf 
    * @date 2018年10月19日 下午4:45:38 
    */
    public class ColorFactory extends Factory{
    
    	@Override
    	public Color getColor(String type) {
    		// TODO Auto-generated method stub
    		if("red".equals(type)) {
    			return new Red();
    		}else if("yello".equals(type)){
    			return new Yello();
    		}
    		return null;
    	}
    
    	@Override
    	public Shape getShape(String type) {
    		// TODO Auto-generated method stub
    		return null;
    	}
    
    }

然后创建一个工厂选择器：

/* 
    * @author zzf 
    * @date 2018年10月19日 下午5:17:22 
    */
    public class ProducerFactory {
    
    	public static Factory getFactory(String type) {
    		if("shape".equals(type)) {
    			return new ShapeFactory();
    		}else if("color".equals(type)){
    			return new ColorFactory();
    		}
    		return null;
    	}
    }

测试类：

public class ColorDemo {
    
    	public static void main(String[] args) {
    		Factory factory1=ProducerFactory.getFactory("color");
    		Factory factory2=ProducerFactory.getFactory("shape");
    		
    		factory1.getColor("red").colour();
    		factory1.getColor("yello").colour();
    		factory2.getShape("rotundity").draw();
    		factory2.getShape("square").draw();
    		
    		
    	}
    }

![70 3][]

**要点：**

**1、所有的工厂都是用来封装对象的创建。**

**2、简单工厂不是真正的设计模式，但是是一个简单的方法可以将客户端程序从具体类解耦。**

**3、工厂方法使用继承：把对象创建委托给子类，子类实现工厂方法来创建对象。**

**4、抽象工厂使用对象组合：对象的创建被实现在工厂接口所暴露出来的方法中。**

**5、所有工厂模式都通过减少应用程序和具体类之间的依赖促进松耦合。**

**6、工厂方法允许将类实例化延迟到子类进行。**

**7、抽象工厂创建相关对象家族，而不需要依赖他们的具体类。**

**8、依赖倒置原则，知道我们避免依赖具体类型，而要尽量依赖抽象。**

**9、工厂帮助我们针对抽象编程，而不针对具体类编程。**

参考：[https://www.w3cschool.cn/shejimoshi/abstract-factory-pattern.html][https_www.w3cschool.cn_shejimoshi_abstract-factory-pattern.html]

[70]: /images/20220505/cbf9ca2eee9649cdbb67e681d0378cd0.png
[70 1]: /images/20220505/6f3a0e7d1ba64107937d91302f601bfb.png
[70 2]: /images/20220505/dfe54fddfcf44925877c19b36bec93a2.png
[70 3]: /images/20220505/e13f5e4a88e448e2814736da0c3076cd.png
[https_www.w3cschool.cn_shejimoshi_abstract-factory-pattern.html]: https://www.w3cschool.cn/shejimoshi/abstract-factory-pattern.html