Abstract Factory Pattern

Abstract Factory Pattern, somut sınıflarını ana uygulama koduna maruz bırakmadan ilgili nesnelerin ailelerini oluşturmak için kullanılan yaratıcı bir tasarım modelidir. Bir uygulamanın birbirine ait olan ve tutarlı bir grup olarak çalışması gereken birden fazla nesne oluşturması gerektiğinde kullanışlıdır.

Bu model, birden fazla temayı, platformu, database sürücülerini, kullanıcı arayüzü bileşenlerini, ödeme sağlayıcılarını, dosya aktarıcılarını veya hizmet ailelerini destekleyen yazılım sistemlerinde yaygın olarak kullanılır. Abstract Factory Pattern, her nesneyi ayrı ayrı oluşturmak yerine, ortak bir sözleşme aracılığıyla ilgili nesneleri oluşturan bir fabrika arayüzü sağlar.

Giriş

Bu Design Patterns serisinin önceki makalesinde Factory Pattern'yu tartışmıştık. Factory Pattern, girişe, yapılandırmaya veya iş kurallarına göre tek tür nesne oluşturmaya yardımcı olur. Nesne oluşturmayı merkezileştirir ve business logicnı daha temiz tutar.

Abstract Factory Pattern bir adım daha ileri gidiyor. Yalnızca tek bir nesne oluşturmak yerine, ilgili nesnelerden oluşan bir grup veya aile oluşturulur. Bu nesneler genellikle birlikte çalışacak ve aynı stili, sağlayıcıyı, platformu veya ortamı takip edecek şekilde tasarlanmıştır.

Örneğin, bir kullanıcı arayüzü sisteminin düğmeler, onay kutuları ve giriş alanları oluşturması gerekebilir. Uygulama hem açık temayı hem de koyu temayı destekliyorsa her temanın kendi eşleşen bileşenlerini sağlaması gerekir. Abstract Factory, ilgili tüm bileşenlerin aynı aileden oluşturulmasına yardımcı olur.

Abstract Factory Pattern Nedir?

Abstract Factory Pattern, kesin somut sınıflarını belirtmeden ilgili nesnelerin ailelerini oluşturmak için bir arayüz tanımlayan bir tasarım modelidir.

Basit bir ifadeyle, fabrika hangi somut sınıfların kullanılması gerektiğine karar verirken uygulamanın bir fabrikadan bir grup nesne istemesine olanak tanır.

Ana uygulama kodunun açık tema, koyu tema, MySQL sürücüsü, PostgreSQL sürücüsü, Stripe sağlayıcısı veya PayPal sağlayıcısı kullanıp kullanmadığını bilmesine gerek yoktur. Yalnızca soyut arayüzlere bağlıdır.

Abstract Factorynın Ana Fikri

Abstract Factory'nin ana fikri, ilgili nesnelerin oluşturulmasını onları kullanan koddan ayırmaktır. Desen genellikle şunları içerir:

İlgili nesneleri oluşturmaya yönelik yöntemleri tanımlayan soyut bir fabrika arayüzü.
Soyut fabrika arayüzünü uygulayan somut fabrika sınıfları.
Oluşturulan nesnelerin davranışını tanımlayan ürün arayüzleri.
Belirli ailelere ait somut ürün sınıfları.
Yalnızca fabrika ve ürün arayüzlerini kullanan müşteri kodu.

Bu yapı, uygulamanın ana business logicnı değiştirmeden nesne aileleri arasında geçiş yapabilmesi nedeniyle sistemi esnek hale getirir.

Abstract Factory Neden Önemlidir?

Abstract Factory önemlidir çünkü birçok uygulamanın tutarlı kalması gereken ilgili nesnelerle çalışması gerekir. Bu nesnelerin farklı yerlerde manuel olarak oluşturulması durumunda uyumsuz sınıfların karıştırılması kolaylaşır.

Örneğin, birden fazla kullanıcı arayüzü temasını destekleyen bir uygulama, yanlışlıkla koyu tema onay kutusuyla birlikte açık renkli bir tema düğmesi oluşturmamalıdır. Bir raporlama sistemi, PDF'ye özgü başlık bileşenlerini Excel'e özgü gövde bileşenleriyle karıştırmamalıdır. Bir ödeme sistemi, Stripe ödeme nesnelerini PayPal iade nesneleriyle karıştırmamalıdır.

