Slides by Alex Mariakakis with material from David Mailhot, Hal Perkins, Mike Ernst Section 9: Design Patterns.

Slides:



Advertisements
Similar presentations
Singleton vs utility class  at first glance, the singleton pattern does not seem to offer any advantages to using a utility class  i.e., a utility class.
Advertisements

CS 106 Introduction to Computer Science I 04 / 11 / 2008 Instructor: Michael Eckmann.
George Blank University Lecturer. CS 602 Java and the Web Object Oriented Software Development Using Java Chapter 4.
CS 106 Introduction to Computer Science I 04 / 16 / 2010 Instructor: Michael Eckmann.
Aalborg Media Lab 23-Jun-15 Inheritance Lecture 10 Chapter 8.
Abstract Classes and Interfaces
What Is a Factory Pattern?.  Factories are classes that create or construct something.  In the case of object-oriented code languages, factories construct.
Programming Languages and Paradigms Object-Oriented Programming.
Chapter 6 Class Inheritance F Superclasses and Subclasses F Keywords: super F Overriding methods F The Object Class F Modifiers: protected, final and abstract.
Design Patterns.
Writing Classes (Chapter 4)
JavaONE Kjartan Aanestad (Objectware)1 JavaONE 2007.
CSSE 374: Introduction to Gang of Four Design Patterns
1 TCSS 360, Spring 2005 Lecture Notes Design Patterns: Singleton, Memento, Flyweight.
Chapter 26 GoF Design Patterns. The Adapter Design Pattern.
Design Pattern. The Observer Pattern The Observer Pattern defines a one-to-many dependency between objects so that when one object changes state, all.
Patterns in programming 1. What are patterns? “A design pattern is a general, reusable solution to a commonly occurring problem in software. A design.
Effective Java: Creating and Destroying Objects Last Updated: Fall 2012.
APCS Java AB 2004 Review of CS1 and CS2 Review for AP test #1 Sources: 2003 Workshop notes from Chris Nevison (Colgate University) AP Study Guide to go.
Inheritance - Polymorphism ITI 1121 Nour El Kadri.
Dependency Injection Technion – Institute of Technology Author: Gal Lalouche - Technion 2015 ©
Slides adapted from Alex Mariakakis, with material from David Mailhot, Hal Perkins, Mike Ernst Section 9: Design Patterns.
L11-12: Design Patterns Definition Iterator (L4: Inheritance)‏ Factory (L4: Inheritance)‏ Strategy (L5: Multiple Inheritance)‏ Composite (L6: Implementation.
Design Patterns Gang Qian Department of Computer Science University of Central Oklahoma.
Define an interface for creating an object, but let subclasses decide which class to instantiate Factory Method Pattern.
Factory Method Explained. Intent  Define an interface for creating an object, but let subclasses decide which class to instantiate.  Factory Method.
Define an interface for creating an object, but let subclasses decide which class to instantiate.
CSE 331 Software Design & Implementation Hal Perkins Winter 2012 Design Patterns Part 2 (Slides by Mike Ernst and David Notkin) 1.
Chapter 14 Abstract Classes and Interfaces. Abstract Classes An abstract class extracts common features and functionality of a family of objects An abstract.
The Singleton Pattern SE-2811 Dr. Mark L. Hornick 1.
Inheritance. Inheritance - Introduction Idea behind is to create new classes that are built on existing classes – you reuse the methods and fields and.
DESIGN PATTERNS COMMONLY USED PATTERNS What is a design pattern ? Defining certain rules to tackle a particular kind of problem in software development.
Sadegh Aliakbary. Copyright ©2014 JAVACUP.IRJAVACUP.IR All rights reserved. Redistribution of JAVACUP contents is not prohibited if JAVACUP.
Software Design Patterns Curtsy: Fahad Hassan (TxLabs)
Design patterns (part 2) CSE 331 University of Washington.
Design Patterns Software Engineering CS 561. Last Time Introduced design patterns Abstraction-Occurrence General Hierarchy Player-Role.
Design Patterns Introduction
Design Patterns SE464 Derek Rayside images from NetObjectives.com & Wikipedia.
Java Design Patterns Java Design Patterns. What are design patterns? the best solution for a recurring problem a technique for making code more flexible.
Application development with Java Lecture 21. Inheritance Subclasses Overriding Object class.
SOEN 343 Software Design Section H Fall 2006 Dr Greg Butler
The State Pattern (Behavioral) ©SoftMoore ConsultingSlide 1.
1 CSE 331 Design Patterns 1: Iterator, Adapter, Singleton, Flyweight slides created by Marty Stepp based on materials by M. Ernst, S. Reges, D. Notkin,
The Factory Method Pattern (Creational) ©SoftMoore ConsultingSlide 1.
The Singleton Pattern (Creational)
Quick Review of OOP Constructs Classes:  Data types for structured data and behavior  fields and methods Objects:  Variables whose data type is a class.
 Creational design patterns abstract the instantiation process.  make a system independent of how its objects are created, composed, and represented.
Singleton Pattern. Problem Want to ensure a single instance of a class, shared by all uses throughout a program Context Need to address initialization.
1 Chapter 8 Class Inheritance and Interfaces F Superclasses and Subclasses  Keywords: super F Overriding methods  The Object Class  Modifiers: protected,
POLYMORPHISM Chapter 6. Chapter Polymorphism  Polymorphism concept  Abstract classes and methods  Method overriding  Concrete sub classes and.
FINAL REVIEW. Stronger vs Weaker (one more time!) Requires more? Promises more? (stricter specifications on what the effects entail) weaker stronger.
Classes CS 162 (Summer 2009). Parts of a Class Instance Fields Methods.
Section 9: Design Patterns
MPCS – Advanced java Programming
Design Patterns C++ Java C#.
Low Budget Productions, LLC
Factory Patterns 1.
Design Patterns C++ Java C#.
CSE 331 Software Design & Implementation
Section 9: Design Patterns
Section 9: Design Patterns
Advanced Programming Behnam Hatami Fall 2017.
Section 8: Design Patterns
Singleton Pattern Pattern Name: Singleton Pattern Context
Section 9: Design Patterns
Section 9: Design Patterns
Outline Anatomy of a Class Encapsulation Anatomy of a Method
Section 9: Design Patterns
GoF Patterns Ch. 26.
Presentation transcript:

Slides by Alex Mariakakis with material from David Mailhot, Hal Perkins, Mike Ernst Section 9: Design Patterns

Agenda What are design patterns? Creational patterns Structural patterns

What Is A Design Pattern A standard solution to a common programming problem A technique for making code more flexible Shorthand for describing program design and how program components are connected

Creational Patterns Problem: Constructors in Java are not flexible o Always return a fresh new object, never reuse one o Can’t return a subtype of the class they belong to Solution: Creational patterns! o Sharing Singleton Interning Flyweight o Factories Factory method Factory object o Builder

Creational Patterns: Sharing The old way: Java constructors always return a new object Singleton: only one object exists at runtime o Factory method returns the same object every time Interning: only one object with a particular (abstract) value exists at runtime o Factory method returns an existing object, not a new one Flyweight: separate intrinsic and extrinsic state, represents them separately, and interns the intrinsic state o Implicit representation uses no space o Not as common/important

Creational Patterns: Singleton For a class where only one object of that class can ever exist Two possible implementations o Eager instantiation: creates the instance when the class is loaded to guarantee availability o Lazy instantiation: only creates the instance once it’s needed to avoid unnecessary creation

Creational Patterns: Singleton Eager instantiation public class Bank { private static Bank INSTANCE = new Bank(); // private constructor private Bank() { … } // factory method public static Bank getInstance() { return INSTANCE; } Bank b = new Bank(); Bank b = Bank.getInstance();

Creational Patterns: Singleton Lazy instantiation public class Bank { private static Bank INSTANCE; // private constructor private Bank() { … } // factory method public static Bank getInstance() { if (INSTANCE == null) { INSTANCE = new Bank(); } return INSTANCE; } Bank b = new Bank(); Bank b = Bank.getInstance();

Creational Patterns: Singleton Would you prefer eager or lazy instantiation for an HTTPRequest class? o handles authentication o definitely needed for any HTTP transaction Would you prefer eager or lazy instantiation for a Comparator class? o compares objects o may or may not be used at runtime

Creational Patterns: Singleton public class HttpRequest { private static class HttpRequestHolder { public static final HttpRequest INSTANCE = new HttpRequest(); } /* Singleton – Don’t instantiate */ private HttpRequest() { … } public static HttpRequest getInstance() { return HttpRequestHolder.INSTANCE; }

Creational Patterns: Singleton public class LengthComparator implements Comparator { private int compare(String s1, String s2) { return s1.length()-s2.length(); } /* Singleton – Don’t instantiate */ private LengthComparator() { … } private static LengthComparator comp = null; public static LengthComparator getInstance() { if (comp == null) { comp = new LengthComparator(); } return comp; }

Creational Patterns: Interning Similar to Singleton, except instead of just having one object per class, there’s one object per abstract value of the class Saves memory by compacting multiple copies Requires the class being interned to be immutable. Why?

Creational Patterns: Interning public class Point { private int x, y; public Point(int x, int y) { this.x = x; this.y = y; } public int getX() { return x; } public int getY() { return y; public String toString() { return “(” + x + “,” + y + “)”; }

Creational Patterns: Interning public class Point { private static Map instances = new WeakHashMap (); public static Point getInstance(int x, int y) { String key = x + “,”, + y; if (!instances.containsKey(key)) instances.put(key, new Point(x,y)); return instances.get(key); } private final int x, y; // immutable private Point(int x, int y) {…} } If our point was represented with r and theta, we’d need to constrain them for use in the key. Otherwise, we’d have “5, pi” and “5, 3pi” as different entries in our map even though they are the same abstract value.

Creational Patterns: Factories public class City { public Stereotype getStereotypicalPerson() {…} } City seattle = new City(); seattle.getSterotypicalPerson(); // we want a SeattleStereotype

Creational Patterns: Factories Factories solve the problem that Java constructors cannot return a subtype of the class they belong to Two options: o Factory method Helper method creates and returns objects Method defines the interface for creating an object, but defers instantiation to subclasses o Factory object Abstract superclass defines what can be customized Concrete subclass does the customization, returns appropriate subclass Object provides the interface for creating families of related/dependent objects without specifying their concrete classes

Creational Patterns: Factory Method public class City { public Stereotype getStereotypicalPerson() {…} } public class Seattle extends City public Stereotype getStereotypicalPerson() { return new SeattleStereotype(); } City seattle = new Seattle(); seattle.getSterotypicalPerson();

Creational Patterns: Factory Object interface StereotypeFactory { Stereotype getStereotype(); } class SeattleStereotypeFactory implements StereotypeFactory { public Stereotype getStereotype() { return new SeattleStereotype(); } public class City { public City(StereotypeFactory f) {…} public Stereotype getStereotypicalPerson() { f.getStereotype(); } City seattle = new City(new SeattleStereotypeFactory()); seattle.getSterotypicalPerson();

Creational Patterns: Factory Object interface Button { void paint(); } class WinButton implements Button { public void paint() { System.out.println("I'm a WinButton"); } class OSXButton implements Button { public void paint() { System.out.println("I'm an OSXButton"); } interface GUIFactory { Button createButton(); } class WinFactory implements GUIFactory { public Button createButton() { return new WinButton(); } class OSXFactory implements GUIFactory { public Button createButton() { return new OSXButton(); } From:

Creational Patterns: Factory Object public class Application { public static void main(String[] args) { GUIFactory factory = createOSSpecificFactory(); Button button = factory.createButton(); button.paint(); } public static GUIFactory createOsSpecificFactory() { int sys = readFromConfigFile("OS_TYPE"); if (sys == 0) return new WinFactory(); else return new OSXFactory(); } From:

Creational Patterns: Builder The class has an inner class Builder and is created using the Builder instead of the constructor The Builder takes optional parameters via setter methods (e.g., setX(), setY(), etc.) When the client is done supplying parameters, she calls build() on the Builder, finalizing the builder and returning an instance of the object desired

Creational Patterns: Builder public class NutritionFacts { // required private final int servingSize, servings; // optional private final int calories, fat, sodium; public NutritionFacts(int servingSize, int servings) { this(servingSize, servings, 0); } public NutritionFacts(int servingSize, int servings, int calories) { this(servingSize, servings, calories, 0); } public NutritionFacts(int servingSize, int servings, int calories, int fat) { this(servingSize, servings, calories, fat, 0); } … public NutritionFacts(int servingSize, int servings, int calories, int fat, int sodium) { this.servingSize = servingSize; this.servings = servings; this.calories = calories; this.fat = fat; this.sodium = sodium; }

Creational Patterns: Builder public class NutritionFacts { private final int servingSize, servings, calories, fat, sodium; public static class Builder { // required private final int servingSize, servings; // optional, initialized to default values private final int calories = 0; private final int fat = 0; private final int sodium = 0; public Builder(int servingSize, int servings) { this.servingSize = servingSize; this.servings = servings; } public Builder calories(int val) { calories = val; return this; } public Builder fat(int val) { fat = val; return this; } public Builder sodium(int val) { sodium = val; return this; } public NutritionFacts build() { return new NutritionFacts(this); } } public NutritionFacts(Builder builder) { this.servingSize = builder.servingSize; this.servings = builder.servings; this.calories = builder.calories; this.fat = builder.fat; this.sodium = builder.sodium; }

Creational Patterns: Builder Useful when you have many constructor parameters o It is hard to remember which order they should all go in Easily allows for optional parameters o If you have n optional parameters, you need 2^n constructors, but only one builder

Structural Patterns Problem: Sometimes difficult to realize relationships between entities o Important for code readability Solution: Structural patterns! o We’re just going to talk about wrappers, which translate between incompatible interfaces PatternFunctionalityInterfacePurpose Adaptersamedifferentmodify the interface Decoratordifferentsameextend behavior Proxysame restrict access

Structural Patterns: Adapter Changes an interface without changing functionality o Rename a method o Convert units Examples: o Angles passed in using radians vs. degrees o Bytes vs. strings o Hex vs. decimal numbers

Structural Patterns: Decorator Adds functionality without changing the interface o Add caching Adds to existing methods to do something additional while still preserving the previous spec o Add logging Decorators can remove functionality without changing the interface oUnmodifiableList with add() and put()

Structural Patterns: Proxy Wraps the class while maintaining the same interface and functionality Integer vs. int, Boolean vs. boolean Controls access to other objects o Communication: manage network details when using a remote object o Security: permit access only if proper credentials o Creation: object might not yet exist because creation is expensive