Java /* Przykład GUIFactory */

abstract class GUIFactory { public static GUIFactory getFactory() { int sys = readFromConfigFile("OS_TYPE"); if (sys == 0) { return new WinFactory(); } else { return new OSXFactory();

public abstract Button createButton(); }

class WinFactory extends GUIFactory { public Button createButton() { return new WinButton();

class OSXFactory extends GUIFactory { public Button createButton() { return new OSXButton();

abstract class Button { public abstract void paint(); }

class WinButton extends Button { public void paint() { System.out.println("Przycisk WinButton");

class OSXButton extends Button { public void paint() { System.out.println("Przycisk OSXButton");

public class Application { public static void main(String[] args) { GUIFactory factory = GUIFactory.getFactory(); Button button = factory.createButton(); button.paint();

// Wyświetlony zostanie tekst: // "Przycisk WinButton" // lub: // "Przycisk OSXButton" }

Rust trait Button { fn paint(&self); }

struct WinButton; impl Button for WinButton { fn paint(&self) { println!("Windows Button");

struct OsxButton; impl Button for OsxButton { fn paint(&self) { println!("OSX Button");

trait GuiFactory { fn create_button(&self) -> Box; }

struct WinFactory; impl GuiFactory for WinFactory { fn create_button(&self) -> Box { Box::new(WinButton)

struct OsxFactory; impl GuiFactory for OsxFactory { fn create_button(&self) -> Box { Box::new(OsxButton)

fn main() { let factory = WinFactory; let button = factory.create_button(); button.paint(); }

C# using System; using System.Collections.Generic;

namespace TheAbstractFactoryPattern { enum OS_TYPE

Windows, OsX

// Przykład GUIFactory

abstract class GUIFactory

/// /// getFactory returns concrete Factory, ///instead parameter abstract Factory can get OS_Type from outer method /// /// Operating System /// public static GUIFactory getFactory(OS_TYPE type)

switch (type)

case OS_TYPE.Windows: return new WinFactory();

case OS_TYPE.OsX: return new OSXFactory(); default: throw new NotImplementedException();

public abstract Button createButton();

class WinFactory : GUIFactory

public override Button createButton()

return new WinButton();

class OSXFactory : GUIFactory

public override Button createButton()

return new OSXButton();

abstract class Button

public abstract void paint();

class WinButton : Button

public override void paint()

Console.WriteLine("Przycisk WinButton");

class OSXButton : Button

public override void paint()

Console.WriteLine("Przycisk OSXButton");

public class Application

public static void Main(String[] args)

GUIFactory factory = GUIFactory.getFactory(OS_TYPE.Windows); Button button = factory.createButton(); button.paint(); Console.ReadLine();

// Wyświetlony zostanie tekst: // "Przycisk WinButton" // lub: // "Przycisk OSXButton"

C++ // source: factory.hpp #ifndef GUI_FACTORY_HPP_ #define GUI_FACTORY_HPP_

enum OSType { OS_Windows, OS_OSX, OS_Unknown

class Button;

class GUIFactory { public: static GUIFactory* getFactory(OSType type); virtual Button* createButton() = 0;

class OSXFactory : public GUIFactory { public: virtual Button* createButton();

class WindowsFactory : public GUIFactory { public: virtual Button* createButton();

class Button { public: virtual void paint() = 0;

class OSXButton : public Button { public: virtual void paint();

class WindowsButton : public Button { public: virtual void paint();

#endif // GUI_FACTORY_HPP_

// source: factory.cpp // #include "factory.hpp" #include

class NotImplementedException : public std::exception {};

GUIFactory* GUIFactory::getFactory(OSType type){ switch (type) { case OS_Windows: return new WindowsFactory(); case OS_OSX: return new OSXFactory(); default: throw NotImplementedException();

Button* OSXFactory::createButton() { return new OSXButton(); }

Button* WindowsFactory::createButton() { return new WindowsButton(); }

#include

void OSXButton::paint() { std::cout << "OSX Button" createButton();

button->paint();

delete button; delete factory; }