CS 4240: Bridge andAbstract Factory

CS 4240: Bridge andAbstract Factory

Readings: Chap. 10 and 11

Readings: Chap. 10 and 11

Let’s Recap Some Ideas and Strategies

Let’s Recap Some Ideas and Strategies

We’ll assume some design-planning is useful up-front

Design with change in mindChange will happenNot sure exactly what it will beCan predict in advance where it’s

likely to happen

We’ll assume some design-planning is useful up-front

Design with change in mindChange will happenNot sure exactly what it will beCan predict in advance where it’s

likely to happen

OutlineOutline

First, factory patternsThen, Bridge pattern

First, factory patternsThen, Bridge pattern

FactoriesFactories

What’s a factory?An object whose responsibilities are

creating one or more objects for clients

Why bother? Why not let client create its own instances?What do you think?

What’s a factory?An object whose responsibilities are

creating one or more objects for clients

Why bother? Why not let client create its own instances?What do you think?

Design Goal of FactoriesDesign Goal of Factories

Sometimes we can separate knowledge of “how to use” from knowledge of “what exactly to create”Client knows first part, factory second part

Abstract class (or interface) vs. object implements that interfaceProgram to abstractionsEncapsulate what varies

Factory provides objects that meet interface but client doesn’t know concrete class of that object

Sometimes we can separate knowledge of “how to use” from knowledge of “what exactly to create”Client knows first part, factory second part

Abstract class (or interface) vs. object implements that interfaceProgram to abstractionsEncapsulate what varies

Factory provides objects that meet interface but client doesn’t know concrete class of that object

Reminder: Static Factory Method

Reminder: Static Factory Method

Static factory methodCoding techniqueClass-level method, returns an

instanceQuestion: what design pattern relied

on thisHint: like factories, also a creational

pattern (a design pattern responsible for creating objects)

Static factory methodCoding techniqueClass-level method, returns an

instanceQuestion: what design pattern relied

on thisHint: like factories, also a creational

pattern (a design pattern responsible for creating objects)

Remember Singleton?Remember Singleton?

Example code: GameMaster gm = GameMaster.getInstance();

Note here a class-level operation returns an instanceNot a separate factory object

Example code: GameMaster gm = GameMaster.getInstance();

Note here a class-level operation returns an instanceNot a separate factory object

Factory Method PatternFactory Method Pattern

Our book doesn’t mention this one, but it’s easy

GoF book intent:Define an interface for creating an object,

but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.

Client uses reference to a factory-interface to get an object it needs

Our book doesn’t mention this one, but it’s easy

GoF book intent:Define an interface for creating an object,

but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.

Client uses reference to a factory-interface to get an object it needs

Document Processing ExampleDocument Processing Example

Client gets factory object

Asks factory for document

Factory provides some instance

Client doesn’t know exactly what subtype

How does factory know?

Client gets factory object

Asks factory for document

Factory provides some instance

Client doesn’t know exactly what subtype

How does factory know?

Choices and FactoriesChoices and Factories

Might be one factory object that can create different types of objectsClient passes a string or some identifierComments on this kind of design?

(Coupling?)

Often more than one kind of factory objectHow does client get one? Ideas?

Might be one factory object that can create different types of objectsClient passes a string or some identifierComments on this kind of design?

(Coupling?)

Often more than one kind of factory objectHow does client get one? Ideas?

Choices and Factories (cont’d)Choices and Factories (cont’d)Somehow client gets a factory objectSometimes a static method provides this

DocFactory df = DocFactory.getFactory();Note: DocFactory will be abstract class here

How does that method know?One option: stored in configuration file or

Java propertyBottom line: some factor decides, and it’s

“bound” to the client somewhere.What makes sense? Best coupling?

Somehow client gets a factory objectSometimes a static method provides this

DocFactory df = DocFactory.getFactory();Note: DocFactory will be abstract class here

How does that method know?One option: stored in configuration file or

Java propertyBottom line: some factor decides, and it’s

“bound” to the client somewhere.What makes sense? Best coupling?

Example: XML parsingExample: XML parsing

XML documentsMany parsers available, different

strategies, many options for parsingSAXParser is a standard interface

JAXP: an API but not a parserLibraries provide parsers that work

