Java基础（四）设计模式

骑猪看日落 2022-02-27 08:36 211阅读 0赞

# java的设计模式大体上分为三大类： #

*  创建型模式（5种）：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。
 *  结构型模式（7种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。
 *  行为型模式（11种）：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

# **设计模式遵循的原则有6个：** #

**1、开闭原则（Open Close Principle）**

对扩展开放，对修改关闭。

**2、里氏代换原则（Liskov Substitution Principle）**

只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。

**3、依赖倒转原则（Dependence Inversion Principle）**

这个是开闭原则的基础，对接口编程，依赖于抽象而不依赖于具体。

**4、接口隔离原则（Interface Segregation Principle）**

使用多个隔离的借口来降低耦合度。

**5、迪米特法则（最少知道原则）（Demeter Principle）**

一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

**6、合成复用原则（Composite Reuse Principle）**

原则是尽量使用合成/聚合的方式，而不是使用继承。继承实际上破坏了类的封装性，超类的方法可能会被子类修改。

# 1. 工厂模式（Factory Method） #

常用的工厂模式是静态工厂，利用static方法，作为一种类似于常见的工具类Utils等辅助效果，一般情况下工厂类不需要实例化。这是一个简单的例子：

interface food{}
    
    class A implements food{}
    class B implements food{}
    class C implements food{}
    
    public class StaticFactory {
    
        private StaticFactory(){}
        
        public static food getA(){  return new A(); }
        public static food getB(){  return new B(); }
        public static food getC(){  return new C(); }
    }
    
    class Client{
        //客户端代码只需要将相应的参数传入即可得到对象
        //用户不需要了解工厂类内部的逻辑。
        public void get(String name){
            food x = null ;
            if ( name.equals("A")) {
                x = StaticFactory.getA();
            }else if ( name.equals("B")){
                x = StaticFactory.getB();
            }else {
                x = StaticFactory.getC();
            }
        }
    }

## 模式的定义与特点 ##

工厂方法（FactoryMethod）模式的定义：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。  
  
我们把被创建的对象称为“产品”，把创建产品的对象称为“工厂”。如果要创建的产品不多，只要一个工厂类就可以完成，这种模式叫“简单工厂模式”，它不属于 GoF 的 23 种经典[设计模式][Link 1]，它的缺点是增加新产品时会违背“开闭原则”。  
  
本节介绍的“工厂方法模式”是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。  
  
工厂方法模式的主要优点有：

*  用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程；
 *  在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足开闭原则；

其缺点是：每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度。

## 模式的结构与实现 ##

工厂方法模式由抽象工厂、具体工厂、抽象产品和具体产品等4个要素构成。本节来分析其基本结构和实现方法。

1. 模式的结构

工厂方法模式的主要角色如下。

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

其结构图如图 所示。

![工厂方法模式的结构图][3-1Q114135A2M3.gif]  
                                                                                图 工厂方法模式的结构图

2. 模式的实现

根据图 1 写出该模式的代码如下：

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();
        }
    }

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;
             }
        }
    }

注意：该程序中用到了 XML 文件，如果想要获取该文件，请点击“[下载][Link 2]”，就可以对其进行下载。  
  
程序运行结果如下：

具体工厂1生成-->具体产品1...
    具体产品1显示...

如果将 XML 配置文件中的 ConcreteFactory1 改为 ConcreteFactory2，则程序运行结果如下：

具体工厂2生成-->具体产品2...
    具体产品2显示...

## 模式的应用实例 ##

【例1】用工厂方法模式设计畜牧场。  
  
分析：有很多种类的畜牧场，如养马场用于养马，养牛场用于养牛，所以该实例用工厂方法模式比较适合。  
  
对养马场和养牛场等具体工厂类，只要定义一个生成动物的方法 newAnimal() 即可。由于要显示马类和牛类等具体产品类的图像，所以它们的构造函数中用到了 JPanel、JLabd 和 ImageIcon 等组件，并定义一个 show() 方法来显示它们。  
  
客户端程序通过对象生成器类 ReadXML2 读取 XML 配置文件中的数据来决定养马还是养牛。其结构图如图 所示。

![畜牧场结构图][3-1Q11413554DT.gif]  
                                                                                 图 畜牧场结构图

注意：该程序中用到了 XML 文件，并且要显示马类和牛类等具体产品类的图像，如果想要获取 HTML 文件和图片，请点击“[下载][Link 3]”，就可以对其进行下载。  
  
程序代码如下：

package FactoryMethod;
    import java.awt.*;
    import javax.swing.*;
    public class AnimalFarmTest
    {
        public static void main(String[] args)
        {
            try
            {
                Animal a;
                AnimalFarm af;
                af=(AnimalFarm) ReadXML2.getObject();
                a=af.newAnimal();
                a.show();
            }
            catch(Exception e)
            {
                System.out.println(e.getMessage());
            }
        }
    }
    //抽象产品：动物类
    interface Animal
    {
        public void show();
    }
    //具体产品：马类
    class Horse implements Animal
    {
        JScrollPane sp;
        JFrame jf=new JFrame("工厂方法模式测试");
        public Horse()
        {
            Container contentPane=jf.getContentPane();
            JPanel p1=new JPanel();
            p1.setLayout(new GridLayout(1,1));
            p1.setBorder(BorderFactory.createTitledBorder("动物：马"));
            sp=new JScrollPane(p1);
            contentPane.add(sp, BorderLayout.CENTER);
            JLabel l1=new JLabel(new ImageIcon("src/A_Horse.jpg"));
            p1.add(l1);       
            jf.pack();       
            jf.setVisible(false);
            jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);    //用户点击窗口关闭 
        }
        public void show()
        {
            jf.setVisible(true);
        }
    }
    //具体产品：牛类
    class Cattle implements Animal
    {
        JScrollPane sp;
        JFrame jf=new JFrame("工厂方法模式测试");
        public Cattle()
        {
            Container contentPane=jf.getContentPane();
            JPanel p1=new JPanel();
            p1.setLayout(new GridLayout(1,1));
            p1.setBorder(BorderFactory.createTitledBorder("动物：牛"));
            sp=new JScrollPane(p1);
            contentPane.add(sp,BorderLayout.CENTER);
            JLabel l1=new JLabel(new ImageIcon("src/A_Cattle.jpg"));
            p1.add(l1);       
            jf.pack();       
            jf.setVisible(false);
            jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);    //用户点击窗口关闭 
        }
        public void show()
        {
            jf.setVisible(true);
        }
    }
    //抽象工厂：畜牧场
    interface AnimalFarm
    {
        public Animal newAnimal();
    }
    //具体工厂：养马场
    class HorseFarm implements AnimalFarm
    {
        public Animal newAnimal()
        {
            System.out.println("新马出生！");
            return new Horse();
        }
    }
    //具体工厂：养牛场
    class CattleFarm implements AnimalFarm
    {
        public Animal newAnimal()
        {
            System.out.println("新牛出生！");
            return new Cattle();
        }
    }

