Absztrakt gyár (tervminta)
Az oldal jelenlegi verzióját még nem ellenőrizték tapasztalt közreműködők, és jelentősen eltérhet a 2018. március 2-án felülvizsgált
verziótól ; az ellenőrzések 25 szerkesztést igényelnek .
| Absztrakt gyár |
|---|
| absztrakt gyár |
| Típusú |
generáló |
| Célja |
Interfészt biztosít a kapcsolódó vagy egymástól függő objektumok családjainak létrehozásához anélkül, hogy megadná konkrét osztályaikat. |
| Szerkezet |
|
| esetekben érvényes |
- Amikor a programnak függetlennek kell lennie a folyamattól és a létrehozott új objektumok típusától.
- Amikor egymáshoz kapcsolódó objektumok családjait vagy csoportjait kell létrehozni, kizárva az ezekből a különböző halmazokból származó objektumok egyidejű használatának lehetőségét ugyanabban a kontextusban [1] .
|
| profik |
- elkülöníti az egyes osztályokat;
- leegyszerűsíti a termékcsaládok cseréjét;
- garantálja a termék kompatibilitását.
|
| Mínuszok |
- nehéz új típusú termékhez támogatást adni.
|
| Leírása: Tervezési minták |
Igen |
Az absztrakt gyár egy generatív tervezési minta , amely interfészt biztosít egymáshoz kapcsolódó vagy egymástól függő objektumok családjainak létrehozásához anélkül, hogy megadná konkrét osztályaikat. A mintát egy Factory absztrakt osztály létrehozásával valósítjuk meg, amely egy felület a rendszerkomponensek létrehozásához (például ablakfelülethez ablakokat és gombokat hozhat létre). Ezután olyan osztályokat írnak , amelyek megvalósítják ezt az interfészt [2] .
Időpont
Interfészt biztosít a kapcsolódó vagy egymástól függő objektumok családjainak létrehozásához anélkül, hogy megadná konkrét osztályaikat.
Megvalósítás
Előnyök
- elkülöníti az egyes osztályokat;
- leegyszerűsíti a termékcsaládok cseréjét;
- garantálja a termék kompatibilitását.
Hátrányok
- nehéz új típusú termékhez támogatást adni.
Alkalmazás
- A rendszer nem függhet attól, hogy a benne szereplő objektumokat hogyan készítik, szerelik össze és mutatják be.
- A gyűjteményben lévő kapcsolódó objektumokat együtt kell használni, és ezt a korlátozást érvényesíteni kell.
- A rendszert az alkotó objektumok valamelyik családjának kell konfigurálnia.
- Az objektumok könyvtárát kell biztosítani, amely csak az interfészeiket tárja fel, a megvalósításukat nem.
Példák
Swift példa
Swift forráskód
//: Játszótér - főnév: olyan hely, ahol az emberek játszhatnak
/// <summary>
/// Abstract factory class
/// </summary>
protokoll AbstractFactory {
func createProductA () -> AbstractProductA
func createProductB () -> AbstractProductB
}
/// <summary>
/// Gyári osztály #1
/// </summary>
class ConcreteFactory1 : AbstractFactory {
public func createProductA () -> AbstractProductA {
return ProductA1 ()
}
public func createProductB () -> AbstractProductB {
return ProductB1 ()
}
}
/// <summary>
/// Gyári osztály #2
/// </summary>
class ConcreteFactory2 : AbstractFactory {
public func createProductA () -> AbstractProductA {
return ProductA2 ()
}
public func createProductB () -> AbstractProductB {
return ProductB2 ()
}
}
/// <summary>
/// Absztrakt termékosztály A
/// </summary>
protokoll AbstractProductA {}
//
/// <summary>
/// B absztrakt termékosztály
/// </summary>
protokoll AbstractProductB {
func interact ( a : AbstractProductA )
}
/// <summary>
/// A típusú első termékosztály
/// </summary>
ProductA1 osztály : AbstractProductA {}
/// <summary>
/// B típusú első termékosztály
/// </summary>
class ProductB1 : AbstractProductB {
public func interact ( a : AbstractProductA ) {
print ( " \( type ( of : self )) interacts with \ ( típus ( of : a . self )) " )
}
}
/// <summary>
/// A típusú második termékosztály
/// </summary>
ProductA2 osztály : AbstractProductA {}
/// <summary>
/// B típusú második termékosztály
/// </summary>
class ProductB2 : AbstractProductB {
public func interact ( a : AbstractProductA ) {
print ( " \( type ( of : self )) interacts with \ ( típus ( of : a . self )) " )
}
}
/// <summary>
/// A kliens osztály, amelyben az objektumok közötti interakció megtörténik
/// </summary>
class Client {
private let _abstractProductA : AbstractProductA
private let _abstractProductB : AbstractProductB
// Constructor
public init ( gyári : AbstractFactory ) {
_abstractProductB = factory . CreateProductB ();
_abstractProductA = gyári . CreateProductA ();
}
public func run () {
_abstractProductB . interact ( a : _abstractProductA )
}
}
/// <summary>
/// Alkalmazás belépési pontja
/// </summary>
// Absztrakt gyár hívása #1
let factory1 = ConcreteFactory1 ()
let client1 = Ügyfél ( gyári : gyár1 )
client1 . futni ()
// A 2. absztrakt gyár hívása
let factory2 = ConcreteFactory2 ()
let client2 = Client ( gyári : factory2 )
client2 . futni ()
Példa a C#-ban [3]
Forráskód a
C Sharpban
a rendszer használatával ;
névtér DoFactory.GangOfFour.Abstract.Structural
{
class MainApp
{
/// <summary>
/// Alkalmazás belépési pont
/// </summary>
public static void Main ()
{
// Absztrakt gyári hívás #1
AbstractFactory factory1 = new ConcreteFactory1 ();
Kliens kliens1 = új kliens ( gyári1 );
kliens1 . futni ();
// Abstract factory #2 hívása
AbstractFactory factory2 = new ConcreteFactory2 ();
Kliens kliens2 = új kliens ( gyári2 );
kliens2 . futni ();
// Bemenetre vár
Konzol . ReadKey ();
}
}
/// <summary>
/// Abstract factory class
/// </summary>
abstract class AbstractFactory
{
public abstract AbstractProductA CreateProductA ();
public abstract AbstractProductB CreateProductB ();
}
/// <summary>
/// Gyári osztály #1
/// </summary>
class ConcreteFactory1 : AbstractFactory
{
public override AbstractProductA CreateProductA ()
{
return new ProductA1 ();
}
public override AbstractProductB CreateProductB ()
{
return new ProductB1 ();
}
}
/// <summary>
/// Gyári osztály #2
/// </summary>
class ConcreteFactory2 : AbstractFactory
{
public override AbstractProductA CreateProductA ()
{
return new ProductA2 ();
}
public override AbstractProductB CreateProductB ()
{
return new ProductB2 ();
}
}
/// <summary>
/// Absztrakt termékosztály A
/// </summary>
absztrakt osztály AbstractProductA
{
}
/// <summary>
/// B absztrakt termékosztály
/// </summary>
abstract class AbstractProductB
{
public abstract void Interact ( AbstractProductA a );
}
/// <summary>
/// Az A típusú első termékosztály
/// </summary>
Class ProductA1 : AbstractProductA
{
}
/// <summary>
/// B típusú első termékosztály
/// </summary>
class ProductB1 : AbstractProductB
{
public override void Interact ( AbstractProductA a )
{
Console . WriteLine ( ez . GetType (). Name +
" interacts with " + a . GetType (). Név );
}
}
/// <summary>
/// A típusú második termékosztály
/// </summary>
Class ProductA2 : AbstractProductA
{
}
/// <summary>
/// B típusú második termékosztály
/// </summary>
class ProductB2 : AbstractProductB
{
public override void Interact ( AbstractProductA a )
{
Console . WriteLine ( ez . GetType (). Name +
" interacts with " + a . GetType (). Név );
}
}
/// <summary>
/// A kliens osztály, amelyben az objektumok közötti interakció megtörténik
/// </summary>
class Client
{
private AbstractProductA _abstractProductA ;
private AbstractProductB _abstractProductB ;
// Constructor
public Client ( AbstractFactory factory )
{
_abstractProductB = factory . CreateProductB ();
_abstractProductA = gyári . CreateProductA ();
}
public void Futtatás ()
{
_abstractProductB . Interact ( _abstractProductA );
}
}
}
Java példa
Java forrás
public class AbstractFactoryExample {
public static void main ( String [ ] args ) {
AbstractFactory factory1 = new ConcreteFactory1 ();
Kliens kliens1 = új kliens ( gyári1 );
kliens1 . végrehajtani ();
AbstractFactory factory2 = new ConcreteFactory2 ();
Kliens kliens2 = új kliens ( gyári2 );
kliens2 . végrehajtani ();
}
}
class Client {
private AbstractProductA productA ;
privát AbsztraktTermékB termékB ;
Kliens ( AbstractFactory factory ) {
productA = gyár . CreateProductA ();
termékB = gyár . CreateProductB ();
}
void execute () {
productB . interakció ( termékA );
}
}
interface AbstractFactory {
AbstractProductA createProductA ();
AbstractProductB createProductB ();
}
interface AbstractProductA {
void interact ( AbstractProductB b );
}
interface AbstractProductB {
void interact ( AbstractProductA a );
}
class ConcreteFactory1 megvalósítja az AbstractFactory {
@Override
public AbstractProductA createProductA () {
return new ProductA1 ();
}
@A
publikus felülbírálása AbstractProductB createProductB () {
return new ProductB1 ();
}
}
class ConcreteFactory2 valósítja meg az AbstractFactory {
@Override
public AbstractProductA createProductA () {
return new ProductA2 ();
}
@A
public AbstractProductB createProductB () {
return new ProductB2 ();
}
}
osztály ProductA1 implementálja az AbstractProductA {
@A
public void interact ( AbstractProductB b ) {
System . ki . println ( ez . getClass (). getName () + " kölcsönhatásba lép a következővel: " + b . getClass (). getName ());
}
}
Class ProductB1 implementálja az AbstractProductB {
@A
public void interact felülbírálása ( AbstractProductA a ) {
Rendszer . ki . println ( ez . getClass (). getName () + " interacts with " + a . getClass (). getName ());
}
}
osztály ProductA2 implementálja az AbstractProductA {
@Override
public void interact ( AbstractProductB b ) {
System . ki . println ( ez . getClass (). getName () + " kölcsönhatásba lép a következővel: " + b . getClass (). getName ());
}
}
Class ProductB2 implementálja az AbstractProductB {
@A
public void interact felülbírálása ( AbstractProductA a ) {
Rendszer . ki . println ( ez . getClass (). getName () + " interacts with " + a . getClass (). getName ());
}
}
PHP5 példa
PHP5 forráskód
interface IHead
{
public function drawHead ( $x , $y );
}
class RedHead implements IHead
{
public function drawHead ( $x , $y ) {
echo 'A vörös fejed az x tengelyen =' . $x . ' és y tengely =' . $y . '</br>' . PHP_EOL ;
}
}
class WhiteHead implementálja az IHead
{
public function drawHead ( $x , $y ) {
echo 'A fehér fejed az x tengelyen = ' . $x . ' és y tengely =' . $y . '</br>' . PHP_EOL ;
}
}
interface IBody
{
public function drawBody ( $x , $y );
}
class RedBody implementálja az IBody-t
{
public function drawBody ( $x , $y ) {
echo 'Az Ön vörös teste az x tengelyen =' . $x . ' és y tengely =' . $y . '</br>' . PHP_EOL ;
}
}
class WhiteBody implementálja az IBody-t
{
public function drawBody ( $x , $y ) {
echo 'A fehér tested az x tengelyen =' . $x . ' és y tengely =' . $y . '</br>' . PHP_EOL ;
}
}
/**
* Interface ISnowman - ez absztrakt gyári
*/
interface ISnowman
{
public function drawHead ( $x , $y );
publikus függvény drawBody ( $x , $y );
}
/**
* Class WhiteSnowman - betongyár
*/
osztály WhiteSnowman implements ISnowman
{
protected $head ;
védett $test ;
public function __construct () {
$this -> head = new WhiteHead ();
$this -> body = new WhiteBody ();
}
public function drawHead ( $x , $y ) {
$this -> head -> drawHead ( $x , $y );
}
public function drawBody ( $x , $y ) {
$this -> body -> drawBody ( $x , $y );
}
}
/**
* Class RedSnowman - betongyár
*/
osztály RedSnowman implements ISnowman
{
protected $head ;
védett $test ;
public function __construct () {
$this -> head = new RedHead ();
$this -> body = új RedBody ();
}
public function drawHead ( $x , $y ) {
$this -> head -> drawHead ( $x , $y );
}
public function drawBody ( $x , $y ) {
$this -> body -> drawBody ( $x , $y );
}
}
function hóember ( ISnowman $hóember ) {
$hóember -> drawHead ( 1 , 1 );
$hóember -> drawBody ( 1 , 2 );
}
$typeSnowman = 'piros' ;
// kiválasztjuk a család típusát a kód elején
if ( $typeSnowman == 'red' )
$hóember = new RedSnowman ();
else
$hóember = új FehérHóember ();
hóember ( $hóember );
Python példa
Forráskód
Pythonban
abc importból ABCMeta , abstractmethod _
osztály Sör ( metaclass = ABCMeta ):
passz
osztály Snack ( metaosztály = ABCMeta ):
@abstractmethod
def interact ( self , beer : Beer ) -> None :
pass
osztály AbstractShop ( metaclass = ABCMeta ):
@abstractmethod
def buy_beer ( self ) -> Beer :
passz
@abstractmethod
def buy_snack ( self ) -> Snack :
passz
osztály Tuborg ( Beer ):
bérlet
osztály Staropramen ( Sör ):
bérlet
osztály földimogyoró ( Snack ):
def interact ( self , beer : Beer ) -> None :
print ( 'Megittunk egy üveg sört {} és megettük mogyoróval' . format (
sör . __class__ . __name__ ))
osztályú chips ( Snack ):
def interact ( self , beer : Beer ) -> None :
print ( 'Ittunk néhány sört {} és ettünk egy zacskó chipset' . format (
sör . __class__ . __name__ ))
osztályú ExpensiveShop ( AbstractShop ):
def buy_beer ( self ) -> Beer :
return Tuborg ()
def buy_snack ( self ) -> Snack :
return Mogyoró ()
osztályú CheapShop ( AbstractShop ):
def buy_beer ( self ) -> Beer :
vissza Staropramen ()
def buy_snack ( self ) -> Snack :
chipek visszaküldése ()
if __name__ == '__main__' :
drága_bolt = DrágaShop ( )
cheap_shop = OlcsóBolt ()
print ( 'OUTPUT:' )
sör = drága_bolt . vásárol_sört ()
snack = olcsó_bolt . buy_snack ()
snack . interact ( sör )
sör = olcsó_bolt . vásárol_sört ()
snack = drága_bolt . buy_snack ()
snack . interakció ( sör )
'''
KIMENET:
Ittunk néhány doboz Tuborg sört és ettünk egy zacskó chipset
Megittunk egy üveg Staropramen sört és megharaptuk mogyoróval
'''
Scala példa
Scala forráskód
abstract class AbstractTerrestrialAnimal {
def walk : String
}
absztrakt osztály _ _
def swim : húr
_
absztrakt osztály _ _
def getCity : String
def getTerrestrialAnimal : AbstractTerrestrialAnimal
def getWaterAnimal : AbstractWaterAnimal
}
osztály Wolverine extends AbstractTerrestrialAnimal {
override def walk : String = "Wolverine sétál"
}
class HoneyBadger extends AbstractTerrestrialAnimal {
override def walk : String = "Mézes borz sétál"
}
class Walrus extends AbstractWaterAnimal {
override def swim : String = "Rozmár úszik"
}
class SeaLion kiterjeszti AbstractWaterAnimal {
override def swim : String = "Oroszlánfóka úszik"
}
class MunichZoo kiterjeszti AbstractZoo {
def getCity felülírása : String = "München"
felülírás def getTerrestrialAnimal : AbstractTerrestrialAnimal = new Wolverine
def getWaterAnimal felülírása : AbstractWaterAnimal = új rozmár
}
class CapeTownZoo kiterjeszti AbstractZoo {
def getCity felülírása : String = "Fokváros"
def getTerrestrialAnimal felülírása : AbstractTerrestrialAnimal = új HoneyBadger
def getWaterAnimal felülírása : AbstractWaterAnimal = új SeaLion
}
object AbstractFactoryTest {
private def testZoo ( állatkert : AbstractZoo ): Unit = {
println ( s"Zoo of ${ zoo . getCity } :" )
println ( állatkert . getTerrestrialAnimal . walk )
println ( állatkert . getWaterAnimal . úszni )
}
def main ( args : Array [ String ]) Unit = {
testZoo ( new CapeTownZoo )
testZoo ( new MünchenZoo )
}
}
Menjen a példa
Forráskód a
Go- ban
csomag fő
import "fmt"
type Unit interface {
What () string
}
type Action interface {
What () string
}
type Place interface {
What () string
}
típus TransportFactory interfész {
MakeUnit () Unit
MakeAction () Action
MakePlace () Hely
}
típus Car struct {}
func ( self Car ) What () string {
return "car"
}
írja be a Ride struct {} karakterláncot
func ( self Ride ) What () string {
return "ride"
}
típusú útszerkezet { }
func ( self Road ) What () string {
return "road"
}
típus LandTransportFactory struct {}
func ( saját LandTransportFactory ) MakeUnit () Unit {
return & Car {}
}
func ( saját LandTransportFactory ) MakeAction () Action {
return & Ride {}
}
func ( saját LandTransportFactory ) MakePlace ( ) Place {
return & Road {}
}
típus Boat struct {}
func ( self Boat ) What () string {
return "boat"
}
vitorla szerkezet típusa {}
func ( self Sail ) What () string {
return "vitorla"
}
típus Sea struct {}
func ( self Sea ) What () string {
return "tenger"
}
típus SeaTransportFactory struct {}
func ( saját SeaTransportFactory ) MakeUnit ( ) Unit {
return & Boat {}
}
func ( saját SeaTransportFactory ) MakeAction ( ) Action {
return & Sail {}
}
func ( saját SeaTransportFactory ) MakePlace ( ) Place {
return & Sea {}
}
func action ( gyári TransportFactory ) {
unit := factory . MakeUnit ()
unit_action := gyári . MakeAction ()
hely := gyár . MakePlace ()
fmt . Printf ( "A %s %ss a %s felett.\n" ,
egység . Mit (), egység_akció . Mi (), hely . Mit ())
}
func main () {
action ( & LandTransportFactory {})
action ( & SeaTransportFactory {})
}
Következtetés
Az autó áthalad az úton.
A csónak a tenger felett vitorlázik.
Példa a Rubyban
Ruby forráskód
modul AbstractFactoryPattern
# Adjon interfészt kapcsolódó vagy objektumcsaládok létrehozásához anélkül, hogy megadná a konkrét osztályokat
# Abstract Factory
osztály WarriorFactory
def create_knight
raise NotImplementedError
end
def create_archer
raise NotImplementedError
end
end
# Concrete Factory
osztály OrcWarriorFactory < WarriorFactory
def create_knight
OrcKnight . új
vég
def create_archer
OrcArcher . új
vég
vége
# Concrete Factory
osztály ElfWarriorFactory < WarriorFactory
def create_knight
ElfKnight . új
vég
def create_archer
ElfArcher . új
vég
vége
# Absztrakt
termékosztály Knight
def ellenőrzi
magát . osztály . név . split ( '::' ) . utolsó
vég
vége
# Absztrakt
termékosztály Az Archer
ellenőrzi magát
. osztály . név . split ( '::' ) . utolsó vég vége
#
Termékosztály OrcKnight < Knight end
#
Termékosztály ElfKnight < Knight end
#
Termékosztály OrcArcher < Archer end
#
Termékosztály ElfArcher < Archer end
# Kliens
osztály Army
def inicializálás ( gyári )
@knights = []
3 . alkalommal { @lovagok << gyár . lovag létrehozása }
@íjászok = []
3 . alkalommal { @íjászok << gyár . create_archer }
end
def inspect
"Knights #{ @knights . map ( & : inspect ) } Archers #{ @archers . map ( & : inspect ) } "
end
end
def self . fuss
orkok = Army . new ( OrcWarriorFactory . new )
"Orcs army: # { orcs . inspect } "
manók = hadsereg . new ( ElfWarriorFactory . new )
felteszi az "Elves army: #{ elves . inspect } "
end
end end
AbstractFactoryPattern . fuss
# Ork hadsereg: Lovagok ["OrcKnight", "OrcKnight", "OrcKnight"] Íjászok ["OrcArcher", "OrcArcher", "OrcArcher"]
# Elfek hadsereg: Lovagok ["ElfKnight", "ElfKnight", "ElfKnight"] Íjászok ["ElfArcher", "ElfArcher", "ElfArcher"]
Irodalom
- E. Gamma, R. Helm, R. Johnson, J. Vlissides . Objektumorientált tervezés technikái. Tervezési minták = Design Patterns: Az újrafelhasználható objektum-orientált szoftver elemei. - Szentpétervár. : "Péter" , 2007. - S. 366. - ISBN 978-5-469-01136-1 . ( ISBN 5-272-00355-1 is )
Linkek
Jegyzetek
- ↑ Absztrakt gyári minta . Letöltve: 2013. június 14. Az eredetiből archiválva : 2013. június 14.. (határozatlan)
- ↑ Minták generálása: Absztrakt gyár . Letöltve: 2013. június 14. Az eredetiből archiválva : 2013. június 14.. (határozatlan)
- ↑ Abstract Factory .NET tervezési minta C# és VB nyelven - dofactory.com . www.dofactory.com Hozzáférés dátuma: 2016. március 3. Az eredetiből archiválva : 2016. március 3. (határozatlan)