Design Patterns & Refactoring

Total Page：16

File Type：pdf, Size：1020Kb

Design Patterns & Refactoring Bridge Oliver Haase HTWG Konstanz À computer once beat me at chess, but it was no match to me at kick-boxing' | Emo Philips Oliver Haase (HTWG Konstanz) Design Patterns & Refactoring 1 / 11 Description I Classification: object based structural pattern Purpose: decouple abstraction (interfaces) and implementation, such that both can evolve independently Oliver Haase (HTWG Konstanz) Design Patterns & Refactoring 2 / 11 Motivation Scenario: Provide more comfortable RemoteOpComm interface without modification of existing type hierarchy. Oliver Haase (HTWG Konstanz) Design Patterns & Refactoring 3 / 11 Motivation Problem: Implementation classes TCPCommunication and UDPCommunication must be duplicated. Oliver Haase (HTWG Konstanz) Design Patterns & Refactoring 4 / 11 Motivation Oliver Haase (HTWG Konstanz) Design Patterns & Refactoring 5 / 11 Structure using Bridge Pattern Client Bridge Communication impl CommImpl send(op, params): void sendImpl() receive(): Result receiveImpl() impl.sendImpl(op,params); return impl.receiveImpl(); RemoteOpComm TcpCommunication UdpCommunication invoke(op, params): Result sendImpl(op, params): void sendImpl(op, params): void receiveImpl(): Result receiveImpl(): Result send(op, params); return receive(); Oliver Haase (HTWG Konstanz) Design Patterns & Refactoring 6 / 11 Implications Please note that the abstractions (left hand side) use only the functionality provided by class CommImpl. Additional functionality in the subclasses cannot be taken advantage of; additional functionality in sub-interfaces must be achieved only through usage of the general functionality as contained in the root interface. Oliver Haase (HTWG Konstanz) Design Patterns & Refactoring 7 / 11 General Structure Client Bridge Abstraction impl Implementor operation() operationImpl() impl.operationImpl(); ConcreteImplementorA ConcreteImplementorB Specialization operationImpl() operationImpl() Oliver Haase (HTWG Konstanz) Design Patterns & Refactoring 8 / 11 Description II Members: Abstraction (Communication): defines interface of the abstraction maintains reference to Implementor instance Specialization (RemoteOpComm): extends Abstraction interface through usage of its operations Implementor (CommImpl): defines interface for implementation classes (can differ from Abstraction interface) ConcreteImplementor (TcpCommunication): provides implementation of Implementor interface Oliver Haase (HTWG Konstanz) Design Patterns & Refactoring 9 / 11 Description III Interactions: Abstraction delegates requests to Implementor object Consequences: loose coupling of abstraction and implementation Implementor object can be replaced at run-time Oliver Haase (HTWG Konstanz) Design Patterns & Refactoring 10 / 11 Implementation Who decides when and how, what particular Implementor object to use? 1 Specialization object, based on the params passed in at construction time. Example: Collection object that gets initialized with small initial size uses LinearList implementation. Large Collection object uses BTree implementation. (Note: Implementation can be dynamically replaced as the collection grows.) 2 Others decide ! creational patterns! Specialization object gets fed with factory or prototype Dependency injection ! Specialization object gets passed in Implementor object by Client. Oliver Haase (HTWG Konstanz) Design Patterns & Refactoring 11 / 11.

Copy Link

Recommended publications

