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

Decorator

What is the Decorator Design Pattern?

• The Decorator allows you to modify an object dynamically.

• You would use it when you want the capabilities of inheritance with subclasses, but you need to add functionality at run time.

• It is more flexible than inheritance.

• Simplifies code because you add functionality using many simple classes.

• Rather than rewrite old code you can extend with new code.

Sample Code

• Pizza.java

 // 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

 }

 */

• ThreeCheesePizza.java

 // 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;

     }

 }

• PlainPizza.java

 // 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;

     }

 }

• ToppingDecorator.java

 // 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();

     }

 }

• Mozzarella.java

 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;

     }

 }

• TomatoSauce.java

 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;

     }

 }

• PizzaMaker.java

 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());

     }

 }

Adapter

What is the Adapter Design Pattern?

• Allows 2 incompatible interfaces to work together.

• Used when the client expects a (target) interface.

• The Adapter class allows the use of the available interface and the Target interface.

• Any class can work together as long as the Adapter solves the issue that all classes must implement every method defined by the shared interface.

Sample Code

• EnemyAttacker.java

 // 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.java

 // 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");

     }

 }

• EnemyRobot.java

 // 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);

     }

 }

• EnemyRobotAdapter.java

 // 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);

     }

 }

• TestEnemyAttackers.java

 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();

     }

 }

Facade

What is the Facade Design Pattern?

• When you create a simplified interface that performs many other actions behind the scenes.

• Can I withdrawal $50 from the bank?

• Check if the checking account is valid.

• Check if the security code is valid.

• Check if funds are available.

• Make changes accordingly.

Sample Code

• WelcomeToBank.java

 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");

     }

 }

• AccountNumberCheck.java

 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;

         }

     }

 }

• SecurityCodeCheck.java

 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;

         }

     }

 }

• FundsCheck.java

 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());

     }

 }

• BankAccountFacade.java

 // 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");

                 }

     }

 }

• TestBankAccount.java

 public class TestBankAccount {

     public static void main(String[] args){

         BankAccountFacade accessingBank = new BankAccountFacade(12345678, 1234);

         accessingBank.withdrawCash(50.00);

         accessingBank.withdrawCash(990.00);

     }

 }

Bridge

What is the Bridge Design Pattern?

• Decouple an abstraction from its implementation so that the two can vary independently.

• The Bridge Design Pattern is very poorly explained.

• Everyone seems to explain it differently.

• Progressively adding functionality while separating out major differences using abstract classes.

When to use the Bridge Design Pattern?

• When you want to be able to change both the abstractions (abstract classes) and concrete classes independently.

• When you want the first abstract class to define rules (Abstract TV).

• The concrete class adds additional rules (Concrete TV).

• An abstract class has a reference to the device and it defines abstract methods that will be defined (Abstract Remote).

• The Concrete Remote defines the abstract methods required.

Sample Code

• EntertainmentDevice.java

 // 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);

     }

 }

• TVDevice.java

 // 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++;

     }

 }

• RemoteButton.java

 // 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();

 }

• TVRemoteMute.java

 // 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");

     }

 }

• TVRemotePause.java

 // 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");

     }

 }

• TestTheRemote.java

 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();

     }

 }

Flyweight

What is the Flyweight Design Pattern?

• Used when you need to create a large number of similar objects.

• To reduce memory usage you share objects that are similar in some way rather than creating new ones.

• Intrinsic State: Color.

• Extrinsic State: Size.

Sample Code

• FlyWeightTest.java

 // 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]; 

     }

 }

• MyRect.java

 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);

    }

    */

 }

• RectFactory.java

 // 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;

     }

 }

Proxy

What is the Proxy Design Pattern?

• Provide a class which will limit access to another class.

• You may do this for security reasons, because an Object is intensive to create, or is accessed from a remote location.

Sample Code

• ATMMachine.java

 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; }

 }

• GetATMData.java

 // 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();

 }

• ATMProxy.java

 // 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();

     }

 }

• TestATMMachine.java

 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);

     }

 }

• ATMState.java

 public interface ATMState {

     void insertCard();

     void ejectCard();

     void insertPin(int pinEntered);

     void requestCash(int cashToWithdraw);

 }

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