Abstract Factory - Dasturlashda Patternlar. (4-qism)

Abstract Factory o'zbekchaga tarjima qilganda Abstrakt fabrika bo'ladi. Biz uni asl terminda ishlatganimiz qulay va oson bo'ladi.

Abstract Factory - bu obyekt yaratishga oid dizayn pattern bo‘lib, u bir-biri bilan bog‘liq obyektlar oilasini yaratishga yordam beradi. Bunda kod aniq classlarga qattiq bog‘lanib qolmaydi.

Oddiy qilib aytganda:
Abstract Factory bir xil uslubdagi yoki bir-biriga mos keladigan obyektlarni bitta joydan yaratib beradi.

Masalan, mebel do‘koni dasturini tasavvur qiling. Unda quyidagi mahsulotlar bor:

• kreslo;

• divan;

• stolcha.

Lekin bu mahsulotlarning turli uslublari bo‘lishi mumkin:

• Neoklassika uslubi;

• Modern uslubi;

• Art-deko uslubi.

Muammo shundaki, Modern kreslo yoniga Neoklassika divan qo‘yilsa, ular bir-biriga mos kelmaydi. Dastur esa bunday nomuvofiqlikni oldini olishi kerak.

🚩 Muammo

Siz mebel do‘koni simulyatorini yozayapsiz. Kodingizda bir nechta bog‘liq mahsulotlar mavjud:

Kreslo + Divan + Stolcha

Bu mahsulotlar bir nechta uslubda bo‘lishi mumkin:

Modern, Neoklassika, Art-deko.

Sizga shunday yechim kerakki, dastur bir xil oilaga tegishli mahsulotlarni yaratib bersin. Ya’ni agar foydalanuvchi Modern uslubini tanlasa, kreslo ham, divan ham, stolcha ham Modern bo‘lishi kerak.

Bundan tashqari, yangi uslub yoki yangi mahsulot qo‘shilganda eski kodni ko‘p o‘zgartirishni xohlamaysiz. Chunki biznesda mahsulotlar, kataloglar va talablar tez-tez o‘zgaradi.

💡 Yechim

Abstract Factory patterni avval har bir mahsulot turi uchun umumiy interfeys yaratishni taklif qiladi.

Masalan:

interface Chair {}
interface Sofa {}
interface CoffeeTable {}

Keyin barcha mahsulotlarni yaratadigan umumiy factory (fabrika) interfeysi yaratiladi:

interface FurnitureFactory {
    Chair createChair();
    Sofa createSofa();
    CoffeeTable createCoffeeTable();
}

Endi har bir uslub uchun alohida factory qilinadi:

class ModernFurnitureFactory implements FurnitureFactory {
    public Chair createChair() {
        return new ModernChair();
    }

    public Sofa createSofa() {
        return new ModernSofa();
    }

    public CoffeeTable createCoffeeTable() {
        return new ModernCoffeeTable();
    }
}

Neoklassika uslubi uchun esa boshqa factory bo‘ladi:

class NeoclassicismFurnitureFactory implements FurnitureFactory {
    public Chair createChair() {
        return new NeoclassicismChair();
    }

    public Sofa createSofa() {
        return new NeoclassicismSofa();
    }

    public CoffeeTable createCoffeeTable() {
        return new NeoclassicismCoffeeTable();
    }
}

Shunda client kod aniq classlar bilan ishlamaydi. U faqat umumiy interfeysni biladi:

FurnitureFactory factory = new ModernFurnitureFactory();

Chair chair = factory.createChair();
Sofa sofa = factory.createSofa();
CoffeeTable table = factory.createCoffeeTable();

Client kod uchun mahsulot aynan qaysi classdan yaratilgani muhim emas. Muhimi - ular bir-biriga mos bo‘lishi.

Oddiy qilib tushuntirsak Abstract Factory - bu bir-biriga mos obyektlar to‘plamini yaratadigan fabrika.

Masalan:

Ya’ni fabrika qaysi uslubda bo‘lsa, undan chiqadigan barcha obyektlar ham shu uslubda bo‘ladi.

🧩 Real hayotdagi misol

Tasavvur qiling, siz cross-platform desktop dastur yozayapsiz.

Dastur Windows, macOS va Linux’da ishlaydi. Har bir operatsion tizimda tugma, checkbox, input kabi UI elementlar biroz boshqacha ko‘rinadi.

Windows’da:

WindowsButton
WindowsCheckbox

macOS’da:

MacButton
MacCheckbox

Linux’da:

LinuxButton
LinuxCheckbox

Siz Windows’da ishlayotgan dasturda tasodifan macOS checkbox chiqib qolishini xohlamaysiz. Abstract Factory aynan shu muammoni hal qiladi.

Dastur ishga tushganda qaysi OS ishlatilayotganini aniqlaydi va mos factoryni tanlaydi:

GUIFactory factory;

if (os.equals("Windows")) {
    factory = new WindowsFactory();
} else if (os.equals("Mac")) {
    factory = new MacFactory();
} else {
    factory = new LinuxFactory();
}

Keyin client kod faqat shu fabrika orqali UI elementlarni yaratadi:

Button button = factory.createButton();
Checkbox checkbox = factory.createCheckbox();

Natijada barcha elementlar bitta platformaga mos bo‘ladi.

Abstract Factory patternida odatda quyidagi qismlar bo‘ladi:

1. Abstract Product