package FactoryMethod;
    import javax.xml.parsers.*;
    import org.w3c.dom.*;
    import java.io.*;
    class ReadXML2
    {
        public static Object getObject()
        {
            try
            {
                DocumentBuilderFactory dFactory=DocumentBuilderFactory.newInstance();
                DocumentBuilder builder=dFactory.newDocumentBuilder();
                Document doc;                           
                doc=builder.parse(new File("src/FactoryMethod/config2.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;
            }
        }
    }

程序的运行结果如图 所示。

![畜牧场养殖的运行结果][3-1Q114135422T9.gif]  
                                                                                     图 畜牧场养殖的运行结果

## 模式的应用场景 ##

工厂方法模式通常适用于以下场景。

*  客户只知道创建产品的工厂名，而不知道具体的产品名。如 TCL 电视工厂、海信电视工厂等。
 *  创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口。
 *  客户不关心创建产品的细节，只关心产品的品牌。

## 模式的扩展 ##

当需要生成的产品不多且不会增加，一个具体工厂类就可以完成任务时，可删除抽象工厂类。这时工厂方法模式将退化到简单工厂模式，其结构图如图  所示。

![简单工厂模式的结构图][3-1Q114135306120.gif]  
                                                                                     图 简单工厂模式的结构图

# 2. 抽象工厂模式（Abstract Factory） #

前面介绍的[工厂模式][Link 4]中考虑的是一类产品的生产，如畜牧场只养动物、电视机厂只生产电视机、计算机软件学院只培养计算机软件专业的学生等。  
  
同种类称为同等级，也就是说：[工厂模式][Link 4]只考虑生产同等级的产品，但是在现实生活中许多工厂是综合型的工厂，能生产多等级（种类） 的产品，如农场里既养动物又种植物，电器厂既生产电视机又生产洗衣机或空调，大学既有软件专业又有生物专业等。  
  
本节要介绍的抽象工厂模式将考虑多等级产品的生产，将同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族，图 1 所示的是海尔工厂和 TCL 工厂所生产的电视机与空调对应的关系图。

![电器工厂的产品等级与产品族][3-1Q1141559151S.gif]  
                                                                   图1 电器工厂的产品等级与产品族

一个基础接口定义了功能，每个实现接口的子类就是产品，然后定义一个工厂接口，实现了工厂接口的就是工厂，这时候，接口编程的优点就出现了，我们可以新增产品类（只需要实现产品接口），只需要同时新增一个工厂类，客户端就可以轻松调用新产品的代码。

抽象工厂的灵活性就体现在这里，无需改动原有的代码，毕竟对于客户端来说，静态工厂模式在不改动StaticFactory类的代码时无法新增产品，如果采用了抽象工厂模式，就可以轻松的新增拓展类。

实例代码：

interface food{}
    
    class A implements food{}
    class B implements food{}
    
    interface produce{ food get();}
    
    class FactoryForA implements produce{
        @Override
        public food get() {
            return new A();
        }
    }
    class FactoryForB implements produce{
        @Override
        public food get() {
            return new B();
        }
    }
    public class AbstractFactory {
        public void ClientCode(String name){
            food x= new FactoryForA().get();
            x = new FactoryForB().get();
        }
    }

## 模式的定义与特点 ##

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

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

抽象工厂模式除了具有工厂方法模式的优点外，其他主要优点如下。

*  可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
 *  当增加一个新的产品族时不需要修改原代码，满足开闭原则。

其缺点是：当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。

## 模式的结构与实现 ##

抽象工厂模式同工厂方法模式一样，也是由抽象工厂、具体工厂、抽象产品和具体产品等 4 个要素构成，但抽象工厂中方法个数不同，抽象产品的个数也不同。现在我们来分析其基本结构和实现方法。

1. 模式的结构

抽象工厂模式的主要角色如下。

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

抽象工厂模式的结构图如图 2 所示。

![抽象工厂模式的结构图][3-1Q11416002NW.gif]  
                                                                             图2 抽象工厂模式的结构图

2. 模式的实现

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

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

(2) 具体工厂：实现了产品的生成方法。

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();
        }
    }

## 模式的应用实例 ##

【例1】用抽象工厂模式设计农场类。  
  
分析：农场中除了像畜牧场一样可以养动物，还可以培养植物，如养马、养牛、种菜、种水果等，所以本实例比前面介绍的畜牧场类复杂，必须用抽象工厂模式来实现。  
  
本例用抽象工厂模式来设计两个农场，一个是韶关农场用于养牛和种菜，一个是上饶农场用于养马和种水果，可以在以上两个农场中定义一个生成动物的方法 newAnimal() 和一个培养植物的方法 newPlant()。  
  
对马类、牛类、蔬菜类和水果类等具体产品类，由于要显示它们的图像（[点此下载图片][Link 5]），所以它们的构造函数中用到了 JPanel、JLabel 和 ImageIcon 等组件，并定义一个 show() 方法来显示它们。  
  