with it

XML documentsMany parsers available, different

strategies, many options for parsingSAXParser is a standard interface

JAXP: an API but not a parserLibraries provide parsers that work

with it

Code sampleCode sample

Typical use:

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();factory.setValidating(true); // factory properties

DocumentBuilder builder = factory.newDocumentBuilder();

Document doc = builder.parse(aDocFile);How is parser set? Java properties

Typical use:

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();factory.setValidating(true); // factory properties

DocumentBuilder builder = factory.newDocumentBuilder();

Document doc = builder.parse(aDocFile);How is parser set? Java properties

Abstract FactoryAbstract Factory

Intent from GoF:Provide an interface for creating families of

related or dependent objects without specifying their concrete classes

Same idea as beforeSeparate responsibilities of what-to-create

from how-to-use

Difference: families of related objects

Intent from GoF:Provide an interface for creating families of

related or dependent objects without specifying their concrete classes

Same idea as beforeSeparate responsibilities of what-to-create

from how-to-use

Difference: families of related objects

Possible ExamplesPossible Examples

GUIs for multiple platforms etcButton, Label, etc.Different implementations, but all need to

be the same “family”XML docs

Nodes, labels, childrenSame operations but different parsers may

produce different versionsWhat would make this approach work?

What’s common between families?

GUIs for multiple platforms etcButton, Label, etc.Different implementations, but all need to

be the same “family”XML docs

Nodes, labels, childrenSame operations but different parsers may

produce different versionsWhat would make this approach work?

What’s common between families?

The Abstract in Abstract Factory

The Abstract in Abstract Factory

In this pattern, the factory creates objects called “products” for a common familyFamily could change

What doesn’t change:Each product meets an abstract interfaceE.g. Button is an abstract class, and all

versions meet thatSo client references products as

abstractions

In this pattern, the factory creates objects called “products” for a common familyFamily could change

What doesn’t change:Each product meets an abstract interfaceE.g. Button is an abstract class, and all

versions meet thatSo client references products as

abstractions

Same Ole Song, No?Same Ole Song, No?

What varies:Family defined differences between,

say, two kinds of buttonSo encapsulate this variation

Also, what varies is choice of familySometimes this, another time thatEncapsulate what-to-create inside

Factory object

What varies:Family defined differences between,

say, two kinds of buttonSo encapsulate this variation

Also, what varies is choice of familySometimes this, another time thatEncapsulate what-to-create inside

Factory object

Textbook’s ExampleTextbook’s Example

Client works with a computer’s drivers.

Depending on computer, uses:High Resolution Display Driver and

High Resolution Printer Driver -- OR --

Low Resolution Display Driver and Low Resolution Printer Driver

Client works with a computer’s drivers.

Depending on computer, uses:High Resolution Display Driver and

High Resolution Printer Driver -- OR --

Low Resolution Display Driver and Low Resolution Printer Driver

You Know to Do ThisYou Know to Do This

Application programs to interfaces But how to make sure always using consistent

objects in one family?

Application programs to interfaces But how to make sure always using consistent

objects in one family?

Use vs. CreateUse vs. Create

Client could take full responsibility for creating objectsSwitch on “selection-factor”Creating a bunch of things from one family

Now client is less cohesiveCoupling: If more families added, family

details change, client must change

Client could take full responsibility for creating objectsSwitch on “selection-factor”Creating a bunch of things from one family

Now client is less cohesiveCoupling: If more families added, family

details change, client must change

Abstract Factory SolutionAbstract Factory Solution

Take what we learned from Factory Method patternAn object is responsible for creating things

for a client to useBut now:

create many different products (e.g. Button, Label, TextField, etc.)

Have one interface for creating all theseClient gets and uses an instance of the

Factory object to create things

Take what we learned from Factory Method patternAn object is responsible for creating things

for a client to useBut now:

create many different products (e.g. Button, Label, TextField, etc.)

Have one interface for creating all theseClient gets and uses an instance of the

Factory object to create things

Sequence of EventsSequence of Events

Make sure you understand the order of eventsClient gets a factory of type

ResFactoryWhich one? How does it know?

Calls methods in this ResFactory objects to get products it needs

