设计模式教程（Design Patterns Tutorial）笔记之一创建型模式（Creational Patterns）

概述

最近在YouTube上看了一套不错的设计模式视频，同时翻看GOF的《设计模式可复用面向对象软件的基础》，刷新了我对设计模式的认识。加之之前的一篇博文《设计模式笔记——GoF设计模式汇总》中未提及比较少用的解释器和访问者模式，以及大陆无法打开YouTube等原因，所以将这套视频所学到的主要内容记录成笔记，供未来需要时查阅和复习。

Factory

What is the Factory Design Pattern?

• When a method returns one of several possible classes that share a common super class.

• Create a new enemy in a game.

• Random number generator picks a number assigned to a specific enemy.

• The factory returns the enemy associated with that number.

• The class is chosen at run time.

Sample Code

• EnemyShip.java

 public abstract class EnemyShip {

     private String name;

     private double speed;

     private double directionX;

     private double directionY;

     private double amtDamage;

     public String getName() { return name; }

     public void setName(String newName) { name = newName; }

     public double getDamage() { return amtDamage; }

     public void setDamage(double newDamage) { amtDamage = newDamage; }

     public void followHeroShip(){

         System.out.println(getName() + " is following the hero");

     }

     public void displayEnemyShip(){

         System.out.println(getName() + " is on the screen");

     }

     public void enemyShipShoots() {

         System.out.println(getName() + " attacks and does " + getDamage() + " damage to hero");

     }

 }

• UFOEnemyShip.java

 public class UFOEnemyShip extends EnemyShip {

     public UFOEnemyShip(){

         setName("UFO Enemy Ship");

         setDamage(20.0);

     }

 }

• RocketEnemyShip.java

 public class RocketEnemyShip extends EnemyShip {

     public RocketEnemyShip(){

         setName("Rocket Enemy Ship");

         setDamage(10.0);

     }

 }

• EnemyShipTesting.java

 import java.util.Scanner;

 public class EnemyShipTesting {

     public static void main(String[] args){

         // Create the factory object

         EnemyShipFactory shipFactory = new EnemyShipFactory();

         // Enemy ship object

         EnemyShip theEnemy = null;

         Scanner userInput = new Scanner(System.in);

         System.out.print("What type of ship? (U / R / B)");

         if (userInput.hasNextLine()){

             String typeOfShip = userInput.nextLine();

             theEnemy = shipFactory.makeEnemyShip(typeOfShip);

             if(theEnemy != null){

                 doStuffEnemy(theEnemy);

             } else System.out.print("Please enter U, R, or B next time");

         }

         /*

         EnemyShip theEnemy = null;

         // Old way of creating objects

         // When we use new we are not being dynamic

         EnemyShip ufoShip = new UFOEnemyShip();

         doStuffEnemy(ufoShip);

         System.out.print("\n");

         // -----------------------------------------

         // This allows me to make the program more dynamic

         // It doesn't close the code from being modified

         // and that is bad!

         // Defines an input stream to watch: keyboard

         Scanner userInput = new Scanner(System.in);

         String enemyShipOption = "";

         System.out.print("What type of ship? (U or R)");

         if (userInput.hasNextLine()){

             enemyShipOption = userInput.nextLine();

         }

         if (enemyShipOption == "U"){

             theEnemy = new UFOEnemyShip();

         } else 

         if (enemyShipOption == "R"){

             theEnemy = new RocketEnemyShip();

         } else {

             theEnemy = new BigUFOEnemyShip();

         }

         doStuffEnemy(theEnemy);

         // --------------------------------------------

         */

     }

     // Executes methods of the super class

     public static void doStuffEnemy(EnemyShip anEnemyShip){

         anEnemyShip.displayEnemyShip();

         anEnemyShip.followHeroShip();

         anEnemyShip.enemyShipShoots();

     }

 }

