Design Patterns - Part 1 of 2

Design Patterns sample for a picture in the title slide Savio Sebastian, Patterns Component Team January 11, 2008

Agenda sample for a picture in the divider slide Introduction Creational Patterns 2.1. Singleton Pattern 2.2. Factory Method and Abstract Factory Patterns Structural Patterns 3.1. Adapter Pattern 3.2. Decorator Pattern 3.3. Façade Pattern Behavioral Patterns 4.1. Command Pattern 4.2. Observer Pattern © SAP 2007 / Page 2/104

© SAP 2007 / Page 4 Introduction to Design Patterns What? Template for writing code Patterns use OO Design Principles Concepts like abstraction, inheritance, polymorphism Why? Readability – familiarity Maintenance Speed – tested, proven development paradigms Communication – shared vocabulary

Types of Design Patterns © SAP 2007 / Page 5

What Patterns are NOT Library of Code? Structure for classes to solve certain problems But aren’t Libraries and Frameworks also Design Patterns? They are specific implementations to which we link our code They use Design Patterns to write their Java Code Is it something to do with s/w architecture? © SAP 2007 / Page 6

Interface == Abstract Class While we study Design Patterns, Abstract Classes and Interface often mean the same thing. © SAP 2007 / Page 7

Singleton Pattern – the simplest pattern Ensures a class has only one instance, and provides a global point of access to it Where to use? Caches Objects that handle registry settings For Logging Device drivers Patterns Component Example of Singleton Pattern Usage: IWDComponentUsagecomponentUsage = patternAccessPoint.getSingleton(IPatternRtApi.TRANSACTION); © SAP 2007 / Page 9

Singleton Class Diagram © SAP 2007 / Page 10

Improving performance © SAP 2007 / Page 11