Uses these references to productsAbstract class or interface

Make sure you understand the order of eventsClient gets a factory of type

ResFactoryWhich one? How does it know?

Calls methods in this ResFactory objects to get products it needs

Uses these references to productsAbstract class or interface

Choice of FactoryChoice of Factory

Again, how does the client choose one factory? Where?Might have a line of code to get a specific

one: ResFactory factory = new LowResFact();

Might be in a configuration fileClass-level method in ResFactoryOther possible ways (user pref, cookie,…)

But: one place to change this!“One rule, one place”

Again, how does the client choose one factory? Where?Might have a line of code to get a specific

one: ResFactory factory = new LowResFact();

Might be in a configuration fileClass-level method in ResFactoryOther possible ways (user pref, cookie,…)

But: one place to change this!“One rule, one place”

General FormGeneral Form

Our Book Points Out…Our Book Points Out…

Adaptors often used here to make concrete products fit AbstractProduct interface

Switches (or decisions) still here probably, just moved to one place

Adaptors often used here to make concrete products fit AbstractProduct interface

Switches (or decisions) still here probably, just moved to one place

SummarySummary

Division of responsibilitiesHow to use (client needs to know)What to create

If abstraction used, client doesn’t need to know

Hand off responsibility to factory object

Coupling of client to family-details reduced greatly

Division of responsibilitiesHow to use (client needs to know)What to create

If abstraction used, client doesn’t need to know

Hand off responsibility to factory object

Coupling of client to family-details reduced greatly

Bridge PatternBridge Pattern

GoF book’s intent says:De-couple an abstraction from its

implementation so that the two can vary independently

Implementation here means:Not the concrete class that implements an

abstractionInstead, the logic or code that makes the

hard work happenAssume this is in a helper-object

GoF book’s intent says:De-couple an abstraction from its

implementation so that the two can vary independently

Implementation here means:Not the concrete class that implements an

abstractionInstead, the logic or code that makes the

hard work happenAssume this is in a helper-object

CVA yada yada yada…CVA yada yada yada…

What varies here?First, we have the usual abstraction hierarchy of

IS-A’sSecond, we have multiple ways work gets done

(implementations)These need to be combined

Plan:Encapsulate what variesPrefer aggregation to inheritance

But inheritance is in here tooDon’t use inheritance to combine across dimensions of

variation

What varies here?First, we have the usual abstraction hierarchy of

IS-A’sSecond, we have multiple ways work gets done

(implementations)These need to be combined

Plan:Encapsulate what variesPrefer aggregation to inheritance

But inheritance is in here tooDon’t use inheritance to combine across dimensions of

variation

Book’s ExampleBook’s Example

Client wants to draw shapesHas two drawing programs (engines)

Keep possibility of using either oneBut shapes know which, and client doesn’t

Drawing programs may have different interfaces for drawing primitives

Client wants to draw shapesHas two drawing programs (engines)

Keep possibility of using either oneBut shapes know which, and client doesn’t

Drawing programs may have different interfaces for drawing primitives

Book’s ExampleBook’s Example

ShapesRectangle, Circle, ...

Two drawing "programs" or componentsWe need two versions of each Shape

One uses DP1, the other DP2

“Implementation” here means:the drawing component used for a given

Shape object

ShapesRectangle, Circle, ...

Two drawing "programs" or componentsWe need two versions of each Shape

One uses DP1, the other DP2

“Implementation” here means:the drawing component used for a given

Shape object

What Might Vary and Where?

What Might Vary and Where?

Drawing programsDifferent methods for primitive drawing

operationsdraw a line, draw a circle

ShapesRules for drawing a rectangle does NOT vary

four lines between corners

So this logic belongs in abstract Rectangle class

Drawing programsDifferent methods for primitive drawing

operationsdraw a line, draw a circle

ShapesRules for drawing a rectangle does NOT vary

four lines between corners

So this logic belongs in abstract Rectangle class

UML for Shape HierarchyUML for Shape Hierarchy

Linking in the DPsLinking in the DPs

Note four concrete classes2 Shapes x 2 DPs = 4 variations

The “V1 versions” must use a DP1 objectE.g. for V1Rectangle, drawLine() calls DP1’s