• BigUFOEnemyShip.java

 public class BigUFOEnemyShip extends UFOEnemyShip {

     public BigUFOEnemyShip(){

         setName("Big UFO Enemy Ship");

         setDamage(40.0);

     }

 }

• EnemyShipFactory.java

 // This is a factory thats only job is creating ships

 // By encapsulating ship creation, we only have one

 // place to make modifications

 public class EnemyShipFactory{

     // This could be used as a static method if we

     // are willing to give up subclassing it

     public EnemyShip makeEnemyShip(String newShipType){

         EnemyShip newShip = null;

         if (newShipType.equals("U")){

             return new UFOEnemyShip();

         } else 

         if (newShipType.equals("R")){

             return new RocketEnemyShip();

         } else 

         if (newShipType.equals("B")){

             return new BigUFOEnemyShip();

         } else return null;

     }

 }

Abstract Factory

What is the Abstract Factory Design Pattern?

• It is like a factory, but everything is encapsulated.

• The method that orders the object.

• The factories that build the object.

• The final objects.

• The final objects contain objects that use the Strategy Design Pattern.

• Composition: Object class fields are objects.

What can you do with an Abstract Factory Design Pattern?

• Allows you to create families of related objects without specifying a concrete class.

• Use when you have many objects that can be added, or changed dynamically during runtime.

• You can model anything you can imagine and have those objects interact through common interfaces.

• The Bad: Things can get complicated.

Sample Code

• EnemyShipTesting.java

 public class EnemyShipTesting {

 public static void main(String[] args) {

         // EnemyShipBuilding handles orders for new EnemyShips

         // You send it a code using the orderTheShip method &

         // it sends the order to the right factory for creation

         EnemyShipBuilding MakeUFOs = new UFOEnemyShipBuilding();

         EnemyShip theGrunt = MakeUFOs.orderTheShip("UFO");

         System.out.println(theGrunt + "\n");

         EnemyShip theBoss = MakeUFOs.orderTheShip("UFO BOSS");

         System.out.println(theBoss + "\n");

     }

 }

• EnemyShipBuilding.java

 public abstract class EnemyShipBuilding {

     // This acts as an ordering mechanism for creating

     // EnemyShips that have a weapon, engine & name

     // & nothing else

     // The specific parts used for engine & weapon depend

     // upon the String that is passed to this method

     protected abstract EnemyShip makeEnemyShip(String typeOfShip);

     // When called a new EnemyShip is made. The specific parts

     // are based on the String entered. After the ship is made

     // we execute multiple methods in the EnemyShip Object

     public EnemyShip orderTheShip(String typeOfShip) {

         EnemyShip theEnemyShip = makeEnemyShip(typeOfShip);

         theEnemyShip.makeShip();

         theEnemyShip.displayEnemyShip();

         theEnemyShip.followHeroShip();

         theEnemyShip.enemyShipShoots();

         return theEnemyShip;

     }

 }

• UFOEnemyShipBuilding.java

 // This is the only class that needs to change, if you

 // want to determine which enemy ships you want to

 // provide as an option to build

 public class UFOEnemyShipBuilding extends EnemyShipBuilding {

     protected EnemyShip makeEnemyShip(String typeOfShip) {

         EnemyShip theEnemyShip = null;

         // If UFO was sent grab use the factory that knows

         // what types of weapons and engines a regular UFO

         // needs. The EnemyShip object is returned & given a name

         if(typeOfShip.equals("UFO")){

             EnemyShipFactory shipPartsFactory = new UFOEnemyShipFactory();

             theEnemyShip = new UFOEnemyShip(shipPartsFactory);

             theEnemyShip.setName("UFO Grunt Ship");

         } else 

         // If UFO BOSS was sent grab use the factory that knows

         // what types of weapons and engines a Boss UFO

         // needs. The EnemyShip object is returned & given a name

         if(typeOfShip.equals("UFO BOSS")){

             EnemyShipFactory shipPartsFactory = new UFOBossEnemyShipFactory();

             theEnemyShip = new UFOBossEnemyShip(shipPartsFactory);

             theEnemyShip.setName("UFO Boss Ship");

         } 

         return theEnemyShip;

     }

 }