客户端程序通过对象生成器类 ReadXML 读取 XML 配置文件中的数据来决定养什么动物和培养什么植物（[点此下载 XML 文件][XML]）。其结构图如图 3 所示。

![农场类的结构图][3-1Q114160132648.gif]  
                                                                            图3 农场类的结构图

程序代码如下：

package AbstractFactory;
    import java.awt.*;
    import javax.swing.*;
    public class FarmTest
    {
        public static void main(String[] args)
        {
            try
            {          
                Farm f;
                Animal a;
                Plant p;
                f=(Farm) ReadXML.getObject();
                a=f.newAnimal();
                p=f.newPlant();
                a.show();
                p.show();
            }
            catch(Exception e)
            {
                System.out.println(e.getMessage());
            }
        }
    }
    //抽象产品：动物类
    interface Animal
    {
        public void show();
    }
    //具体产品：马类
    class Horse implements Animal
    {
        JScrollPane sp;
        JFrame jf=new JFrame("抽象工厂模式测试");
        public Horse()
        {
            Container contentPane=jf.getContentPane();
            JPanel p1=new JPanel();
            p1.setLayout(new GridLayout(1,1));
            p1.setBorder(BorderFactory.createTitledBorder("动物：马"));
            sp=new JScrollPane(p1);
            contentPane.add(sp, BorderLayout.CENTER);
            JLabel l1=new JLabel(new ImageIcon("src/A_Horse.jpg"));
            p1.add(l1);       
            jf.pack();       
            jf.setVisible(false);
            jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//用户点击窗口关闭 
        }
        public void show()
        {
            jf.setVisible(true);
        }
    }
    //具体产品：牛类
    class Cattle implements Animal
    {
        JScrollPane sp;
        JFrame jf=new JFrame("抽象工厂模式测试");
        public Cattle() {
            Container contentPane=jf.getContentPane();
            JPanel p1=new JPanel();
            p1.setLayout(new GridLayout(1,1));
            p1.setBorder(BorderFactory.createTitledBorder("动物：牛"));
            sp=new JScrollPane(p1);
            contentPane.add(sp, BorderLayout.CENTER);
            JLabel l1=new JLabel(new ImageIcon("src/A_Cattle.jpg"));
            p1.add(l1);       
            jf.pack();       
            jf.setVisible(false);
            jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//用户点击窗口关闭 
        }
        public void show()
        {
            jf.setVisible(true);
        }
    }
    //抽象产品：植物类
    interface Plant
    {
        public void show();
    }
    //具体产品：水果类
    class Fruitage implements Plant
    {
        JScrollPane sp;
        JFrame jf=new JFrame("抽象工厂模式测试");
        public Fruitage()
        {
            Container contentPane=jf.getContentPane();
            JPanel p1=new JPanel();
            p1.setLayout(new GridLayout(1,1));
            p1.setBorder(BorderFactory.createTitledBorder("植物：水果"));
            sp=new JScrollPane(p1);
            contentPane.add(sp, BorderLayout.CENTER);
            JLabel l1=new JLabel(new ImageIcon("src/P_Fruitage.jpg"));
            p1.add(l1);       
            jf.pack();       
            jf.setVisible(false);
            jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//用户点击窗口关闭 
        }
        public void show()
        {
            jf.setVisible(true);
        }
    }
    //具体产品：蔬菜类
    class Vegetables implements Plant
    {
        JScrollPane sp;
        JFrame jf=new JFrame("抽象工厂模式测试");
        public Vegetables()
        {
            Container contentPane=jf.getContentPane();
            JPanel p1=new JPanel();
            p1.setLayout(new GridLayout(1,1));
            p1.setBorder(BorderFactory.createTitledBorder("植物：蔬菜"));
            sp=new JScrollPane(p1);
            contentPane.add(sp, BorderLayout.CENTER);
            JLabel l1=new JLabel(new ImageIcon("src/P_Vegetables.jpg"));
            p1.add(l1);       
            jf.pack();       
            jf.setVisible(false);
            jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//用户点击窗口关闭 
        }
        public void show()
        {
            jf.setVisible(true);
        }
    }
    //抽象工厂：农场类
    interface Farm
    {
        public Animal newAnimal();
        public Plant newPlant();
    }
    //具体工厂：韶关农场类
    class SGfarm implements Farm
    {
        public Animal newAnimal()
        {
            System.out.println("新牛出生！");
            return new Cattle();
        }
        public Plant newPlant()
        {
            System.out.println("蔬菜长成！");
            return new Vegetables();
        }
    }
    //具体工厂：上饶农场类
    class SRfarm implements Farm
    {
        public Animal newAnimal()
        {
            System.out.println("新马出生！");
            return new Horse();
        }
        public Plant newPlant()
        {
            System.out.println("水果长成！");
            return new Fruitage();
        }
    }

package AbstractFactory;
    import javax.xml.parsers.*;
    import org.w3c.dom.*;
    import java.io.*;
    class ReadXML
    {
        public static Object getObject()
        {
            try
            {
                DocumentBuilderFactory dFactory=DocumentBuilderFactory.newInstance();
                DocumentBuilder builder=dFactory.newDocumentBuilder();
                Document doc;                           
                doc=builder.parse(new File("src/AbstractFactory/config.xml"));
                NodeList nl=doc.getElementsByTagName("className");
                Node classNode=nl.item(0).getFirstChild();
                String cName="AbstractFactory."+classNode.getNodeValue();
                System.out.println("新类名："+cName);
                Class<?> c=Class.forName(cName);
                  Object obj=c.newInstance();
                return obj;
            }  
            catch(Exception e)
            {
                   e.printStackTrace();
                   return null;
            }
        }
    }

程序运行结果如图 4 所示。

![农场养殖的运行结果][3-1Q11416021C61.jpg]  
                                                                          图4 农场养殖的运行结果

## 模式的应用场景 ##

