Java/Design Pattern/Singleton Pattern

A static class implementation of Singleton pattern

/*
The Design Patterns Java Companion
Copyright (C) 1998, by James W. Cooper
IBM Thomas J. Watson Research Center
*/
final class Spooler {
  
  static public void print(String s) {
    System.out.println(s);
  }
}

public class StaticSpool {
  public static void main(String argv[]) {
    Spooler.print("here it is");
  }
}

Singleton

/*
 * Copyright (c) Ian F. Darwin, http://www.darwinsys.ru/, 1996-2002.
 * All rights reserved. Software written by Ian F. Darwin and others.
 * $Id: LICENSE,v 1.8 2004/02/09 03:33:38 ian Exp $
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS""
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 * 
 * Java, the Duke mascot, and all variants of Sun"s Java "steaming coffee
 * cup" logo are trademarks of Sun Microsystems. Sun"s, and James Gosling"s,
 * pioneering role in inventing and promulgating (and standardizing) the Java 
 * language and environment is gratefully acknowledged.
 * 
 * The pioneering role of Dennis Ritchie and Bjarne Stroustrup, of AT&T, for
 * inventing predecessor languages C and C++ is also gratefully acknowledged.
 */
/** An example of a Singleton implementation in Java.
 * The Singleton design pattern is described in GOF; the idea is to ensure
 * that only one instance of the class will exist in a given application.
 * @author Ian F. Darwin, http://www.darwinsys.ru/
 * @version $Id: Singleton.java,v 1.7 2004/02/09 03:33:58 ian Exp $
 */
public class Singleton {
  private static Singleton singleton = new Singleton();
  /** A private Constructor prevents any other class from instantiating. */
  private Singleton() {
  }
  /** Static "instance" method */
  public static Singleton getInstance() {
    return singleton;
  }
  // other methods protected by singleton-ness would be here...
  /** A simple demo method */
  public String demoMethod() {
    return "demo";
  }
}

Singleton Pattern 2

//[C] 2002 Sun Microsystems, Inc.---
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextArea;
public class RunSingletonPattern {
  public static void main(String[] arguments) {
    System.out.println("Example for Singleton pattern");
    System.out.println();
    System.out.println("This example will demonstrate the use of");
    System.out.println(" the Singleton pattern by creating two GUI");
    System.out.println(" editors, both of which will reference the");
    System.out.println(" same underlying history list.");
    System.out.println("Creating the first editor");
    System.out.println();
    SingletonGui editor1 = new SingletonGui();
    editor1.createGui();
    System.out.println("Creating the second editor");
    System.out.println();
    SingletonGui editor2 = new SingletonGui();
    editor2.createGui();
  }
}
class SingletonGui implements ActionListener {
  private JFrame mainFrame;
  private JTextArea display;
  private JButton newContact, newAppointment, undo, refresh, exit;
  private JPanel controlPanel, displayPanel;
  private static int historyCount;
  public void createGui() {
    mainFrame = new JFrame("Singleton Pattern Example");
    Container content = mainFrame.getContentPane();
    content.setLayout(new BoxLayout(content, BoxLayout.Y_AXIS));
    displayPanel = new JPanel();
    display = new JTextArea(20, 60);
    display.setEditable(false);
    displayPanel.add(display);
    content.add(displayPanel);
    controlPanel = new JPanel();
    newContact = new JButton("Create contact");
    newAppointment = new JButton("Create appointment");
    undo = new JButton("Undo");
    refresh = new JButton("Refresh");
    exit = new JButton("Exit");
    controlPanel.add(newContact);
    controlPanel.add(newAppointment);
    controlPanel.add(undo);
    controlPanel.add(refresh);
    controlPanel.add(exit);
    content.add(controlPanel);
    newContact.addActionListener(this);
    newAppointment.addActionListener(this);
    undo.addActionListener(this);
    refresh.addActionListener(this);
    exit.addActionListener(this);
    mainFrame.addWindowListener(new WindowCloseManager());
    mainFrame.pack();
    mainFrame.setVisible(true);
  }
  public void refreshDisplay(String actionMessage) {
    display.setText(actionMessage + "\nCOMMAND HISTORY:\n"
        + HistoryList.getInstance().toString());
  }
  public void actionPerformed(ActionEvent evt) {
    Object originator = evt.getSource();
    if (originator == newContact) {
      addCommand(" New Contact");
    } else if (originator == newAppointment) {
      addCommand(" New Appointment");
    } else if (originator == undo) {
      undoCommand();
    } else if (originator == refresh) {
      refreshDisplay("");
    } else if (originator == exit) {
      exitApplication();
    }
  }
  private class WindowCloseManager extends WindowAdapter {
    public void windowClosing(WindowEvent evt) {
      exitApplication();
    }
  }
  private void addCommand(String message) {
    HistoryList.getInstance().addCommand((++historyCount) + message);
    refreshDisplay("Add Command: " + message);
  }
  private void undoCommand() {
    Object result = HistoryList.getInstance().undoCommand();
    historyCount--;
    refreshDisplay("Undo Command: " + result);
  }
  private void exitApplication() {
    System.exit(0);
  }
}
class HistoryList {
  private List history = Collections.synchronizedList(new ArrayList());
  private static HistoryList instance = new HistoryList();
  private HistoryList() {
  }
  public static HistoryList getInstance() {
    return instance;
  }
  public void addCommand(String command) {
    history.add(command);
  }
  public Object undoCommand() {
    return history.remove(history.size() - 1);
  }
  public String toString() {
    StringBuffer result = new StringBuffer();
    for (int i = 0; i < history.size(); i++) {
      result.append("  ");
      result.append(history.get(i));
      result.append("\n");
    }
    return result.toString();
  }
}

