java设计模式

一、设计模式分类：

1. 目的来分（用来完成什么工作）

创建型模式：
	    描述“怎样创建对象”，它的主要特点是“将对象的创建与使用分离”
		单例、原型、工厂方法、抽象工厂、建造者等5种
结构型模式：
		描述如何将类或对象按某种布局组成更大的结构，
		代理、适配器、桥接、装饰、外观、享元、组合等7种
行为型模式：
		描述类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，以及怎样分配职责。
		模板方法、策略、命令、职责链、状态、观察者、中介者、迭代器、访问者、备忘录、解释器等11种

2. 根据作用范围来分（用于类上还是主要用于对象上来分）

	类模式：
		用于处理类与子类之间的关系，这些关系通过继承来建立，是静态的，在编译时刻便确定下来了。
		工厂方法、适配器、模板方法、解释器 属于该模式。
	对象模式：
		用于处理对象之间的关系，这些关系可以通过组合或聚合来实现，在运行时刻是可以变化的，更具动态性。
		除了以上4种，其他的都是对象模式。

二、七大设计原则

2.1、开闭原则

• 软件实体应当对扩展开放，对修改关闭

	软件实体包括：
		项目中划分出的模块
		类与接口
		方法	
【例】Windows 的桌面主题设计
	分析：Windows 的主题是桌面背景图片、窗口颜色和声音等元素的组合。用户可以根据自己的喜爱更换自己的桌面主题，也可以从网上下载新的主题。
	这些主题有共同的特点，可以为其定义一个抽象类（Abstract Subject），而每个具体的主题（Specific Subject）是其子类。用户窗体可以根据需要选择或者增加新的主题，而不需要修改原代码，所以它是满足开闭原则的，如图所示

2.2、里氏替换原则

• 里氏替换原则主要阐述了有关继承的一些原则，就是什么时候应该使用继承，什么时候不应该使用继承。
• 它反映了基类与子类之间的关系，是对开闭原则的补充，是对实现抽象化的具体步骤的规范
• 具体体现

1、子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法
2、子类中可以增加自己特有的方法
3、当子类的方法重载父类的方法时，方法的前置条件（即方法的输入参数）要
	比父类的方法更宽松
4、当子类的方法实现父类的方法时（重写/重载或实现抽象方法），方法的后置条
	件（即方法的的输出/返回值）要比父类的方法更严格或相等

• 【例1】里氏替换原则在“几维鸟不是鸟”实例中的应用。
• 分析：鸟一般都会飞行，如燕子的飞行速度大概是每小时 120 千米。但是新西兰的几维鸟由于翅膀退化无法飞行。假如要设计一个实例，计算这两种鸟飞行 300 千米要花费的时间。显然，拿燕子来测试这段代码，结果正确，能计算出所需要的时间；但拿几维鸟来测试，结果会发生“除零异常”或是“无穷大”，明显不符合预期

package principle;
public class LSPtest {
    public static void main(String[] args) {
        Bird bird1 = new Swallow();
        Bird bird2 = new BrownKiwi();
        bird1.setSpeed(120);
        bird2.setSpeed(120);
        System.out.println("如果飞行300公里：");
        try {
            System.out.println("燕子将飞行" + bird1.getFlyTime(300) + "小时.");
            System.out.println("几维鸟将飞行" + bird2.getFlyTime(300) + "小时。");
        } catch (Exception err) {
            System.out.println("发生错误了!");
        }
    }
}
//鸟类
class Bird {
    double flySpeed;
    public void setSpeed(double speed) {
        flySpeed = speed;
    }
    public double getFlyTime(double distance) {
        return (distance / flySpeed);
    }
}
//燕子类
class Swallow extends Bird {
}
//几维鸟类
class BrownKiwi extends Bird {
    public void setSpeed(double speed) {
        flySpeed = 0;
    }
}

• 程序运行错误的原因是：几维鸟类重写了鸟类的 setSpeed(double speed) 方法，这违背了里氏替换原则。正确的做法是：取消几维鸟原来的继承关系，定义鸟和几维鸟的更一般的父类，如动物类，它们都有奔跑的能力。几维鸟的飞行速度虽然为 0，但奔跑速度不为 0，可以计算出其奔跑 300 千米所要花费的时间