Abstract Factory, aynı fabrika ailesinden ilgili nesneler oluşturarak bu tür tutarsızlıkları önler.

Abstract Factory Olmadan Sorun

İki tasarım temasını destekleyen bir uygulama düşünün: açık ve koyu. Uygulamanın her tema için düğmeler ve giriş alanları oluşturması gerekir.

Abstract Factory olmadan kod aşağıdaki gibi koşullar içerebilir:

if ($theme === 'light') {
    $button = new LightButton();
    $input = new LightInput();
} elseif ($theme === 'dark') {
    $button = new DarkButton();
    $input = new DarkInput();
}

Bu küçük bir örnekte işe yarayabilir ancak uygulamanın çok sayıda bileşeni olduğunda sorun daha da büyür. Sistem daha sonra kartlar, modeller, menüler, uyarılar ve tablolar eklerse koşullu mantık büyür ve bakımı zorlaşır.

Abstract Factory, bu oluşturma mantığını özel fabrika sınıflarına taşır ve client codenu daha temiz tutar.

Abstract Factory Yapısı

Tipik bir Abstract Factory yapısı birkaç parçadan oluşur. İlk olarak, ürün arayüzleri her ürün türü için ortak davranışı tanımlar. Daha sonra somut ürünler bu arayüzleri uygular. Bundan sonra soyut bir fabrika arayüzü, ürün aileleri oluşturmaya yönelik yöntemleri tanımlar. Son olarak beton fabrikaları eşleşen ürünler yaratır.

Bu ilk başta karmaşık görünebilir, ancak fikir basittir: Bir fabrika birbiriyle ilişkili nesnelerden oluşan tutarlı bir aile yaratır.

PHP'da Abstract Factory Örneği

Aşağıdaki örnek, tema tabanlı bir kullanıcı arayüzü sistemi için bir Abstract Factory uygulamasını göstermektedir.

interface Button
{
    public function render(): string;
}

interface Input
{
    public function render(): string;
}

class LightButton implements Button
{
    public function render(): string
    {
        return 'Rendering light button';
    }
}

class LightInput implements Input
{
    public function render(): string
    {
        return 'Rendering light input';
    }
}

class DarkButton implements Button
{
    public function render(): string
    {
        return 'Rendering dark button';
    }
}

class DarkInput implements Input
{
    public function render(): string
    {
        return 'Rendering dark input';
    }
}

Bu örnekte Düğme ve Giriş ürün arayüzleridir. LightButton, LightInput, DarkButton ve DarkInput somut ürünlerdir.

Abstract Factory Arayüzü Oluşturma

Artık ilgili UI bileşenlerini oluşturan soyut bir fabrika arayüzü tanımlayabiliriz:

interface UiFactory
{
    public function createButton(): Button;

    public function createInput(): Input;
}

Bu arayüz açık veya koyu temalar hakkında hiçbir şey bilmiyor. Yalnızca herhangi bir UI fabrikasının bir düğme ve giriş oluşturabilmesi gerektiğini tanımlar.

Beton Factoryları Oluşturmak

Daha sonra her tema için somut fabrikalar oluşturuyoruz:

class LightThemeFactory implements UiFactory
{
    public function createButton(): Button
    {
        return new LightButton();
    }

    public function createInput(): Input
    {
        return new LightInput();
    }
}

class DarkThemeFactory implements UiFactory
{
    public function createButton(): Button
    {
        return new DarkButton();
    }

    public function createInput(): Input
    {
        return new DarkInput();
    }
}

Her fabrika tutarlı bir nesne ailesi oluşturur. LightThemeFactory yalnızca açık renkli bileşenler oluştururken DarkThemeFactory yalnızca koyu renkli bileşenler oluşturur.

Abstract Factoryyı Kullanma

client code artık UiFactory arayüzünü somut sınıflara bağlı olmadan kullanabilir:

class PageRenderer
{
    public function __construct(
        private UiFactory $factory
    ) {
    }

    public function render(): string
    {
        $button = $this->factory->createButton();
        $input = $this->factory->createInput();

        return $button->render() . PHP_EOL . $input->render();
    }
}

$factory = new DarkThemeFactory();
$page = new PageRenderer($factory);

echo $page->render();

PageRenderer sınıfı, fabrikanın açık renkli bileşenler mi yoksa koyu renkli bileşenler mi oluşturduğunu bilmiyor. Bu yalnızca UiFactory arayüzüne bağlıdır.

