第二章创建型模式

1、创建型模式概述

主要特点
将对象的创建与使用分离”，这样可以降低系统的耦合度。
创建型模式分为以下几种：
⑴单例（Singleton）模式：某个类只能生成一个实例，该类提供了一个全局访问点供外部获取该实例，其拓展是有限多例模式。
⑵ 原型（Prototype）模式：将一个对象作为原型，通过对其进行复制而克隆出多个和原型类似的新实例。
⑶ 工厂方法（Factory Method）模式：定义一个用于创建产品的接口，由子类决定生产什么产品。
⑷ 抽象工厂（Abstract Factory）模式：提供一个创建产品族的接口，其每个子类可以生产一系列相关的产品。
⑸ 建造者（Builder）模式：将一个复杂对象分解成多个相对简单的部分，然后根据不同需要分别创建它们，最后构建成该复杂对象。

2、单例模式（Singleton）

（1）模式的定义与特点

定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。例如，Windows中的任务管理器、回收站等
特点：
1）单例类只有一个实例对象；
2）该单例对象必须由单例类自行创建；
3）单例类对外提供一个访问该单例的全局访问点。

（2）模式的结构与实现

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

1、结构

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

2、实现

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

结构图：
在这里插入图片描述
代码如下：

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

例：用懒汉式单例模式模拟产生美国当今总统对象。
在这里插入图片描述
代码：
测试类：


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("他们不是同一人！");
        } 
	}
}

President类：

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

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

代码如下：

public class HungrySingleton {
	//类加载时候创建实例
    private static final HungrySingleton instance = newHungrySingleton();

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

例：用饿汉式单例模式模拟产生猪八戒对象。
结构图：
在这里插入图片描述
代码如下：
测试类：

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

    }
}

Bajie 类：

class Bajie extends JPanel {
	//类加载时创建
    private static Bajie instance = new Bajie();

    private Bajie() {
        JLabel l1 = new JLabel(new ImageIcon("src/chapter02/singleton/Bajie.jpg"));
        this.add(l1);
    }

    public static Bajie getInstance() {
        return instance;
    }
}