Automatic Verification of Java Design Patterns
Automatic Verification of Java Design Patterns Alex Blewitt, Alan Bundy, Ian Stark Division of Informatics, University of Edinburgh 80 South Bridge, Edinburgh EH1 1HN, UK [email protected] [email protected] [email protected] Abstract 2. Design patterns There are a number of books which catalogue and de- Design patterns are widely used by object oriented de- scribe design patterns [4, 1, 6] including an informal de- signers and developers for building complex systems in ob- scription of the key features and examples of their use. ject oriented programming languages such as Java. How- However, at the moment there are no books which attempt ever, systems evolve over time, increasing the chance that to formalise these descriptions, possibly for the following the pattern in its original form will be broken. reasons: We attempt to show that many patterns (implemented in Java) can be verified automatically. Patterns are defined 1. The implementation (and description) of the pattern is in terms of variants, mini-patterns, and constraints in a language-specific. pattern description language called SPINE. These specifi- 2. There are often several ways to implement a pattern cations are then processed by HEDGEHOG, an automated within the same language. proof tool that attempts to prove that Java source code 3. Formal language descriptions are not common within meets these specifications. the object oriented development community. Instead, each pattern is presented as a brief description, and an example of its implementation and use. Designers and developers are then expected to learn the ‘feel’ of a pat- 1.
[Show full text]
Addison Wesley, 2000, Pp
------==Proudly Presented by MODELER==------ preface.fm Page xv Wednesday, June 6, 2001 4:18 PM Preface Design patterns and object-oriented programming. They hold such promise to make your life as a software designer and developer eas- ier. Their terminology is bandied about every day in the technical and even the popular press. But it can be hard to learn them, to become proficient with them, to understand what is really going on. Perhaps you have been using an object-oriented or object-based language for years. Have you learned that the true power of objects is not inheritance but is in “encapsulating behaviors”? Perhaps you are curious about design patterns and have found the literature a bit too esoteric and high-falutin. If so, this book is for you. It is based on years of teaching this material to software developers, both experienced and new to object orientation. It is based upon the belief—and our experience—that once you understand the basic principles and motivations that underlie these concepts, why they are doing what they do, your learning curve will be incredibly shorter. And in our discussion of design patterns, you will under- stand the true mindset of object orientation, which is a necessity before you can become proficient. As you read this book, you will gain a solid understanding of the ten most essential design patterns. You will learn that design pat- terns do not exist on their own, but are supposed to work in con- cert with other design patterns to help you create more robust applications.
[Show full text]
Object-Oriented Analysis, Design and Implementation
Undergraduate Topics in Computer Science Brahma Dathan Sarnath Ramnath Object-Oriented Analysis, Design and Implementation An Integrated Approach Second Edition Undergraduate Topics in Computer Science Undergraduate Topics in Computer Science (UTiCS) delivers high-quality instruc- tional content for undergraduates studying in all areas of computing and information science. From core foundational and theoretical material to final-year topics and applications, UTiCS books take a fresh, concise, and modern approach and are ideal for self-study or for a one- or two-semester course. The texts are all authored by established experts in their fields, reviewed by an international advisory board, and contain numerous examples and problems. Many include fully worked solutions. More information about this series at http://www.springer.com/series/7592 Brahma Dathan • Sarnath Ramnath Object-Oriented Analysis, Design and Implementation An Integrated Approach Second Edition 123 Brahma Dathan Sarnath Ramnath Department of Information and Computer Department of Computer Science Science and Information Technology Metropolitan State University St. Cloud State University St. Paul, MN St. Cloud, MN USA USA Series editor Ian Mackie Advisory Board Samson Abramsky, University of Oxford, Oxford, UK Karin Breitman, Pontifical Catholic University of Rio de Janeiro, Rio de Janeiro, Brazil Chris Hankin, Imperial College London, London, UK Dexter Kozen, Cornell University, Ithaca, USA Andrew Pitts, University of Cambridge, Cambridge, UK Hanne Riis Nielson, Technical University of Denmark, Kongens Lyngby, Denmark Steven Skiena, Stony Brook University, Stony Brook, USA Iain Stewart, University of Durham, Durham, UK A co-publication with the Universities Press (India) Private Ltd., licensed for sale in all countries outside of India, Pakistan, Bhutan, Bangladesh, Sri Lanka, Nepal, The Maldives, Middle East, Malaysia, Indonesia and Singapore.
[Show full text]
Dependency Injection with Unity
D EPEN DEPENDENCY INJECTION WITH UNITY Over the years software systems have evolutionarily become more and more patterns & practices D ENCY complex. One of the techniques for dealing with this inherent complexity Proven practices for predictable results of software systems is dependency injection – a design pattern that I allows the removal of hard-coded dependencies and makes it possible to Save time and reduce risk on your NJECT assemble a service by changing dependencies easily, whether at run-time software development projects by or compile-time. It promotes code reuse and loosely-coupled design which incorporating patterns & practices, I leads to more easily maintainable and flexible code. Microsoft’s applied engineering ON guidance that includes both production The guide you are holding in your hands is a primer on using dependency quality source code and documentation. W I injection with Unity – a lightweight extensible dependency injection TH DEPENDENCY INJECTION container built by the Microsoft patterns & practices team. It covers The guidance is designed to help U software development teams: various styles of dependency injection and also additional capabilities N I of Unity container, such as object lifetime management, interception, Make critical design and technology TY and registration by convention. It also discusses the advanced topics of selection decisions by highlighting WITH UNITY enhancing Unity with your custom extensions. the appropriate solution architectures, technologies, and Microsoft products The guide contains plenty of trade-off discussions and tips and tricks for for common scenarios managing your application cross-cutting concerns and making the most out of both dependency injection and Unity. These are accompanied by a Understand the most important Dominic Betts real world example that will help you master the techniques.
[Show full text]
Designpatternsphp Documentation Release 1.0
DesignPatternsPHP Documentation Release 1.0 Dominik Liebler and contributors Jul 18, 2021 Contents 1 Patterns 3 1.1 Creational................................................3 1.1.1 Abstract Factory........................................3 1.1.2 Builder.............................................8 1.1.3 Factory Method......................................... 13 1.1.4 Pool............................................... 18 1.1.5 Prototype............................................ 21 1.1.6 Simple Factory......................................... 24 1.1.7 Singleton............................................ 26 1.1.8 Static Factory.......................................... 28 1.2 Structural................................................. 30 1.2.1 Adapter / Wrapper....................................... 31 1.2.2 Bridge.............................................. 35 1.2.3 Composite............................................ 39 1.2.4 Data Mapper.......................................... 42 1.2.5 Decorator............................................ 46 1.2.6 Dependency Injection...................................... 50 1.2.7 Facade.............................................. 53 1.2.8 Fluent Interface......................................... 56 1.2.9 Flyweight............................................ 59 1.2.10 Proxy.............................................. 62 1.2.11 Registry............................................. 66 1.3 Behavioral................................................ 69 1.3.1 Chain Of Responsibilities...................................
[Show full text]
Design Patterns in Ocaml
Design Patterns in OCaml Antonio Vicente [email protected] Earl Wagner [email protected] Abstract The GOF Design Patterns book is an important piece of any professional programmer's library. These patterns are generally considered to be an indication of good design and development practices. By giving an implementation of these patterns in OCaml we expected to better understand the importance of OCaml's advanced language features and provide other developers with an implementation of these familiar concepts in order to reduce the eﬀort required to learn this language. As in the case of Smalltalk and Scheme+GLOS, OCaml's higher order features allows for simple elegant implementation of some of the patterns while others were much harder due to the OCaml's restrictive type system. 1 Contents 1 Background and Motivation 3 2 Results and Evaluation 3 3 Lessons Learned and Conclusions 4 4 Creational Patterns 5 4.1 Abstract Factory . 5 4.2 Builder . 6 4.3 Factory Method . 6 4.4 Prototype . 7 4.5 Singleton . 8 5 Structural Patterns 8 5.1 Adapter . 8 5.2 Bridge . 8 5.3 Composite . 8 5.4 Decorator . 9 5.5 Facade . 10 5.6 Flyweight . 10 5.7 Proxy . 10 6 Behavior Patterns 11 6.1 Chain of Responsibility . 11 6.2 Command . 12 6.3 Interpreter . 13 6.4 Iterator . 13 6.5 Mediator . 13 6.6 Memento . 13 6.7 Observer . 13 6.8 State . 14 6.9 Strategy . 15 6.10 Template Method . 15 6.11 Visitor . 15 7 References 18 2 1 Background and Motivation Throughout this course we have seen many examples of methodologies and tools that can be used to reduce the burden of working in a software project.
[Show full text]
Simple Injector Documentation Release 5
Simple Injector Documentation Release 5 Simple Injector Contributors Jul 27, 2021 Contents 1 Quick Start 3 1.1 Overview.................................................3 1.2 Getting started..............................................3 1.3 A Quick Example............................................4 1.3.1 Dependency Injection......................................4 1.3.2 Introducing Simple Injector...................................5 1.4 More information.............................................6 2 Using Simple Injector 7 2.1 Resolving instances...........................................9 2.2 Conﬁguring Simple Injector....................................... 10 2.2.1 Auto-Registration/Batch-registration.............................. 13 2.3 Collections................................................ 14 2.3.1 Collection types......................................... 16 2.3.2 Auto-registering collections.................................. 16 2.3.3 Adding registrations to an existing collection......................... 17 2.4 Verifying the container’s conﬁguration................................. 17 2.5 Automatic constructor injection / auto-wiring.............................. 18 2.6 More information............................................. 19 3 Object Lifetime Management 21 3.1 Transient Lifestyle............................................ 22 3.2 Singleton Lifestyle............................................ 22 3.3 Scoped Lifestyle............................................. 23 3.3.1 Disposing a Scope......................................
[Show full text]
Java Design Patterns I
Java Design Patterns i Java Design Patterns Java Design Patterns ii Contents 1 Introduction to Design Patterns 1 1.1 Introduction......................................................1 1.2 What are Design Patterns...............................................1 1.3 Why use them.....................................................2 1.4 How to select and use one...............................................2 1.5 Categorization of patterns...............................................3 1.5.1 Creational patterns..............................................3 1.5.2 Structural patterns..............................................3 1.5.3 Behavior patterns...............................................3 2 Adapter Design Pattern 5 2.1 Adapter Pattern....................................................5 2.2 An Adapter to rescue.................................................6 2.3 Solution to the problem................................................7 2.4 Class Adapter..................................................... 11 2.5 When to use Adapter Pattern............................................. 12 2.6 Download the Source Code.............................................. 12 3 Facade Design Pattern 13 3.1 Introduction...................................................... 13 3.2 What is the Facade Pattern.............................................. 13 3.3 Solution to the problem................................................ 14 3.4 Use of the Facade Pattern............................................... 16 3.5 Download the Source Code.............................................
[Show full text]
1. Difference Between Factory Pattern and Abstract Factory Pattern S.No
1. Difference between Factory Pattern and Abstract Factory Pattern S.No Factory Pattern Abstract Factory Pattern 1 Create object through inheritance Create object through composition 2 Produce only one product Produce families of products 3 Implements code in the abstract creator Concrete factories implements factory that make use of the concrete type that method to create product sub class produces 2.Difference between Abstract Factory Pattern And Builder Pattern S.No Builder Pattern Abstract Factory Pattern 1 In Builder Pattern, there will be one Abstract Factory Pattern will return the Director class which will instruct Builder instance directly. class to build the different parts/properties of our object and finally retrieve the object. 2 It will have reference to the created It does not keep the track of it's created object. object. 3.Difference between Builder Pattern And Composite Pattern S.No Builder Pattern Composite Pattern 1 It is used to create group of objects of It creates Parent - Child relations between predefined types. our objects. 4.Difference between MVC and MVP S.No MVP MVC 1 MVP is a bit more complex to MVC is easier to implement than MVP. implement than MVC .Also, it has additional layer for view interfaces. 2 The request is always received by the The request is received by the controller View and delegated to the presenter which in turn gets the required data and which in turn gets the data does the loads up the appropriate view processing 3 The presentation and view logic an be The controller logic can be unit tested.
[Show full text]
Scala-Language.Pdf
Scala Language #scala Table of Contents About 1 Chapter 1: Getting started with Scala Language 2 Remarks 2 Versions 2 Examples 3 Hello World by Defining a 'main' Method 3 Hello World by extending App 4 Delayed Initialization 4 Delayed Initialization 4 Hello World as a script 5 Using the Scala REPL 5 Scala Quicksheet 6 Chapter 2: Annotations 8 Syntax 8 Parameters 8 Remarks 8 Examples 8 Using an Annotation 8 Annotating the main constructor 8 Creating Your Own Annotations 9 Chapter 3: Best Practices 11 Remarks 11 Examples 11 Keep it simple 11 Don't pack too much in one expression. 11 Prefer a Functional Style, Reasonably 12 Chapter 4: Case Classes 13 Syntax 13 Examples 13 Case Class Equality 13 Generated Code Artifacts 13 Case Class Basics 15 Case Classes and Immutabilty 15 Create a Copy of an Object with Certain Changes 16 Single Element Case Classes for Type Safety 16 Chapter 5: Classes and Objects 18 Syntax 18 Examples 18 Instantiate Class Instances 18 Instantiating class with no parameter: {} vs () 19 Singleton & Companion Objects 20 Singleton Objects 20 Companion Objects 20 Objects 21 Instance type checking 21 Constructors 23 Primary Constructor 23 Auxiliary Constructors 24 Chapter 6: Collections 25 Examples 25 Sort A List 25 Create a List containing n copies of x 26 List and Vector Cheatsheet 26 Map Collection Cheatsheet 27 Map and Filter Over A Collection 28 Map 28 Multiplying integer numbers by two 28 Filter 28 Checking pair numbers 28 More Map and Filter examples 29 Introduction to Scala Collections 29 Traversable types 30 Fold 31 Foreach 32 Reduce 32 Chapter 7: Continuations Library 34 Introduction 34 Syntax 34 Remarks 34 Examples 34 Callbacks are Continutations 34 Creating Functions That Take Continuations 35 Chapter 8: Currying 37 Syntax 37 Examples 37 A configurable multiplier as a curried function 37 Multiple parameter groups of different types, currying parameters of arbitrary positions 37 Currying a function with a single parameter group 37 Currying 38 Currying 38 When to use Currying 39 A real world use of Currying.
[Show full text]
Design Pattern Driven Development of Model Transformations
DESIGN PATTERN DRIVEN DEVELOPMENT OF MODEL TRANSFORMATIONS by HUSEYIN ERGIN JEFF GRAY, COMMITTEE CHAIR JEFFREY CARVER RALF LAEMMEL RANDY SMITH EUGENE SYRIANI SUSAN VRBSKY A DISSERTATION Submitted in partial fulfillment of the requirements for the degree of Doctor of Philosophy in the Department of Computer Science in the Graduate School of The University of Alabama TUSCALOOSA, ALABAMA 2017 Copyright Huseyin Ergin 2017 ALL RIGHTS RESERVED ABSTRACT Model-Driven Engineering (MDE) is considered a well-established software development ap- proach that uses abstraction to bridge the gap between the problem space and the software implementation. These abstractions are represented by models that make the validation of the real system easier. In MDE, many problems are solved using model transformation, which is a paradigm that manipulates high-level models to translate, evolve, or simulate them. However, the development of a model transformation for a specific problem is still a hard task. The main reason is the lack of a development process where transformations must be designed before implemented. Design patterns provide experiential reuse to soft- ware engineers when faced with recurring problems. In the literature, design patterns have been used to generate partially reusable software designs in order to help developers. There are many design patterns focused development methodologies proposed. However, most of them specialize in object-oriented design patterns. Given the various contexts in which de- sign patterns have been applied, model transformations may also benefit from a patterns approach. Although several studies have proposed design patterns for model transforma- tion, there is still no accepted common language to express them or a methodology that places design patterns at the heart of the development of model transformations.
[Show full text]
Design Patterns Design Patterns
Design Patterns • More design patterns (GoF) – Structural: Adapter, Bridge, Façade – Creational: Abstract Factory, Singleton – Behavioral: Observer, Iterator, State, Visitor Design Patterns-10, CS431 F06, BG Ryder/A Rountev 1 Design Patterns • Design patterns have become very popular in the last decade or so • Major source: GoF book 1995 • “Design Patterns: Elements of Reusable Object- Oriented Software” • Gamma, Helm, Johnson, Vlissides (gang of 4) • Patterns describe well-known solutions to common design problems • Used in Java libraries, especially in the GUI libraries Design Patterns-10, CS431 F06, BG Ryder/A Rountev 2 1 Design Patterns (LAR Ch26; GoF) • Structural • Concerned with how classes and objects are composed to make larger structures (Adapter, Bridge, Composite, Façade) • Creational • Abstract the instantiation process to make a system independent of how its objects are created & represented (Abstract Factory, Singleton) • Behavioral • Describe patterns of communication and interaction between objects (algorithms and responsibility assignment) (Observer, State, Strategy, Mediator) Design Patterns-10, CS431 F06, BG Ryder/A Rountev 3 Adapter Pattern: Interface Matcher • Problem: incompatible interfaces • Solution: create a wrapper that maps one interface to another • Key point: neither interface has to change and they execute in decoupled manner – Think of how you use a power plug adaptor when you travel to Europe • Example: – Client written against some interface – Server with the right functionality but with the wrong interface
[Show full text]