抽象工厂模式最早的应用是用于创建属于不同操作系统的视窗构件。如 java 的 AWT 中的 Button 和 Text 等构件在 Windows 和 UNIX 中的本地实现是不同的。  
  
抽象工厂模式通常适用于以下场景：

1.  当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。
2.  系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。
3.  系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。

## 模式的扩展 ##

抽象工厂模式的扩展有一定的“开闭原则”倾斜性：

1.  当增加一个新的产品族时只需增加一个新的具体工厂，不需要修改原代码，满足开闭原则。
2.  当产品族中需要增加一个新种类的产品时，则所有的工厂类都需要进行修改，不满足开闭原则。

另一方面，当系统中只存在一个等级结构的产品时，抽象工厂模式将退化到工厂方法模式。

# 3. 单例模式（Singleton） #

在有些系统中，为了节省内存资源、保证数据内容的一致性，对某些类要求只能创建一个实例，这就是所谓的单例模式。

## 单例模式的定义与特点 ##

单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。  
  
在计算机系统中，还有 Windows 的回收站、操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用程序的日志对象、数据库的连接池、网站的计数器、Web 应用的配置对象、应用程序中的对话框、系统中的缓存等常常被设计成单例。  
  
单例模式有 3 个特点：

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

## 单例模式的结构与实现 ##

单例模式是[设计模式][Link 1]中最简单的模式之一。通常，普通类的构造函数是公有的，外部类可以通过“new 构造函数()”来生成多个实例。但是，如果将类的构造函数设为私有的，外部类就无法调用该构造函数，也就无法生成多个实例。这时该类自身必须定义一个静态私有实例，并向外提供一个静态的公有函数用于创建或获取该静态私有实例。  
  
下面来分析其基本结构和实现方法。

### 1. 单例模式的结构 ###

单例模式的主要角色如下。

*  单例类：包含一个实例且能自行创建这个实例的类。
 *  访问类：使用单例的类。

其结构如图 1 所示。

![单例模式的结构图][3-1Q1131K441K2.gif]  
                                                                            图1 单例模式的结构图

### 2. 单例模式的实现 ###

Singleton 模式通常有两种实现形式。

第 1 种：懒汉式单例

该模式的特点是类加载时没有生成单例，只有当第一次调用 getlnstance 方法时才去创建这个单例。代码如下：

public class LazySingleton
    {
        private static volatile LazySingleton instance=null;    //保证 instance 在所有线程中同步
        private LazySingleton(){}    //private 避免类在外部被实例化
        public static synchronized LazySingleton getInstance()
        {
            //getInstance 方法前加同步
            if(instance==null)
            {
                instance=new LazySingleton();
            }
            return instance;
        }
    }

注意：如果编写的是多线程程序，则不要删除上例代码中的关键字 volatile 和 synchronized，否则将存在线程非安全的问题。如果不删除这两个关键字就能保证线程安全，但是每次访问时都要同步，会影响性能，且消耗更多的资源，这是懒汉式单例的缺点。

第 2 种：饿汉式单例

该模式的特点是类一旦加载就创建一个单例，保证在调用 getInstance 方法之前单例已经存在了。

public class HungrySingleton
    {
        private static final HungrySingleton instance=new HungrySingleton();
        private HungrySingleton(){}
        public static HungrySingleton getInstance()
        {
            return instance;
        }
    }

饿汉式单例在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以是线程安全的，可以直接用于多线程而不会出现问题。

## 单例模式的应用实例 ##

【例1】用懒汉式单例模式模拟产生美国当今总统对象。  
  
分析：在每一届任期内，美国的总统只有一人，所以本实例适合用单例模式实现，图 2 所示是用懒汉式单例实现的结构图。

![美国总统生成器的结构图][3-1Q1131K529345.gif]  
                                                                          图2 美国总统生成器的结构图

程序代码如下：

public class SingletonLazy
    {
        public static void main(String[] args)
        {
            President zt1=President.getInstance();
            zt1.getName();    //输出总统的名字
            President zt2=President.getInstance();
            zt2.getName();    //输出总统的名字
            if(zt1==zt2)
            {
               System.out.println("他们是同一人！");
            }
            else
            {
               System.out.println("他们不是同一人！");
            }
        }
    }
    class President
    {
        private static volatile President instance=null;    //保证instance在所有线程中同步
        //private避免类在外部被实例化
        private President()
        {
            System.out.println("产生一个总统！");
        }
        public static synchronized President getInstance()
        {
            //在getInstance方法上加同步
            if(instance==null)
            {
                   instance=new President();
            }
            else
            {
               System.out.println("已经有一个总统，不能产生新总统！");
            }
            return instance;
        }
        public void getName()
        {
            System.out.println("我是美国总统：特朗普。");
        }  
    }

程序运行结果如下：

产生一个总统！
    我是美国总统：特朗普。
    已经有一个总统，不能产生新总统！
    我是美国总统：特朗普。
    他们是同一人！

【例2】用饿汉式单例模式模拟产生猪八戒对象。  
  
分析：同上例类似，猪八戒也只有一个，所以本实例同样适合用单例模式实现。本实例由于要显示猪八戒的图像（[点此下载该程序所要显示的猪八戒图片][Link 6]），所以用到了框架窗体 JFrame 组件，这里的猪八戒类是单例类，可以将其定义成面板 JPanel 的子类，里面包含了标签，用于保存猪八戒的图像，客户窗体可以获得猪八戒对象，并显示它。图 3 所示是用饿汉式单例实现的结构图。

![猪八戒生成器的结构图][3-1Q1131K55X41.gif]  
                                                                                   图3 猪八戒生成器的结构图

程序代码如下：