Bu, tasarımın esnek olmasını ve genişletilmesinin kolay olmasını sağlar.

Nesne Ailelerini Değiştirme

Abstract Factory'nin en büyük faydalarından biri, uygulamanın fabrikayı değiştirerek tüm nesne ailesini değiştirebilmesidir.

Örneğin:

$theme = 'light';

$factory = match ($theme) {
    'light' => new LightThemeFactory(),
    'dark' => new DarkThemeFactory(),
    default => throw new InvalidArgumentException('Invalid theme.'),
};

$page = new PageRenderer($factory);

Tema değişirse uygulama farklı bir fabrika kullanır. PageRenderer mantığının geri kalanı değişmeden kalır.

Abstract Factory vs Factory Pattern

Factory Pattern ve Abstract Factory Pattern birbiriyle ilişkilidir ancak farklı tasarım sorunlarını çözerler.

Factory Pattern genellikle tek tür nesne oluşturur. Örneğin, PaymentFactory bir CreditCardPayment, PayPalPayment veya BankTransferPayment nesnesi oluşturabilir.

Abstract Factory Pattern ilgili nesnelerin ailelerini oluşturur. Örneğin bir ThemeFactory, tümü aynı temaya ait olan bir Düğme, Giriş, Modal ve Onay Kutusu oluşturabilir.

Kısacası Factory tek bir ürün oluşturmaya odaklanırken, Abstract Factory ilgili ürün ailelerini oluşturmaya odaklanır.

Factory ve Abstract Factory Arasındaki Temel Farklılıklar

Temel farklar şunlardır:

Factory Pattern: Olası sınıflar grubundan bir nesne yaratır.
Abstract Factory Pattern: Aynı aileye ait birden çok ilişkili nesne oluşturur.
Factory Pattern: Genellikle tek bir oluşturma yöntemi vardır.
Abstract Factory Pattern: Genellikle birden fazla oluşturma yöntemi vardır.
Factory Pattern: Bir uygulamayı seçmek için kullanışlıdır.
Abstract Factory Pattern: İlgili uygulamaları tutarlı tutmak için kullanışlıdır.

Her iki model de nesne oluşturmayı geliştirir, ancak Abstract Factory, nesnelerin uyumlu bir grup olarak birlikte oluşturulması gerektiğinde daha uygundur.

Gerçek Dünyadan Örnek: Veritabanı Sürücüsü Ailesi

Başka bir pratik örnek, farklı database motorlarını destekleyen bir database sistemidir. MySQL ailesi bir bağlantı nesnesi, sorgu oluşturucu ve schema yöneticisi içerebilir. Bir PostgreSQL ailesi aynı kavramların farklı uygulamalarını sağlayabilir.

Abstract Factory, database ile ilgili tüm nesnelerin aynı database ailesinden gelmesini sağlayabilir.

interface Connection
{
    public function connect(): string;
}

interface QueryBuilder
{
    public function select(string $table): string;
}

interface DatabaseFactory
{
    public function createConnection(): Connection;

    public function createQueryBuilder(): QueryBuilder;
}

Her beton database fabrikası, database motoru için eşleşen nesneler oluşturabilir.

Veritabanı Factorysı Uygulaması

class MySqlConnection implements Connection
{
    public function connect(): string
    {
        return 'Connecting to MySQL';
    }
}

class MySqlQueryBuilder implements QueryBuilder
{
    public function select(string $table): string
    {
        return 'SELECT * FROM `' . $table . '`';
    }
}

class MySqlFactory implements DatabaseFactory
{
    public function createConnection(): Connection
    {
        return new MySqlConnection();
    }

    public function createQueryBuilder(): QueryBuilder
    {
        return new MySqlQueryBuilder();
    }
}

Bir PostgreSQL fabrikası, PostgreSQL'e özgü bağlantı ve sorgu oluşturucu nesneleri oluşturabilir. Uygulama kodu, somut database türünü bilmeden DatabaseFactory'ye bağlı olabilir.

Gerçek Dünyadan Örnek: Ödeme Sağlayıcı Ailesi

Ödeme sistemleri başka bir yararlı örnektir. Bir ödeme sağlayıcısı, ödeme işleme, geri ödeme işlemleri, abonelik yönetimi ve fatura oluşturma gibi çeşitli ilgili hizmetleri içerebilir.

