设计模式教程（Design Patterns Tutorial）笔记之二 结构型模式（Structural Patterns）

// Blueprint for classes that will have decorators public interface Pizza { public String getDescription(); public double getCost(); } /*
public abstract class Pizza{ public abstract void setDescription(String newDescription);
public abstract String getDescription(); public abstract void setCost(double newCost);
public abstract double getCost(); // I could use getter and setter methods for every
// potential Pizza topping }
*/

// By going this route I'll have to create a new subclass
// for an infinite number of pizza.
// I'd also have to change prices in many classes
// when just 1 Pizza topping cost changes // Inheritance is static while composition is dynamic
// Through composition I'll be able to add new functionality
// by writing new code rather than by changing current code public class ThreeCheesePizza extends Pizza{ private String description = "Mozzarella, Fontina, Parmesan Cheese Pizza";
private double cost = 10.50; public void setDescription(String newDescription) { description = newDescription; } public String getDescription() { return description; } public void setCost(double newCost) { cost = newCost; } public double getCost() { return cost; }
}

// Implements the Pizza interface with only the required
// methods from the interface // Every Pizza made will start as a PlainPizza public class PlainPizza implements Pizza { public String getDescription() { return "Thin dough"; } public double getCost() { System.out.println("Cost of Dough: " + 4.00); return 4.00; } }

// Has a "Has a" relationship with Pizza. This is an
// Aggregation Relationship abstract class ToppingDecorator implements Pizza { protected Pizza tempPizza; // Assigns the type instance to this attribute
// of a Pizza // All decorators can dynamically customize the Pizza
// instance PlainPizza because of this public ToppingDecorator(Pizza newPizza){ tempPizza = newPizza; } public String getDescription() { return tempPizza.getDescription(); } public double getCost() { return tempPizza.getCost(); } }

