Corak Reka Bentuk Kilang Abstrak

Corak reka bentuk kaedah kilang abstrak :- pada asasnya ia adalah corak di dalam corak ia adalah corak reka bentuk ciptaan yang diperlukan untuk mencipta objek yang tergolong dalam keluarga objek yang serupa dengan cara kami mempunyai reka bentuk kilang corak di mana kami mencipta objek yang mempunyai jenis yang serupa di sini kami menggunakan kilang kilang untuk mencipta objek yang tergolong dalam keluarga objek serupa.

Perbezaan corak reka bentuk kilang dan kilang abstrak

Corak Kilang Abstrak adalah serupa dengan Corak Kaedah Kilang, tetapi dengan satu lapisan tambahan. Dalam Kilang Abstrak, terdapat antara muka pusat (atau "kilang") yang mentakrifkan kaedah untuk membuat sekumpulan objek berkaitan (seperti butang atau kotak pilihan).

Setiap kelas Kilang Konkrit menentukan kilang tertentu (contohnya, satu untuk Windows atau Mac) akan digunakan untuk mencipta objek sebenar. Logik untuk mencipta objek akhir (seperti butang Mac atau kotak semak Windows) kemudiannya dilaksanakan dalam kelas Produk Konkrit ini.

Ringkasnya:

1. Kilang Abstrak mentakrifkan kaedah untuk mencipta keluarga objek.
2. Kilang Konkrit menentukan kilang tertentu yang hendak digunakan berdasarkan beberapa logik.
3. Produk Konkrit (objek sebenar) dicipta berdasarkan logik di kilang-kilang ini.

Corak ini membantu mencipta objek berkaitan tanpa menggandingkan kod dengan ketat pada pelaksanaan tertentu.

Rajah Kelas corak reka bentuk kilang abstrak

        +----------------------+
        |   AbstractFactory     | <------------------------------+
        |---------------------- |                                  |
        | + createProductA()    |                                  |
        | + createProductB()    |                                  |
        +----------------------+                                   |
                  ^                                                |
                  |                                                |
   +-------------------------+             +-------------------------+
   |     ConcreteFactory1     |             |     ConcreteFactory2     |
   |------------------------- |             |-------------------------|
   | + createProductA()       |             | + createProductA()       |
   | + createProductB()       |             | + createProductB()       |
   +-------------------------+             +-------------------------+
            |                                       |
            |                                       |
    +---------------+                      +---------------+
    |   ProductA1   |                      |   ProductA2   |
    +---------------+                      +---------------+
    +---------------+                      +---------------+
    |   ProductB1   |                      |   ProductB2   |
    +---------------+                      +---------------+

Analogi untuk memahami corak reka bentuk kilang abstrak: Pengeluar Telefon Pintar

Bayangkan syarikat telefon pintar yang menawarkan dua barisan produk: Android dan iPhone. Kedua-dua talian termasuk Telefon dan Pengecas, tetapi model khusus untuk setiap talian berbeza.

Sebuah syarikat telefon pintar membuat dua barisan produk: Android dan iPhone, masing-masing mempunyai Telefon dan Pengecas.

• Kilang Abstrak: Anggap ia sebagai pelan tindakan yang mentakrifkan produk (Telefon dan Pengecas) yang perlu dibuat.
• Kilang Konkrit: Ini seperti jabatan Android dan iPhone, bertanggungjawab untuk mencipta produk tertentu berdasarkan baris yang dipilih (Android atau iPhone).
• Produk Konkrit: Item sebenar (Telefon Android, Pengecas Android, iPhone, Pengecas iPhone) yang dibuat oleh jabatan.
• Pelanggan: Anda, sebagai pelanggan, memilih antara Android atau iPhone dan produk yang sesuai dicipta untuk anda tanpa perlu mengetahui cara ia dibina. Corak ini memastikan produk yang serasi (Telefon dan Pengecas) dicipta bersama tanpa mendedahkan logik penciptaan dalaman.

Berikut ialah rajah UML untuk analogi di atas

                 +--------------------+
                 |   AbstractFactory   |  <--- Abstract Interface for creating products
                 +--------------------+
                 | + createPhone()     |
                 | + createCharger()   |
                 +--------------------+
                          /\
                          ||
        +-------------------------------------------+
        |                                           |
