• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Java Course 11: Design Patterns
 

Java Course 11: Design Patterns

on

  • 2,096 views

Lecture 11 from the IAG0040 Java course in TTÜ. ...

Lecture 11 from the IAG0040 Java course in TTÜ.
See the accompanying source code written during the lectures: https://github.com/angryziber/java-course

Describes goods and bads of software architecture as well as common design patterns.

Statistics

Views

Total Views
2,096
Views on SlideShare
2,096
Embed Views
0

Actions

Likes
4
Downloads
97
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Java Course 11: Design Patterns Java Course 11: Design Patterns Presentation Transcript

    • Java course - IAG0040 Design PatternsAnton Keks 2011
    • The Increasing Complexity Complexity of software systems Time New programming paradigms Higher level of abstraction HW Assembler Structural P. (DSL, AOP?) CPUs Procedural P. OOP ...Java course – IAG0040 Lecture 11Anton Keks Slide 2
    • The emerge of OOP ● Response to complexity ● Software crisis: difficulty of writing correct, understandable, and verifiable programs ● Emphasizes modularity & reusability ● Solves the “Tramp Data” problem ● Closer to the Real World ● Program == cooperating objects, not a list of instructionsJava course – IAG0040 Lecture 11Anton Keks Slide 3
    • What are design patterns? ● Anywhere in the world you can find recurring patterns ● Design patterns – are building blocks of a systems architecture – are recurring solutions to design problems that you see over – identify and specify abstractions that are above the level of single classes and instancesJava course – IAG0040 Lecture 11Anton Keks Slide 4
    • Where do they come from? ● First referenced in early 80s, with the emerge of OOP ● Formally defined in 1994 in the GOF book (even before Java!) ● Hundreds more have been identified since then ● Are usually discovered (through pattern- mining) rather than inventedJava course – IAG0040 Lecture 11Anton Keks Slide 5
    • GOF (Gang of Four) book ● Title: Design Patterns: Elements of Reusable Object-Oriented Software ● Is the first and essential book on patterns ● Patterns are well classified and described ● Every professional software developer must know themJava course – IAG0040 Lecture 11Anton Keks Slide 6
    • MVC ● Model-View-Controller ● One of the first patterns, comes from Smalltalk language ● Is a “best practice” of splitting GUI applications into – Model - holds/stores data and provides data access interface – View - displays data to the user obtained from the model – Controller - manipulates the model, selects appropriate views ● Therefore, the code consists of three decoupled layers, which can work together or independently ● Any of the layers can be modified/rewritten without modifications to other layersJava course – IAG0040 Lecture 11Anton Keks Slide 7
    • Pattern classification● The GOF book defines 3 major types of patterns: – Creational patterns are ones that create objects for you, rather than having you instantiate objects directly. This gives your program more flexibility in deciding which objects need to be created for a given case. – Structural patterns help you compose groups of objects into larger structures, such as complex user interfaces or accounting data. – Behavioral patterns help you define the communication between objects in your system and how the flow is controlled in a complex program.Java course – IAG0040 Lecture 11Anton Keks Slide 8
    • Anti-patterns ● This term is also widely used to define certain patterns, which should be avoided in software design ● Anti-patterns (aka pitfalls) are commonly reinvented bad solutions to problems ● Knowing anti-patterns is as important as knowing patterns ● Another term used in Agile Software Development is code smell (eliminated by refactoring) ● See Wikipedia articles on both Anti-pattern and Code smell for more info and examplesJava course – IAG0040 Lecture 11Anton Keks Slide 9
    • Software Design vs Architecture ● Software design is the structure of code and relations between its elements (classes) ● Software architecture is the same as software design, but used when people want to make it look important (after Martin Fowler) – Architecture is the part of design that is difficult to change – Therefore it is undesired :-)Java course – IAG0040 Lecture 11Anton Keks Slide 10
    • Some design considerations ● Thinking about design is very important at all stages during a project. If it needs corrections then refactoring should be used ● Consistent API and loosely coupled code are very important - they make changes easy ● Unit tests and TDD help a lot ● Design patterns help make your design better and more understandable to othersJava course – IAG0040 Lecture 11Anton Keks Slide 11
    • General concepts of design ● Fundamental reason for patterns: keep classes separated, prevent them from knowing too much about each other ● Abstract classes and interfaces are major tools ● Program to interfaces, not to implementations ● Prefer object composition to inheritance; it usually results in cleaner code (this is simply a construction of objects that contain others) – Delegation may be used for reusing “parent” behaviorJava course – IAG0040 Lecture 11Anton Keks Slide 12
    • Iterator ● Behavioral pattern, synonym: Cursor ● You already know it from the Collections API! ● Iterator provides a way for accessing elements of an aggregate object sequentially without exposing its underlying representation ● Iterator is a special object provided by an aggregate object for holding of iteration state – better than if aggregate objects change their state during iteration (e.g. provide their own next() methods) – better than index-based element access - hides implementation details – several iterators may be used at once on the same dataJava course – IAG0040 Lecture 11Anton Keks Slide 13
    • Lazy Initialization ● The idea is to initialize “expensive” objects on demand, e.g. only when they are accessed (this is sometimes referred to as “caching”) – if expensive object is never accessed then it is never created ● If initialization takes time and several threads access the object, then synchronization is needed ● Double-checked locking is a clever (but broken) trick: – public Object getExpensiveObject() { if (instance == null) { synchronized (this) { if (instance == null) instance = new ... } } return instance; }Java course – IAG0040 Lecture 11Anton Keks Slide 14
    • Singleton ● Creational pattern, sometimes uses lazy initialization ● Ensures a class has only one instance, and provides global access point to it ● public class Singleton { private Singleton() {} // private constructor private static Singleton uniqueInstance = new Singleton(); public static Singleton getInstance() { return uniqueInstance; // can be lazily initialized } }Java course – IAG0040 Lecture 11Anton Keks Slide 15
    • Singleton (2) ● Better than global variables (controlled access, doesnt pollute namespace) ● More flexible than class operations (static methods): can be polymorphic and subclassed, permits easy design changes, etc ● Disadvantages: may result in coupled code, if used directly too much. Difficult to mock in unit tests ● (better alternative – use singletons in an IoC container, like PicoContainer or Spring)Java course – IAG0040 Lecture 11Anton Keks Slide 16
    • Factory Method ● Creational pattern, synonyms: Factory, Virtual Constructor ● Defines an interface for creating an object of particular abstract type, but lets subclasses decide which concrete class to instantiate ● Used by many modern frameworks and APIs (e.g. SAXParserFactory) ● public class BulldogFactory implements DogFactory { public Dog createDog() { return new Bulldog(); } } ● public class DachshundFactory implements DogFactory { public Dog createDog() { return new Dachshund(); } }Java course – IAG0040 Lecture 11Anton Keks Slide 17
    • Factory Method (2) ● Allows writing of polymorphic code that can work with different implementations of interfaces without any direct references to them, eliminates hardcoding of implementation class names ● The method must be non-static, if you want to override it in a superclass of factory ● Variation: factory method can be static and decide itself what to instantiate – using configuration – with the help of parametersJava course – IAG0040 Lecture 11Anton Keks Slide 18
    • Abstract Factory ● Creational pattern, synonym: Kit ● Provides an interface for creating families of related or dependent objects without specifying their concrete classes ● Abstract Factory is similar to Factory Method with the exception that methods are never static and Factories are always subclassed in order to return different sets of instancesJava course – IAG0040 Lecture 11Anton Keks Slide 19
    • Abstract Factory (2) ● Example: GUI toolkit with Factories for creation of widgets with different look and feel ● public interface AbstractWidgetFactory { public Button createButton(); public ScrollBar createScrollBar(); } public class MotifLookAndFeelWidgetFactory implements AbstractWidgetFactory { ... }Java course – IAG0040 Lecture 11Anton Keks Slide 20
    • Builder ● Creational pattern ● Eliminates telescoping constructors – without sacrificing immutability – has all advantages of Factory ● Create Builder inner static class with methods returning this and build() method returning the class instance ● Pizza pizza = new Pizza.Builder(). withOnion().doubleCheese().build(); ● Very readable, better than infinite number of constructors with boolean or numeric arguments, or settersJava course – IAG0040 Lecture 11Anton Keks Slide 21
    • Common structural patterns ● Decorator ● Adapter ● Composite ● (Proxy)Java course – IAG0040 Lecture 11Anton Keks Slide 22
    • Decorator ● Structural pattern, synonym: Wrapper ● Attach additional responsibilities to an object dynamically. ● Decorators provide a flexible alternative to subclassing for extending functionality ● Useful for adding responsibilities dynamically to objects, not classes. ● Decorator must have the same interface as the decorated object.Java course – IAG0040 Lecture 11Anton Keks Slide 23
    • Decorator (2) ● Decorator delegates all method calls to wrapped instance and does something else before or after. Every object can be decorated several times. ● BufferedInputStream decorates any InputStream ● public class LoggingConnection implements Connection { private Connection conn; ... public boolean isActive() { System.out.println(“isActive was called!”); return conn.isActive(); } ... }Java course – IAG0040 Lecture 11Anton Keks Slide 24
    • Adapter ● Structural pattern, synonym: Wrapper ● Converts the interface of a class into another interface clients expect ● Adapter lets classes work together that couldnt otherwise because of incompatible interfacesJava course – IAG0040 Lecture 11Anton Keks Slide 25
    • Adapter (2) ● In other words, Adapter just translates requests to another API of the wrapped class ● Examples – InputStreamReader adapts an InputStream to the Reader interface – Arrays.asList() represents java arrays as List instances – Collections.enumeration() represents Iterators as EnumerationsJava course – IAG0040 Lecture 11Anton Keks Slide 26
    • Composite ● Structural pattern, similar to Decorator ● Composes objects into tree structures to represent part-whole hierarchies ● Composite lets clients treat individual objects and compositions of objects uniformlyJava course – IAG0040 Lecture 11Anton Keks Slide 27
    • Composite (2) ● Example: in a GUI toolkit, a Window is a composite of other Widgets, while is a Widget itself ● Many GUI toolkits have base classes named Composite, which can have a layout manager assigned and an arbitrary number of child Composites ● SequenceInputStream is a composite of many InputStreamsJava course – IAG0040 Lecture 11Anton Keks Slide 28
    • Proxy ● Decorator, Adapter, and Composite – any of them can be called Proxy ● Proxy is a class, functioning as an interface to another thing ● In a more specific sense (Virtual Proxy): wrapping classes can – control access to wrapped objects – lazily initialize the delegates inside themJava course – IAG0040 Lecture 11Anton Keks Slide 29
    • Strategy● Behavioral pattern, synonym: Policy● Defines a family of algorithms, encapsulates each one, and makes them interchangeable; eliminates conditions from the code (GoF)● Capture the abstraction in an interface, bury implementation details in derived classes● Strategy lets the algorithm vary independently from clients that use it – Algorithms can be changed on-the-fly at runtimeJava course – IAG0040 Lecture 11Anton Keks Slide 30
    • Strategy (2) ● Strategy pattern allows adding of new algorithms easily and/or dynamically ● Participants: – Strategy – an interface or abstract class of all strategies – ConcreteStrategy – each is a different implementation of Strategy – Context – a class, initialized to use and maintain a ConcreteStrategy, can provide additional (context specific) data to itJava course – IAG0040 Lecture 11Anton Keks Slide 31
    • State ● Behavioral pattern, similar to Strategy ● Each “Strategy” is one of the states of the Context – Strategy usually represents a single abstraction – each State can implement several behaviors (different actions, methods) – State interface may as well provide methods for transitions in order to implement a Finite State MachineJava course – IAG0040 Lecture 11Anton Keks Slide 32
    • Façade ● Structural pattern ● Provides a unified interface to a set of interfaces in subsystem ● Facade defines a higher-level interface that makes the subsystem easier to use ● Structuring a system into subsystems reduces complexity. Then subsystems can communicate only through Facades, while using their own lower-level interfaces internally. This reduces coupling ● Example: consider internals of a compiler: it can have classes like Scanner, Parser, ProgramNode, BytecodeStream, etc, but externally you use the Facade class named Compiler, which simply takes input file and produces an output file ● Facade just delegates requests to appropriate subsystem classes, it doesnt do anything itselfJava course – IAG0040 Lecture 11Anton Keks Slide 33
    • Prototype ● Creational pattern ● Specifies the kind of objects to create using the prototypical instance – creates new objects by copying (cloning) the prototype ● Allows having an initialized reference instance of some abstract class, then it can be cloned or recreated with reflection API for creation of new objects ● Useful when creating new instances is too complex (and slow) or less convenient than cloning ● Convenient for implementation of plug-in architectures, where implementations may be added/removed dynamicallyJava course – IAG0040 Lecture 11Anton Keks Slide 34
    • Observer ● Behavioral pattern, synonym: Publish- Subscribe ● Defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically ● Provides decoupled classes, which can work together or independentlyJava course – IAG0040 Lecture 11Anton Keks Slide 35
    • Observer (2) ● Participants: – Subject (Observable) – the data to observe – Observer – an updating interface for objects, which are notified – ConcreteSubject – sends notifications to all registered ConcreteObservers – ConcreteObserver – knows about ConcreteSubject, updates itself on notifications ● Java provides both Observable abstract class and Observer interfaceJava course – IAG0040 Lecture 11Anton Keks Slide 36