设计模式习题.docx

设计模式习题.docx

《设计模式习题.docx》由会员分享，可在线阅读，更多相关《设计模式习题.docx（43页珍藏版）》请在冰豆网上搜索。

设计模式习题

一、   模式（Pattern）定义 

策略模式（Strategy）   

定义：

策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。

策略模式让算法独立于使用它的客户而独立变化。

类图：

 Context（适用性）:

1）       需要使用ConcreteStrategy提供的算法。

2）       内部维护一个Strategy的实例。

3）       负责动态设置运行时Strategy具体的实现算法。

4）       负责跟Strategy之间的交互和数据传递。

Strategy（抽象策略类）：

定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，Context使用这个接口调用不同的算法，一般使用接口或抽象类实现。

ConcreteStrategy（具体策略类）：

实现了Strategy定义的接口，提供具体的算法实现。

适用性:

对于Strategy模式来说，主要有这些适用性：

1、 多个类只区别在表现行为不同，可以使用Strategy模式，在运行时动态选择具体要执行的行为。

（例如FlyBehavior和QuackBehavior）

2、 需要在不同情况下使用不同的策略（算法），或者策略还可能在未来用其它方式来实现。

（例如FlyBehavior和QuackBehavior的具体实现可任意变化或扩充）

3、 对客户（Duck）隐藏具体策略（算法）的实现细节，彼此完全独立。

策略模式顺序图：

1.观察者模式（ObserverPattern） 

定义：

定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。

类图：

P52      

主要解决问题：

l        当一个抽象模型有两个方面的，其中一个方面依赖与另一个方面。

l        当一个对象的改变需要同时改变其他对象，而不知道具体有多对象有待改变

l        当一个对象必须通知其他对象，而它又不能假定其他对象是谁。

生活中的例子：

观察者定义了对象间一对多的关系，当一个对象的状态变化时，所有依赖它的对象都得到通知并且自动地更新。

拍卖演示了这种模式。

每个投标人都有一个标有数字的牌子用于出价。

拍卖师开始拍卖时，他观察是否有牌子举起出价。

每次接受一个新的出价都改变了拍卖的当前价格，并且广播给所有的投标人进行新的出价。

图2使用拍卖例子的观察者模式

第一次试验实例：

1.观察者模式适用场景

1）     对一个对象状态的更新，需要其他对象同步更新，而且其他对象的数量动态可变。

2）     对象仅需要将自己的更新通知给其他对象而不需要知道其他对象的细节。

1.类图及时序图（见图1、图2）

图1.设计类图

图2.时序图

1.类的实现及代码测试

1）ChicagoPizzaStore类

packagecom.finalcom;

importcom.finalpizza.ChicagoStyleCheesePizza;

importcom.finalpizza.ChicagoStylePepperoniPizza;

importcom.finalpizza.Pizza;

publicclassChicagoPizzaStoreextendsPizzaStore{

    publicPizzacreatePizza（Stringitem）{

        if（item.equals（"cheese"））{

             returnnewChicagoStyleCheesePizza（）;

        }elseif（item.equals（"pepperoni"））{

             returnnewChicagoStylePepperoniPizza（）;

        }elsereturnnull;

    }

}

2）NYPizzaStore类

packagecom.finalcom;

importcom.finalpizza.*;

publicclassNYPizzaStoreextendsPizzaStore{

    publicPizzacreatePizza（Stringitem）{

        if（item.equals（"cheese"））{

             returnnewNYStyleCheesePizza（）;

        }elseif（item.equals（"pepperoni"））{

             returnnewNYStylePepperoniPizza（）;

        }elsereturnnull;

    }

}

3）PizzaStore抽象类

packagecom.finalcom;

importcom.finalpizza.*;

publicabstractclassPizzaStore{

    publicPizzaorderPizza（Stringtype）{

        Pizzapizza;

        pizza=createPizza（type）;

        pizza.prepare（）;

        pizza.bake（）;

        pizza.cut（）;

        pizza.box（）;

        returnpizza;

    }

    protectedabstractPizzacreatePizza（Stringtype）;

}

4）PizzaTestDrive类

packagecom.finalcom;

importcom.finalpizza.*;

