carfield.com.hk

Main.java

2004-03-24T16:00:00Z

package examples.singleton.java;

/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 *
 * This file is part of the design patterns project at UBC
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * either http://www.mozilla.org/MPL/ or http://aspectj.org/MPL/.
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is ca.ubc.cs.spl.patterns.
 *
 * Contributor(s): 
 */

/**
 * Implements the driver for the Singleton design pattern example. 
 *
 * Intent: Ensure that a class has only one instance and provide a global
 * point of access to it.
 *
 * Participatng objects are <code>PrinterSingleton</code> p1, p2, p3 and 
 * <code>PrinterSubclass</code> ps1, ps2, ps3.
 *
 * Three different objects of both PrinterSingleton and PrinterSubclass are
 * instantiated and compared. 
 *
 * This Implementation treats the singleton property as a non-inherited 
 * property. This meant that Singleton classes can still be subclassed
 * and these subclasses can access the Singleton constructor normally.
 *
 * This is the Java version.
 *
 * @author Jan Hannemann
 * @author Gregor Kiczales
 * @version 1.0, 05/13/02
 * 
 * @see PrinterSingleton
 * @see PrinterSubclass
 */

class Main { 
 
 /**
 * the three object references to instances of the Singleton class.
 */
 
	private static PrinterSingleton p1, p2, p3;

 /**
 * the three object references to instances of sublcasses of the 
 * Singleton class.
 */

	private static PrinterSubclass ps1, ps2, ps3;

 /**
 * Implements the first test case. Creates 3 references to the 
 * Singleton by (a) using the regular constructor and then by (b) 
 * using a factory method. (a) should fail, (b) should create three 
 * identical objects.
 */	
	
	private static void test1() {
		System.out.println("Test 1a: Try to call regular constructor. Should "
		 + "fail.");
		p1 = new PrinterSingleton();
		p2 = new PrinterSingleton();
		p3 = new PrinterSingleton(); 
		p1.print();
		p2.print();
		p3.print(); 
		System.out.println("\tOO Problem: Classes in the same package can "
		 + "still access constructor.");
		
		System.out.println("Test 1b: Using instance() instead. Should create "
		 + "three identical objects.");
		p1 = PrinterSingleton.instance();
		p2 = PrinterSingleton.instance();
		p3 = PrinterSingleton.instance(); 
		p1.print();
		p2.print();
		p3.print(); 
	}
	

 /**
 * Implements the first test case. Tests if the 3 objects from test 1 are
 * in fact identical
 */	

	private static void test2() {
		System.out.println("Test 2: All three objects should be identical");

		System.out.print("\tThey are ");
		if ((p1 == p2) && (p1 == p3)) { System.out.println("identical"); }
		else {System.out.println("not identical"); }
	}
	

 /**
 * Implements the first test case. Creates 3 instances of a Singleton
 * 's subclass. These objects should be different.
 */	

	private static void test3() {
		System.out.println("Test 3: Ensuring that subclasses can access the" 
		 + "constructor");
		System.out.println(" (All three outputs should be different)");
		ps1 = new PrinterSubclass();
		ps2 = new PrinterSubclass();
		ps3 = new PrinterSubclass(); 
		ps1.print();
		ps2.print();
		ps3.print(); 
	}
	
 /**
 * This is the driver for the <code>Singleton</code> case. It performes
 * three tests:
 *
 * <OL>
 * <LI> Create 3 references to the Singleton by (a) using the
 * regular constructor and then by (b) using a factory method.
 * (a) should fail, (b) should create three identical objects.
 * <LI> Test if the above 3 objects are in fact identical
 * <LI> Create 3 instances of a Singleton's subclass. These
 * objects should be different.
 * </OL>
 */
			
	public static void main (String[] args) { 
		System.out.println("Testing pattern SINGLETON (java) ...");
		test1();
		test2();
		test3();
		System.out.println("... done.");
	}
}

Printer.java

2004-03-24T16:00:00Z

package examples.singleton.aspectj;

/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 *
 * This file is part of the design patterns project at UBC
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * either http://www.mozilla.org/MPL/ or http://aspectj.org/MPL/.
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is ca.ubc.cs.spl.patterns.
 *
 * Contributor(s): 
 */

/**
 * Implements a sample class that will be assigned the Singleton role
 * in this example. The class's functionality
 * is to store an instance-specific ID and provide a <code>print()</code>
 * method that shows an object's ID. 
 *
 * Note that in this implementation the class does not have to know
 * that it is a Singleton (i.e. has to have appropriate code in it).
 *
 * @author Jan Hannemann
 * @author Gregor Kiczales
 * @version 1.0, 05/13/02
 * 
 * @see PrinterSubclass
 */

public class Printer { 	// Can just say to implement the interface here 


 /**
 * Counts the instances of this class
 */
 
	protected static int objectsSoFar = 0;

 /**
 * Each instance has an ID to distinguish them.
 */
 
	protected int id;

	public Printer() {
		id = ++ objectsSoFar;
	}
	
 /**
 * Prints the instance's ID to <code>System.out</code>.
 */
 
	public void print() {
		System.out.println("\tMy ID is "+id);
	}
}

PrinterSingleton.java

2004-03-24T16:00:00Z

PrinterSubclass.java

2004-03-24T16:00:00Z

SingletonInstance.java

2004-03-24T16:00:00Z

package examples.singleton.aspectj;


/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 *
 * This file is part of the design patterns project at UBC
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * either http://www.mozilla.org/MPL/ or http://aspectj.org/MPL/.
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is ca.ubc.cs.spl.patterns.
 *
 * Contributor(s): 
 */

import ca.ubc.cs.spl.pattern.library.SingletonProtocol;

/**
 * Implements a concrete instance of the Singleton pattern. It declares
 * Printer to be Singleton and defines an exception to the Singleton
 * of the constructor: PrinterSubclass (a subclass of the Singleton) can still
 * access Printer's constructor.
 *
 * @author Jan Hannemann
 * @author Gregor Kiczales
 * @version 1.0, 05/13/02
 * 
 * @see Printer
 * @see PrinterSubclass
 */


public aspect SingletonInstance extends SingletonProtocol { 
 
 /**
 * Assigns the Singleton to <code>Printer</code>
 */
 
	declare parents: Printer implements Singleton;		 // Alternatively, Printer can just declare to implement it
	
 /**
 * This declaration allows <code>PrinterSubclass</code> (and all its
 * subclasses) to access <code>Printer</code>'s constructor within
 * a its constructor (to allow for <code>super()</code> calls).
 */
 
 	protected pointcut protectionExclusions(): call((PrinterSubclass+).new(..)); // To allow access to regular constructor (for subclasses etc.)
}

files.lst

2004-03-24T16:00:00Z