• EnemyShipFactory.java

 // With an Abstract Factory Pattern you won't

 // just build ships, but also all of the components

 // for the ships

 // Here is where you define the parts that are required

 // if an object wants to be an enemy ship

 public interface EnemyShipFactory{

     public ESWeapon addESGun();

     public ESEngine addESEngine();

 }

• UFOEnemyShipFactory.java

 // This factory uses the EnemyShipFactory interface

 // to create very specific UFO Enemy Ship

 // This is where we define all of the parts the ship

 // will use by defining the methods implemented

 // being ESWeapon and ESEngine

 // The returned object specifies a specific weapon & engine

 public class UFOEnemyShipFactory implements EnemyShipFactory{

     // Defines the weapon object to associate with the ship

     public ESWeapon addESGun() {

         return new ESUFOGun(); // Specific to regular UFO

     }

     // Defines the engine object to associate with the ship

     public ESEngine addESEngine() {

         return new ESUFOEngine(); // Specific to regular UFO

     }

 }

• UFOBossEnemyShipFactory.java

 // This factory uses the EnemyShipFactory interface

 // to create very specific UFO Enemy Ship

 // This is where we define all of the parts the ship

 // will use by defining the methods implemented

 // being ESWeapon and ESEngine

 // The returned object specifies a specific weapon & engine

 public class UFOBossEnemyShipFactory implements EnemyShipFactory{

     // Defines the weapon object to associate with the ship

     public ESWeapon addESGun() {

         return new ESUFOBossGun(); // Specific to Boss UFO

     }

     // Defines the engine object to associate with the ship

     public ESEngine addESEngine() {

         return new ESUFOBossEngine(); // Specific to Boss UFO

     }

 }

• EnemyShip.java

 public abstract class EnemyShip {

     private String name;

     // Newly defined objects that represent weapon & engine

     // These can be changed easily by assigning new parts

     // in UFOEnemyShipFactory or UFOBossEnemyShipFactory

     ESWeapon weapon;

     ESEngine engine;

     public String getName() { return name; }

     public void setName(String newName) { name = newName; }

     abstract void makeShip();

     // Because I defined the toString method in engine

     // when it is printed the String defined in toString goes

     // on the screen

     public void followHeroShip(){

         System.out.println(getName() + " is following the hero at " + engine );

     }

     public void displayEnemyShip(){

         System.out.println(getName() + " is on the screen");

     }

     public void enemyShipShoots(){

         System.out.println(getName() + " attacks and does " + weapon);

     }

     // If any EnemyShip object is printed to screen this shows up

     public String toString(){

         String infoOnShip = "The " + name + " has a top speed of " + engine +

                 " and an attack power of " + weapon;

         return infoOnShip;

     }

 }

• UFOEnemyShip.java

 public class UFOEnemyShip extends EnemyShip{

     // We define the type of ship we want to create

     // by stating we want to use the factory that

     // makes enemy ships

     EnemyShipFactory shipFactory;

     // The enemy ship required parts list is sent to

     // this method. They state that the enemy ship

     // must have a weapon and engine assigned. That

     // object also states the specific parts needed

     // to make a regular UFO versus a Boss UFO

     public UFOEnemyShip(EnemyShipFactory shipFactory){

         this.shipFactory = shipFactory;

     }

     // EnemyShipBuilding calls this method to build a

     // specific UFOEnemyShip

     void makeShip() {

         System.out.println("Making enemy ship " + getName());

         // The specific weapon & engine needed were passed in

         // shipFactory. We are assigning those specific part

         // objects to the UFOEnemyShip here

         weapon = shipFactory.addESGun();

         engine = shipFactory.addESEngine();

     }

 }