import java.awt.*;
    import javax.swing.*;
    public class SingletonEager
    {
        public static void main(String[] args)
        {
            JFrame jf=new JFrame("饿汉单例模式测试");
            jf.setLayout(new GridLayout(1,2));
            Container contentPane=jf.getContentPane();
            Bajie obj1=Bajie.getInstance();
            contentPane.add(obj1);    
            Bajie obj2=Bajie.getInstance(); 
            contentPane.add(obj2);
            if(obj1==obj2)
            {
                System.out.println("他们是同一人！");
            }
            else
            {
                System.out.println("他们不是同一人！");
            }   
            jf.pack();       
            jf.setVisible(true);
            jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        }
    }
    class Bajie extends JPanel
    {
        private static Bajie instance=new Bajie();
        private Bajie()
        { 
            JLabel l1=new JLabel(new ImageIcon("src/Bajie.jpg"));
            this.add(l1);   
        }
        public static Bajie getInstance()
        {
            return instance;
        }
    }

程序运行结果如图 4 所示。

![猪八戒生成器的运行结果][3-1Q1131I0563U.gif]  
                                                                            图4 猪八戒生成器的运行结果

## 单例模式的应用场景 ##

前面分析了单例模式的结构与特点，以下是它通常适用的场景的特点。

*  在应用场景中，某类只要求生成一个对象的时候，如一个班中的班长、每个人的身份证号等。
 *  当对象需要被共享的场合。由于单例模式只允许创建一个对象，共享该对象可以节省内存，并加快对象访问速度。如 Web 中的配置对象、数据库的连接池等。
 *  当某类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池、网络连接池等。

## 单例模式的扩展 ##

单例模式可扩展为有限的多例（Multitcm）模式，这种模式可生成有限个实例并保存在 ArmyList 中，客户需要时可随机获取，其结构图如图 5 所示。

![有限的多例模式的结构图][3-1Q1131KQ4K8.gif]  
                                                                     图5 有限的多例模式的结构图

## ##

# 4.建造者模式（Builder） #

在了解之前，先假设有一个问题，我们需要创建一个学生对象，属性有name,number,class,sex,age,school等属性，如果每一个属性都可以为空，也就是说我们可以只用一个name,也可以用一个school,name,或者一个class,number，或者其他任意的赋值来创建一个学生对象，这时该怎么构造？

难道我们写6个1个输入的构造函数，15个2个输入的构造函数.......吗？这个时候就需要用到Builder模式了。给个例子，大家肯定一看就懂：

public class Builder {
    
        static class Student{
            String name = null ;
            int number = -1 ;
            String sex = null ;
            int age = -1 ;
            String school = null ;
    
    　　　　　//构建器，利用构建器作为参数来构建Student对象
            static class StudentBuilder{
                String name = null ;
                int number = -1 ;
                String sex = null ;
                int age = -1 ;
                String school = null ;
                public StudentBuilder setName(String name) {
                    this.name = name;
                    return  this ;
                }
    
                public StudentBuilder setNumber(int number) {
                    this.number = number;
                    return  this ;
                }
    
                public StudentBuilder setSex(String sex) {
                    this.sex = sex;
                    return  this ;
                }
    
                public StudentBuilder setAge(int age) {
                    this.age = age;
                    return  this ;
                }
    
                public StudentBuilder setSchool(String school) {
                    this.school = school;
                    return  this ;
                }
                public Student build() {
                    return new Student(this);
                }
            }
    
            public Student(StudentBuilder builder){
                this.age = builder.age;
                this.name = builder.name;
                this.number = builder.number;
                this.school = builder.school ;
                this.sex = builder.sex ;
            }
        }
    
        public static void main( String[] args ){
            Student a = new Student.StudentBuilder().setAge(13).setName("LiHua").build();
            Student b = new Student.StudentBuilder().setSchool("sc").setSex("Male").setName("ZhangSan").build();
        }
    }

# 5. 原型模式（Protype） #

原型模式就是讲一个对象作为原型，使用clone()方法来创建新的实例。

public class Prototype implements Cloneable{
    
        private String name;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        protected Object clone()   {
            try {
                return super.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }finally {
                return null;
            }
        }
    
        public static void main ( String[] args){
            Prototype pro = new Prototype();
            Prototype pro1 = (Prototype)pro.clone();
        }
    }

此处使用的是浅拷贝，关于深浅拷贝，大家可以另行查找相关资料。

# 6.适配器模式（Adapter） #

适配器模式的作用就是在原来的类上提供新功能。主要可分为3种：

*  类适配：创建新类，继承源类，并实现新接口，例如 
    
        class  adapter extends oldClass  implements newFunc{}
 *  对象适配：创建新类持源类的实例，并实现新接口，例如 
    
        class adapter implements newFunc { private oldClass oldInstance ;}
 *  接口适配：创建新的抽象类实现旧接口方法。例如 
    
        abstract class adapter implements oldClassFunc { void newFunc();}

# 7.装饰模式（Decorator） #

给一类对象增加新的功能，装饰方法与具体的内部逻辑无关。例如：

interface Source{ void method();}
    public class Decorator implements Source{
    
        private Source source ;
        public void decotate1(){
            System.out.println("decorate");
        }
        @Override
        public void method() {
            decotate1();
            source.method();
        }
    }

# 8.代理模式（Proxy） #

客户端通过代理类访问，代理类实现具体的实现细节，客户只需要使用代理类即可实现操作。

这种模式可以对旧功能进行代理，用一个代理类调用原有的方法，且对产生的结果进行控制。

interface Source{ void method();}
    
    class OldClass implements Source{
        @Override
        public void method() {
        }
    }
    
    class Proxy implements Source{
        private Source source = new OldClass();
    
        void doSomething(){}
        @Override
        public void method() {
            new Class1().Func1();
            source.method();
            new Class2().Func2();
            doSomething();
        }
    }

# 9.外观模式（Facade） #

为子系统中的一组接口提供一个一致的界面，定义一个高层接口，这个接口使得这一子系统更加容易使用。这句话是百度百科的解释，有点难懂，但是没事，看下面的例子，我们在启动停止所有子系统的时候，为它们设计一个外观类，这样就可以实现统一的接口，这样即使有新增的子系统subSystem4,也可以在不修改客户端代码的情况下轻松完成。