2.3、依赖倒置原则

• 原始定义为：高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象。
• 核心思想是：要面向接口编程，不要面向实现编程
• 依赖倒置原则的目的是通过要面向接口的编程来降低类间的耦合性，所以我们在实际编程中只要遵循以下4点

	每个类尽量提供接口或抽象类，或者两者都具备。
	变量的声明类型尽量是接口或者是抽象类。
	任何类都不应该从具体类派生。
	使用继承时尽量遵循里氏替换原则。

• 【例1】依赖倒置原则在“顾客购物程序”中的应用
• 本程序反映了 “顾客类”与“商店类”的关系。商店类中有 sell() 方法，顾客类通过该方法购物,以下代码定义了顾客类通过韶关网店 ShaoguanShop 购物

class Customer {
    public void shopping(ShaoguanShop shop) {
        //购物
        System.out.println(shop.sell());
    }
}

• 但是，这种设计存在缺点，如果该顾客想从另外一家商店（如婺源网店 WuyuanShop）购物，就要将该顾客的代码修改如下

	class Customer {
	    public void shopping(WuyuanShop shop) {
	        //购物
	        System.out.println(shop.sell());
	    }
	}

• 顾客每更换一家商店，都要修改一次代码，这明显违背了开闭原则。
• 存在以上缺点的原因是：顾客类设计时同具体的商店类绑定了，这违背了依赖倒置原则。
• 解决方法是：定义“婺源网店”和“韶关网店”的共同接口 Shop，顾客类面向该接口编程，其代码修改如下，这样，不管顾客类 Customer 访问什么商店，或者增加新的商店，都不需要修改原有代码了

class Customer {
    public void shopping(Shop shop) {
        //购物
        System.out.println(shop.sell());
    }
}

• 全部代码

package principle;
public class DIPtest {
    public static void main(String[] args) {
        Customer wang = new Customer();
        System.out.println("顾客购买以下商品：");
        wang.shopping(new ShaoguanShop());
        wang.shopping(new WuyuanShop());
    }
}
//商店
interface Shop {
    public String sell(); //卖
}
//韶关网店
class ShaoguanShop implements Shop {
    public String sell() {
        return "韶关土特产：香菇、木耳……";
    }
}
//婺源网店
class WuyuanShop implements Shop {
    public String sell() {
        return "婺源土特产：绿茶、酒糟鱼……";
    }
}
//顾客
class Customer {
    public void shopping(Shop shop) {
        //购物
        System.out.println(shop.sell());
    }
}

//顾客购买以下商品：
//韶关土特产：香菇、木耳……
//婺源土特产：绿茶、酒糟鱼……

2.4、单一职责原则

• 单一职责规定一个类应该有且仅有一个引起它变化的原因，否则类应该被拆分。及对象不应该承担太多职责。
• 案例
• 分析：大学学生工作主要包括学生生活辅导和学生学业指导两个方面的工作，其中生活辅导主要包括班委建设、出勤统计、心理辅导、费用催缴、班级管理等工作，学业指导主要包括专业引导、学习辅导、科研指导、学习总结等工作。如果将这些工作交给一位老师负责显然不合理，正确的做 法是生活辅导由辅导员负责，学业指导由学业导师负责，其类图如图 1 所示
  
• 单一职责同样也适用于方法。一个方法应该尽可能做好一件事情。如果一个方法处理的事情太多，其颗粒度会变得很粗，不利于重用。

2.5、接口隔离原则

• 要为各个类建立它们需要的专用接口，而不要试图去建立一个很庞大的接口供所有依赖它的类去调用。
• 具体应用接口隔离原则时，应该根据以下几个规则来衡量。

	接口尽量小，但是要有限度。一个接口只服务于一个子模块或业务逻辑。
	为依赖接口的类定制服务。只提供调用者需要的方法，屏蔽不需要的方法。
	了解环境，拒绝盲从。每个项目或产品都有选定的环境因素，环境不同，接口拆分的标准
就不同深入了解业务逻辑。
	提高内聚，减少对外交互。使接口用最少的方法去完成最多的事情。

• 【例】学生成绩管理程序
• 学生成绩管理程序一般包含插入成绩、删除成绩、修改成绩、计算总分、计算均分、打印成绩信息、査询成绩信息等功能，如果将这些功能全部放到一个接口中显然不太合理，正确的做法是将它们分别放在输入模块、统计模块和打印模块等 3 个模块中
  

