Corak Kilang

Apakah corak Kilang?

Corak kilang ialah corak ciptaan yang mentakrifkan antara muka untuk mencipta objek, tetapi membenarkan subkelas menentukan kelas mana yang hendak digunakan. Corak kilang membolehkan kelas menangguhkan instantiasi kepada subkelas.

Bila nak guna?

Gunakan corak Kilang apabila anda mempunyai hierarki warisan "produk" dan mungkin menambah produk lain padanya. (Produk merujuk kepada objek yang dikembalikan melalui kaedah Kilang)

Masalah

Jika anda tidak tahu tentang Simple Factory, saya sarankan untuk mengkajinya terlebih dahulu. Terdapat banyak sumber tetapi blog saya ada di sini.

Sebelum ini, kami memperkenalkan kilang Simple dan kami boleh menghasilkan pelbagai jenis burger sambil mengasingkan penciptaan objek daripada kod pelanggan. Kedai burger kami telah berjaya memperoleh keuntungan dan kini kami mahu melancarkan kedai burger lain di kawasan berbeza.

kaedah orderBurger mentakrifkan proses untuk menjual burger untuk pelanggan.

// This is our Client
public class BurgerShop {

    public Burger orderBurger(BurgerType type) {
        // Factory is responsible for object creation
        Burger burger = SimpleBurgerFactory.createBurger(type);

        burger.prepareBun();
        burger.grillPatty();
        burger.addToppings();
        burger.wrap();

        return burger;
    }
}

Ini betul-betul baik, tetapi bagaimana jika kami melancarkan kedai burger lain? Katakan kami melancarkan "SeaSideBurgerShop", kami akan mencipta kelas SeaSideBurgerShop dan mentakrifkan orderBurger(). Masalahnya, mereka mungkin terlupa untuk menambah topping atau melakukan proses dalam susunan yang salah.

Kedai SeaSideBurger Bermasalah:

public class SeaSideBurgerShop {

    public Burger orderBurger(BurgerType type) {
        Burger burger = SimpleBurgerFactory.createBurger(type);

        burger.prepareBun();
        burger.wrap(); // Wrap a burger before grilling a patty??
        burger.grillPatty();
        // They forget to add toppings!!

        return burger;
    }
}

Untuk mengelakkan perkara ini, kami memerlukan rangka kerja untuk kedai burger kami yang menentukan mengikut urutan mereka melakukan proses dan perkara yang perlu dilakukan, namun masih membenarkan perkara itu kekal fleksibel.

Penyelesaian

1. Kedai Burger
   Kelas abstrak ini mempunyai dua kaedah, orderBurger() dan createBurger(). orderBurger() mentakrifkan perkara yang perlu dilakukan dan mengikut urutan proses itu harus dilakukan. Ini menghalang kedai burger melupakan beberapa proses atau mengacaukan pesanan proses. creatBurger() ialah kaedah abstrak yang membolehkan subkelas menentukan jenis burger yang akan dibuat.

2. Subkelas BurgerShop
   BurgerShops konkrit ini bertanggungjawab untuk mencipta burger konkrit. Setiap subkelas yang memanjangkan BurgerShop mentakrifkan pelaksanaannya sendiri untuk createBurger().

3. Burger
   Kelas abstrak ini menyediakan antara muka biasa antara semua burger dan mentakrifkan gelagat lalai.

4. Subkelas burger
   Berikut adalah produk konkrit kami. Mereka boleh melaksanakan tingkah laku tertentu dengan mengatasi kaedah selagi mereka melanjutkan kelas Burger.

Struktur

Pelaksanaan di Jawa

// This is our Client
public class BurgerShop {

    public Burger orderBurger(BurgerType type) {
        // Factory is responsible for object creation
        Burger burger = SimpleBurgerFactory.createBurger(type);

        burger.prepareBun();
        burger.grillPatty();
        burger.addToppings();
        burger.wrap();

        return burger;
    }
}

public class SeaSideBurgerShop {

    public Burger orderBurger(BurgerType type) {
        Burger burger = SimpleBurgerFactory.createBurger(type);

        burger.prepareBun();
        burger.wrap(); // Wrap a burger before grilling a patty??
        burger.grillPatty();
        // They forget to add toppings!!

        return burger;
    }
}