• UFOBossEnemyShip.java

 public class UFOBossEnemyShip extends EnemyShip{

     // We define the type of ship we want to create

     // by stating we want to use the factory that

     // makes enemy ships

     EnemyShipFactory shipFactory;

     // The enemy ship required parts list is sent to

     // this method. They state that the enemy ship

     // must have a weapon and engine assigned. That

     // object also states the specific parts needed

     // to make a Boss UFO versus a Regular UFO

     public UFOBossEnemyShip(EnemyShipFactory shipFactory){

         this.shipFactory = shipFactory;

     }

     // EnemyShipBuilding calls this method to build a

     // specific UFOBossEnemyShip

     void makeShip() {

         // TODO Auto-generated method stub

         System.out.println("Making enemy ship " + getName());

         // The specific weapon & engine needed were passed in

         // shipFactory. We are assigning those specific part

         // objects to the UFOBossEnemyShip here

         weapon = shipFactory.addESGun();

         engine = shipFactory.addESEngine();

     }

 }

• ESEngine.java

 // Any part that implements the interface ESEngine

 // can replace that part in any ship

 public interface ESEngine{

     // User is forced to implement this method

     // It outputs the string returned when the

     // object is printed

     public String toString();

 }

• ESWeapon.java

 // Any part that implements the interface ESWeapon

 // can replace that part in any ship

 public interface ESWeapon{

     // User is forced to implement this method

     // It outputs the string returned when the

     // object is printed

     public String toString();

 }

• ESUFOGun.java

 // Here we define a basic component of a space ship

 // Any part that implements the interface ESWeapon

 // can replace that part in any ship

 public class ESUFOGun implements ESWeapon{

     // EnemyShip contains a reference to the object

     // ESWeapon. It is stored in the field weapon

     // The Strategy design pattern is being used here

     // When the field that is of type ESUFOGun is printed

     // the following shows on the screen

     public String toString(){

         return "20 damage";

     }

 }

• ESUFOEngine.java

 // Here we define a basic component of a space ship

 // Any part that implements the interface ESEngine

 // can replace that part in any ship

 public class ESUFOEngine implements ESEngine{

     // EnemyShip contains a reference to the object

     // ESWeapon. It is stored in the field weapon

     // The Strategy design pattern is being used here

     // When the field that is of type ESUFOGun is printed

     // the following shows on the screen

     public String toString(){

         return "1000 mph";

     }

 }

• ESUFOBossGun.java

 // Here we define a basic component of a space ship

 // Any part that implements the interface ESWeapon

 // can replace that part in any ship

 public class ESUFOBossGun implements ESWeapon{

     // EnemyShip contains a reference to the object

     // ESWeapon. It is stored in the field weapon

     // The Strategy design pattern is being used here

     // When the field that is of type ESUFOGun is printed

     // the following shows on the screen

     public String toString(){

         return "40 damage";

     }

 }

• ESUFOBossEngine.java

 // Here we define a basic component of a space ship

 // Any part that implements the interface ESEngine

 // can replace that part in any ship

 public class ESUFOBossEngine implements ESEngine{

     // EnemyShip contains a reference to the object

     // ESWeapon. It is stored in the field weapon

     // The Strategy design pattern is being used here

     // When the field that is of type ESUFOGun is printed

     // the following shows on the screen

     public String toString(){

         return "2000 mph";

     }

 }

Singleton

What is the Singleton Design Pattern?

• It is used when you want to eliminate the option of instantiating more than one object.

• I'll Samplenstrate it using a class that holds all the potential Scrabble letters and spits out new ones upon request.

• Each player will share the same potential letter list.

• Each player has their own set of letters.

Sample Code