public class Mozzarella extends ToppingDecorator { public Mozzarella(Pizza newPizza) { super(newPizza); System.out.println("Adding Dough"); System.out.println("Adding Moz");
} // Returns the result of calling getDescription() for
// PlainPizza and adds " mozzarella" to it public String getDescription(){ return tempPizza.getDescription() + ", mozzarella"; } public double getCost(){ System.out.println("Cost of Moz: " + .50); return tempPizza.getCost() + .50; } }

public class TomatoSauce extends ToppingDecorator { public TomatoSauce(Pizza newPizza) {
super(newPizza); System.out.println("Adding Sauce");
} // Returns the result of calling getDescription() for
// PlainPizza, Mozzarella and then TomatoSauce public String getDescription(){ return tempPizza.getDescription() + ", tomato sauce"; } public double getCost(){ System.out.println("Cost of Sauce: " + .35); return tempPizza.getCost() + .35; } }

public class PizzaMaker { public static void main(String[] args){ // The PlainPizza object is sent to the Mozzarella constructor
// and then to the TomatoSauce constructor Pizza basicPizza = new TomatoSauce(new Mozzarella(new PlainPizza())); System.out.println("Ingredients: " + basicPizza.getDescription()); System.out.println("Price: " + basicPizza.getCost()); } }

// This is the Target Interface : This is what the client
// expects to work with. It is the adapters job to make new
// classes compatible with this one. public interface EnemyAttacker { public void fireWeapon(); public void driveForward(); public void assignDriver(String driverName); }

// EnemyTank implements EnemyAttacker perfectly
// Our job is to make classes with different methods
// from EnemyAttacker to work with the EnemyAttacker interface import java.util.Random; public class EnemyTank implements EnemyAttacker{ Random generator = new Random(); public void fireWeapon() { int attackDamage = generator.nextInt(10) + 1; System.out.println("Enemy Tank Does " + attackDamage + " Damage"); } public void driveForward() { int movement = generator.nextInt(5) + 1; System.out.println("Enemy Tank moves " + movement + " spaces"); } public void assignDriver(String driverName) { System.out.println(driverName + " is driving the tank"); } }

// This is the Adaptee. The Adapter sends method calls
// to objects that use the EnemyAttacker interface
// to the right methods defined in EnemyRobot import java.util.Random; public class EnemyRobot{ Random generator = new Random(); public void smashWithHands() { int attackDamage = generator.nextInt(10) + 1; System.out.println("Enemy Robot Causes " + attackDamage + " Damage With Its Hands"); } public void walkForward() { int movement = generator.nextInt(5) + 1; System.out.println("Enemy Robot Walks Forward " + movement + " spaces"); } public void reactToHuman(String driverName) { System.out.println("Enemy Robot Tramps on " + driverName); } }

// The Adapter must provide an alternative action for
// the the methods that need to be used because
// EnemyAttacker was implemented. // This adapter does this by containing an object
// of the same type as the Adaptee (EnemyRobot)
// All calls to EnemyAttacker methods are sent
// instead to methods used by EnemyRobot public class EnemyRobotAdapter implements EnemyAttacker{ EnemyRobot theRobot; public EnemyRobotAdapter(EnemyRobot newRobot){ theRobot = newRobot; } public void fireWeapon() { theRobot.smashWithHands(); } public void driveForward() { theRobot.walkForward(); } public void assignDriver(String driverName) { theRobot.reactToHuman(driverName); } }

public class TestEnemyAttackers{ public static void main(String[] args){ EnemyTank rx7Tank = new EnemyTank(); EnemyRobot fredTheRobot = new EnemyRobot(); EnemyAttacker robotAdapter = new EnemyRobotAdapter(fredTheRobot); System.out.println("The Robot"); fredTheRobot.reactToHuman("Paul");
fredTheRobot.walkForward();
fredTheRobot.smashWithHands();
System.out.println(); System.out.println("The Enemy Tank"); rx7Tank.assignDriver("Frank");
rx7Tank.driveForward();
rx7Tank.fireWeapon();
System.out.println(); System.out.println("The Robot with Adapter"); robotAdapter.assignDriver("Mark");
robotAdapter.driveForward();
robotAdapter.fireWeapon(); } }

public class WelcomeToBank{ public WelcomeToBank() { System.out.println("Welcome to ABC Bank");
System.out.println("We are happy to give you your money if we can find it\n"); } }

public class AccountNumberCheck{ private int accountNumber = 12345678; public int getAccountNumber() { return accountNumber; } public boolean accountActive(int acctNumToCheck){ if(acctNumToCheck == getAccountNumber()) { return true; } else { return false; } } }

public class SecurityCodeCheck { private int securityCode = 1234; public int getSecurityCode() { return securityCode; } public boolean isCodeCorrect(int secCodeToCheck){ if(secCodeToCheck == getSecurityCode()) { return true; } else { return false; } } }

public class FundsCheck { private double cashInAccount = 1000.00; public double getCashInAccount() { return cashInAccount; } public void decreaseCashInAccount(double cashWithdrawn) { cashInAccount -= cashWithdrawn; } public void increaseCashInAccount(double cashDeposited) { cashInAccount += cashDeposited; } public boolean haveEnoughMoney(double cashToWithdrawal) { if(cashToWithdrawal > getCashInAccount()) { System.out.println("Error: You don't have enough money");
System.out.println("Current Balance: " + getCashInAccount()); return false; } else { decreaseCashInAccount(cashToWithdrawal); System.out.println("Withdrawal Complete: Current Balance is " + getCashInAccount()); return true; } } public void makeDeposit(double cashToDeposit) { increaseCashInAccount(cashToDeposit); System.out.println("Deposit Complete: Current Balance is " + getCashInAccount()); } }

// The Facade Design Pattern decouples or separates the client
// from all of the sub components // The Facades aim is to simplify interfaces so you don't have
// to worry about what is going on under the hood public class BankAccountFacade { private int accountNumber;
private int securityCode; AccountNumberCheck acctChecker;
SecurityCodeCheck codeChecker;
FundsCheck fundChecker; WelcomeToBank bankWelcome; public BankAccountFacade(int newAcctNum, int newSecCode){ accountNumber = newAcctNum;
securityCode = newSecCode; bankWelcome = new WelcomeToBank(); acctChecker = new AccountNumberCheck();
codeChecker = new SecurityCodeCheck();
fundChecker = new FundsCheck(); } public int getAccountNumber() { return accountNumber; } public int getSecurityCode() { return securityCode; } public void withdrawCash(double cashToGet){ if(acctChecker.accountActive(getAccountNumber()) &&
codeChecker.isCodeCorrect(getSecurityCode()) &&
fundChecker.haveEnoughMoney(cashToGet)) { System.out.println("Transaction Complete\n"); } else { System.out.println("Transaction Failed\n"); } } public void depositCash(double cashToDeposit){ if(acctChecker.accountActive(getAccountNumber()) &&
codeChecker.isCodeCorrect(getSecurityCode())) { fundChecker.makeDeposit(cashToDeposit); System.out.println("Transaction Complete\n"); } else { System.out.println("Transaction Failed\n"); } } }

public class TestBankAccount { public static void main(String[] args){ BankAccountFacade accessingBank = new BankAccountFacade(12345678, 1234); accessingBank.withdrawCash(50.00); accessingBank.withdrawCash(990.00); } }

// Implementor
// With the Bridge Design Pattern you create 2 layers of abstraction
// In this example I'll have an abstract class representing
// different types of devices. I also have an abstract class
// that will represent different types of remote controls // This allows me to use an infinite variety of devices and remotes abstract class EntertainmentDevice { public int deviceState; public int maxSetting; public int volumeLevel = 0; public abstract void buttonFivePressed(); public abstract void buttonSixPressed(); public void deviceFeedback() { if(deviceState > maxSetting || deviceState < 0) { deviceState = 0; } System.out.println("On Channel " + deviceState); } public void buttonSevenPressed() { volumeLevel++; System.out.println("Volume at: " + volumeLevel); } public void buttonEightPressed() { volumeLevel--; System.out.println("Volume at: " + volumeLevel); } }

// Concrete Implementor // Here is an implementation of the EntertainmentDevice
// abstract class. I'm specifying what makes it different
// from other devices public class TVDevice extends EntertainmentDevice { public TVDevice(int newDeviceState, int newMaxSetting){ deviceState = newDeviceState; maxSetting = newMaxSetting; } public void buttonFivePressed() { System.out.println("Channel Down"); deviceState--; } public void buttonSixPressed() { System.out.println("Channel Up"); deviceState++; } }

// Abstraction // This is an abstract class that will represent numerous
// ways to work with each device public abstract class RemoteButton{ // A reference to a generic device using aggregation private EntertainmentDevice theDevice; public RemoteButton(EntertainmentDevice newDevice){ theDevice = newDevice; } public void buttonFivePressed() { theDevice.buttonFivePressed(); } public void buttonSixPressed() { theDevice.buttonSixPressed(); } public void deviceFeedback(){ theDevice.deviceFeedback(); } public abstract void buttonNinePressed(); }

// Refined Abstraction // If I decide I want to further extend the remote I can public class TVRemoteMute extends RemoteButton{ public TVRemoteMute(EntertainmentDevice newDevice) {
super(newDevice);
} public void buttonNinePressed() { System.out.println("TV was Muted"); } }

// Refined Abstraction // If I decide I want to further extend the remote I can public class TVRemotePause extends RemoteButton{ public TVRemotePause(EntertainmentDevice newDevice) {
super(newDevice);
} public void buttonNinePressed() { System.out.println("TV was Paused"); } }

