Gyári tervezési minta

Szia barátom! Ma folytatjuk a tervezési minták tanulmányozását. Ebben a leckében a gyárakról fogunk beszélni. Megvitatjuk azt a problémát, amelyet ez a minta megold, és megnézünk egy példát arra, hogyan segíthet egy gyár kávézó megnyitásában. Ezenkívül adok 5 egyszerű lépést a gyár létrehozásához. Ahhoz, hogy megbizonyosodjon arról, hogy mindannyian egy hullámhosszon vagyunk, és gyorsan megértheti ezt a fogalmat, ismernie kell a következő témákat:

• Öröklés Java nyelven
• Referenciatípusok szűkítése és szélesítése Java nyelven
• Kölcsönhatás a különböző osztályok és objektumok között.

Mi az a gyár?

A gyári tervezési minta lehetővé teszi az objektumok létrehozásának vezérlését. Egy új objektum létrehozásának folyamata nem túl egyszerű, de nem is túl bonyolult. Mindannyian tudjuk, hogy szükségünk van az newoperátorra egy új objektum létrehozásához. Talán úgy tűnik, hogy itt nincs mit ellenőrizni, de ez nem igaz. Tegyük fel, hogy az alkalmazásunknak van egy bizonyos osztálya, amelynek sok leszármazottja van. Nehézségek adódhatnak, ha bizonyos feltételektől függően egy adott osztály példányát kell létrehozni. A gyár olyan tervezési minta, amely segít megoldani a különböző objektumok létrehozásának problémáját bizonyos feltételektől függően. Hogy szól ez egy elvont fogalomhoz? Ez világosabb és pontosabb lesz, ha megnézzük az alábbi példát.

Készítsünk különféle kávéfajtákat

Tegyük fel, hogy egy kávézót szeretnénk automatizálni. Meg kell tanítanunk a programunkat, hogyan készítsünk különböző kávéfajtákat. Ehhez létrehozunk egy kávéosztályt és néhány származékos osztályt, amelyek az általunk elkészített kávéfajtákat képviselik: Americano, cappuccino, espresso és latte. Kezdjük egy általános kávéórával:

public class Coffee {
    public void grindCoffee(){
        // Grind the coffee
    }
    public void makeCoffee(){
        // Brew the coffee
    }
    public void pourIntoCup(){
        // Pour into a cup
    }
}

Ezután létrehozzuk a gyermekosztályait:

public class Americano extends Coffee {}
public class Cappuccino extends Coffee {}
public class CaffeLatte extends Coffee {}
public class Espresso extends Coffee {}

Ügyfeleink bármilyen típusú kávét rendelhetnek. Megrendeléseiket át kell adni a programnak. Ez sokféleképpen megtehető, például a használatával String. De enumerre a legjobb. Létrehozunk enumés meghatározunk egy enum mezőket, amelyek megfelelnek a rendelhető kávéfajtáknak:

public enum CoffeeType {
    ESPRESSO,
    AMERICANO,
    CAFFE_LATTE,
    CAPPUCCINO
}

Nagy. Most írjuk meg kávézónk kódját:

public class CoffeeShop {
    
    public Coffee orderCoffee(CoffeeType type) {
        Coffee coffee = null;
        
        switch (type) {
            case AMERICANO:
                coffee = new Americano();
                break;
            case ESPRESSO:
                coffee = new Espresso();
                break;
            case CAPPUCCINO:
                coffee = new Cappucсino();
                break;
            case CAFFE_LATTE:
                coffee = new CaffeLatte();
                break;
        }

        coffee.grindCoffee();
        coffee.makeCoffee();
        coffee.pourIntoCup();

        System.out.println("Here's your coffee! Thanks! Come again!");
        return coffee;
    }
}

A orderCoffeemódszer két részre osztható:

1. Egy adott kávépéldány létrehozása egy nyilatkozatban switch. Itt a gyár azt teszi, amit – a körülményektől függően hoz létre egy adott típust.
2. Elkészítés - ez az őrlés, a főzés és a csészébe öntés.

A következőket érdemes tudni, ha a jövőben módosítania kell a módszert:

1. Magának az előkészítésnek a lépései (darálás, főzés, csészébe öntés) változatlanok maradnak (legalábbis ezzel számolunk).
2. De a kávéválaszték változhat. Talán elkezdünk mokát főzni... Frappu... Mochacci... Mindegy, egy újfajta kávé.