publicclassPizzaTestDrive{

    publicstaticvoidmain（String[]args）{

        PizzaStorenyStore=newNYPizzaStore（）;

        PizzaStorechicagoStore=newChicagoPizzaStore（）;

        Pizzapizza;

        pizza=nyStore.orderPizza（"cheese"）;         

System.out.println（"======================"）;

        pizza=nyStore.orderPizza（"pepperoni"）;

        System.out.println（"======================"）;

        pizza=chicagoStore.orderPizza（"cheese"）;

        System.out.println（"======================"）;

        pizza=chicagoStore.orderPizza（"pepperoni"）;

        System.out.println（"======================"）;

    }

}

5）ChicagoStyleCheesePizza类

packagecom.finalpizza;

publicclassChicagoStyleCheesePizzaextendsPizza{

    publicChicagoStyleCheesePizza（）{

        setName（"ChicagoStyleSauceandCheesePizza"）;

        setDough（"ExtraThinCrustDough"）;

        setSauce（"PlumTomatoSauce"）;

        toppings.add（"ShreddedMozzarella10ouncecheese"）;}

    publicvoidcut（）{

        System.out.println（"Cuttingthepizzaintosquareslices"）;

    }

}

6）ChicagoStylePepperoniPizza类

packagecom.finalpizza;

publicclassChicagoStylePepperoniPizzaextendsPizza{

    publicChicagoStylePepperoniPizza（）{

        setName（"ChicagoStyleSauceandPepperoniPizza"）;

        setDough（"ExtraThinCrustDough"）;

        setSauce（"PlumTomatoSauce"）;

        toppings.add（"ShreddedMozzarella10ouncepepperoni"）;

    }

    publicvoidcut（）{

        System.out.println（"Cuttingthepizzaintosquareslices"）;

    }

}

                                                 接右上角

7）NYStyleCheesePizza类

packagecom.finalpizza;

publicclassNYStyleCheesePizzaextendsPizza{

    publicNYStyleCheesePizza（）{

        setName（"NYStyleSauceandCheesePizza"）;

        setDough（"ThinCrustDough"）;

        setSauce（"MarinaraSauce"）;

        toppings.add（"GratedReggiano5ouncecheese"）;

    }

}

8）NYStylePepperoniPizza类

packagecom.finalpizza;

publicclassNYStylePepperoniPizzaextendsPizza{

    publicNYStylePepperoniPizza（）{

        setName（"NYStyleSauceandPepperoniPizza"）;

        setDough（"ThinCrustDough"）;

        setSauce（"MarinaraSauce"）;

        toppings.add（"GratedReggiano5ouncepepperoni"）;

    }

}

9）Pizza抽象类

packagecom.finalpizza;

importjava.util.ArrayList;

publicabstractclassPizza{

    privateStringname;

    privateStringdough;

    privateStringsauce;

    ArrayListtoppings=newArrayList（）;

    publicvoidprepare（）{

        System.out.println（"Preparing"+name）;

        System.out.println（"Tossingdough..."）;

        System.out.println（"Addingsauce"）;

        System.out.print（"Addingtoppings:

"）;

        for（inti=0;i

             System.out.println（""+toppings.get（i））;

        }

    }

    publicvoidbake（）{

        System.out.println（"Bakefor25minutesat350"）;

    }

    publicvoidcut（）{

        System.out.println（"Cuttingthepizzaintodiagonalslices"）;

    }

    publicvoidbox（）{

        System.out.println（"PlacepizzainofficialPizzaStorebox"）;

    }

    publicStringgetName（）{

        returnname;

    }

    publicvoidsetName（Stringname）{

        this.name=name;

    }

    publicStringgetDough（）{

        returndough;

    }

    publicvoidsetDough（Stringdough）{

        this.dough=dough;

    }