public class Facade {
        private subSystem1 subSystem1 = new subSystem1();
        private subSystem2 subSystem2 = new subSystem2();
        private subSystem3 subSystem3 = new subSystem3();
        
        public void startSystem(){
            subSystem1.start();
            subSystem2.start();
            subSystem3.start();
        }
        
        public void stopSystem(){
            subSystem1.stop();
            subSystem2.stop();
            subSystem3.stop();
        }
    }

# 10.桥接模式（Bridge） #

这里引用下[http://www.runoob.com/design-pattern/bridge-pattern.html][http_www.runoob.com_design-pattern_bridge-pattern.html]的例子。Circle类将DrwaApi与Shape类进行了桥接，代码：

interface DrawAPI {
        public void drawCircle(int radius, int x, int y);
    }
    class RedCircle implements DrawAPI {
        @Override
        public void drawCircle(int radius, int x, int y) {
            System.out.println("Drawing Circle[ color: red, radius: "
                    + radius +", x: " +x+", "+ y +"]");
        }
    }
    class GreenCircle implements DrawAPI {
        @Override
        public void drawCircle(int radius, int x, int y) {
            System.out.println("Drawing Circle[ color: green, radius: "
                    + radius +", x: " +x+", "+ y +"]");
        }
    }
    
    abstract class Shape {
        protected DrawAPI drawAPI;
        protected Shape(DrawAPI drawAPI){
            this.drawAPI = drawAPI;
        }
        public abstract void draw();
    }
    
    class Circle extends Shape {
        private int x, y, radius;
    
        public Circle(int x, int y, int radius, DrawAPI drawAPI) {
            super(drawAPI);
            this.x = x;
            this.y = y;
            this.radius = radius;
        }
    
        public void draw() {
            drawAPI.drawCircle(radius,x,y);
        }
    }
    
    //客户端使用代码
    Shape redCircle = new Circle(100,100, 10, new RedCircle());
    Shape greenCircle = new Circle(100,100, 10, new GreenCircle());
    redCircle.draw();
    greenCircle.draw();

# 11.组合模式（Composite） #

组合模式是为了表示那些层次结构，同时部分和整体也可能是一样的结构，常见的如文件夹或者树。举例：

abstract class component{}
    
    class File extends  component{ String filename;}
    
    class Folder extends  component{
        component[] files ;  //既可以放文件File类，也可以放文件夹Folder类。Folder类下又有子文件或子文件夹。
        String foldername ;
        public Folder(component[] source){ files = source ;}
        
        public void scan(){
            for ( component f:files){
                if ( f instanceof File){
                    System.out.println("File "+((File) f).filename);
                }else if(f instanceof Folder){
                    Folder e = (Folder)f ;
                    System.out.println("Folder "+e.foldername);
                    e.scan();
                }
            }
        }
        
    }

# 12.享元模式（Flyweight） #

使用共享对象的方法，用来尽可能减少内存使用量以及分享资讯。通常使用工厂类辅助，例子中使用一个HashMap类进行辅助判断，数据池中是否已经有了目标实例，如果有，则直接返回，不需要多次创建重复实例。

**享元模式的定义与特点**

享元（Flyweight）模式的定义：运用共享技术来有効地支持大量细粒度对象的复用。它通过共享已经存在的又橡来大幅度减少需要创建的对象数量、避免大量相似类的开销，从而提高系统资源的利用率。  
  
享元模式的主要优点是：相同对象只要保存一份，这降低了系统中对象的数量，从而降低了系统中细粒度对象给内存带来的压力。  
  
其主要缺点是：

1.  为了使对象可以共享，需要将一些不能共享的状态外部化，这将增加程序的复杂性。
2.  读取享元模式的外部状态会使得运行时间稍微变长。

**享元模式的结构与实现**

享元模式中存在以下两种状态：

1.  内部状态，即不会随着环境的改变而改变的可共享部分；
2.  外部状态，指随环境改变而改变的不可以共享的部分。享元模式的实现要领就是区分应用中的这两种状态，并将外部状态外部化。下面来分析其基本结构和实现方法。

1. 模式的结构

享元模式的主要角色有如下。

1.  抽象享元角色（Flyweight）:是所有的具体享元类的基类，为具体享元规范需要实现的公共接口，非享元的外部状态以参数的形式通过方法传入。
2.  具体享元（Concrete Flyweight）角色：实现抽象享元角色中所规定的接口。
3.  非享元（Unsharable Flyweight)角色：是不可以共享的外部状态，它以参数的形式注入具体享元的相关方法中。
4.  享元工厂（Flyweight Factory）角色：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检査系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。

图 1 是享元模式的结构图。图中的 UnsharedConcreteFlyweight 是与淳元角色，里面包含了非共享的外部状态信息 info；而 Flyweight 是抽象享元角色，里面包含了享元方法 operation(UnsharedConcreteFlyweight state)，非享元的外部状态以参数的形式通过该方法传入；ConcreteFlyweight 是具体享元角色，包含了关键字 key，它实现了抽象享元接口；FlyweightFactory 是享元工厂角色，它逝关键字 key 来管理具体享元；客户角色通过享元工厂获取具体享元，并访问具体享元的相关方法。

![享元模式的结构图][3-1Q115161342242.gif]  
                                                                                 图1 享元模式的结构图

2. 模式的实现

享元模式的实现代码如下：

