CSE 331 Software Design & Implementation

Slides:



Advertisements
Similar presentations
1 Structural Design Patterns - Neeraj Ray. 2 Structural Patterns - Overview n Adapter n Bridge n Composite n Decorator.
Advertisements

Design Patterns Section 7.1 (JIA’s) Section (till page 259) (JIA’s) Section 7.2.2(JIA’s) Section (JIA’s)
CSE 331 SOFTWARE DESIGN & IMPLEMENTATION DESIGN PATTERNS II Autumn 2011.
Communication in Distributed Systems –Part 2
Design Patterns Based on Design Patterns. Elements of Reusable Object-Oriented Software. by E.Gamma, R. Helm, R. Johnson,J. Vlissides.
What Is a Factory Pattern?.  Factories are classes that create or construct something.  In the case of object-oriented code languages, factories construct.
Proxy Design Pattern Source: Design Patterns – Elements of Reusable Object- Oriented Software; Gamma, et. al.
Client/Server Software Architectures Yonglei Tao.
CSE 331 Software Design & Implementation Hal Perkins Winter 2013 Design Patterns Part 3 (Slides by Mike Ernst and David Notkin) 1.
Programming Languages and Paradigms Object-Oriented Programming.
Classes and Class Members Chapter 3. 3 Public Interface Contract between class and its clients to fulfill certain responsibilities The client is an object.
Design Patterns.
CS 325: Software Engineering March 17, 2015 Applying Patterns (Part A) The Façade Pattern The Adapter Pattern Interfaces & Implementations The Strategy.
CSCI 6962: Server-side Design and Programming Web Services.
Object Oriented Programming: Java Edition By: Samuel Robinson.
Design Patterns: Structural Design Patterns
Design Pattern. The Observer Pattern The Observer Pattern defines a one-to-many dependency between objects so that when one object changes state, all.
CSE 425: Object-Oriented Programming I Object-Oriented Programming A design method as well as a programming paradigm –For example, CRC cards, noun-verb.
Design Patterns Gang Qian Department of Computer Science University of Central Oklahoma.
Java Dynamic Proxy Bibliography: reflection/proxy.html
Patterns in programming1. 2 What are patterns? Answers to common design problems. A language used by developers –To discuss answers to design problems.
Design Patterns CSIS 3701: Advanced Object Oriented Programming.
ECE450 - Software Engineering II1 ECE450 – Software Engineering II Today: Design Patterns IV Structural Patterns.
ECE450 - Software Engineering II1 ECE450 – Software Engineering II Today: Design Patterns VIII Chain of Responsibility, Strategy, State.
CSE 331 Software Design & Implementation Hal Perkins Winter 2012 Design Patterns Part 2 (Slides by Mike Ernst and David Notkin) 1.
Behavioral Patterns CSE301 University of Sunderland Harry R Erwin, PhD.
Sadegh Aliakbary. Copyright ©2014 JAVACUP.IRJAVACUP.IR All rights reserved. Redistribution of JAVACUP contents is not prohibited if JAVACUP.
(1) ICS 313: Programming Language Theory Chapter 12: Object Oriented Programming.
Object Oriented Programming
Design patterns (part 2) CSE 331 University of Washington.
Design Patterns, cont. Based on material by Michael Ernst, University of Washington.
Design Patterns Introduction “Patterns are discovered, not invented” Richard Helm.
Application development with Java Lecture 21. Inheritance Subclasses Overriding Object class.
29-July-2002cse Inheritance © 2002 University of Washington1 Inheritance CSE 142, Summer 2002 Computer Programming 1
Team Member Assessments Preliminary Round Second and Third can Influence Grade CSE 403, Winter 2011, Alverson, Brun.
S.Ducasse Stéphane Ducasse 1 Decorator.
The Decorator Pattern (Structural) ©SoftMoore ConsultingSlide 1.
CS 210 Proxy Pattern Nov 16 th, RMI – A quick review A simple, easy to understand tutorial is located here:
Design Patterns: Structural Design Patterns General and reusable solutions to common problems in software design Software University
CSE 331 Software Design & Implementation Dan Grossman Spring 2015 Design Patterns, Part 2 (Based on slides by Mike Ernst, Dan Grossman, David Notkin, Hal.
Zach Tatlock / Winter 2016 CSE 331 Software Design and Implementation Lecture 21 Design Patterns 2.
Design Patterns: MORE Examples
Abstract Factory Pattern
Section 9: Design Patterns
Chapter 10 Design Patterns.
MPCS – Advanced java Programming
CSE 403 Design Patterns (Part 2)
Structural Design Patterns
Behavioral Design Patterns
Week 4 Object-Oriented Programming (1): Inheritance
object oriented Principles of software design
Abstract Factory Pattern
Section 9: Design Patterns
Section 9: Design Patterns
Object Oriented Analysis and Design
Advanced Programming Behnam Hatami Fall 2017.
CSE 331 Software Design and Implementation
MSIS 670 Object-Oriented Software Engineering
Object Oriented Design Patterns - Structural Patterns
CSE 331 Software Design and Implementation
Section 9: Design Patterns
Section 9: Design Patterns
Structural Patterns: Adapter and Bridge
10. Façade Pattern SE2811 Software Component Design
CSE 331 Software Design & Implementation
Section 9: Design Patterns
Adapter Pattern Jim Fawcett
Lecture 8 Object Oriented Programming (OOP)
Adapter Pattern Jim Fawcett
Message Passing Systems
Presentation transcript:

CSE 331 Software Design & Implementation Hal Perkins Autumn 2013 Design Patterns Part 2 (Slides by Mike Ernst and David Notkin)

Outline Introduction to design patterns Creational patterns (constructing objects) Structural patterns (controlling heap layout) Behavioral patterns (affecting object semantics)

Structural patterns: Wrappers A wrapper translates between incompatible interfaces Wrappers are a thin veneer over an encapsulated class modify the interface extend behavior restrict access The encapsulated class does most of the work Pattern Functionality Interface Adapter same different Decorator Proxy

Adapter Change an interface without changing functionality rename a method convert units implement a method in terms of another Example: angles passed in radians vs. degrees

Adapter example: scaling rectangles We have this Rectangle interface interface Rectangle { // grow or shrink this by the given factor void scale(float factor); ... float getWidth(); float area(); } Goal: client code wants to use this library to “implement” Rectangle without rewriting code that uses Rectangle: class NonScaleableRectangle { // not a Rectangle void setWidth(float width) { ... } void setHeight(float height) { ... } // no scale method

Adaptor: Use subclassing class ScaleableRectangle1 extends NonScaleableRectangle implements Rectangle { void scale(float factor) { setWidth(factor * getWidth()); setHeight(factor * getHeight()); }

Adaptor: use delegation Delegation: forward requests to another object class ScaleableRectangle2 implements Rectangle { NonScaleableRectangle r; ScaleableRectangle2(w,h) { this.r = new NonScaleableRectangle(w,h); } void scale(float factor) { setWidth(factor * r.getWidth()); setHeight(factor * r.getHeight()); float getWidth() { return r.getWidth(); } float circumference() { return r.circumference(); } ...

Subclassing vs. delegation Subclassing automatically gives access to all methods of superclass built in to the language (syntax, efficiency) Delegation permits removal of methods (compile-time checking) wrappers can be added and removed dynamically objects of arbitrary concrete classes can be wrapped multiple wrappers can be composed Some wrappers have qualities of more than one of adapter, decorator, and proxy Delegation vs. composition Differences are subtle For CSE 331, consider them to be equivalent

Types of adapter Goal of adapter: connect incompatible interfaces Adapter with delegation Adapter with subclassing: no extension is permitted Adapter with subclassing

Decorator Add functionality without changing the interface Add to existing methods to do something additional (while still preserving the previous specification) Not all subclassing is decoration

Decorator example: Bordered windows interface Window { // rectangle bounding the window Rectangle bounds(); // draw this on the specified screen void draw(Screen s); ... } class WindowImpl implements Window {

Bordered window implementations Via subclasssing: class BorderedWindow1 extends WindowImpl { void draw(Screen s) { super.draw(s); bounds().draw(s); } Via delegation: class BorderedWindow2 implements Window { Window innerWindow; BorderedWindow2(Window innerWindow) { this.innerWindow = innerWindow; innerWindow.draw(s); innerWindow.bounds().draw(s); Delegation permits multiple borders on a window, or a window that is both bordered and shaded (or either one of those)

A decorator can remove functionality Remove functionality without changing the interface Example: UnmodifiableList What does it do about methods like add and put? Problem: UnmodifiableList is a Java subtype, but not a true subtype, of List Decoration can create a class with no Java subtyping relationship, which is desirable

Proxy Same interface and functionality as the wrapped class Control access to other objects communication: manage network details when using a remote object locking: serialize access by multiple clients security: permit access only if proper credentials creation: object might not yet exist (creation is expensive) hide latency when creating object avoid work if object is never used