Create Unique Instance Eagerly Code: public class Singleton { private static Singleton uniqueInstance = new Singleton(); // other useful instance variables here private Singleton() {} public static synchronized Singleton getInstance() { return uniqueInstance; } // other useful methods here } This code is guaranteed to be thread-safe! © SAP 2007 / Page 12

Double-Checked Locking Code: // Danger! This implementation of Singleton not guaranteed to work prior to Java 5 public class Singleton { private volatilestatic Singleton uniqueInstance; private Singleton() {} public static Singleton getInstance() { if (uniqueInstance == null) { synchronized (Singleton.class) { if (uniqueInstance == null) { uniqueInstance = new Singleton(); } } } return uniqueInstance; } } This is thread-safe again! © SAP 2007 / Page 13

Factory Method Pattern Creates objects without specifying the exact class to create Most popular OO Pattern © SAP 2007 / Page 14

Compare Two Implementations © SAP 2007 / Page 15

Compare Dependencies © SAP 2007 / Page 16 PizzaStore PizzaStore Pizza NYStyle PeppoPizza NYStyle VeggiePizza NYStyle CheesePizza NYStyle PeppoPizza NYStyle VeggiePizza NYStyle CheesePizza ChicagoStyle PeppoPizza ChicagoStyle VeggiePizza ChicagoStyle CheezePizza ChicagoStyle PeppoPizza ChicagoStyle VeggiePizza ChicagoStyle CheezePizza

Explanations © SAP 2007 / Page 17

Class Diagram of Factory Method © SAP 2007 / Page 18

Abstract Factory Pattern Groups object factories that have a common theme Groups together a set of related products Uses Composition and Inheritance Uses Factory Method to create products Essentially FACTORY © SAP 2007 / Page 19

Families – Ingredients / Pizzas © SAP 2007 / Page 20

Factory Method versus Abstract Factory © SAP 2007 / Page 21 PizzaStore PizzaStore Pizza Ingredients Pizza Pizza ChicagoStyle CheesePizza PeppoPizza VeggiePizza NYStyle PeppoPizza NYStyle VeggiePizza NYStyle NYStyle CheesePizza ChicagoStyle PeppoPizza ChicagoStyle VeggiePizza ChicagoStyle CheezePizza

Quick Reference: Different Types of Creational Patterns © SAP 2007 / Page 22

Adapter Pattern Adapter lets classes work together that couldn't otherwise because of incompatible interfaces © SAP 2007 / Page 24 Vendor Class Adapter Your Existing System

Ducks Target Interface public interface Duck { public void quack(); public void fly(); } An implementation the Target Interface public class MallardDuck implements Duck { public void quack() { System.out.println("Quack"); } public void fly() { System.out.println("I'm flying"); } } © SAP 2007 / Page 25

Turkeys To-Be-Adapted Interface public interface Turkey { public void gobble(); public void fly(); } An implementation of To-Be-Adapted Interface public class WildTurkey implements Turkey { public void gobble() { System.out.println("Gobble gobble"); } public void fly() { System.out.println("I'm flying a short distance"); } } © SAP 2007 / Page 26

Turkey Adapted public class TurkeyAdapter implements Duck { Turkey turkey; public TurkeyAdapter(Turkey turkey) { this.turkey = turkey; } public void quack() { turkey.gobble(); } public void fly() { for(inti=0; i < 5; i++) { turkey.fly(); } } } © SAP 2007 / Page 27

Client Application Test Drive public class DuckTestDrive { public static void main(String[] args) { MallardDuck duck = new MallardDuck(); WildTurkey turkey = new WildTurkey(); Duck turkeyAdapter = new TurkeyAdapter(turkey); System.out.println("The Turkey says..."); turkey.gobble(); turkey.fly(); System.out.println("The Duck says..."); testDuck(duck); System.out.println("TheTurkeyAdapter says..."); testDuck(turkeyAdapter); } static void testDuck(Duck duck) { duck.quack(); duck.fly(); } } © SAP 2007 / Page 28

Adapting Enumerations to Iterators public class EnumerationIterator implements Iterator { Enumeration enumeration; public EnumerationIterator(Enumeration enumeration) { this.enumeration = enumeration; } public booleanhasNext() { return enumeration.hasMoreElements(); } public Object next() { return enumeration.nextElement(); } public void remove() { throw new UnsupportedOperationException(); } } © SAP 2007 / Page 29

Decorator Pattern Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to sub-classing for extending functionality. Decorators have the same super-type as the objects they decorate You can use more than one decorators to wrap an object © SAP 2007 / Page 30 Each component can be used on its own, or wrapped by a decorator Concrete Component we can dynamically add new behavior Concrete Decorator has an instance variable for the thing it decorates

java.io uses decorator to extend behaviors © SAP 2007 / Page 31

FilterInputStream.java public class FilterInputStream extends InputStream { protected volatile InputStream in; protected FilterInputStream(InputStream in) { this.in = in; } public int read() throws IOException { return in.read(); } public int read(byte b[], int off, intlen) throws IOException { return in.read(b, off, len); } public long skip(long n) throws IOException { return in.skip(n); } } © SAP 2007 / Page 32

Extending java.io  New ClassLowerCaseInputStream.java public class LowerCaseInputStream extends FilterInputStream { public LowerCaseInputStream(InputStream in) { super(in); } public int read() throws IOException { int c = super.read(); return (c == -1 ? c : Character.toLowerCase((char)c)); } public int read(byte[] b, int offset, intlen) throws IOException { int result = super.read(b, offset, len); for (inti = offset; i < offset+result; i++) { b[i] = (byte)Character.toLowerCase((char)b[i]); } return result; } } © SAP 2007 / Page 33

LowerCaseInputStream.java Test Drive public class InputTest { public static void main(String[] args) throws IOException { int c; try { InputStream in = new LowerCaseInputStream( new BufferedInputStream( new FileInputStream("test.txt"))); while((c = in.read()) >= 0) { System.out.print((char)c); } in.close(); } catch (IOException e) { e.printStackTrace(); } } } © SAP 2007 / Page 34 Set up the FileInputStream and decorate it, first with a BufferedInputStream and then with our brand new LowerCaseInputStream filter

Remember! Inheritance is one form of extension, but there are other ways to do the same Designs should allow behavior to be extended without the need to modify existing code Decorator Pattern involves a set of decorator classes that are used to wrap concrete classes You can wrap a component with any number of decorators We use inheritance to achieve the type matching, but we aren’t using inheritance to get behavior Decorators can result in many small objects in our design, and overuse can be complex © SAP 2007 / Page 35

Decorator and Adapter © SAP 2007 / Page 36

Façade Pattern Facade defines a higher-level interface that makes the sub-system easier to use Do not create design that have a large number of classes coupled together so that changes in one part of the system cascade to other parts When you build a lot of dependencies between many classes, you are building a fragile system that will be costly to maintain and complex for others to understand Patterns Team understands Façade better than many people  Threading in Java is also another example of Façade Pattern © SAP 2007 / Page 37

Command Pattern Encapsulate a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support ‘undo’ operations. A command class is a convenient place to collect code and data related to a command. A command object can hold information about the command, such as its name or which user launched it; and answer questions about it, such as how long it will likely take. The command is a useful abstraction for building generic components The Command Pattern decouples an object, making a request from the one that knows how to perform it “Smart” Command objects implement the request themselves rather than delegating it to a receiver © SAP 2007 / Page 40

Home Automation through Command PatternLight.java public class Light { public Light() { } public void on() { System.out.println("Light is on"); } public void off() { System.out.println("Light is off"); } } © SAP 2007 / Page 41

LightOnCommand.java public class LightOnCommand implements Command { Light light; public LightOnCommand(Light light) { this.light = light; } public void execute() { light.on(); } public void undo() { light.off(); } } © SAP 2007 / Page 43

LightOffCommand.java public class LightOffCommand implements Command { Light light; public LightOffCommand(Light light) { this.light = light; } public void execute() { light.off(); } public void undo() { light.on(); } } © SAP 2007 / Page 44

Test Drive Command Pattern RemoteLoader.java public class RemoteLoader { public static void main(String[] args) { RemoteControlWithUndoremoteControl = new RemoteControlWithUndo(); Light livingRoomLight = new Light("Living Room"); LightOnCommandlivingRoomLightOn = new LightOnCommand(livingRoomLight); LightOffCommandlivingRoomLightOff = new LightOffCommand(livingRoomLight); livingRoomLightOn.execute() ; livingRoomLightOff.execute(); } } © SAP 2007 / Page 45

Observer Pattern Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically. © SAP 2007 / Page 48

Subject Interface Isubject.java public interface ISubject { public void registerObserver( IObserver o ) ; public void removeObserver( IObserver o ) ; public void notifyObservers() ; } © SAP 2007 / Page 49

Observer Interface IObserver.java public interface IObserver { public void notify( int temp , int humidity , int pressure ) ; } © SAP 2007 / Page 50

Design Principle © SAP 2007 / Page 51 The Subject doesn’t care, it will deliver notifications to any object that implements the Observer Interface Loosely coupled designs allow us to build flexible OO Systems that can handle change because they minimize the interdependency between objects Pull is considered more Correct than Push Swing makes heavy use of the Observer Pattern Observer Pattern defines a one-to-many relationship between objects

References Head First Design Patterns Eric & Elizabeth Freeman with Kathy Sierra & Bert Bates Wikipedia http://en.wikipedia.org/wiki/Design_pattern_%28computer_science%29 YouTube http://www.youtube.com/codingkriggs © SAP 2007 / Page 53

Design Patterns - Part 1 of 2

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Design Patterns - Part 1 of 2

Similar to Design Patterns - Part 1 of 2 (20)

Recently uploaded

Recently uploaded (20)

Design Patterns - Part 1 of 2