Singleton pattern in Java 1

/*
The Design Patterns Java Companion
Copyright (C) 1998, by James W. Cooper
IBM Thomas J. Watson Research Center
*/
public class InstanceSpooler {
  static public void main(String argv[]) {
    Spooler pr1, pr2;
    //open one printer--this should always work
    System.out.println("Opening one spooler");
    pr1 = Spooler.Instance();
    if (pr1 != null)
      System.out.println("got 1 spooler");
    //try to open another printer --should fail
    System.out.println("Opening two spoolers");
    pr2 = Spooler.Instance();
    if (pr2 == null)
      System.out.println("no instance available");
    //fails because constructor is privatized
    //iSpooler pr3 = new iSpooler();
  }
}
class Spooler {
  //this is a prototype for a printer-spooler class
  //such that only one instance can ever exist
  static boolean instance_flag = false; //true if 1 instance
  private Spooler() {
  }
  static public Spooler Instance() {
    if (!instance_flag) {
      instance_flag = true;
      return new Spooler();
    } else
      return null;
  }
  public void finalize() {
    instance_flag = false;
  }
}

Singleton pattern in Java 2

/*
The Design Patterns Java Companion
Copyright (C) 1998, by James W. Cooper
IBM Thomas J. Watson Research Center
*/
class Spooler {
  //this is a prototype for a printer-spooler class
  //such that only one instance can ever exist
  static boolean instance_flag = false; //true if 1 instance
  public Spooler() throws SingletonException {
    if (instance_flag)
      throw new SingletonException("Only one printer allowed");
    else
      instance_flag = true; //set flag for 1 instance
    System.out.println("printer opened");
  }
  public void finalize() {
    instance_flag = false;
  }
}
class SingletonException extends RuntimeException {
  //new exception type for singleton classes
  public SingletonException() {
    super();
  }
  public SingletonException(String s) {
    super(s);
  }
}
public class SingleSpooler {
  static public void main(String argv[]) {
    Spooler pr1, pr2;
    //open one printer--this should always work
    System.out.println("Opening one spooler");
    try {
      pr1 = new Spooler();
    } catch (SingletonException e) {
      System.out.println(e.getMessage());
    }
    //try to open another printer --should fail
    System.out.println("Opening two spoolers");
    try {
      pr2 = new Spooler();
    } catch (SingletonException e) {
      System.out.println(e.getMessage());
    }
  }
}

Singleton pattern in Java 3

/*
The Design Patterns Java Companion
Copyright (C) 1998, by James W. Cooper
IBM Thomas J. Watson Research Center
*/
class Printer {
  //this is a prototype for a printer-spooler class
  //such that only one instance can ever exist
  static boolean instance_flag = false; //true if 1 instance
  public Printer() throws SingletonException {
    if (instance_flag)
      throw new SingletonException("Only one printer allowed");
    else
      instance_flag = true; //set flag for 1 instance
    System.out.println("printer opened");
  }
  public void finalize() {
    instance_flag = false;
  }
}
class SingletonException extends RuntimeException {
  //new exception type for singleton classes
  public SingletonException() {
    super();
  }
  public SingletonException(String s) {
    super(s);
  }
}
public class SinglePrinter {
  static public void main(String argv[]) {
    Printer pr1, pr2;
    //open one printer--this should always work
    System.out.println("Opening one printer");
    try {
      pr1 = new Printer();
    } catch (SingletonException e) {
      System.out.println(e.getMessage());
    }
    //try to open another printer --should fail
    System.out.println("Opening two printers");
    try {
      pr2 = new Printer();
    } catch (SingletonException e) {
      System.out.println(e.getMessage());
    }
  }
}