package flyweight;
    import java.util.HashMap;
    public class FlyweightPattern
    {
        public static void main(String[] args)
        {
            FlyweightFactory factory=new FlyweightFactory();
            Flyweight f01=factory.getFlyweight("a");
            Flyweight f02=factory.getFlyweight("a");
            Flyweight f03=factory.getFlyweight("a");
            Flyweight f11=factory.getFlyweight("b");
            Flyweight f12=factory.getFlyweight("b");       
            f01.operation(new UnsharedConcreteFlyweight("第1次调用a。"));       
            f02.operation(new UnsharedConcreteFlyweight("第2次调用a。"));       
            f03.operation(new UnsharedConcreteFlyweight("第3次调用a。"));       
            f11.operation(new UnsharedConcreteFlyweight("第1次调用b。"));       
            f12.operation(new UnsharedConcreteFlyweight("第2次调用b。"));
        }
    }
    //非享元角色
    class UnsharedConcreteFlyweight
    {
        private String info;
        UnsharedConcreteFlyweight(String info)
        {
            this.info=info;
        }
        public String getInfo()
        {
            return info;
        }
        public void setInfo(String info)
        {
            this.info=info;
        }
    }
    //抽象享元角色
    interface Flyweight
    {
        public void operation(UnsharedConcreteFlyweight state);
    }
    //具体享元角色
    class ConcreteFlyweight implements Flyweight
    {
        private String key;
        ConcreteFlyweight(String key)
        {
            this.key=key;
            System.out.println("具体享元"+key+"被创建！");
        }
        public void operation(UnsharedConcreteFlyweight outState)
        {
            System.out.print("具体享元"+key+"被调用，");
            System.out.println("非享元信息是:"+outState.getInfo());
        }
    }
    //享元工厂角色
    class FlyweightFactory
    {
        private HashMap<String, Flyweight> flyweights=new HashMap<String, Flyweight>();
        public Flyweight getFlyweight(String key)
        {
            Flyweight flyweight=(Flyweight)flyweights.get(key);
            if(flyweight!=null)
            {
                System.out.println("具体享元"+key+"已经存在，被成功获取！");
            }
            else
            {
                flyweight=new ConcreteFlyweight(key);
                flyweights.put(key, flyweight);
            }
            return flyweight;
        }
    }

程序运行结果如下：

具体享元a被创建！
    具体享元a已经存在，被成功获取！
    具体享元a已经存在，被成功获取！
    具体享元b被创建！
    具体享元b已经存在，被成功获取！
    具体享元a被调用，非享元信息是:第1次调用a。
    具体享元a被调用，非享元信息是:第2次调用a。
    具体享元a被调用，非享元信息是:第3次调用a。
    具体享元b被调用，非享元信息是:第1次调用b。
    具体享元b被调用，非享元信息是:第2次调用b。

## 享元模式的应用实例 ##

【例1】享元模式在五子棋游戏中的应用。  
  
分析：五子棋同围棋一样，包含多个“黑”或“白”颜色的棋子，所以用享元模式比较好。  
  
本实例中的棋子（ChessPieces）类是抽象享元角色，它包含了一个落子的 DownPieces(Graphics g,Point pt) 方法；白子（WhitePieces）和黑子（BlackPieces）类是具体享元角色，它实现了落子方法；Point 是非享元角色，它指定了落子的位置；WeiqiFactory 是享元工厂角色，它通过 ArrayList 来管理棋子，并且提供了获取白子或者黑子的 getChessPieces(String type) 方法；客户类（Chessboard）利用 Graphics 组件在框架窗体中绘制一个棋盘，并实现 mouseClicked(MouseEvent e) 事件处理方法，该方法根据用户的选择从享元工厂中获取白子或者黑子并落在棋盘上。图 2 所示是其结构图。

![五子棋游戏的结构图][3-1Q11516141M29.gif]  
                                                                             图2 五子棋游戏的结构图

程序代码如下：

package flyweight;
    import java.awt.*;
    import java.awt.event.*;
    import java.util.ArrayList;
    import javax.swing.*;
    public class WzqGame
    {
        public static void main(String[] args)
        {
            new Chessboard();
        }
    }
    //棋盘
    class Chessboard extends MouseAdapter
    {
        WeiqiFactory wf;
        JFrame f;   
        Graphics g;
        JRadioButton wz;
        JRadioButton bz;
        private final int x=50;
        private final int y=50;
        private final int w=40;    //小方格宽度和高度
        private final int rw=400;    //棋盘宽度和高度
        Chessboard()
        {
            wf=new WeiqiFactory();
            f=new JFrame("享元模式在五子棋游戏中的应用");
            f.setBounds(100,100,500,550);
            f.setVisible(true);       
            f.setResizable(false);
            f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            JPanel SouthJP=new JPanel();
            f.add("South",SouthJP);
            wz=new JRadioButton("白子");
            bz=new JRadioButton("黑子",true);
            ButtonGroup group=new ButtonGroup();
            group.add(wz);
            group.add(bz);
            SouthJP.add(wz);
            SouthJP.add(bz);      
            JPanel CenterJP=new JPanel();
            CenterJP.setLayout(null);
            CenterJP.setSize(500, 500);
            CenterJP.addMouseListener(this);
            f.add("Center",CenterJP);      
            try
            {
                Thread.sleep(500);
            }
            catch(InterruptedException e)
            {
                e.printStackTrace();
            }               
            g=CenterJP.getGraphics();
            g.setColor(Color.BLUE);   
            g.drawRect(x, y, rw, rw);
            for(int i=1;i<10;i++)
            {
                //绘制第i条竖直线
                g.drawLine(x+(i*w),y,x+(i*w),y+rw);
                //绘制第i条水平线
                g.drawLine(x,y+(i*w),x+rw,y+(i*w));
            }   
        }
        public void mouseClicked(MouseEvent e)
        {
            Point pt=new Point(e.getX()-15,e.getY()-15);
            if(wz.isSelected())
            {
                ChessPieces c1=wf.getChessPieces("w");
                c1.DownPieces(g,pt);
            }
            else if(bz.isSelected())
            {
                ChessPieces c2=wf.getChessPieces("b");       
                c2.DownPieces(g,pt);  
            }
        }
    }
    //抽象享元角色：棋子
    interface ChessPieces
    {
        public void DownPieces(Graphics g,Point pt);    //下子
    }
    //具体享元角色：白子
    class WhitePieces implements ChessPieces
    {
        public void DownPieces(Graphics g,Point pt)
        {       
            g.setColor(Color.WHITE);
            g.fillOval(pt.x,pt.y,30,30);
        }
    }
    //具体享元角色：黑子
    class BlackPieces implements ChessPieces
    {
        public void DownPieces(Graphics g,Point pt)
        {
            g.setColor(Color.BLACK);
            g.fillOval(pt.x,pt.y,30,30);
        }
    }
    //享元工厂角色
    class WeiqiFactory
    {
        private ArrayList<ChessPieces> qz;   
        public WeiqiFactory()
        {
            qz=new ArrayList<ChessPieces>();
            ChessPieces w=new WhitePieces();
            qz.add(w);
            ChessPieces b=new BlackPieces();
            qz.add(b);
        }   
        public ChessPieces getChessPieces(String type)
        {
            if(type.equalsIgnoreCase("w"))
            {
                return (ChessPieces)qz.get(0);
            }
            else if(type.equalsIgnoreCase("b"))
            {
                return (ChessPieces)qz.get(1);
            }
            else
            {
                return null;
            }
        }
    }