• Singleton.java

 import java.util.Arrays;

 import java.util.Collections;

 import java.util.LinkedList;

 public class Singleton {

     private static Singleton firstInstance = null;

     String[] scrabbleLetters = {"a", "a", "a", "a", "a", "a", "a", "a", "a",

             "b", "b", "c", "c", "d", "d", "d", "d", "e", "e", "e", "e", "e",

             "e", "e", "e", "e", "e", "e", "e", "f", "f", "g", "g", "g", "h",

             "h", "i", "i", "i", "i", "i", "i", "i", "i", "i", "j", "k", "l",

             "l", "l", "l", "m", "m", "n", "n", "n", "n", "n", "n", "o", "o",

             "o", "o", "o", "o", "o", "o", "p", "p", "q", "r", "r", "r", "r",

             "r", "r", "s", "s", "s", "s", "t", "t", "t", "t", "t", "t", "u",

             "u", "u", "u", "v", "v", "w", "w", "x", "y", "y", "z",};  

     private LinkedList<String> letterList = new LinkedList<String> (Arrays.asList(scrabbleLetters));

     // Used to slow down 1st thread

     static boolean firstThread = true;

     // Created to keep users from instantiation

     // Only Singleton will be able to instantiate this class

     private Singleton() { }

     // We could make getInstance a synchronized method to force

     // every thread to wait its turn. That way only one thread

     // can access a method at a time. This can really slow everything

     // down though

     // public static synchronized Singleton getInstance()

     public static Singleton getInstance() {

         if(firstInstance == null) {

             // This is here to test what happens if threads try

             // to create instances of this class

             if(firstThread){

                 firstThread = false;

                 try {

                     Thread.currentThread();

                     Thread.sleep(1000);

                 } catch (InterruptedException e) {

                     e.printStackTrace();

                 }

             }

             // Here we just use synchronized when the first object

             // is created

             synchronized(Singleton.class){ 

                 if(firstInstance == null) {

                     // If the instance isn't needed it isn't created

                     // This is known as lazy instantiation

                     firstInstance = new Singleton();

                     // Shuffle the letters in the list

                     Collections.shuffle(firstInstance.letterList);

                 }

             }

         }

         // Under either circumstance this returns the instance

         return firstInstance;

     }

     public LinkedList<String> getLetterList(){

         return firstInstance.letterList;

     }

     public LinkedList<String> getTiles(int howManyTiles){

         // Tiles to be returned to the user

         LinkedList<String> tilesToSend = new LinkedList<String>();

         // Cycle through the LinkedList while adding the starting

         // Strings to the to be returned LinkedList while deleting

         // them from letterList

         for(int i = 0; i <= howManyTiles; i++){

             tilesToSend.add(firstInstance.letterList.remove(0));

         }

         // Return the number of letter tiles requested

         return tilesToSend;

     }

 }

• ScrabbleTest.java

 import java.util.LinkedList;

 public class ScrabbleTest {

     public static void main(String[] args){

         // How you create a new instance of Singleton

         Singleton newInstance = Singleton.getInstance();

         // Get unique id for instance object

         System.out.println("1st Instance ID: " + System.identityHashCode(newInstance));

         // Get all of the letters stored in the List

         System.out.println(newInstance.getLetterList());

         LinkedList<String> playerOneTiles = newInstance.getTiles(7);

         System.out.println("Player 1: " + playerOneTiles);

         System.out.println(newInstance.getLetterList());

         // Try to make another instance of Singleton

         // This doesn't work because the constructor is private

         // Singleton instanceTwo = new Singleton();

         // Try getting a new instance using getInstance

         Singleton instanceTwo = Singleton.getInstance();

         // Get unique id for the new instance object

         System.out.println("2nd Instance ID: " + System.identityHashCode(instanceTwo));

         // This returns the value of the first instance created

         System.out.println(instanceTwo.getLetterList());

         // Player 2 draws 7 tiles

         LinkedList<String> playerTwoTiles = newInstance.getTiles(7);

         System.out.println("Player 2: " + playerTwoTiles);

     }

 }

