�ݺ�ߣ

Design Patterns Introduction to Design Patterns Rafael Coutinho - [email_address]

Agenda Motivation Brief history Definition Categories Examples Conclusion Questions

Motivation Context: Home to live in Problem: Protect home from rain Solutions: Live in a cave Live in a tent Build a house with a roof

Motivation It’s a solution, not a receipt

Motivation Advantages of a standard design Speed up the development process More robust solution Easy to maintain Easy to evolve Allow beginners to act as experienced professional

Brief history 1977 - Christopher Alexander - Architecture A Pattern Language: Towns, Buildings, Construction Mid-to-late 1980 – Object oriented use 1995 - Design Patterns: Elements of Reusable Object-Oriented Software Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides Gang of Four

Definition Christopher Alexander "Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice"

Definition A design pattern is defined using the following template: Pattern name and classification: A conceptual handle and category for the pattern Intent: What problem does the pattern address? Also known as: Other common names for the pattern Motivation: A scenario that illustrates the problem Applicability: In what situations can the pattern be used? Structure: Diagram UML Participants: Classes and objects in design

Definition A design pattern is defined using the following template: Collaborations: How classes and objects in the design collaborate Consequences: What objectives does the pattern achieve? What are the tradeoffs? Implementation: Implementation details to consider, language-specific issues Sample code: Sample code in a selected language (Smalltalk, Java or C++) Known uses: Examples from the real world Related patterns: Comparison and discussion of related patterns

Sample Singleton – Creational Pattern Pattern name and Classification Ensure a class only has one (or a limited number of) instance, and provide a global point of access to it. Intention

Singleton Singleton define a getInstance operation that lets clients access its unique instance. Structure and Participants

Singleton Controlled access to sole instance. Improvement over global variables. Permits a variable number of instances Consequences

Singleton Implementation and Code public class Singleton { private static Singleton instance; private Singleton(){ } public static synchronized Singleton getInstance() { if (instance == null ) { instance = new Singleton(); } return instance; } }

Singleton Motivation Printers Files Applicability One instance of a class Well-known access point

Singleton Examples: java.lang.Runtime getRuntime Known Uses Abstract Factory Related Patterns

Categories Fundamental Creational Structural Behavioral

Fundamental Patterns They are fundamental in the sense that they are widely used by other patterns or are frequently used in a large number of programs. Interface Immutable Proxy*

Structural Patterns A re concerned with how classes and objects are composed to form larger structures Structural class patterns use inheritance to compose interfaces or implementations Rather than composing interfaces or implementations, structural object patterns describe ways to compose objects to realize new functionality Proxy Facade Composite Decorator Adapter

Behavioral Patterns Patterns that identify common communication patterns between objects and realize these patterns. By doing so, these patterns increase flexibility in carrying out this communication Related to interaction and responsability. Design Patterns (GoF): Observer Strategy Visitor Chain of Responsability Command Iterator

Creational Patterns Creational design patterns abstract the instantiation process Help make a system independent of how its objects are created, composed, and represented Encapsulate knowledge about which concrete classes the system uses. Hide how instances of classes are created and put together Design Patterns: Singleton Abstract Factory Factory Method Prototype

Some More Patterns Samples Structural Decorator Creational Abstract Factory

Decorator Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality Intention Motivation

Decorator To add responsibilities to individual objects dynamically and transparently, that is, without affecting other objects For responsibilities that can be withdrawn When extension by subclassing is impractical. Sometimes a large number of independent extensions are possible and would produce an explosion of subclasses to support every combination. Or a class definition may be hidden or otherwise unavailable for subclassing Applicability

Decorator Structure and Participants

Decorator Decorator forwards requests to its Component object. It may optionally perform additional operations before and after forwarding the request More flexibility than static inheritance Avoids feature-laden classes high up in the hierarchy A decorator and its component aren't identical Lots of little objects Consequences

Decorator Implementation and Code 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, int len) throws IOException { int result = super.read(b, offset, len); for ( int i = offset; i < offset+result; i++) { b[i] = ( byte ) Character .toLowerCase( ( char )b[i] ); } return result; } } public class InputTest { public static void main( String [] args) { 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(); } } }

Decorator Adapter Composite Strategy Known Uses Related Pattners

Abstract Factory Provide an interface for creating families of related or dependent objects without specifying their concrete classes. Intention Motivation GUI

Abstract Factory independence of how its products are created, composed and represented a system should be configured with one of multiple families of products a family of related product objects is designed to be used together. provide a class library of products, and reveal just their interfaces, not their implementations. Applicability

Abstract Factory Structure and Participants

Abstract Factory It isolates concrete classes. It makes exchanging product families easy. It promotes consistency among products. Supporting new kinds of products is hard. (new methods) Consequences

Abstract Factory public interface class DAOFactory { public User getUser(); } public class MySQLDAOFactory implements DAOFactory { public User getUser() { MySqlConnection conn = new MySqlConnection(); User u = new MySqlUser(); … u.setName(rs.getString(“NAME”)); return u ; } } public class Client { public static void main(String[] args){ DAOFactory factory = new MySQLDAOFactory(); User userDao = factory.getUser(); } } public class Db2DAOFactory implements DAOFactory { public User getUser() { Db2Connection conn = new Db2Connection(); User u = new Db2User(); … u.setName(rs.getString(“NAME”)); return u ; } }

Abstract Factory Factory Method Singleton Prototype Known Uses javax.net.SocketFactory SocketFactory.getDefault() Related Patterns

Conclusion Design Patterns – it’s based on three aspects: Context, problem and solution Can be implemented in N ways Speed up development Allow easier maintenance Easy to extend the solution Improve the solution

Resources Design Patterns bestseller book: Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides , Design Patterns: Elements of Reusable Object-Oriented Software , Addison-Wesley, 1994. ISBN 0-201-63361-2 Wikipedia website http:// en.wikipedia.org/wiki/Adapter_pattern and http:// en.wikipedia.org/wiki/Decorator_pattern . Object Oriented System course from Department of Computer Science of University of Texas at San Antonio http://vip.cs.utsa.edu/classes/cs4773s2004/index.html . Joseph Bergin professor at Pace University personal website http://csis.pace.edu/~bergin/

�ݺ�ߣ

Design Patterns

Recommended

More Related Content

What's hot (20)

Viewers also liked (6)

Similar to Design Patterns (20)

Design Patterns