Scribd
Upload
80 views2 pages

Abstract Factory

The abstract factory pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes. Some key points: - Abstract factories define an interface for creating products but let subclasses decide which products to return. This allows a system to work with different sets of products. - Concrete factories return concrete products that belong to a single variant. Products are guaranteed to be compatible with each other. - Products have base interfaces and concrete classes that implement those interfaces. Products can interact with each other through their base interfaces. - Clients work with factories and products through their abstract interfaces, which decouples them from concrete classes and makes the system extensible to new variants.

Uploaded by

alejo casta
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
80 views2 pages

Abstract Factory

The abstract factory pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes. Some key points: - Abstract factories define an interface for creating products but let subclasses decide which products to return. This allows a system to work with different sets of products. - Concrete factories return concrete products that belong to a single variant. Products are guaranteed to be compatible with each other. - Products have base interfaces and concrete classes that implement those interfaces. Products can interact with each other through their base interfaces. - Clients work with factories and products through their abstract interfaces, which decouples them from concrete classes and makes the system extensible to new variants.

Uploaded by

alejo casta
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 2

13/5/2021 Abstract Factory

As a result, you don’t need to modify the client code each time you add a new variation of UI
elements to your app. You just have to create a new factory class that produces these elements
and slightly modify the app’s initialization code so it selects that class when appropriate.

// The abstract factory interface declares a set of methods that


// return different abstract products. These products are called
// a family and are related by a high-level theme or concept.
// Products of one family are usually able to collaborate among
// themselves. A family of products may have several variants,
// but the products of one variant are incompatible with the
// products of another variant.
interface GUIFactory is
method createButton():Button
method createCheckbox():Checkbox

// Concrete factories produce a family of products that belong


// to a single variant. The factory guarantees that the
// resulting products are compatible. Signatures of the concrete
// factory's methods return an abstract product, while inside
// the method a concrete product is instantiated.
class WinFactory implements GUIFactory is
method createButton():Button is
return new WinButton()
method createCheckbox():Checkbox is
return new WinCheckbox()

// Each concrete factory has a corresponding product variant.


class MacFactory implements GUIFactory is
method createButton():Button is
return new MacButton()
method createCheckbox():Checkbox is
return new MacCheckbox()

// Each distinct product of a product family should have a base


// interface. All variants of the product must implement this
// interface.
interface Button is
method paint()

// Concrete products are created by corresponding concrete


// factories.
class WinButton implements Button is
method paint() is
// Render a button in Windows style.

https://refactoring.guru/design-patterns/abstract-factory 8/13
13/5/2021 Abstract Factory

class MacButton implements Button is


method paint() is
// Render a button in macOS style.

// Here's the base interface of another product. All products


// can interact with each other, but proper interaction is
// possible only between products of the same concrete variant.
interface Checkbox is
method paint()

class WinCheckbox implements Checkbox is


method paint() is
// Render a checkbox in Windows style.

class MacCheckbox implements Checkbox is


method paint() is
// Render a checkbox in macOS style.

// The client code works with factories and products only


// through abstract types: GUIFactory, Button and Checkbox. This
// lets you pass any factory or product subclass to the client
// code without breaking it.
class Application is
private field factory: GUIFactory
private field button: Button
constructor Application(factory: GUIFactory) is
this.factory = factory
method createUI() is
this.button = factory.createButton()
method paint() is
button.paint()

// The application picks the factory type depending on the


// current configuration or environment settings and creates it
// at runtime (usually at the initialization stage).
class ApplicationConfigurator is
method main() is
config = readApplicationConfigFile()

if (config.OS == "Windows") then


factory = new WinFactory()
else if (config.OS == "Mac") then
factory = new MacFactory()
else
throw new Exception("Error! Unknown operating system.")

Application app = new Application(factory)


https://refactoring.guru/design-patterns/abstract-factory 9/13

You might also like