publicStringgetSauce（）{

        returnsauce;

    }

    publicvoidsetSauce（Stringsauce）{

        this.sauce=sauce;

    }

    publicArrayListgetToppings（）{

        returntoppings;

    }

    publicvoidsetToppings（ArrayListtoppings）{

        this.toppings=toppings;

1.2.    装饰模式（DECORATOR） 

定义：

动态地将责任附加到对象上。

若要扩展功能，装饰者提供了比集成更加有弹性的替代方案。

类图：

P91

生活中的例子：

装饰模式动态地给一个对象添加额外的职责。

不论一幅画有没有画框都可以挂在墙上，但是通常都是有画框的，并且实际上是画框被挂在墙上。

在挂在墙上之前，画可以被蒙上玻璃，装到框子里；这时画、玻璃和画框形成了一个物体。

图2使用有画框的画作为例子的装饰模式对象图

主要解决问题

l        在不影响其他对象的情况下，以动态、透明的方式给单个对象添加责任

l        处理那些可以撤销的职责

l        当不能采用生成子类的方法进行扩时。

一种情况是，可能有大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长。

另一种情况可能是因为类定义被隐藏，或类定义不能用于生成子类。

适用性：

1.需要扩展一个类的功能，或给一个类增加附加责任。

2.需要动态地给一个对象增加功能，这些功能可以再动态地撤销。

3.需要增加由一些基本功能的排列组合而产生的非常大量的功能，从而使继承关系变得不现实。

1.3.    工厂方法模式（FactoryMethod）【P117去理解简单工厂模式，这里不列举】 

定义：

创建对象的接口，但由子类决定要实例化的类是哪一个。

工厂方法让类把实例化推迟到子类。

类图：

P134

第二次试验实例：

工厂模式的类图及其代码（如图4）

图4.工厂模式的类图

代码实现:

1）ChicagoPizzaStore类

packagecom.finalcom;

importcom.finalpizza.ChicagoStyleCheesePizza;

importcom.finalpizza.Pizza;

publicclassChicagoPizzaStoreextendsPizzaStore{

   publicPizzacreatePizza（Stringitem）{

      if（item.equals（"cheese"））{

          returnnewChicagoStyleCheesePizza（）;

      }

   }

}

3）PizzaStore抽象类

packagecom.finalcom;

importcom.finalpizza.*;

publicabstractclassPizzaStore{

   publicPizzaorderPizza（Stringtype）{

      Pizzapizza;

      pizza=createPizza（type）;

      pizza.prepare（）;

      pizza.bake（）;

      pizza.cut（）;

      pizza.box（）;

      returnpizza;

   }

   protectedabstractPizzacreatePizza（Stringtype）;

}

4）PizzaTestDrive类

packagecom.finalcom;

importcom.finalpizza.*;

publicclassPizzaTestDrive{

   publicstaticvoidmain（String[]args）{

      PizzaStorechicagoStore=newChicagoPizzaStore（）;

      Pizzapizza;

      pizza=chicagoStore.orderPizza（"cheese"）;

      System.out.println（"======================"）;

   }

}

5）ChicagoStyleCheesePizza类

packagecom.finalpizza;

publicclassChicagoStyleCheesePizzaextendsPizza{

   publicChicagoStyleCheesePizza（）{

      setName（"ChicagoStyleSauceandCheesePizza"）;

   publicvoidcut（）{

      System.out.println（"Cuttingthepizzaintosquareslices"）;

   }

}

9）Pizza抽象类

packagecom.finalpizza;

publicabstractclassPizza{

   privateStringname;

   publicvoidprepare（）{

      System.out.println（"Preparing"+name）;

   }

   publicvoidbake（）{

      System.out.println（"Bakefor25minutesat350"）;

   }

   publicvoidcut（）{

      System.out.println（"Cuttingthepizzaintodiagonalslices"）;

   }

   publicvoidbox（）{

      System.out.println（"PlacepizzainofficialPizzaStorebox"）;

   }

   publicStringgetName（）{

      returnname;

   }

   publicvoidsetName（Stringname）{

      this.name=name;

   }

}

生活中的例子：

工厂方法定义一个用于创建对象的接口，但是让子类决定实例化哪个类。

压注成型演示了这种模式。

塑料玩具制造商加工塑料粉，将塑料注入到希望形状的模具中。

玩具的类别（车，人物等等）是由模具决定的。

适用性：

在以下情况下，适用于工厂方法模式：

1.当一个类不知道它所必须创建的对象的类的时候。

2.当一个类希望由它的子类来指定它所创建的对象的时候。

3.当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候

1.4.    抽象工厂方法（AbstractFactory） 

定义：

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

类图：

P156

代码实现：

第二次实验课：

抽象工厂的类图及其代码（如图7）

图7.抽象工厂的类图

代码实现：

（简化部分）

1）NYPizzaStore类

packagecom.abcom;

importcom.abpizzamaterial.CheesePizza;

importcom.abpizzamaterial.Pizza;

publicclassNYPizzaStoreextendsPizzaStore{

   protectedPizzacreatePizza（Stringitem）{

      Pizzapizza=null;

      PizzaIngredientFactoryingredientFactory=

          newNYPizzaIngredientFactory（）;

      if（item.equals（"cheese"））{

          pizza=newCheesePizza（ingredientFactory）;

          pizza.setName（"NewYorkStyleCheesePizza"）;

      }

      returnpizza;

   }

}

2）PizzaIngtedientFactory接口

packagecom.abc