Örneğin, bir Stripe ailesi StripePaymentProcessor, StripeRefundService ve StripeSubscriptionService'i içerebilir. PayPal ailesi PayPalPaymentProcessor, PayPalRefundService ve PayPalSubscriptionService'i içerebilir.

Abstract Factory, sağlayıcıya özel doğru hizmet grubunu oluşturabilir ve farklı sağlayıcılardan gelen hizmetlerin karıştırılmasını önleyebilir.

Ödeme Sağlayıcı Özet Factory Örneği

interface PaymentProcessor
{
    public function pay(float $amount): bool;
}

interface RefundProcessor
{
    public function refund(float $amount): bool;
}

interface PaymentProviderFactory
{
    public function createPaymentProcessor(): PaymentProcessor;

    public function createRefundProcessor(): RefundProcessor;
}

class StripeProviderFactory implements PaymentProviderFactory
{
    public function createPaymentProcessor(): PaymentProcessor
    {
        return new StripePaymentProcessor();
    }

    public function createRefundProcessor(): RefundProcessor
    {
        return new StripeRefundProcessor();
    }
}

class PayPalProviderFactory implements PaymentProviderFactory
{
    public function createPaymentProcessor(): PaymentProcessor
    {
        return new PayPalPaymentProcessor();
    }

    public function createRefundProcessor(): RefundProcessor
    {
        return new PayPalRefundProcessor();
    }
}

Bu tasarım, uygulamanın tüm ilgili hizmetleri tutarlı tutarken ödeme sağlayıcıları arasında geçiş yapmasına olanak tanır.

Abstract Factory Pattern'nun Faydaları

Abstract Factory Pattern, bir uygulamanın ilgili nesne ailelerine ihtiyacı olduğunda birçok fayda sağlar.

Ana faydalar şunları içerir:

İlgili nesnelerin ailelerini tutarlı bir şekilde oluşturur.
Farklı ailelerden uyumsuz nesnelerin karıştırılmasını önler.
Nesne oluşturmayı business logicndan ayırır.
Arayüz tabanlı tasarımı ve polimorfizmi destekler.
Aileler arasında geçiş yapmayı kolaylaştırır.
Büyük sistemlerde sürdürülebilirliği artırır.
Dikkatlice tasarlandığında Açık Kapalı Prensibini destekler.

Bu avantajlar, Abstract Factory'yi birden fazla sağlayıcıyı, temayı, platformu, ortamı veya ürün ailesini destekleyen sistemlerde kullanışlı hale getirir.

Abstract Factory Pattern'nun dezavantajları

Abstract Factory güçlü olmasına rağmen karmaşıklığı da artırabilir. Genellikle birden fazla arayüz, birden fazla somut sınıf ve birkaç fabrika sınıfı gerektirir.

Bu, küçük projeler veya basit nesne oluşturma için gereksiz olabilir. Uygulamanın ilgili nesne ailelerini oluşturması gerekmiyorsa, basit bir fabrika veya doğrudan nesne oluşturma işlemi daha iyi olabilir.

Diğer bir dezavantaj ise her aileye yeni bir ürün tipinin eklenmesinin tüm fabrika arayüzlerinde ve beton fabrikalarında değişiklik gerektirebilmesidir. Örneğin, bir kullanıcı arayüzü fabrikası düğmeler ve girişler oluşturuyorsa yeni bir createModal yöntemi eklemek, tüm tema fabrikalarının güncellenmesini gerektirir.

Abstract Factory Pattern Ne Zaman Kullanılır?

Uygulamanızın ilgili nesne aileleri oluşturması gerektiğinde ve bu nesnelerin tutarlı bir şekilde birlikte kullanılması gerektiğinde Abstract Factory'yi kullanın.

Abstract Factory şu durumlarda faydalıdır:

Uygulama birden fazla temayı veya platformu destekler.
Birbiriyle ilişkili birkaç nesnenin aynı aileden gelmesi gerekir.
Kod somut sınıflara bağlı olmamalıdır.
Sistemin tam nesne aileleri arasında geçiş yapması gerekiyor.
Uyumsuz nesnelerin karışmasını önlemek istiyorsunuz.
Nesne oluşturma kuralları karmaşıktır ve merkezileştirilmesi gerekir.