draw-a-line methodSo a DP1 object linked to V1Rectangle

See sequence chart, p. 166Note only 3 objects at run-time:

client, someV1Rectangle, theDp1

Note four concrete classes2 Shapes x 2 DPs = 4 variations

The “V1 versions” must use a DP1 objectE.g. for V1Rectangle, drawLine() calls DP1’s

draw-a-line methodSo a DP1 object linked to V1Rectangle

See sequence chart, p. 166Note only 3 objects at run-time:

client, someV1Rectangle, theDp1

What’s the problem(s)?What’s the problem(s)?

Explosion of classesFor each variation of shape, multiply

that by variation in DPCoupling

Every concrete class needs to know its family

Explosion of classesFor each variation of shape, multiply

that by variation in DPCoupling

Every concrete class needs to know its family

Improvement (?)Improvement (?)

Have an abstraction based on shape-typeAbstract class: V1ShapeMove link to particular DP up there

See next UML diagram

Have an abstraction based on shape-typeAbstract class: V1ShapeMove link to particular DP up there

See next UML diagram

Better? Problem(s)?Better? Problem(s)?

Class explosion still hereHard to see since 2+2 == 2x2But another DP? 6 concrete classesOr another Shape? 6 concrete classes

RedundancyBoth V1Rectangle and V2Rectangle

have logic of how lines are used to form a rectangle

Class explosion still hereHard to see since 2+2 == 2x2But another DP? 6 concrete classesOr another Shape? 6 concrete classes

RedundancyBoth V1Rectangle and V2Rectangle

have logic of how lines are used to form a rectangle

The Overall ProblemThe Overall Problem

Need to decouple two abstractionsShape (domain object hierarchy)Drawing program (implementation)

Both varyIndependently

Use aggregation for this coupling/link/relationship

Need to decouple two abstractionsShape (domain object hierarchy)Drawing program (implementation)

Both varyIndependently

Use aggregation for this coupling/link/relationship

Once again:Aggregation separates single “thing”

into two components

Once again:Aggregation separates single “thing”

into two components

More DetailsMore Details

Two Abstractions in the BridgeTwo Abstractions in the Bridge

Comments on BridgeComments on Bridge

Again, note what’s meant by “implementation” hereWhat a class needs to carry out the job

Note Rectangle and Circle are now concrete classesRules for how-to-draw-myself are hereOne rule, one place! (See p. 179)

Note V1Drawing and V2Drawing (bad names?) are concrete classesQuiz! What pattern is Drawing, V1Drawing, and

DP1?

Again, note what’s meant by “implementation” hereWhat a class needs to carry out the job

Note Rectangle and Circle are now concrete classesRules for how-to-draw-myself are hereOne rule, one place! (See p. 179)

Note V1Drawing and V2Drawing (bad names?) are concrete classesQuiz! What pattern is Drawing, V1Drawing, and

DP1?

Comments on Bridge (2)Comments on Bridge (2)

How does link/connect between a Shape object and a particular Drawing get made?E.g. someRectangle uses V1Drawing objectClient must make this happen

What if clients wants lots of shapes, each using same DP?Have we seen a pattern to help us here?Answer:

How does link/connect between a Shape object and a particular Drawing get made?E.g. someRectangle uses V1Drawing objectClient must make this happen

What if clients wants lots of shapes, each using same DP?Have we seen a pattern to help us here?Answer:

Real ExamplesReal Examples

Device drivers (e.g. printer drivers)Various types of printer with

variationsB&W, duplex, paper control

Various implementations for particular hardware

JDBC: Java to SQL DB driver

Device drivers (e.g. printer drivers)Various types of printer with

variationsB&W, duplex, paper control

Various implementations for particular hardware

JDBC: Java to SQL DB driver

AWT WindowsAWT Windows

SummarySummary

See book for other commentsImportant point about Bridge

Decouple two abstractions that can vary simultaneously

One uses the other to implement functionality

Avoid explosion of subclasses, poor coupling, redundant code

Often used with other patternsß

See book for other commentsImportant point about Bridge

Decouple two abstractions that can vary simultaneously

One uses the other to implement functionality

Avoid explosion of subclasses, poor coupling, redundant code

Often used with other patternsß

ENDEND