package principle;

public class ISPtest {
    public static void main(String[] args) {
        InputModule input = StuScoreList.getInputModule();
        CountModule count = StuScoreList.getCountModule();
        PrintModule print = StuScoreList.getPrintModule();
        input.insert();
        count.countTotalScore();
        print.printStuInfo();
        //print.delete();
    }
}

//输入模块接口
interface InputModule {
    void insert();

    void delete();

    void modify();
}

//统计模块接口
interface CountModule {
    void countTotalScore();

    void countAverage();
}

//打印模块接口
interface PrintModule {
    void printStuInfo();

    void queryStuInfo();
}

//实现类
class StuScoreList implements InputModule, CountModule, PrintModule {
    private StuScoreList() {
    }
    public static InputModule getInputModule() {
        return (InputModule) new StuScoreList();
    }
    public static CountModule getCountModule() {
        return (CountModule) new StuScoreList();
    }
    public static PrintModule getPrintModule() {
        return (PrintModule) new StuScoreList();
    }
    public void insert() {
        System.out.println("输入模块的insert()方法被调用！");
    }
    public void delete() {
        System.out.println("输入模块的delete()方法被调用！");
    }
    public void modify() {
        System.out.println("输入模块的modify()方法被调用！");
    }
    public void countTotalScore() {
        System.out.println("统计模块的countTotalScore()方法被调用！");
    }
    public void countAverage() {
        System.out.println("统计模块的countAverage()方法被调用！");
    }
    public void printStuInfo() {
        System.out.println("打印模块的printStuInfo()方法被调用！");
    }
    public void queryStuInfo() {
        System.out.println("打印模块的queryStuInfo()方法被调用！");
    }
}
//输入模块的insert()方法被调用！
//统计模块的countTotalScore()方法被调用！
//打印模块的printStuInfo()方法被调用！

2.6、迪米特法则

• 定义是：只与你的直接朋友交谈，不跟“陌生人”说话
• 含义是：如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用。
• 其目的是降低类之间的耦合度，提高模块的相对独立性
• 主要强调以下两点

	从依赖者的角度来说，只依赖应该依赖的对象。
	从被依赖者的角度说，只暴露应该暴露的方法。

• 运用迪米特法则时要注意以下 6 点

1、在类的划分上，应该创建弱耦合的类。类与类之间的耦合越弱，就越有利于实现可复用的目标。
2、在类的结构设计上，尽量降低类成员的访问权限。
3、在类的设计上，优先考虑将一个类设置成不变类。
4、在对其他类的引用上，将引用其他对象的次数降到最低。
5、不暴露类的属性成员，而应该提供相应的访问器（set 和 get 方法）。
6、谨慎使用序列化（Serializable）功能

• 明星与经纪人的关系实例
• 分析：明星由于全身心投入艺术，所以许多日常事务由经纪人负责处理，如与粉丝的见面会，与媒体公司的业务洽淡等。
• 这里的经纪人是明星的朋友，而粉丝和媒体公司是陌生人，所以适合使用迪米特法则
  

package principle;

public class LoDtest {
    public static void main(String[] args) {
        Agent agent = new Agent();
        agent.setStar(new Star("林心如"));
        agent.setFans(new Fans("粉丝韩丞"));
        agent.setCompany(new Company("中国传媒有限公司"));
        agent.meeting();
        agent.business();
    }
}

//经纪人
class Agent {
    private Star myStar;
    private Fans myFans;
    private Company myCompany;

    public void setStar(Star myStar) {
        this.myStar = myStar;
    }

    public void setFans(Fans myFans) {
        this.myFans = myFans;
    }

    public void setCompany(Company myCompany) {
        this.myCompany = myCompany;
    }

    public void meeting() {
        System.out.println(myFans.getName() + "与明星" + myStar.getName() + "见面了。");
    }

    public void business() {
        System.out.println(myCompany.getName() + "与明星" + myStar.getName() + "洽淡业务。");
    }
}

//明星
class Star {
    private String name;