• ScrabbleTestThreads.java

 public class ScrabbleTestThreads{

     public static void main(String[] args){

         // Create a new Thread created using the Runnable interface

         // Execute the code in run after 10 seconds

         Runnable getTiles = new GetTheTiles();

         Runnable getTilesAgain = new GetTheTiles();

         // Call for the code in the method run to execute

         new Thread(getTiles).start();

         new Thread(getTilesAgain).start();

     }

 }

• GetTheTiles.java

 import java.util.LinkedList;

 public class GetTheTiles implements Runnable {

     public void run(){

             // How you create a new instance of Singleton

             Singleton newInstance = Singleton.getInstance();

             // Get unique id for instance object

             System.out.println("1st Instance ID: " + System.identityHashCode(newInstance));

             // Get all of the letters stored in the List

             System.out.println(newInstance.getLetterList());

             LinkedList<String> playerOneTiles = newInstance.getTiles(7);

             System.out.println("Player 1: " + playerOneTiles);

         System.out.println("Got Tiles");

     }

 }

Builder

What is the Builder Design Pattern?

• Pattern used to create objects made from a bunch of other objects.

• When you want to build an object made up from other objects.

• When you want the creation of these parts to be independent of the main object.

• Hide the creation of the parts from the client so both aren't dependent.

• The builder knows the specifics and nobody else dose.

Sample Code

• RobotPlan.java

 // This is the interface that will be returned from the builder

 public interface RobotPlan{

     public void setRobotHead(String head);

     public void setRobotTorso(String torso);

     public void setRobotArms(String arms);

     public void setRobotLegs(String legs);

 }

• Robot.java

 // The concrete Robot class based on the RobotPlan interface

 public class Robot implements RobotPlan{

     private String robotHead;

     private String robotTorso;

     private String robotArms;

     private String robotLegs;

     public void setRobotHead(String head) {

         robotHead = head;

     }

     public String getRobotHead(){ return robotHead; }

     public void setRobotTorso(String torso) {

         robotTorso = torso;

     }

     public String getRobotTorso(){ return robotTorso; }

     public void setRobotArms(String arms) {

         robotArms = arms;

     }

     public String getRobotArms(){ return robotArms; }

     public void setRobotLegs(String legs) {

         robotLegs = legs;

     }

     public String getRobotLegs(){ return robotLegs; }

 }

• RobotBuilder.java

 // Defines the methods needed for creating parts

 // for the robot

 public interface RobotBuilder {

     public void buildRobotHead();

     public void buildRobotTorso();

     public void buildRobotArms();

     public void buildRobotLegs();

     public Robot getRobot();

 }

• OldRobotBuilder.java

 // The concrete builder class that assembles the parts

 // of the finished Robot object

 public class OldRobotBuilder implements RobotBuilder {

     private Robot robot;

     public OldRobotBuilder() {

         this.robot = new Robot();

     }

     public void buildRobotHead() {

         robot.setRobotHead("Tin Head");

     }

     public void buildRobotTorso() {

         robot.setRobotTorso("Tin Torso");

     }

     public void buildRobotArms() {

         robot.setRobotArms("Blowtorch Arms");

     }

     public void buildRobotLegs() {

         robot.setRobotLegs("Rollar Skates");

     }

     public Robot getRobot() {

         return this.robot;

     }

 }

• RobotEngineer.java

 // The director / engineer class creates a Robot using the

 // builder interface that is defined (OldRobotBuilder)

 public class RobotEngineer {

     private RobotBuilder robotBuilder;

     // OldRobotBuilder specification is sent to the engineer

     public RobotEngineer(RobotBuilder robotBuilder){

         this.robotBuilder = robotBuilder;

     }

     // Return the Robot made from the OldRobotBuilder spec

     public Robot getRobot(){

         return this.robotBuilder.getRobot();

     }

     // Execute the methods specific to the RobotBuilder

     // that implements RobotBuilder (OldRobotBuilder)

     public void makeRobot() {

         this.robotBuilder.buildRobotHead();

         this.robotBuilder.buildRobotTorso();

         this.robotBuilder.buildRobotArms();

         this.robotBuilder.buildRobotLegs();

     }

 }