程序运行结果如图 3 所示。

![五子棋游戏的运行结果][3-1Q115162I4425.gif]  
                                                                                      图3 五子棋游戏的运行结果

## 享元模式的应用场景 ##

前面分析了享元模式的结构与特点，下面分析它适用的应用场景。享元模式是通过减少内存中对象的数量来节省内存空间的，所以以下几种情形适合采用享元模式。

1.  系统中存在大量相同或相似的对象，这些对象耗费大量的内存资源。
2.  大部分的对象可以按照内部状态进行分组，且可将不同部分外部化，这样每一个组只需保存一个内部状态。
3.  由于享元模式需要额外维护一个保存享元的数据结构，所以应当在有足够多的享元实例时才值得使用享元模式。

## 享元模式的扩展 ##

在前面介绍的享元模式中，其结构图通常包含可以共享的部分和不可以共享的部分。在实际使用过程中，有时候会稍加改变，即存在两种特殊的享元模式：单纯享元模式和复合享元模式，下面分别对它们进行简单介绍。  
  
(1) 单纯享元模式，这种享元模式中的所有的具体享元类都是可以共享的，不存在非共享的具体享元类，其结构图如图 4 所示。

![单纯享元模式的结构图][3-1Q115161549429.gif]  
                                                                            图4 单纯享元模式的结构图

(2) 复合享元模式，这种享元模式中的有些享元对象是由一些单纯享元对象组合而成的，它们就是复合享元对象。虽然复合享元对象本身不能共享，但它们可以分解成单纯享元对象再被共享，其结构图如图 5 所示。

![复合享元模式的结构图][3-1Q11516162C42.gif]  
                                                                          图5 复合享元模式的结构图

各模式详细请见：[http://c.biancheng.net/view/1317.html][http_c.biancheng.net_view_1317.html]

[Link 1]: http://c.biancheng.net/design_pattern/
[3-1Q114135A2M3.gif]: /images/20220227/79a3b78d126c4b1a8ab9d1b78f44c6d7.png
[Link 2]: http://c.biancheng.net/uploads/soft/181113/3-1Q114140222.zip
[3-1Q11413554DT.gif]: /images/20220227/7efde926bd194288a3cd09efbf263f00.png
[Link 3]: http://c.biancheng.net/uploads/soft/181113/3-1Q114140526.zip
[3-1Q114135422T9.gif]: /images/20220227/8ed374835f0e47658a83df0324a21146.png
[3-1Q114135306120.gif]: /images/20220227/221e90c7f8d3478da72fdb0653080fde.png
[Link 4]: http://c.biancheng.net/view/1348.html
[3-1Q1141559151S.gif]: /images/20220227/a22e5fbb01af4b83973843448b3a4128.png
[3-1Q11416002NW.gif]: /images/20220227/aeae04a928f64d6290fa46f47be6379c.png
[Link 5]: http://c.biancheng.net/uploads/soft/181113/3-1Q114160J0.zip
[XML]: http://c.biancheng.net/uploads/soft/181113/3-1Q114160S7.zip
[3-1Q114160132648.gif]: /images/20220227/90ae48f6cafc41a6a47d4e386f0b2349.png
[3-1Q11416021C61.jpg]: /images/20220227/1d1d0487412142a296c79c24da181b4e.png
[3-1Q1131K441K2.gif]: /images/20220227/3eb797bae510486b8394cb3c73f0b9c5.png
[3-1Q1131K529345.gif]: /images/20220227/60dca581275b49a2bc0eb09268e318e3.png
[Link 6]: http://c.biancheng.net/uploads/soft/181113/3-1Q1131J636.zip
[3-1Q1131K55X41.gif]: /images/20220227/e6b9470c7d434d06bea37b2dddf931bf.png
[3-1Q1131I0563U.gif]: /images/20220227/9a90cb3c41c94bdcb220421038b49f46.png
[3-1Q1131KQ4K8.gif]: /images/20220227/94e6e02e24d94bffaed319ccf319603a.png
[http_www.runoob.com_design-pattern_bridge-pattern.html]: http://www.runoob.com/design-pattern/bridge-pattern.html
[3-1Q115161342242.gif]: /images/20220227/01a55caf312146d0aa7f95248bc5b1d9.png
[3-1Q11516141M29.gif]: /images/20220227/5e1a39044f3b4182b19852143a61107d.png
[3-1Q115162I4425.gif]: /images/20220227/cd760ba9e08d4eb5b894dec83aaf5ef8.png
[3-1Q115161549429.gif]: /images/20220227/15f6cb60d9134a3d8c988dd29ff3bdf2.png
[3-1Q11516162C42.gif]: /images/20220227/55d6aa43155a4c78a4e41a9622a9b613.png
[http_c.biancheng.net_view_1317.html]: http://c.biancheng.net/view/1317.html