รูปแบบการออกแบบโรงงาน

ไงเพื่อน! วันนี้เราจะมาศึกษารูปแบบการออกแบบกันต่อนะครับ ในบทเรียนนี้ เราจะพูดถึงโรงงาน เราจะหารือเกี่ยวกับปัญหาที่รูปแบบนี้แก้ไขได้ และดูตัวอย่างว่าโรงงานสามารถช่วยคุณเปิดร้านกาแฟได้อย่างไร นอกจากนี้ ฉันจะให้ 5 ขั้นตอนง่ายๆ ในการสร้างโรงงานแก่คุณ เพื่อให้แน่ใจว่าเราทุกคนอยู่ในช่วงความยาวคลื่นเดียวกัน และคุณจะเข้าใจแนวคิดนี้ได้อย่างรวดเร็ว คุณควรคุ้นเคยกับหัวข้อต่อไปนี้:

• มรดกใน Java
• การจำกัดและการขยายประเภทการอ้างอิงใน Java
• ปฏิสัมพันธ์ระหว่างคลาสและวัตถุต่างๆ

โรงงานคืออะไร?

รูปแบบการออกแบบจากโรงงานช่วยให้คุณควบคุมการสร้างวัตถุได้ กระบวนการสร้างวัตถุใหม่นั้นไม่ง่ายนัก แต่ก็ไม่ซับซ้อนจนเกินไป เราทุกคนรู้ว่าเราต้องการnewตัวดำเนินการเพื่อสร้างวัตถุใหม่ บางทีดูเหมือนว่าไม่มีอะไรจะควบคุมที่นี่ แต่นั่นไม่เป็นความจริง สมมติว่าแอปพลิเคชันของเรามีคลาสหนึ่งที่มีลูกหลานจำนวนมาก ความยากลำบากอาจเกิดขึ้นเมื่อจำเป็นต้องสร้างอินสแตนซ์ของคลาสเฉพาะโดยขึ้นอยู่กับเงื่อนไขบางประการ โรงงานเป็นรูปแบบการออกแบบที่ช่วยแก้ปัญหาในการสร้างวัตถุต่าง ๆ ขึ้นอยู่กับเงื่อนไขบางประการ เป็นอย่างไรสำหรับแนวคิดเชิงนามธรรม? สิ่งนี้จะชัดเจนและเฉพาะเจาะจงมากขึ้นเมื่อเราดูตัวอย่างด้านล่าง

มาเตรียมกาแฟประเภทต่างๆ กันเถอะ

สมมติว่าเราต้องการทำให้ร้านกาแฟเป็นแบบอัตโนมัติ เราต้องสอนโปรแกรมของเราถึงวิธีการชงกาแฟประเภทต่างๆ ในการทำเช่นนี้ เราจะสร้างคลาสกาแฟและคลาสอนุพันธ์สองสามคลาสเพื่อแสดงถึงประเภทของกาแฟที่เราจะเตรียม: อเมริกาโน คาปูชิโน เอสเพรสโซ และลาเต้ เริ่มต้นด้วยคลาสกาแฟทั่วไป:

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

ต่อไป เราจะสร้างคลาสย่อย:

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

ลูกค้าของเราสามารถสั่งกาแฟชนิดใดก็ได้ คำสั่งของพวกเขาจะต้องถูกส่งไปยังโปรแกรม ทำได้หลายวิธี เช่นStringใช้ แต่สิ่งenumที่ดีที่สุดสำหรับสิ่งนี้ เราจะสร้างenumและกำหนดฟิลด์ enum ที่ตรงกับประเภทของกาแฟที่สามารถสั่งซื้อได้:

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

ยอดเยี่ยม. ตอนนี้เรามาเขียนโค้ดสำหรับร้านกาแฟของเรากัน:

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

วิธี การorderCoffeeสามารถแบ่งออกเป็นสองส่วน:

1. การสร้างตัวอย่างเฉพาะของกาแฟในswitchแถลงการณ์ นี่คือสิ่งที่โรงงานทำ - สร้างประเภทเฉพาะขึ้นอยู่กับเงื่อนไข
2. การเตรียม — นี่คือการบด การต้ม และการเทลงในถ้วย

ต่อไปนี้คือสิ่งสำคัญที่ต้องทราบหากคุณจำเป็นต้องเปลี่ยนแปลงวิธีการในอนาคต:

1. ขั้นตอนที่เกี่ยวข้องในการเตรียม (การบด การชง และการเทใส่ถ้วย) จะไม่เปลี่ยนแปลง (อย่างน้อยเราก็คาดหวังในเรื่องนี้)
2. แต่ประเภทของกาแฟอาจมีการเปลี่ยนแปลง บางทีเราอาจจะเริ่มทำมอคค่า... แฟรปปุ... มอคค่าชี่... อะไรก็ตามที่เป็นกาแฟรูปแบบใหม่

