三：装饰者模式
装饰者模式动态地将责任附加到对象上。若要扩展功能，装饰者提供了比继承更有弹性的替代方案。
意图：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。
主要解决：一般的，我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。
何时使用：在不想增加很多子类的情况下扩展类。
如何解决：将具体功能职责划分，同时继承装饰者模式。
关键代码： 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());
}
}
在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);
}
}
要点：
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();
}
}
五：抽象工厂模式
抽象工厂模式提供一个接口用于创建相关或依赖对象的家族，而不需要指定具体类。
意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
主要解决：主要解决接口选择的问题。
何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。
如何解决：在一个产品族里面，定义多个产品。
关键代码：在一个工厂里聚合多个同类产品。
应用实例：工作了，为了参加一些聚会，肯定有两套或多套衣服吧，比如说有商务装（成套，一系列具体产品）、时尚装（成套，一系列具体产品），甚至对于一个家庭来说，可能有商务女装、商务男装、时尚女装、时尚男装，这些也都是成套的，即一系列具体产品。假设一种情况（现实中是不存在的，要不然，没法进入共产主义了，但有利于说明抽象工厂模式），在您的家中，某一个衣柜（具体工厂）只能存放某一种这样的衣服（成套，一系列具体产品），每次拿这种成套的衣服时也自然要从这个衣柜中取出了。用 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();
}
}
要点：
1、所有的工厂都是用来封装对象的创建。
2、简单工厂不是真正的设计模式，但是是一个简单的方法可以将客户端程序从具体类解耦。
3、工厂方法使用继承：把对象创建委托给子类，子类实现工厂方法来创建对象。
4、抽象工厂使用对象组合：对象的创建被实现在工厂接口所暴露出来的方法中。
5、所有工厂模式都通过减少应用程序和具体类之间的依赖促进松耦合。
6、工厂方法允许将类实例化延迟到子类进行。
7、抽象工厂创建相关对象家族，而不需要依赖他们的具体类。
8、依赖倒置原则，知道我们避免依赖具体类型，而要尽量依赖抽象。
9、工厂帮助我们针对抽象编程，而不针对具体类编程。
参考：https://www.w3cschool.cn/shejimoshi/abstract-factory-pattern.html