Bu koşullar mevcutsa, Abstract Factory tasarımı iyileştirebilir ve sistemin genişletilmesini kolaylaştırabilir.

Abstract Factory Pattern Ne Zaman Kullanılmamalı?

Nesne oluşturma sorunu basit olduğunda Abstract Factory'yi kullanmayın. Uygulama yalnızca bir nesne türü oluşturuyorsa Factory Pattern yeterli olabilir. Nesnenin yaratılması doğrudan ve değişme olasılığı düşükse, fabrikaya ihtiyaç duyulmayabilir.

Aşağıdaki durumlarda Abstract Factory'den kaçının:

Tek ürün tipi bulunmaktadır.
İlgili nesne ailesi yok.
Desen, gerçek bir fayda sağlamayan çok fazla sınıf ekliyor.
Proje küçük ve basittir.
Doğrudan bağımlılık enjeksiyonu sorunu zaten temiz bir şekilde çözüyor.

Design Patterns uzun vadeli karmaşıklığı azaltmalı, gereksiz yapılar yaratmamalıdır.

Abstract Factory ve Dependency Injection

Abstract Factory bağımlılık enjeksiyonuyla iyi çalışır. Doğrudan müşteri sınıfının içinde somut bir fabrika oluşturmak yerine, fabrika yapıcı aracılığıyla enjekte edilebilir.

Bu, client codenu daha test edilebilir ve esnek hale getirir.

class CheckoutService
{
    public function __construct(
        private PaymentProviderFactory $factory
    ) {
    }

    public function checkout(float $amount): bool
    {
        $processor = $this->factory->createPaymentProcessor();

        return $processor->pay($amount);
    }
}

CheckoutService, PaymentProviderFactory arayüzüne bağlıdır. Çalışma zamanı sırasında uygulama StripeProviderFactory, PayPalProviderFactory veya başka bir sağlayıcı fabrikasına enjekte edebilir.

Laravel'daki Abstract Factory

Laravel'da, bir uygulama birden fazla hizmet ailesini desteklediğinde Abstract Factory kullanılabilir. Örneğin bir proje çeşitli ödeme sağlayıcılarını, dışa aktarma formatlarını, bildirim sağlayıcılarını veya depolama sistemlerini destekleyebilir.

Laravel'nun servis konteyneri, konfigürasyona göre doğru fabrikanın enjekte edilmesine yardımcı olabilir. Bir hizmet sağlayıcı, uygulama genelinde somut sınıfları manuel olarak seçmek yerine doğru fabrika uygulamasını bağlayabilir.

$this->app->bind(
    PaymentProviderFactory::class,
    StripeProviderFactory::class
);

Artık PaymentProviderFactory'ye bağlı olan herhangi bir hizmet, yapılandırılmış fabrikayı otomatik olarak alabilir.

Symfony'daki Abstract Factory

Symfony ayrıca hizmetler, bağımlılık ekleme ve yapılandırma yoluyla Abstract Factory'yi de destekler. Geliştiriciler farklı fabrika hizmetlerini tanımlayabilir ve ortama, yapılandırmaya veya iş kurallarına bağlı olarak doğru olanı ekleyebilir.

Bu yaklaşım, iş sınıflarını değiştirmeden hizmet ailelerinin değiştirilmesi gereken büyük Symfony uygulamalarında kullanışlıdır.

Abstract Factory ve Temiz Mimari

Abstract Factory, yüksek düzey business logicnı düşük düzey uygulama ayrıntılarından bağımsız tutmaya yardımcı olduğunda clean architecture'yu destekleyebilir.

Örneğin business logic, doğrudan Stripe veya PayPal sınıflarına bağlı olmak yerine PaymentProviderFactory arayüzüne bağlı olabilir. Bu, temel uygulama mantığını daha kararlı ve test edilmesi daha kolay tutar.

Ancak Abstract Factory her yerde kullanılmamalıdır. Sistemin gerçekten birbiriyle değiştirilebilir ilgili nesne ailelerine ihtiyaç duyduğu durumlarda kullanılmalıdır.

Abstract Factory ve Açık Kapalı Prensibi

Abstract Factory Pattern, client codenu değiştirmeden yeni nesne ailelerinin eklenmesine izin vererek Açık Kapalı İlkesini destekleyebilir.