public class TestTheRemote{ public static void main(String[] args){ RemoteButton theTV = new TVRemoteMute(new TVDevice(1, 200)); RemoteButton theTV2 = new TVRemotePause(new TVDevice(1, 200)); // HOMEWORK -------------- RemoteButton theDVD = new DVDRemote(new DVDDevice(1,14)); // ----------------------- System.out.println("Test TV with Mute"); theTV.buttonFivePressed();
theTV.buttonSixPressed();
theTV.buttonNinePressed(); System.out.println("\nTest TV with Pause"); theTV2.buttonFivePressed();
theTV2.buttonSixPressed();
theTV2.buttonNinePressed();
theTV2.deviceFeedback(); // HOMEWORK System.out.println("\nTest DVD"); theDVD.buttonFivePressed();
theDVD.buttonSixPressed();
theDVD.buttonNinePressed();
theDVD.buttonNinePressed(); } }

// The Flyweight design pattern is used when you need to
// create a large number of similar objects // To reduce memory this pattern shares Objects that are
// the same rather than creating new ones import javax.swing.*; import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Graphics; import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random; public class FlyWeightTest extends JFrame{ private static final long serialVersionUID = 1L; JButton startDrawing; int windowWidth = 1750;
int windowHeight = 1000; // A new rectangle is created only if a new color is needed Color[] shapeColor = {Color.orange, Color.red, Color.yellow,
Color.blue, Color.pink, Color.cyan, Color.magenta,
Color.black, Color.gray}; public static void main(String[] args){ new FlyWeightTest(); } public FlyWeightTest(){ // Create the frame, position it and handle closing it this.setSize(windowWidth,windowHeight);
this.setLocationRelativeTo(null);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setTitle("Flyweight Test"); JPanel contentPane = new JPanel(); contentPane.setLayout(new BorderLayout()); final JPanel drawingPanel = new JPanel(); startDrawing = new JButton("Button 1"); contentPane.add(drawingPanel, BorderLayout.CENTER); contentPane.add(startDrawing, BorderLayout.SOUTH); startDrawing.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent event) {
Graphics g = drawingPanel.getGraphics(); long startTime = System.currentTimeMillis(); for(int i=0; i < 100000; ++i) { //
// Uses rectangles stored in the HashMap to
// speed up the program MyRect rect = RectFactory.getRect(getRandColor());
rect.draw(g, getRandX(), getRandY(),
getRandX(), getRandY()); //
/*
MyRect rect = new MyRect(getRandColor(), getRandX(), getRandY(), getRandX(), getRandY());
rect.draw(g);
*/ //
/*
g.setColor(getRandColor());
g.fillRect(getRandX(), getRandY(), getRandX(), getRandY());
*/ } long endTime = System.currentTimeMillis(); System.out.println("That took " + (endTime - startTime) + " milliseconds"); }
}); this.add(contentPane); this.setVisible(true); } // Picks random x & y coordinates private int getRandX(){ return (int)(Math.random()*windowWidth); } private int getRandY(){ return (int)(Math.random()*windowHeight); } // Picks a random Color from the 9 available private Color getRandColor(){
Random randomGenerator = new Random(); int randInt = randomGenerator.nextInt(9); return shapeColor[randInt]; } }

