„Homlokzat programtervezési minta” változatai közötti eltérés
[ellenőrzött változat] | [ellenőrzött változat] |
a + ruby source tag, magyarázat |
|||
4. sor: | 4. sor: | ||
A homlokzat képes: |
A homlokzat képes: |
||
* egy [[programkönyvtár|szoftverkönyvtár]] használatát, megértését és tesztelését megkönnyíteni, habár a homlokzat kényelmes módszer általános feladatokra |
* egy [[programkönyvtár|szoftverkönyvtár]] használatát, megértését és tesztelését megkönnyíteni, habár a homlokzat kényelmes módszer általános feladatokra |
||
* egy könyvtárat olvashatóbbá tenni, ugyanazon okok miatt |
* egy könyvtárat olvashatóbbá tenni, ugyanazon okok miatt |
||
10. sor: | 11. sor: | ||
== Használata == |
== Használata == |
||
A Homlokzatot akkor használják, amikor valaki egy könnyebb vagy leegyszerűsített interfészt szeretne egy alatta lévő megvalósítási objektumhoz.<ref>{{cite journal |
A Homlokzatot akkor használják, amikor valaki egy könnyebb vagy leegyszerűsített interfészt szeretne egy alatta lévő megvalósítási objektumhoz.<ref>{{cite journal |
||
| last1 = Freeman |
| last1 = Freeman |
||
40. sor: | 42. sor: | ||
}}</ref> |
}}</ref> |
||
Máskor az [[Adapter programtervezési minta|adapter]] használható, ha a becsomagolónak figyelnie kell egy kitüntetett interfészre, és támogatnia kell a [[Többalakúság (számítástudomány)|többalakú]] viselkedést. A [[Díszítő programtervezési minta|díszítő]] lehetővé teszi, hogy hozzáadjunk, vagy módosítsuk egy interfész viselkedését futás időben. |
Máskor az [[Adapter programtervezési minta|adapter]] használható, ha a becsomagolónak figyelnie kell egy kitüntetett interfészre, és támogatnia kell a [[Többalakúság (számítástudomány)|többalakú]] viselkedést. A [[Díszítő programtervezési minta|díszítő]] lehetővé teszi, hogy hozzáadjunk, vagy módosítsuk egy interfész viselkedését futás időben. |
||
{| class="wikitable" |
{| class="wikitable" |
||
|- |
|- |
||
48. sor: | 51. sor: | ||
| [[Díszítő programtervezési minta|Díszítő]] || Dinamikusan felelősségeket ad hozzá az interfészhez becsomagolva az eredeti kódot |
| [[Díszítő programtervezési minta|Díszítő]] || Dinamikusan felelősségeket ad hozzá az interfészhez becsomagolva az eredeti kódot |
||
|- |
|- |
||
| Homlokzat|| Leegyszerűsített interfészt nyújt |
| Homlokzat || Leegyszerűsített interfészt nyújt |
||
|} |
|} |
||
Homlokzatot használnak, ha: |
Homlokzatot használnak, ha: |
||
*le kell egyszerűsíteni a hozzáférést egy komplex rendszerhez |
* le kell egyszerűsíteni a hozzáférést egy komplex rendszerhez |
||
*a rendszer nagyon bo9nyolult vagy nehezen elérhető |
* a rendszer nagyon bo9nyolult vagy nehezen elérhető |
||
*a rétegzett szoftver minden egyes rétegéhez kell belépési pont |
* a rétegzett szoftver minden egyes rétegéhez kell belépési pont |
||
*az absztrakciók és az implementációk között törékeny összefüggés van |
* az absztrakciók és az implementációk között törékeny összefüggés van |
||
== Struktúra == |
== Struktúra == |
||
* Csomagok (angolul ''packages''): Egymástól függetlenül tervezett programcsomagok, amiket egy egységes rendszerben kell használni. |
|||
⚫ | |||
⚫ | |||
[[Image:FacadeDesignPattern.png]] |
[[Image:FacadeDesignPattern.png]] |
||
; Homlokzat (angolul ''facade'') |
|||
⚫ | |||
; Ügyfelek (angolul ''clients'') |
|||
⚫ | |||
== Példák == |
== Példák == |
||
Absztrakt példa arra, hogy a kliens ("te") hogy tud használni egy homlokzat ("számítógép") segítségével egy bonyolult rendszert (belső számítógép részek, mint pl. a processzor v. a merevlemezek). |
Absztrakt példa arra, hogy a kliens ("te") hogy tud használni egy homlokzat ("számítógép") segítségével egy bonyolult rendszert (belső számítógép részek, mint pl. a processzor v. a merevlemezek). |
||
===Java=== |
=== Java === |
||
<source lang="java"> |
<source lang="java"> |
||
/* Bonyolult részek */ |
/* Bonyolult részek */ |
||
115. sor: | 122. sor: | ||
} |
} |
||
</source> |
</source> |
||
===Ruby=== |
=== Ruby === |
||
<source lang="ruby"> |
|||
# Bonyolult részek |
# Bonyolult részek |
||
class CPU |
class CPU |
||
def freeze; end |
def freeze; end |
||
132. sor: | 143. sor: | ||
# Homlokzat |
# Homlokzat |
||
class ComputerFacade |
class ComputerFacade |
||
149. sor: | 161. sor: | ||
# Kliens |
# Kliens |
||
computer_facade = ComputerFacade.new |
computer_facade = ComputerFacade.new |
||
computer_facade.start |
computer_facade.start |
||
</source> |
</source> |
||
===C#=== |
=== C# === |
||
További példák C#-ban: |
További példák C#-ban: |
||
====Absztrakt minta==== |
==== Absztrakt minta ==== |
||
<source lang=CSharp> |
<source lang=CSharp> |
||
namespace DesignPattern.Facade |
namespace DesignPattern.Facade |
||
220. sor: | 237. sor: | ||
==== Példa kód ==== |
==== Példa kód ==== |
||
<source lang=CSharp> |
<source lang=CSharp> |
||
namespace DesignPattern.Facade.Sample |
namespace DesignPattern.Facade.Sample |
||
304. sor: | 322. sor: | ||
</source> |
</source> |
||
==Jegyzetek== |
== Jegyzetek == |
||
{{jegyzetek}} |
{{jegyzetek}} |
||
==További információk== |
== További információk == |
||
{{wikibooks|Computer Science Design Patterns/Facade|Homlokzat programtervezési minta|en}} |
{{wikibooks|Computer Science Design Patterns/Facade|Homlokzat programtervezési minta|en}} |
||
* [http://c2.com/cgi/wiki?FacadePattern Description from the Portland Pattern Repository] |
* [http://c2.com/cgi/wiki?FacadePattern Description from the Portland Pattern Repository] |
||
==Fordítás== |
== Fordítás == |
||
{{fordítás|en|Facade pattern}} |
{{fordítás|en|Facade pattern}} |
||
A lap 2017. június 15., 11:46-kori változata
A homlokzat programtervezési minta az objektumorientált programozásban egy gyakran használt programtervezési minta. Az elnevezés a építészetbeli homlokzat analógiáján alapul.
A homlokzat egy objektum, amely egy leegyszerűsített interfészt biztosít nagyobb kódrészhez, mint pl. egy osztálykönyvtár.
A homlokzat képes:
- egy szoftverkönyvtár használatát, megértését és tesztelését megkönnyíteni, habár a homlokzat kényelmes módszer általános feladatokra
- egy könyvtárat olvashatóbbá tenni, ugyanazon okok miatt
- csökkenteni a külső kód függőségeit a belső könyvtári munkáktól, habár a legtöbb kód használja a homlokzatot, amely nagyobb rugalmasságot biztosít a rendszer fejlesztésekor
- becsomagolja a gyengén tervezett APIk gyűjteményét egy leegyszerűsített jól tervezett API-ba (feladatonként szükséges módon)
Használata
A Homlokzatot akkor használják, amikor valaki egy könnyebb vagy leegyszerűsített interfészt szeretne egy alatta lévő megvalósítási objektumhoz.[1] Máskor az adapter használható, ha a becsomagolónak figyelnie kell egy kitüntetett interfészre, és támogatnia kell a többalakú viselkedést. A díszítő lehetővé teszi, hogy hozzáadjunk, vagy módosítsuk egy interfész viselkedését futás időben.
Minta | Leírás |
---|---|
Illesztő | Egy interfészt egy másikba konvertál, azért, hogy az megfeleljen az ügyfél elvárásainak |
Díszítő | Dinamikusan felelősségeket ad hozzá az interfészhez becsomagolva az eredeti kódot |
Homlokzat | Leegyszerűsített interfészt nyújt |
Homlokzatot használnak, ha:
- le kell egyszerűsíteni a hozzáférést egy komplex rendszerhez
- a rendszer nagyon bo9nyolult vagy nehezen elérhető
- a rétegzett szoftver minden egyes rétegéhez kell belépési pont
- az absztrakciók és az implementációk között törékeny összefüggés van
Struktúra
- Csomagok (angolul packages): Egymástól függetlenül tervezett programcsomagok, amiket egy egységes rendszerben kell használni.
- Homlokzat (angolul facade): A homlokzat osztály az 1-es, 2-es és 3-as csomagok egy absztrakcióját nyújtja, és elválasztja ezeket az alkalmazás többi részéből.
- Ügyfelek (angolul clients): Az objektumok a Homlokzat mintát használják az erőforrások a csomagokból való eléréséhez.
Példák
Absztrakt példa arra, hogy a kliens ("te") hogy tud használni egy homlokzat ("számítógép") segítségével egy bonyolult rendszert (belső számítógép részek, mint pl. a processzor v. a merevlemezek).
Java
/* Bonyolult részek */
class CPU {
public void freeze() { ... }
public void jump(long position) { ... }
public void execute() { ... }
}
class Memory {
public void load(long position, byte[] data) { ... }
}
class HardDrive {
public byte[] read(long lba, int size) { ... }
}
/* Homlokzat */
class Computer {
private CPU processor;
private Memory ram;
private HardDrive hd;
public Computer() {
this.processor = new CPU();
this.ram = new Memory();
this.hd = new HardDrive();
}
public void start() {
processor.freeze();
ram.load(BOOT_ADDRESS, hd.read(BOOT_SECTOR, SECTOR_SIZE));
processor.jump(BOOT_ADDRESS);
processor.execute();
}
}
/* Ügyfél */
class You {
public static void main(String[] args) {
Computer facade = new Computer();
facade.start();
}
}
Ruby
# Bonyolult részek
class CPU
def freeze; end
def jump(position); end
def execute; end
end
class Memory
def load(position, data); end
end
class HardDrive
def read(lba, size); end
end
# Homlokzat
class ComputerFacade
def initialize
@processor = CPU.new
@ram = Memory.new
@hd = HardDrive.new
end
def start
@processor.freeze
@ram.load(BOOT_ADDRESS, @hd.read(BOOT_SECTOR, SECTOR_SIZE))
@processor.jump(BOOT_ADDRESS)
@processor.execute
end
end
# Kliens
computer_facade = ComputerFacade.new
computer_facade.start
C#
További példák C#-ban:
Absztrakt minta
namespace DesignPattern.Facade
{
class SubsystemA
{
public string OperationA1()
{
return "Subsystem A, Method A1\n";
}
public string OperationA2()
{
return "Subsystem A, Method A2\n";
}
}
class SubsystemB
{
public string OperationB1()
{
return "Subsystem B, Method B1\n";
}
public string OperationB2()
{
return "Subsystem B, Method B2\n";
}
}
class SubsystemC
{
public string OperationC1()
{
return "Subsystem C, Method C1\n";
}
public string OperationC2()
{
return "Subsystem C, Method C2\n";
}
}
public class Facade
{
private readonly SubsystemA a = new SubsystemA();
private readonly SubsystemB b = new SubsystemB();
private readonly SubsystemC c = new SubsystemC();
public void Operation1()
{
Console.WriteLine("Operation 1\n" +
a.OperationA1() +
b.OperationB1() +
c.OperationC1());
}
public void Operation2()
{
Console.WriteLine("Operation 2\n" +
a.OperationA2() +
b.OperationB2() +
c.OperationC2());
}
}
}
Példa kód
namespace DesignPattern.Facade.Sample
{
// The 'Subsystem ClassA' class
class CarModel
{
public void SetModel()
{
Console.WriteLine(" CarModel - SetModel");
}
}
/// <summary>
/// The 'Subsystem ClassB' class
/// </summary>
class CarEngine
{
public void SetEngine()
{
Console.WriteLine(" CarEngine - SetEngine");
}
}
// The 'Subsystem ClassC' class
class CarBody
{
public void SetBody()
{
Console.WriteLine(" CarBody - SetBody");
}
}
// The 'Subsystem ClassD' class
class CarAccessories
{
public void SetAccessories()
{
Console.WriteLine(" CarAccessories - SetAccessories");
}
}
// The 'Facade' class
public class CarFacade
{
private readonly CarAccessories accessories;
private readonly CarBody body;
private readonly CarEngine engine;
private readonly CarModel model;
public CarFacade()
{
accessories = new CarAccessories();
body = new CarBody();
engine = new CarEngine();
model = new CarModel();
}
public void CreateCompleteCar()
{
Console.WriteLine("******** Creating a Car **********");
model.SetModel();
engine.SetEngine();
body.SetBody();
accessories.SetAccessories();
Console.WriteLine("******** Car creation is completed. **********");
}
}
// Facade pattern demo
class Program
{
static void Main(string[] args)
{
var facade = new CarFacade();
facade.CreateCompleteCar();
Console.ReadKey();
}
}
}
Jegyzetek
- ↑ (2004) „Head First Design Patterns” (paperback) 1, 243, 252, 258, 260. o, Kiadó: O'Reilly. (Hozzáférés: 2012. július 2.)
További információk
Fordítás
Ez a szócikk részben vagy egészben a Facade pattern című angol Wikipédia-szócikk fordításán alapul. Az eredeti cikk szerkesztőit annak laptörténete sorolja fel. Ez a jelzés csupán a megfogalmazás eredetét és a szerzői jogokat jelzi, nem szolgál a cikkben szereplő információk forrásmegjelöléseként.