Örneğin, bir uygulama zaten LightThemeFactory ve DarkThemeFactory'yi destekliyorsa yeni bir HighContrastThemeFactory eklenebilir. PageRenderer sınıfının UiFactory arayüzüne bağlı olması nedeniyle değişmesine gerek yoktur.

Bu, mevcut müşteri kodunu değişiklik için kapalı tutarken sistemi yeni ailelere açık hale getirir.

Abstract Factory ile İlgili Yaygın Hatalar

Yaygın bir hata, basit nesne oluşturmak için Abstract Factory'yi kullanmaktır. İlgili nesne ailesi yoksa Abstract Factory çok ağır olabilir.

Diğer bir hata ise ürün ailelerinin belirsizleştirilmesidir. Aynı fabrika tarafından üretilen tüm ürünler mantıksal olarak birbirine ait olmalıdır. Factory ilgisiz nesneler yaratırsa tasarım kafa karıştırıcı hale gelir.

Üçüncü bir hata ise business logicnı fabrikanın içine yerleştirmektir. Factory nesne oluşturmaya odaklanmalıdır. İş iş akışları hizmetlerde, etki alanı sınıflarında veya kullanım senaryolarında kalmalıdır.

Dördüncü hata ise çok erken dönemde çok fazla soyutlama yaratmaktır. İhtiyaç netleştiğinde Abstract Factory'yi tanıtmak daha iyidir.

Abstract Factory Pattern için En İyi Uygulamalar

Abstract Factory'yi doğru kullanmak için geliştiricilerin tasarımı odaklı ve anlamlı tutması gerekir.

Yararlı en iyi uygulamalar şunları içerir:

Abstract Factory'yi yalnızca ilgili nesne aileleri için kullanın.
Anlaşılır ürün arayüzleri tanımlayın.
Her ailede somut ürün sınıflarını tutarlı tutun.
Factoryların yaratma mantığına odaklanmasını sağlayın.
İstemci sınıflarına fabrikalar sağlamak için bağımlılık eklemeyi kullanın.
Factoryların içine iş iş akışları eklemekten kaçının.
ThemeFactory, DatabaseFactory veya PaymentProviderFactory gibi anlamlı adlar kullanın.
Basit bir fabrika yeterliyse deseni tanıtmayın.

Bu uygulamalar Abstract Factory Pattern'nun kullanışlı ve anlaşılır kalmasına yardımcı olur.

Abstract Factory'yi Kullanmadan Önce Pratik Kontrol Listesi

Abstract Factory'yi kullanmadan önce şu soruları sorun:

Birden fazla ilgili nesne oluşturmam gerekiyor mu?
Bu nesneler farklı ailelere veya sağlayıcılara mı ait?
Uygulama tam aileler arasında geçiş yapmalı mı?
Uyumsuz nesnelerin karıştırılmasını önlemek önemli mi?
client code arayüzlere bağlı olarak daha temiz hale gelecek mi?
Basit bir Factory Pattern yeterli olur mu?
Bu tasarım gelecekteki değişiklikleri kolaylaştıracak mı?

Bu soruların çoğuna cevabınız evet ise Abstract Factory iyi bir tasarım tercihi olabilir.

Sonuç

Abstract Factory Pattern, somut sınıfları client codena maruz bırakmadan ilgili nesne ailelerini oluşturmak için kullanılan yaratıcı bir tasarım modelidir. Bir uygulama birden çok temayı, platformu, sağlayıcıyı, database motorunu veya hizmet ailesini desteklediğinde özellikle kullanışlıdır.

Factory Pattern ile karşılaştırıldığında, Abstract Factory daha çok uyumlu nesnelerden oluşan gruplar oluşturmaya odaklanmıştır. Tutarlılığı artırır, çok biçimliliği destekler, birleştirmeyi azaltır ve business logicnın nesne oluşturma ayrıntılarından bağımsız kalmasına yardımcı olur.

Ancak Abstract Factory dikkatli kullanılmalıdır. Sorun basit olduğunda karmaşıklığı artırabilir. Geliştiriciler, uygulama gerçekten birbiriyle değiştirilebilir ilgili nesne ailelerine ihtiyaç duyduğunda bunu uygulamalıdır. Doğru kullanıldığında esnek, ölçeklenebilir ve bakımı kolay nesne yönelimli yazılım oluşturmak için güçlü bir modeldir.

Abstract Factory Pattern

Abstract Factory Pattern

Giriş