Pattern ng disenyo ng pabrika

Kamusta, Kaibigan! Ngayon ay patuloy nating pag-aaralan ang mga pattern ng disenyo. Sa araling ito, pag-uusapan natin ang tungkol sa mga pabrika. Tatalakayin natin ang problemang nalulutas ng pattern na ito at titingnan ang isang halimbawa kung paano makakatulong sa iyo ang isang pabrika na magbukas ng coffee shop. Bilang karagdagan, bibigyan kita ng 5 simpleng hakbang upang lumikha ng isang pabrika. Upang matiyak na lahat tayo ay nasa parehong wavelength at mabilis mong mauunawaan ang konseptong ito, dapat ay pamilyar ka sa mga sumusunod na paksa:

• Mana sa Java
• Pagpapaliit at pagpapalawak ng mga uri ng sanggunian sa Java
• Pakikipag-ugnayan sa pagitan ng iba't ibang klase at bagay.

Ano ang pabrika?

Hinahayaan ka ng pattern ng disenyo ng pabrika na kontrolin ang paglikha ng mga bagay. Ang proseso ng paglikha ng isang bagong bagay ay hindi sobrang simple, ngunit hindi rin ito masyadong kumplikado. Alam nating lahat na kailangan natin ang newoperator upang lumikha ng isang bagong bagay. Marahil ay tila walang kontrol dito, ngunit hindi iyon totoo. Ipagpalagay na ang aming aplikasyon ay may isang tiyak na klase na may maraming mga inapo. Ang mga paghihirap ay maaaring lumitaw kapag kinakailangan upang lumikha ng isang halimbawa ng isang partikular na klase depende sa ilang mga kundisyon. Ang pabrika ay isang pattern ng disenyo na tumutulong sa paglutas ng problema sa paglikha ng iba't ibang mga bagay depende sa ilang mga kundisyon. Paano iyon para sa isang abstract na konsepto? Ito ay magiging mas malinaw at mas tiyak kapag titingnan natin ang halimbawa sa ibaba.

Maghanda tayo ng iba't ibang uri ng kape

Ipagpalagay na gusto nating i-automate ang isang coffee shop. Kailangan nating ituro sa ating programa kung paano gumawa ng iba't ibang uri ng kape. Para magawa ito, gagawa kami ng klase ng kape at ilang derivative na klase para kumatawan sa mga uri ng kape na ihahanda namin: Americano, cappuccino, espresso, at latte. Magsimula tayo sa isang pangkalahatang klase ng kape:

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

Susunod, gagawa kami ng mga child class nito:

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

Ang aming mga customer ay maaaring mag-order ng anumang uri ng kape. Ang kanilang mga order ay kailangang maipasa sa programa. Magagawa ito sa maraming paraan, halimbawa, gamit ang String. Ngunit ang isang enumay pinakamahusay para dito. Gagawa kami ng enumat tutukuyin ang mga field ng enum na tumutugma sa mga uri ng kape na maaaring i-order:

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

Malaki. Ngayon isulat natin ang code para sa aming coffee shop:

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;
    }
}

Ang orderCoffeepamamaraan ay maaaring nahahati sa dalawang bahagi:

1. Paglikha ng isang partikular na halimbawa ng kape sa isang switchpahayag. Dito ginagawa ng isang pabrika ang ginagawa nito — lumikha ng isang partikular na uri depende sa mga kundisyon.
2. Paghahanda - ito ay ang paggiling, paggawa ng serbesa, at pagbuhos sa isang tasa.

Narito ang mahalagang malaman kung kailangan mong gumawa ng mga pagbabago sa pamamaraan sa hinaharap:

1. Ang mga hakbang na kasangkot sa paghahanda mismo (paggiling, paggawa ng serbesa, at pagbuhos sa isang tasa) ay mananatiling hindi magbabago (kahit na tayo ay umaasa dito).
2. Ngunit ang assortment ng mga kape ay maaaring magbago. Siguro magsisimula na tayong gumawa ng mocha... Frappu... Mochacci... Whatever, a new kind of coffee.