import java.awt.*;
public class MyRect {
private Color color = Color.black;
private int x, y, x2, y2; public MyRect(Color color) { this.color = color; } public void draw(Graphics g, int upperX, int upperY, int lowerX, int lowerY) {
g.setColor(color);
g.fillRect(upperX, upperY, lowerX, lowerY);
} /* Original forces creation of a rectangle every time public MyRect(Color color, int upperX, int upperY, int lowerX, int lowerY) {
this.color = color;
this.x = upperX;
this.y = upperY;
this.x2 = lowerX;
this.y2 = lowerY;
} public void draw(Graphics g) {
g.setColor(color);
g.fillRect(x, y, x2, y2);
}
*/
}

// This factory only creates a new rectangle if it
// uses a color not previously used // Intrinsic State: Color
// Extrinsic State: X & Y Values import java.util.HashMap;
import java.awt.Color;
public class RectFactory { // The HashMap uses the color as the key for every
// rectangle it will make up to 8 total private static final HashMap<Color, MyRect> rectsByColor = new HashMap<Color, MyRect>(); public static MyRect getRect(Color color) {
MyRect rect = (MyRect)rectsByColor.get(color); // Checks if a rectangle with a specific
// color has been made. If not it makes a
// new one, otherwise it returns one made already if(rect == null) {
rect = new MyRect(color); // Add new rectangle to HashMap rectsByColor.put(color, rect); }
return rect;
}
}

public class ATMMachine implements GetATMData{ public ATMState getYesCardState() { return hasCard; }
public ATMState getNoCardState() { return noCard; }
public ATMState getHasPin() { return hasCorrectPin; }
public ATMState getNoCashState() { return atmOutOfMoney; } // NEW STUFF public ATMState getATMState() { return atmState; }
public int getCashInMachine() { return cashInMachine; }
}

// This interface will contain just those methods
// that you want the proxy to provide access to public interface GetATMData {
public ATMState getATMState();
public int getCashInMachine();
}

// In this situation the proxy both creates and destroys
// an ATMMachine Object public class ATMProxy implements GetATMData { // Allows the user to access getATMState in the
// Object ATMMachine public ATMState getATMState() { ATMMachine realATMMachine = new ATMMachine(); return realATMMachine.getATMState();
} // Allows the user to access getCashInMachine
// in the Object ATMMachine public int getCashInMachine() { ATMMachine realATMMachine = new ATMMachine(); return realATMMachine.getCashInMachine(); } }

public class TestATMMachine { public static void main(String[] args){ ATMMachine atmMachine = new ATMMachine(); atmMachine.insertCard(); atmMachine.ejectCard(); atmMachine.insertCard(); atmMachine.insertPin(1234); atmMachine.requestCash(2000); atmMachine.insertCard(); atmMachine.insertPin(1234); // NEW STUFF : Proxy Design Pattern Code
// The interface limits access to just the methods you want
// made accessible GetATMData realATMMachine = new ATMMachine(); GetATMData atmProxy = new ATMProxy(); System.out.println("\nCurrent ATM State " + atmProxy.getATMState()); System.out.println("\nCash in ATM Machine $" + atmProxy.getCashInMachine()); // The user can't perform this action because ATMProxy doesn't
// have access to that potentially harmful method
// atmProxy.setCashInMachine(10000); } }

public interface ATMState { void insertCard();
void ejectCard();
void insertPin(int pinEntered);
void requestCash(int cashToWithdraw); }