เราค่อนข้างมั่นใจอยู่แล้วว่าในอนาคตเราจะต้องทำการเปลี่ยนแปลงswitchคำสั่ง ของวิธีการ อาจเป็นไปได้ว่าในร้านกาแฟของเราorderCoffeeวิธีการจะไม่ใช่ที่เดียวที่เราจะสร้างกาแฟประเภทต่างๆ ด้วยเหตุนี้จึงต้องทำการเปลี่ยนแปลงในหลายแห่ง คุณคงเข้าใจสิ่งที่ฉันได้รับแล้ว เราจำเป็นต้องปรับโครงสร้างใหม่ ย้ายบล็อกที่รับผิดชอบในการชงกาแฟไปยังชั้นเรียนแยกต่างหากด้วยเหตุผลสองประการ:

1. เราสามารถนำตรรกะการชงกาแฟไปใช้ซ้ำในที่อื่นได้
2. หากการแบ่งประเภทเปลี่ยนไป เราไม่ต้องแก้ไขรหัสทุกที่ที่สร้างกาแฟ แค่เปลี่ยนรหัสของเราในที่เดียวก็เพียงพอแล้ว

กล่าวอีกนัยหนึ่งถึงเวลาแล้วที่จะตั้งโรงงาน

ตั้งโรงงานแห่งแรกของเรา

ในการทำเช่นนี้ เราจะสร้างคลาสใหม่ที่จะรับผิดชอบในการสร้างอินสแตนซ์ที่จำเป็นของคลาสกาแฟเท่านั้น:

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

ยินดีด้วย! เราเพิ่งนำรูปแบบการออกแบบโรงงานมาใช้ในรูปแบบที่ง่ายที่สุด (เกือบ) มันอาจจะง่ายกว่านี้ถ้าเราทำให้createCoffeeเมธอดคงที่ แต่เราจะสูญเสียความสามารถสองประการ:

1. ความสามารถในการสืบทอดSimpleCoffeeFactoryและแทนที่createCoffeeเมธอด
2. ความสามารถในการเพิ่มการใช้งานโรงงานที่จำเป็นในชั้นเรียนของเรา

อย่างไรก็ตาม เมื่อพูดถึงการนำไปใช้งาน... เราต้องกลับไปที่ร้านกาแฟและเพิ่มโรงงานผลิตกาแฟของเรา

ต่อเติมโรงงานร้านกาแฟ

มาเขียนคลาสร้านกาแฟใหม่โดยใช้โรงงานกัน:

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

ยอดเยี่ยม. ตอนนี้เราจะให้คำอธิบายสั้น ๆ เกี่ยวกับโครงสร้างทั่วไปของรูปแบบการออกแบบโรงงาน

5 ขั้นตอนในการเปิดโรงงานของคุณเอง

ขั้นตอนที่ 1 โปรแกรมของคุณมีคลาสที่มีลูกหลานหลายคลาส ดังแผนภาพด้านล่าง: ขั้นตอนที่ 2 คุณสร้าง an enumด้วยฟิลด์สำหรับแต่ละคลาสย่อย:

enum CatType {
    LION,
    TIGER,
    FLUFFY
}

ขั้นตอนที่ 3 สร้างโรงงานของคุณ โทรCatFactoryเลย นี่คือรหัส:

class CatFactory {}

ขั้นตอนที่ 4 ในโรงงานของคุณ สร้างcreateCatวิธีการที่จะCatTypeโต้แย้ง นี่คือรหัส:

class CatFactory {
    public Cat createCat(CatType type) {

    }
}

ขั้นตอนที่ 5 ในเนื้อหาของเมธอด ให้เขียนswitchคำสั่งที่ระบุฟิลด์ enum และสร้างอินสแตนซ์ของคลาสที่สอดคล้องกับenumค่าที่ส่งผ่าน:

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

ตอนนี้คุณสามารถบริหารโรงงานได้เหมือนเจ้านาย :)

วิธีปฏิบัติ

การอ่านเป็นสิ่งที่ดี เขียนโค้ดได้ดียิ่งขึ้น หากชื่อของคุณมีจำนวนตัวอักษรเป็นเลขคู่ ให้ลองสร้างร้านพิชซ่าเสมือนจริงของคุณเอง หากชื่อของคุณมีตัวอักษรเป็นเลขคี่ ให้ลองสร้างซูชิบาร์เสมือนจริง หากคุณไม่มีชื่อคุณก็โชคดี วันนี้คุณสามารถผ่อนคลาย