Már most eléggé biztosak lehetünk abban, hogy a jövőben változtatnunk kell a módszer kijelentésén switch. Az is előfordulhat, hogy kávézónkban orderCoffeenem a módszer lesz az egyetlen hely, ahol különféle kávéfajtákat készítünk. Emiatt több helyen is változtatásokat kell végrehajtani. Valószínűleg már érted, mire célzok. Refaktorizálnunk kell. Két okból helyezze át a kávékészítésért felelős blokkot egy külön osztályba:

1. A kávéfőzési logikát más helyeken is felhasználhatjuk.
2. Ha a választék megváltozik, nem kell mindenhol módosítanunk a kódot, ahol kávét készítenek. Elég lesz a kódunkat egyetlen helyen megváltoztatni.

Más szóval, eljött az ideje egy gyár felállításának.

Első gyárunk felállítása

Ehhez létrehozunk egy új osztályt, amely csak a kávéosztályok szükséges példányainak létrehozásáért lesz felelős:

public class SimpleCoffeeFactory {
    public Coffee createCoffee(CoffeeType type) {
        Coffee coffee = null;

        switch (type) {
            case AMERICANO:
                coffee = new Americano();
                break;
            case ESPRESSO:
                coffee = new Espresso();
                break;
            case CAPPUCCINO:
                coffee = new Cappucino();
                break;
            case CAFFE_LATTE:
                coffee = new CaffeLatte();
                break;
        }
        
        return coffee;
    }
}

Gratulálunk! Most valósítottuk meg a gyári tervezési mintát a legegyszerűbb formájában (majdnem). Még egyszerűbb is lehetett volna, ha createCoffeestatikussá tesszük a módszert. De akkor elveszítenénk két képességünket:

1. SimpleCoffeeFactoryA módszer öröklésének és felülbírálásának képessége createCoffee.
2. Lehetőség a szükséges gyári megvalósítás hozzáadására az osztályainkhoz.

Egyébként, ha már a megvalósításról beszélünk... Vissza kell térnünk a kávézóba, és hozzá kell adni a kávéfőzőt.

Gyár hozzáadása a kávézóhoz

Írjuk át a kávézó osztályát egy gyár segítségével:

public class CoffeeShop {

    private final SimpleCoffeeFactory coffeeFactory;

    public CoffeeShop(SimpleCoffeeFactory coffeeFactory) {
        this.coffeeFactory = coffeeFactory;
    }

    public Coffee orderCoffee(CoffeeType type) {
        Coffee coffee = coffeeFactory.createCoffee(type);
        coffee.grindCoffee();
        coffee.makeCoffee();
        coffee.pourIntoCup();

        System.out.println("Here's your coffee! Thanks! Come again!");
        return coffee;
    }
}

Kiváló. Most egy tömör leírást adunk a gyári tervezési minta általános felépítéséről.

5 lépés a saját gyár megnyitásához

1. lépés. A programodnak van egy osztálya, több leszármazottjával, ahogy az alábbi ábrán látható: 2. lépés: Létrehozol egy enummezőt minden gyermekosztályhoz:

    enum CatType {
        LION,
        TIGER,
        FLUFFY
    }

3. lépés: Építse fel gyárát. Hívd CatFactory. Íme a kód:

class CatFactory {}

4. lépés: A gyárában hozzon létre egy argumentumot createCathasználó metódust CatType. Íme a kód:

    class CatFactory {
        public Cat createCat(CatType type) {
            
        }
    }

5. lépés: A metódus törzsébe írjon egy switchutasítást, amely felsorolja az enum mezőket, és létrehozza az osztály egy példányát, amely megfelel az átadott enumértéknek:

class CatFactory {
        public Cat createCat(CatType type) {
            Cat cat = null;
            
            switch (type) {
                case LION:
                    cat =  new Fluffy();
                    break;
                case TIGER:
                    cat = new Tiger();
                    break;
                case FLUFFY:
                    cat =  new Lion();
                    break;
            }
            
            return cat;
        }
    }

Most már főnökként irányíthat egy gyárat. :)

Hogyan gyakoroljunk

Olvasni jó, kódot írni még jobb. Ha a neve páros számú betűből áll, próbálja meg létrehozni saját virtuális pizzériáját. Ha a neve páratlan számú betűből áll, próbáljon meg létrehozni egy virtuális sushi bárt. Ha nincs neved, szerencséd van. Ma lazíthatsz.