    Star(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

//粉丝
class Fans {
    private String name;

    Fans(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

//媒体公司
class Company {
    private String name;
    
    Company(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

2.7、合成复用原则

• 合成复用原则：是通过将已有的对象纳入新对象中，作为新对象的成员对象来实现的，新对象可以调用已有对象的功能，从而达到复用。
• 要求在软件复用时，要尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现。如果要使用继承关系，则必须严格遵循里氏替换原则。
• 汽车分类管理程序案例
• 分析：

汽车 
     按“动力源”划分可分为汽油汽车、电动汽车等
     按“颜色”划分可分为白色汽车、黑色汽车和红色汽车等

• 下图：所示是用继承关系实现的汽车分类的类图。
  
• 从图 1 可以看出用继承关系实现会产生很多子类，而且增加新的“动力源”或者增加新的“颜色”都要修改源代码，这违背了开闭原则，显然不可取。
• 但如果改用组合关系实现就能很好地解决以上问题，其类图如图 2 所示
  

三、GoF的23种设计模式的功能

3.1、单例模式

• 类只能生成一个实例，提供了一个全局访问点供外部获取该实例。

• 通常，普通类的构造函数是公有的，外部类可以通过“new 构造函数()”来生成多个实例。但是，如果将类的构造函数设为私有的，外部类就无法调用该构造函数，也就无法生成多个实例。这时该类自身必须定义一个静态私有实例，并向外提供一个静态的公有的方法，用于创建或获取该静态私有实例。

• 目的：

    1、节省内存资源。
    2、保证数据的一致性。 
    如，Windows 中只能打开一个任务管理器

• 特点

	单例类只有一个实例对象；
	该单例对象必须由单例类自行创建；
	单例类对外提供一个访问该单例的全局访问点。

• 单例模式的缺点：

	1.单例模式一般没有接口，扩展困难。如果要扩展，则除了修改原来的代码，没有第二种
途径，违背开闭原则。
	2.在并发测试中，单例模式不利于代码调试。在调试过程中，如果单例中的代码没有执
行完，也不能模拟生成一个新的对象。
	3.单例模式的功能代码通常写在一个类中，如果功能设计不合理，则很容易违背单一职
责原则。

• 应用场景

	1、需要频繁创建的一些类，使用单例可以降低系统的内存压力，减少 GC。
	2、某类只要求生成一个对象的时候，如一个班中的班长、每个人的身份证号等。
	3、某些类创建实例时占用资源较多，或实例化耗时较长，且经常使用。
	4、某类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池、网络连接池等。
	5、频繁访问数据库或文件的对象。
	6、对于一些控制硬件级别的操作，或者从系统上来讲应当是单一控制逻辑的操作，如果有多
个实例，则系统会完全乱套。
	7、当对象需要被共享的场合。由于单例模式只允许创建一个对象，共享该对象可以节省内
存，并加快对象访问速度。如 Web 中的配置对象、数据库的连接池等。

• 单例模式的实现
• 第 1 种：懒汉式单例
• 该模式的特点是类加载时没有生成单例，只有当第一次调用 getlnstance 方法时才去创建这个单例

//如果编写的是多线程程序，则不要删除关键字 volatile 和 synchronized，
//否则将存在线程非安全的问题。如果不删除这两个关键字就能保证线程安全.
//懒汉式单例的缺点:每次访问时都要同步,会影响性能，且消耗更多的资源.
//用volatile修饰的变量，线程在每次使用变量的时候，都会读取变量修改后的最的值
public class LazySingleton {
    //保证 instance 在所有线程中同步
    private static volatile LazySingleton instance = null;    
    
    private LazySingleton() {
    }    //private 避免类在外部被实例化

    public static synchronized LazySingleton getInstance() {
        //getInstance 方法前加同步
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

• 第 2 种：饿汉式单例

//该模式的特点是类一旦加载就创建一个单例，保证在调用 getInstance 方法之前单例已经存在
public class HungrySingleton {
    private static final HungrySingleton instance = new HungrySingleton();

    private HungrySingleton() {
    }
    public static HungrySingleton getInstance() {
        return instance;
    }
}

• 用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象

原型（Prototype）模式：将一个对象作为原型，通过对其进行复制而克隆出多个和原型类似的新实例。
工厂方法（Factory Method）模式：定义一个用于创建产品的接口，由子类决定生产什么产品。
抽象工厂（AbstractFactory）模式：提供一个创建产品族的接口，其每个子类可以生产一系列相关的产品。
建造者（Builder）模式：将一个复杂对象分解成多个相对简单的部分，然后根据不同需要分别创建它们，最后构建成该复杂对象。
代理（Proxy）模式：为某对象提供一种代理以控制对该对象的访问。即客户端通过代理间接地访问该对象，从而限制、增强或修改该对象的一些特性。
适配器（Adapter）模式：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。
桥接（Bridge）模式：将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。
装饰（Decorator）模式：动态的给对象增加一些职责，即增加其额外的功能。
外观（Facade）模式：为多个复杂的子系统提供一个一致的接口，使这些子系统更加容易被访问。
享元（Flyweight）模式：运用共享技术来有效地支持大量细粒度对象的复用。
组合（Composite）模式：将对象组合成树状层次结构，使用户对单个对象和组合对象具有一致的访问性。
模板方法（TemplateMethod）模式：定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。
策略（Strategy）模式：定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的改变不会影响使用算法的客户。
命令（Command）模式：将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。
职责链（Chain of Responsibility）模式：把请求从链中的一个对象传到下一个对象，直到请求被响应为止。通过这种方式去除对象之间的耦合。
状态（State）模式：允许一个对象在其内部状态发生改变时改变其行为能力。
观察者（Observer）模式：多个对象间存在一对多关系，当一个对象发生改变时，把这种改变通知给其他多个对象，从而影响其他对象的行为。
中介者（Mediator）模式：定义一个中介对象来简化原有对象之间的交互关系，降低系统中对象间的耦合度，使原有对象之间不必相互了解。
迭代器（Iterator）模式：提供一种方法来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。
访问者（Visitor）模式：在不改变集合元素的前提下，为一个集合中的每个元素提供多种访问方式，即每个元素有多个访问者对象访问。
备忘录（Memento）模式：在不破坏封装性的前提下，获取并保存一个对象的内部状态，以便以后恢复它。
解释器（Interpreter）模式：提供如何定义语言的文法，以及对语言句子的解释方法，即解释器。

3.2、原型模式

• 用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象
• 优点

  1、原型模式基于内存二进制流的复制，在性能上比直接 new 一个对象更加优良。
  2、简化了创建对象的过程，以便在需要的时候使用（例如恢复到历史某一状态），可辅助实现撤销操作

• 缺点

	1、需要为每一个类都配置一个 clone 方法
	2、clone 方法位于类的内部，当对已有类进行改造的时候，需要修改代码，违背了开闭原则。
	3、当实现深克隆时，需要编写较为复杂的代码，而且当对象之间存在多重嵌套引用时，为了
实现深克隆，每一层对象对应的类都必须支持深克隆，实现起来会比较麻烦。因此，深克隆、
浅克隆需要运用得当。

• 模式的实现

原型模式的克隆分为浅克隆和深克隆。
	浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，
仍指向原有属性所指向的对象的内存地址。
	深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址

• Java 中的 Object 类提供了浅克隆的 clone() 方法，具体原型类只要实现 Cloneable 接口就可实现对象的浅克隆，这里的 Cloneable 接口就是抽象原型类

//具体原型类
class Realizetype implements Cloneable {
    Realizetype() {
        System.out.println("具体原型创建成功！");
    }

    public Object clone() throws CloneNotSupportedException {
        System.out.println("具体原型复制成功！");
        return (Realizetype) super.clone();
    }
}

//原型模式的测试类
public class PrototypeTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        Realizetype obj1 = new Realizetype();
        Realizetype obj2 = (Realizetype) obj1.clone();
        System.out.println("obj1==obj2?" + (obj1 == obj2));
    }
}
//具体原型创建成功！
//具体原型复制成功！
//obj1==obj2?false

3.3、简单工厂模式

• 定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点
• 有3 种不同的实现方式，分别是简单工厂模式、工厂方法模式和抽象工厂模式
• 简单工厂模式每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度，违背了“开闭原则”。

简单工厂模式：
	我们把被创建的对象称为“产品”，把创建产品的对象称为“工厂”。
	要创建的产品不多，只要一个工厂类就可以完成，称为简单工程模式。
	简单工厂模式中创建实例的方法通常为静态（static）方法，
	因此简单工厂模式（Simple Factory Pattern）又叫作静态工厂方法模式（Static Factory Method Pattern）

• 代码案例

public class Client {
    public static void main(String[] args) {
    }

    //抽象产品
    public interface Product {
        void show();
    }

    //具体产品：ProductA
    static class ConcreteProduct1 implements Product {
        public void show() {
            System.out.println("具体产品1显示...");
        }
    }

    //具体产品：ProductB
    static class ConcreteProduct2 implements Product {
        public void show() {
            System.out.println("具体产品2显示...");
        }
    }

    final class Const {
        static final int PRODUCT_A = 0;
        static final int PRODUCT_B = 1;
        static final int PRODUCT_C = 2;
    }

    static class SimpleFactory {
        public static Product makeProduct(int kind) {
            switch (kind) {
                case Const.PRODUCT_A:
                    return new ConcreteProduct1();
                case Const.PRODUCT_B:
                    return new ConcreteProduct2();
            }
            return null;
        }
    }
}

3.4、工厂方法模式

• “工厂方法模式”是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。
• 工厂方法模式 由抽象工厂、具体工厂、抽象产品和具体产品 等4个要素构成

	抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方
法 newProduct() 来创建产品。
	具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
	抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
	具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具
体工厂之间一一对应

• 优点

	用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。
	灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。
	典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪
米特法则、依赖倒置原则和里氏替换原则

• 缺点

	类的个数容易过多，增加复杂度
	增加了系统的抽象性和理解难度
	抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决

• 代码

package FactoryMethod;

public class AbstractFactoryTest {
    public static void main(String[] args) {
        try {
            Product a;
            AbstractFactory af;
            af = (AbstractFactory) ReadXML1.getObject();
            a = af.newProduct();
            a.show();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

//抽象产品：提供了产品的接口
interface Product {
    public void show();
}

//具体产品1：实现抽象产品中的抽象方法
class ConcreteProduct1 implements Product {
    public void show() {
        System.out.println("具体产品1显示...");
    }
}

//具体产品2：实现抽象产品中的抽象方法
class ConcreteProduct2 implements Product {
    public void show() {
        System.out.println("具体产品2显示...");
    }
}

//抽象工厂：提供了厂品的生成方法
interface AbstractFactory {
    public Product newProduct();
}

//具体工厂1：实现了厂品的生成方法
class ConcreteFactory1 implements AbstractFactory {
    public Product newProduct() {
        System.out.println("具体工厂1生成-->具体产品1...");
        return new ConcreteProduct1();
    }
}

//具体工厂2：实现了厂品的生成方法
class ConcreteFactory2 implements AbstractFactory {
    public Product newProduct() {
        System.out.println("具体工厂2生成-->具体产品2...");
        return new ConcreteProduct2();
    }
}

• config1.xml

<?xml version="1.0" encoding="UTF-8"?>
<config>
	<className>ConcreteFactory1</className>
</config>

package FactoryMethod;
import javax.xml.parsers.*;
import org.w3c.dom.*;
import java.io.*;

class ReadXML1 {
    //该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象
    public static Object getObject() {
        try {
            //创建文档对象
            DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = dFactory.newDocumentBuilder();
            Document doc;
            doc = builder.parse(new File("src/FactoryMethod/config1.xml"));
            //获取包含类名的文本节点
            NodeList nl = doc.getElementsByTagName("className");
            Node classNode = nl.item(0).getFirstChild();
            String cName = "FactoryMethod." + classNode.getNodeValue();
            //System.out.println("新类名："+cName);
            //通过类名生成实例对象并将其返回
            Class<?> c = Class.forName(cName);
            Object obj = c.newInstance();
            return obj;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

• main

public class AbstractFactoryTest {
    public static void main(String[] args) {
        try {
            Product a;
            AbstractFactory af;
            af = (AbstractFactory) ReadXML1.getObject();
            a = af.newProduct();
            a.show();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

3.5、抽象工厂模式

• 定义：是一种为 访问类 提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。
• 抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品
• 使用抽象工厂模式一般要满足以下条件

	系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。
	系统一次只可能消费其中某一族产品，即同族的产品一起使用。

• 优点

可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品组。
抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码，满足开闭原则。

• 缺点

当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度

• 抽象工厂模式的主要角色

	抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，
可以创建多个不同等级的产品。
	具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
	抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
	具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体
工厂之间是多对一的关系

• 可以看出抽象工厂模式的结构同工厂方法模式的结构相似，不同的是其产品的种类不止一个，所以创建产品的方法也不止一个。下面给出抽象工厂和具体工厂的代码。
• 抽象工厂：提供了产品的生成方法。

interface AbstractFactory {
    public Product1 newProduct1();
    public Product2 newProduct2();
}

• 具体工厂：实现了产品的生成方法

class ConcreteFactory1 implements AbstractFactory {
    public Product1 newProduct1() {
        System.out.println("具体工厂 1 生成-->具体产品 11...");
        return new ConcreteProduct11();
    }
    public Product2 newProduct2() {
        System.out.println("具体工厂 1 生成-->具体产品 21...");
        return new ConcreteProduct21();
    }
}

3.6、建造者模式

• 定义

	它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。这
样的设计模式被称为建造者模式。
	它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。

• 在软件开发过程中有时需要创建一个复杂的对象，这个复杂对象通常由多个子部件按一定的步骤组合而成，例如，计算机是由 CPU、主板、内存、硬盘、显卡、机箱、显示器、键盘、鼠标等部件组装而成的。
• 采购员不可能自己去组装计算机，而是将计算机的配置要求告诉计算机销售公司，计算机销售公司安排技术人员去组装计算机，然后再交给要买计算机的采购员。
• 又如游戏中的不同角色，其性别、个性、能力、脸型、体型、服装、发型等特性都有所差异；还有汽车中的方向盘、发动机、车架、轮胎等部件也多种多样；每封电子邮件的发件人、收件人、主题、内容、附件等内容也各不相同。
• 以上所有这些产品都是由多个部件构成的，各个部件可以灵活选择，但其创建步骤都大同小异。这类产品的创建无法用前面介绍的工厂模式描述，只有建造者模式(计算机技术人员)可以很好地描述该类产品的创建。
• 优点

	封装性好，构建和表示分离。
	扩展性好，各个具体的建造者相互独立，有利于系统的解耦。
    客户端不必知道产品内部组成的细节，建造者可以对创建过程逐步细化，而不对其它模块产生
任何影响，便于控制细节风险。

• 缺点

	产品的组成部分必须相同，这限制了其使用范围。
	如果产品的内部变化复杂，如果产品内部发生变化，则建造者也要同步修改，后期维护成本较大

• 建造者（Builder）模式和工厂模式的关注点不同：建造者模式注重零部件的组装过程，而工厂方法模式更注重零部件的创建过程，但两者可以结合使用。
• 建造者（Builder）模式的主要角色

	产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个零部件。
	抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个
返回复杂产品的方法 getResult()。
	具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。
	指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息

• 具体代码
• (1) 产品角色：包含多个组成部件的复杂对象

class Product {
    private String partA;
    private String partB;
    private String partC;

    public void setPartA(String partA) {
        this.partA = partA;
    }
    public void setPartB(String partB) {
        this.partB = partB;
    }
    public void setPartC(String partC) {
        this.partC = partC;
    }
    public void show() {
        //显示产品的特性
    }
}

• (2) 抽象建造者：包含创建产品各个子部件的抽象方法。

abstract class Builder {
    //创建产品对象
    protected Product product = new Product();

    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract void buildPartC();

    //返回产品对象
    public Product getResult() {
        return product;
    }
}

(3) 具体建造者：实现了抽象建造者接口。

public class ConcreteBuilder extends Builder {
    public void buildPartA() {
        product.setPartA("建造 PartA");
    }
    public void buildPartB() {
        product.setPartB("建造 PartB");
    }
    public void buildPartC() {
        product.setPartC("建造 PartC");
    }
}

(4) 指挥者：调用建造者中的方法完成复杂对象的创建。

class Director {
    private Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }
    //产品构建与组装方法
    public Product construct() {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        return builder.getResult();
    }
}

(5) 客户类。

public class Client {
    public static void main(String[] args) {
        Builder builder = new ConcreteBuilder();
        Director director = new Director(builder);
        Product product = director.construct();
        product.show();
    }
}