单例模式是结构最简单的设计模式，它只包含一个，即单例类。单例模式有3个要点：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。

实验目的：

1. 掌握单例模式（Singleton）的特点

2. 分析具体问题，使用单例模式进行设计。

问题：

1.使用单例模式设计一个多文档窗口(注:在JavaAWT/Swing开发中可使用JDesktopPane和JInternalFrame来实现),要求在主窗体中某个内部子窗体只能实例化一次,即只能弹出一个相同的子窗体,编程实现该功能

package designpatterns.builder;


public class Client {
    public static void main(String args[]){
        new JInternalFrameDemo();
    }
}
package designpatterns.builder;



import javax.swing.JInternalFrame;

public class JInternalFrame1 extends JInternalFrame{

    private static JInternalFrame1 JIF1 = null;
    private JInternalFrame1(String name, boolean b1, boolean b2, boolean b3, boolean b4){
        super(name, b1, b2, b3, b4);
    }

    public static JInternalFrame1 getJInternalFrame1(String name, boolean b1, boolean b2, boolean b3, boolean b4){
        if(JIF1 == null)
            JIF1 = new JInternalFrame1(name, b1, b2, b3, b4);
        return JIF1;
    }
}
package designpatterns.builder;



import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.JButton;
import javax.swing.JDesktopPane;
import javax.swing.JFrame;
import javax.swing.JInternalFrame;
import javax.swing.JTextArea;


public class JInternalFrameDemo extends JFrame implements ActionListener {

    private static JInternalFrame1 internalFrame;
    Container contentPane = this.getContentPane();

    public JInternalFrameDemo(){
        super("主窗体");
        contentPane.setLayout(new BorderLayout());
        JButton button = new JButton("创建一个子窗体");
        button.addActionListener(this);
        contentPane.add(button, BorderLayout.SOUTH);
        this.setSize(new Dimension(300, 300));
        this.setVisible(true);
        this.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
    }
    public void actionPerformed(ActionEvent e) {
        internalFrame = JInternalFrame1.getJInternalFrame1("子窗体"
                , true, true, true, true);
        internalFrame.setSize(new Dimension(200, 200));
        internalFrame.setVisible(true);
        JDesktopPane desktopPane = new JDesktopPane();
        contentPane.add(desktopPane);
        desktopPane.add(internalFrame);
        try {
            internalFrame.setSelected(true);
        } catch (java.beans.PropertyVetoException ex) {
            System.out.println("Exception while selecting");
        }
    }
}

2.某软件公司开发人员要创建一个数据库连接池,将指定个数的(如两个或3个)数据库连接对象存储在连接池中,客户端代码可以从池中随机取一个连接对象来连接数据库试通过对单例类进行改造,设计一个能够自行提供指定个数实例对象的数据库连接类并用Java代码编程模拟。

package designpatterns.builder;
public class Client {
    public static void main(String[] args) {
        Connection connectionA = ConnectionPool.getConnection();
        Connection connectionB = ConnectionPool.getConnection();
        Connection connectionC = ConnectionPool.getConnection();
        connectionA.doQuery();
        connectionB.doQuery();
        connectionC.doQuery();
    }
}
package designpatterns.builder;

public class Connection {
    private String name;
    public Connection(String name) {
        this.name = name;
    }

    public void doQuery() {
        System.out.println(name + "开始连接");
    }
}
package designpatterns.builder;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class ConnectionPool {
    private Integer connectionInitSize = 3;
    private static volatile ConnectionPool connectionPool;
    private List<Connection> connectionList = new ArrayList<>();

    private ConnectionPool(Integer connectionInitSize) {
        this.connectionInitSize = connectionInitSize;
        for (int i = 0; i < connectionInitSize; i++) {
            Connection connection = new Connection("连接" + i);
            connectionList.add(connection);
        }
    }

    private static ConnectionPool getInstance() {
        if (connectionPool == null) {
            synchronized (ConnectionPool.class) {
                if (connectionPool == null) {
                    connectionPool = new ConnectionPool(3);
                }
            }
        }
        return connectionPool;
    }

    public static Connection getConnection() {
        Integer nextInt = new Random().nextInt(getInstance().connectionInitSize);
        return getInstance().connectionList.get(nextInt);
    }
}