• TestRobotBuilder.java

 public class TestRobotBuilder {

     public static void main(String[] args){

         // Get a RobotBuilder of type OldRobotBuilder

         RobotBuilder oldStyleRobot = new OldRobotBuilder();

         // Pass the OldRobotBuilder specification to the engineer

         RobotEngineer robotEngineer = new RobotEngineer(oldStyleRobot);

         // Tell the engineer to make the Robot using the specifications

         // of the OldRobotBuilder class

         robotEngineer.makeRobot();

         // The engineer returns the right robot based off of the spec

         // sent to it on line 11

         Robot firstRobot = robotEngineer.getRobot();

         System.out.println("Robot Built");

         System.out.println("Robot Head Type: " + firstRobot.getRobotHead());

         System.out.println("Robot Torso Type: " + firstRobot.getRobotTorso());

         System.out.println("Robot Arm Type: " + firstRobot.getRobotArms());

         System.out.println("Robot Leg Type: " + firstRobot.getRobotLegs());

     }

 }

Prototype

What is the Prototype Design Pattern?

• Creating new objects (instances) by cloning (copying) other objects.

• Allows for adding of any subclass instance of a known super class at run time.

• When there are numerous potential classes that you want to only use if needed at runtime.

• Reduces the need for creating subclasses.

Sample Code

• Animal.java

 // By making this class cloneable you are telling Java

 // that it is ok to copy instances of this class

 // These instance copies have different results when

 // System.identityHashCode(System.identityHashCode(bike))

 // is called 

 public interface Animal extends Cloneable {

     public Animal makeCopy();

 }

• Sheep.java

 public class Sheep implements Animal {

     public Sheep(){

         System.out.println("Sheep is Made");

     }

     public Animal makeCopy() {

         System.out.println("Sheep is Being Made");

         Sheep sheepObject = null;

         try {

             // Calls the Animal super classes clone()

             // Then casts the results to Sheep

             sheepObject = (Sheep) super.clone();

         }

         // If Animal didn't extend Cloneable this error

         // is thrown

         catch (CloneNotSupportedException e) {

             System.out.println("The Sheep was Turned to Mush");

             e.printStackTrace();

          }

         return sheepObject;

     }

     public String toString(){

         return "Dolly is my Hero, Baaaaa";

     }

 }

• CloneFactory.java

 public class CloneFactory {

     // Receives any Animal, or Animal subclass and

     // makes a copy of it and stores it in its own

     // location in memory

     // CloneFactory has no idea what these objects are

     // except that they are subclasses of Animal

     public Animal getClone(Animal animalSample) {

         // Because of Polymorphism the Sheeps makeCopy()

         // is called here instead of Animals

         return animalSample.makeCopy();

     }

 }

• TestCloning.java

 public class TestCloning {

     public static void main(String[] args){

         // Handles routing makeCopy method calls to the

         // right subclasses of Animal

         CloneFactory animalMaker = new CloneFactory();

         // Creates a new Sheep instance

         Sheep sally = new Sheep();

         // Creates a clone of Sally and stores it in its own

         // memory location

         Sheep clonedSheep = (Sheep) animalMaker.getClone(sally);

         // These are exact copies of each other

         System.out.println(sally);

         System.out.println(clonedSheep);

         System.out.println("Sally HashCode: " + System.identityHashCode(System.identityHashCode(sally)));

         System.out.println("Clone HashCode: " + System.identityHashCode(System.identityHashCode(clonedSheep)));

     }

 }

作者：netoxi
出处：http://www.cnblogs.com/netoxi
本文版权归作者和博客园共有，欢迎转载，未经同意须保留此段声明，且在文章页面明显位置给出原文连接。欢迎指正与交流。