Bu mahsulotlar uchun umumiy interfeys.

Masalan:

interface Button {}
interface Checkbox {}

2. Concrete Product

Bu aniq mahsulot classlari.

Masalan:

class WindowsButton implements Button {}
class MacButton implements Button {}

class WindowsCheckbox implements Checkbox {}
class MacCheckbox implements Checkbox {}

3. Abstract Factory

Bu mahsulotlarni yaratadigan umumiy factory interfeysi.

interface GUIFactory {
    Button createButton();
    Checkbox createCheckbox();
}

4. Concrete Factory

Bu aniq factory classlari.

class WindowsFactory implements GUIFactory {
    public Button createButton() {
        return new WindowsButton();
    }

    public Checkbox createCheckbox() {
        return new WindowsCheckbox();
    }
}

class MacFactory implements GUIFactory {
    public Button createButton() {
        return new MacButton();
    }

    public Checkbox createCheckbox() {
        return new MacCheckbox();
    }
}

5. Client Code

Client kod aniq classlarni bilmaydi. U faqat interfeyslar bilan ishlaydi.

class Application {
    private Button button;
    private Checkbox checkbox;

    public Application(GUIFactory factory) {
        button = factory.createButton();
        checkbox = factory.createCheckbox();
    }
}

Abstract Factory quyidagi holatlarda ishlatgan foydali bo'ladi:

1. Bir-biriga bog‘liq obyektlar oilasi bo‘lsa

Masalan:

• button + checkbox + input;

• chair + sofa + table;

• document + approval flow + notification;

• payment form + payment validator + payment processor.

2. Obyektlar bir-biriga mos bo‘lishi kerak bo‘lsa

Masalan, Windows UI elementlari faqat Windows uslubida bo‘lishi kerak.

3. Client kod aniq classlarga bog‘lanmasligi kerak bo‘lsa

Client kod quyidagicha yozilmasligi kerak:

new WindowsButton();
new WindowsCheckbox();

Buning o‘rniga:

factory.createButton();
factory.createCheckbox();

4. Yangi mahsulot oilalarini qo‘shish kerak bo‘lsa

Masalan, keyinchalik Linux qo‘shmoqchi bo‘lsangiz, client kodni o‘zgartirmaysiz. Faqat yangi LinuxFactory yaratasiz.

✅ Afzalliklari

Abstract Factory patternining asosiy foydalari:

• bir-biriga mos mahsulotlar yaratilishini kafolatlaydi;

• client kodni aniq classlardan ajratadi;

• obyekt yaratish logikasini bitta joyga yig‘adi;

• kodni qo‘llab-quvvatlashni osonlashtiradi;

• yangi mahsulot oilasini qo‘shishni yengillashtiradi;

• Open/Closed Principle’ga mos keladi.

Ya’ni mavjud kodni kamroq o‘zgartirib, yangi imkoniyat qo‘shish mumkin bo‘ladi.

🔴 Kamchiliklari

Bu pattern har doim ham kerak emas. Kamchiliklari ham bor:

• kod murakkablashadi;

• ko‘p interfeys va classlar paydo bo‘ladi;

• har bir yangi mahsulot turi barcha fabrikalarda qo‘shilishi kerak bo‘ladi;

• kichik loyihalarda ortiqcha murakkablik keltirib chiqarishi mumkin.

Masalan, agar sizda faqat bitta Button bo‘lsa, Abstract Factory kerak bo‘lmasligi mumkin. Oddiy Factory Method yetarli bo‘ladi.

Factory Method bilan farqi

Factory Method odatda bitta turdagi obyekt yaratishga qaratiladi.

Masalan:

createButton()

Abstract Factory esa bir nechta bog‘liq obyektlar oilasini yaratadi.

Masalan:

createButton()
createCheckbox()
createInput()

Ya’ni:

Builder bilan farqi Builder murakkab obyektni bosqichma-bosqich yaratadi.Bu mavzuni keyingi mavzuda yoritaman.

Masalan:

new HouseBuilder()
    .buildWalls()
    .buildRoof()
    .buildGarage()
    .build();

Abstract Factory esa tayyor mahsulotlarni darhol yaratadi:

factory.createButton();
factory.createCheckbox();

Builder - murakkab obyektni yig‘adi.
Abstract Factory - mos obyektlar oilasini yaratadi.

Qisqa xulosa

Abstract Factory - bu bir-biriga mos keladigan obyektlar oilasini yaratish uchun ishlatiladigan pattern.

U client kodni aniq classlardan ajratadi va obyekt yaratish jarayonini tartibga soladi.

Bu pattern ayniqsa quyidagi holatlarda foydali:

• bir nechta mahsulot turi bor;

• ularning bir nechta variatsiyasi bor;

• mahsulotlar bir-biriga mos bo‘lishi kerak;

• client kod aniq classlarni bilmasligi kerak;

• loyiha kelajakda kengayishi mumkin.

Xulosa qilsak:

Abstract Factory - bu "bir xil uslubdagi obyektlar oilasini ishlab chiqaradigan fabrika".

Mavzular tushunarli bo'layapti degan umiddaman. Bu mavzular Ingliz va rus tilida keng yoritilgan. Men o'zbekzabon yoshlarimiz tushunishlari oson bo'lishi uchun bularni yoritmoqdaman.

P.S birinchi yangiliklarni blog saytimdan o'qib olishingiz mumkin: blog.jtscorp.uz