Maaari na tayong maging medyo kumpiyansa na sa hinaharap ay kailangan nating gumawa ng mga pagbabago sa switchpahayag ng pamamaraan. Posible rin na sa aming coffee shop ang orderCoffeepamamaraan ay hindi lamang ang lugar kung saan kami ay lilikha ng iba't ibang uri ng kape. Bilang resulta, ang mga pagbabago ay kailangang gawin sa ilang mga lugar. Malamang naiintindihan mo na kung ano ang kinukuha ko. Kailangan nating mag-refactor. Ilipat ang bloke na responsable sa paggawa ng kape sa isang hiwalay na klase para sa dalawang dahilan:

1. Maaari naming muling gamitin ang lohika sa paggawa ng kape sa ibang mga lugar.
2. Kung magbabago ang assortment, hindi namin kailangang i-edit ang code saanman nagagawa ang kape. Ito ay sapat na upang baguhin ang aming code sa isang lugar lamang.

Sa madaling salita, oras na para magtayo ng pabrika.

Pag-set up ng aming unang pabrika

Para magawa ito, gagawa kami ng bagong klase na magiging responsable lang sa paggawa ng mga kinakailangang pagkakataon ng mga klase ng kape:

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;
    }
}

Binabati kita! Ipinatupad lang namin ang pattern ng disenyo ng pabrika sa pinakasimpleng anyo nito (halos). Ito ay maaaring maging mas simple kung ginawa naming createCoffeestatic ang pamamaraan. Ngunit pagkatapos ay mawawalan tayo ng dalawang kakayahan:

1. Ang kakayahang magmana SimpleCoffeeFactoryat mag-override sa createCoffeepamamaraan.
2. Ang kakayahang magdagdag ng kinakailangang pagpapatupad ng pabrika sa aming mga klase.

By the way, speaking of implementation... Kailangan nating bumalik sa coffee shop at idagdag ang coffee-making factory natin.

Pagdaragdag ng isang pabrika sa coffee shop

Isulat muli natin ang klase ng coffee shop gamit ang isang pabrika:

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;
    }
}

Magaling. Ngayon ay magbibigay kami ng isang maigsi na paglalarawan ng pangkalahatang istraktura ng pattern ng disenyo ng pabrika.

5 hakbang sa pagbubukas ng sarili mong pabrika

Hakbang 1. Ang iyong programa ay may isang klase na may ilang mga inapo, tulad ng sa diagram sa ibaba: Hakbang 2. Gumawa ka ng isang enummay field para sa bawat klase ng bata:

    enum CatType {
        LION,
        TIGER,
        FLUFFY
    }

Hakbang 3. Buuin ang iyong pabrika. Tawagan ito CatFactory. Narito ang code:

class CatFactory {}

Hakbang 4. Sa iyong pabrika, gumawa ng createCatparaan na nangangailangan ng CatTypeargumento. Narito ang code:

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

Hakbang 5. Sa katawan ng pamamaraan, sumulat ng isang switchpahayag na nagsasaad ng mga enum na field at lumilikha ng isang instance ng klase na tumutugma sa naipasa na enumhalaga:

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;
        }
    }

Ngayon ay maaari kang magpatakbo ng isang pabrika tulad ng isang boss. :)

Paano magsanay

Ang pagbabasa ay mabuti, ang pagsulat ng code ay mas mahusay. Kung ang iyong pangalan ay may pantay na bilang ng mga titik, subukang gumawa ng sarili mong virtual pizzeria. Kung ang iyong pangalan ay may kakaibang bilang ng mga titik, subukang gumawa ng virtual na sushi bar. Kung wala kang pangalan, maswerte ka. Ngayon ay maaari kang magpahinga.