SlideServe
Télécharger Obtenir Pro
Menu
Accueil Pro
Préférences
ApparenceLight Aide et commentaires
© SlideServe · v2026

Understanding the Decorator Pattern Through an Ice Cream Store Example

olesia avatar
olesia
16 diapositives · 338 Views · Jul 27, 2014

The Decorator Pattern allows you to dynamically add functionality to an existing class without modifying its structure. This example focuses on an Ice Cream Store scenario where subclasses like Cone can be enriched with new toppings like Fudge and Nuts. By wrapping these subclasses with decorators, we achieve flexibility and maintainability, avoiding class explosion and allowing easy adaptation to new requirements. Implementing this pattern enables us to manage costs efficiently by calculating the total when additional toppings are added.

Understanding the Decorator Pattern Through an Ice Cream Store Example - slide 1
01 / 16Understanding the Decorator Pattern Through an Ice Cream Store Example
1 / 17

Télécharger la présentation

Understanding the Decorator Pattern Through an Ice Cream Store Example
Une image / un lien ci-dessous est fourni (tel quel) pour télécharger la présentation

Politique de téléchargement : le contenu du site vous est fourni TEL QUEL pour votre information et votre usage personnel ; il ne peut être vendu, concédé sous licence ni partagé sur d’autres sites sans l’accord de son auteur.Le contenu vous est fourni TEL QUEL, pour votre information et votre usage personnel uniquement. Téléchargez la présentation en cliquant sur ce lien. Lors du téléchargement, si vous ne parvenez pas à télécharger une présentation, l’éditeur a peut-être supprimé le fichier de son serveur.Pendant le téléchargement, si vous ne parvenez pas à obtenir une présentation, le fichier a peut-être été supprimé par l’éditeur.

F I N

Plus de contenu associé

Transcription de la présentation

  1. SE-2811 Dr. Mark L. Hornick

  2. The Decorator Pattern SE-2811 Dr. Mark L. Hornick

  3. Example: The “Ice Cream Store” Ice Cream #description What kind of a class is Ice Cream? What kind of a method is cost? Why? +getDescription() +cost() Dish Cone WaffleCone cost() cost() cost() Subclasses define their own implementation and return the cost of the IceCream.

  4. Decorator Pattern Intent You want to attach additional functionality to an (existing) class dynamically… • …without having to resort to sub-classing the existing class • It’s also possible that the existing class is declared final, in which case you can’t subclass it • …or making any modifications to the existing class • Also, you may not have access to the existing class’s source

  5. The “Ice Cream Store” (contd.) public abstract class IceCream { String description; public String getDescription() { return description; } public abstract double cost(); } Ice Cream description getDescription() cost() public class Cone extends IceCream { public Cone() { description = “Cone”; } public double cost() { return 1.24; } } Dish Cone cost() cost()

  6. Extending functionality • Now in addition to your ice cream, you can also ask for additional toppings (Fudge, M&M’s, peanuts, …) • Charges are extra for each additional topping. • How should we design the system?

  7. Alternative 1: Create a new class for each combination. Any problems with this approach?

  8. Alternative 1: Create a new class for each combination. • Results in class explosion! • Maintenance nightmare! • What happens when a new topping is added? • What happens when the cost of a topping (e.g. Fudge) changes?

  9. Alternative 2: Using instance variables to keep track of the toppings? IceCream -description: String -hasFudge: boolean -hasMnM: boolean ------- +getDescription() +cost() +hasFudge() +hasCaramel() ------

  10. Alternative 2 (contd.) public class Icecream { ……………… public double cost() { double toppingCost = 0; if (hasFudge()) { toppingCost += oreoCost; } if (hasCaramel()) { toppingCost += caramelCost; } …. return toppingCost; } }

  11. Alternative 2 (contd.) public class Cone{ ……………… public double cost() { return 1.24 + super.cost(); } } What is this method calculating and returning?

  12. So what’s the problem? • We want to allow existing classes to be easily adapted to incorporate new behavior without modifying existing code. • We want a design that is flexible enough to take on new functionality to meet changing requirements. The Decorator Pattern comes to the rescue!!

  13. SE-2811 Dr. Mark L. Hornick

  14. SE-2811 Dr. Mark L. Hornick

  15. Using the Decorator Pattern • Take the IceCream object • Let’s create the Cone object. • IceCream cone= new Cone(); • Decorate it with the Fudge topping. • Create a Fudge object and wrap it around Cone. • cone = new Fudge(); • Decorate it with the Nuts topping. • Create a Nuts object and wrap it around Cone. • cone = new Nuts(cone); • Call the cost method and rely on delegation to add the cost of all toppings. • Call cost on the outmost decorator. • System.out.println(cone.cost());

  16. Summary • Decorators have the same super-type as the objects they decorate. • One or more decorators can be used to wrap an object. • Given that the decorator has the same super-type as the object it decorates, we can pass around a decorated object in place of the original (wrapped) object. • The decorator adds its own behavior either before and/or after delegating to the object it decorates to do the rest of the job. • Objects can be decorated at any time, so we can decorate objects at runtime with as many decorators as we like.