public enum BurgerType {
    BEEF,
    CHICKEN,
    FISH,
    VEGGIE
}

public abstract class Burger {
    public BurgerType type;
    public List<String> toppings = new ArrayList<>();

    public void prepareBun() {
        System.out.println("Preparing a bun");
    }

    public void grillPatty() {
        if (type == null) {
            throw new IllegalStateException("pattyType is undefined");
        }
        System.out.println("Grill a " + type + " patty");
    }

    public void addToppings() {
        for (String item : toppings) {
            System.out.println("Add " + item);
        }
    }

    public void wrap() {
        System.out.println("Wrap a burger up");
    }
}

public class CityStyleBeefBurger extends Burger {

    public CityStyleBeefBurger() {
        type = BurgerType.BEEF;
        List<String> items = List.of("lettuce", "pickle slices", "tomato slice", "BBQ sauce");
        toppings.addAll(items);
    }
}

public class CityStyleVeggieBurger extends Burger {

    public CityStyleVeggieBurger() {
        type = BurgerType.VEGGIE;
        List<String> items = List.of("smoked paprika", "garlic chips", "crushed walnuts", "veggie sauce");
        toppings.addAll(items);
    }
}

public class SeaSideStyleBeefBurger extends Burger {

    public SeaSideStyleBeefBurger() {
        type = BurgerType.BEEF;
        // Localized toppings for beef burger in seaside area
        List<String> items = List.of("lettuce", "pickle slices", "tomato slice", "salty sauce");
        toppings.addAll(items);
    }

    // Uses localized wrapping paper
    @Override
    public void wrap() {
        System.out.println("Wrap with a paper with nice sea scenery");
    }
}

public class SeaSideStyleFishBurger extends Burger {

    public SeaSideStyleFishBurger() {
        type = BurgerType.FISH;
        // Localized toppings for fish burger in seaside area
        List<String> items = List.of("red onion slices", "salty sauce", "fried shrimps");
        toppings.addAll(items);
    }

    // Uses localized wrapping paper
    @Override
    public void wrap() {
        System.out.println("Wrap with a paper with nice sea scenery");
    }
}

public abstract class BurgerShop {

    // This method provides a framework for each burger shops to order burgers
    public Burger orderBurger(BurgerType type) {
        Burger burger = createBurger(type);

        burger.prepareBun();
        burger.grillPatty();
        burger.addToppings();
        burger.wrap();

        return burger;
    }

    // This is our factory method. Subclasses will override this method,
    // provide their own implementation, determine which kind of burger gets made.
    public abstract Burger createBurger(BurgerType type);
}

Output:

public class CityBurgerShop extends BurgerShop {

    @Override
    public Burger createBurger(BurgerType type) {
        return switch (type) {
            case BEEF -> new CityStyleBeefBurger();
            case VEGGIE -> new CityStyleVeggieBurger();
            default -> throw new IllegalArgumentException("unknown city burger type");
        };
    }
}

Perangkap

• Komplek untuk dilaksanakan kerana kita perlu mencipta banyak kelas yang memanjangkan pencipta abstrak atau produk abstrak.

Perbandingan dengan kilang Simple

• Di kilang Simple, biasanya terdapat satu kelas kilang untuk menentukan jenis produk yang hendak dibuat, manakala corak Kilang mungkin memperkenalkan beberapa kilang.
• Kilang ringkas sering menggunakan kaedah statik untuk mencipta objek, yang menjadikannya mudah untuk dipanggil tetapi sukar untuk dilanjutkan. Sebaliknya, kaedah Kilang menggunakan kaedah abstrak dalam kelas super, yang bertindak sebagai antara muka untuk semua kilang dan subkelas akan menyediakan pelaksanaan konkrit untuk instantiasi objek.

---

Anda boleh menyemak semua pelaksanaan corak reka bentuk di sini.
Repositori GitHub

---

P.S.
Saya baru menulis blog teknologi, jika anda mempunyai nasihat untuk menambah baik penulisan saya, atau mempunyai sebarang perkara yang mengelirukan, sila tinggalkan komen!
Terima kasih kerana membaca :)

Atas ialah kandungan terperinci Corak Kilang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!