„Homlokzat programtervezési minta” változatai közötti eltérés

A Wikipédiából, a szabad enciklopédiából
[ellenőrzött változat][ellenőrzött változat]
Tartalom törölve Tartalom hozzáadva
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.
* 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.

[[Image:FacadeDesignPattern.png]]
[[Image:FacadeDesignPattern.png]]
; 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 ==
== 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

  1. (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

Az angol Wikikönyvekben
további információk található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.