+----------------------+                  +----------------------+
|  AndroidFactory      |                  |  iPhoneFactory       |  <-- Concrete Factories
+----------------------+                  +----------------------+
| + createPhone()      |                  | + createPhone()      |
| + createCharger()    |                  | + createCharger()    |
+----------------------+                  +----------------------+
        /\                                      /\
        ||                                      ||
+-------------------+                +-------------------+
| AndroidPhone      |                | iPhone            |  <-- Concrete Products
+-------------------+                +-------------------+
| + makeCall()      |                | + makeCall()      |
+-------------------+                +-------------------+
+-------------------+                +-------------------+
| AndroidCharger    |                | iPhoneCharger     |  <-- Concrete Products
+-------------------+                +-------------------+
| + charge()        |                | + charge()        |
+-------------------+                +-------------------+

Client
+----------------------------------+                <-- Client Code
| Calls either AndroidFactory or   |
| iPhoneFactory to get products    |
+----------------------------------+

Berikut ialah kod untuk analogi di atas untuk difahami dengan cara yang lebih baik

// Abstract Factory
class AbstractFactory {
  createPhone() {
    throw new Error('This method should be overridden');
  }

  createCharger() {
    throw new Error('This method should be overridden');
  }
}

// Concrete Factory for Android
class AndroidFactory extends AbstractFactory {
  createPhone() {
    return new AndroidPhone();
  }

  createCharger() {
    return new AndroidCharger();
  }
}

// Concrete Factory for iPhone
class iPhoneFactory extends AbstractFactory {
  createPhone() {
    return new iPhone();
  }

  createCharger() {
    return new iPhoneCharger();
  }
}

// Product classes for Android
class AndroidPhone {
  makeCall() {
    return 'Making a call from Android Phone';
  }
}

class AndroidCharger {
  charge() {
    return 'Charging Android Phone';
  }
}

// Product classes for iPhone
class iPhone {
  makeCall() {
    return 'Making a call from iPhone';
  }
}

class iPhoneCharger {
  charge() {
    return 'Charging iPhone';
  }
}

// Client code
function getFactory(osType) {
  switch (osType) {
    case 'Android':
      return new AndroidFactory();
    case 'iPhone':
      return new iPhoneFactory();
    default:
      throw new Error('Unknown OS type');
  }
}

// Example usage
const androidFactory = getFactory('Android');
const androidPhone = androidFactory.createPhone();
const androidCharger = androidFactory.createCharger();

console.log(androidPhone.makeCall());  // Output: Making a call from Android Phone
console.log(androidCharger.charge());  // Output: Charging Android Phone

const iphoneFactory = getFactory('iPhone');
const iphone = iphoneFactory.createPhone();
const iphoneCharger = iphoneFactory.createCharger();

console.log(iphone.makeCall());        // Output: Making a call from iPhone
console.log(iphoneCharger.charge());   // Output: Charging iPhone

Corak Kilang Abstrak ialah pendekatan reka bentuk berkuasa yang menggalakkan penciptaan keluarga objek berkaitan tanpa menyatakan kelas tepatnya. Dengan mengasingkan kod pelanggan daripada penciptaan produk sebenar, ia memastikan fleksibiliti, skalabiliti dan pengurusan kod yang lebih bersih apabila memperkenalkan keluarga produk baharu. Sama ada untuk mengurus antara muka merentas platform atau mencipta barisan produk yang berbeza, corak ini menawarkan penyelesaian berstruktur dan boleh diselenggara untuk mengendalikan kerumitan penciptaan objek. Melaksanakan Kilang Abstrak membantu anda membuktikan kod anda pada masa hadapan dan mengekalkan pemisahan kebimbangan yang jelas semasa sistem anda berkembang.

Saya ingin mendengar cara anda menggunakan idea ini pada kerja anda? Kongsi pendapat atau soalan anda dalam ulasan di bawah—saya ingin mendengar daripada anda.

Terima kasih kerana menyertai saya dalam perjalanan pembelajaran ini!

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