Yazılım geliştirme bağlamında Builder (Yapıcı) nedir?

Karmaşık bir nesnenin yapımını, onun temsilinden ayıran ve aynı yapım sürecinin farklı temsillerini oluşturmayı sağlayan tasarım kalıbı.

Ana özellikler:

• Sorumlulukların ayrılması: Nesne oluşturma mantığı (yapım adımları) ve nesne temsili (son ürün) ayrılmıştır.
• Adım adım yapım: Nesne adım adım inşa edilir, bu da süreci daha esnek ve anlaşılır kılar.
• Farklı temsiller: Aynı yapım süreci, nesnenin farklı varyasyonlarını oluşturmak için kullanılabilir.
• Kapsülleme: Nesne oluşturma detayları müşteriden gizlenir, bu da kullanımını kolaylaştırır.

Ana katılımcılar:

• Builder (İnşaatçı): Ürünün parçalarını oluşturmak için adımları tanımlayan soyut arayüz veya sınıf.
• ConcreteBuilder (Somut İnşaatçı): Gerçek nesne yapımını gerçekleştiren ve sonucu saklayan inşaatçının somut uygulaması.
• Director (Yönetici): Bir ConcreteBuilder nesnesini kullanarak ürünü inşa eden ve uygun yöntemleri belirli bir sırayla çağıran sınıf.
• Product (Ürün): İnşa edilen karmaşık nesne.

Kullanım örneği:

Farklı malzemelerle Pizza nesnesi oluşturma:

// Ürün
class Pizza {
    private String dough;
    private String sauce;
    private String cheese;
    private List<String> toppings;

    public void setDough(String dough) { this.dough = dough; }
    public void setSauce(String sauce) { this.sauce = sauce; }
    public void setCheese(String cheese) { this.cheese = cheese; }
    public void addTopping(String topping) {
        if (toppings == null) {
            toppings = new ArrayList<>();
        }
        toppings.add(topping);
    }

    @Override
    public String toString() {
        return "Pizza hamuru: " + dough + ", sos: " + sauce + ", peynir: " + cheese + ", malzemeler: " + toppings;
    }
}

// Builder arayüzü
interface PizzaBuilder {
    void buildDough();
    void buildSauce();
    void buildCheese();
    void addTopping(String topping);
    Pizza getResult();
}

// Somut Builder
class MargheritaPizzaBuilder implements PizzaBuilder {
    private Pizza pizza;

    public MargheritaPizzaBuilder() {
        this.pizza = new Pizza();
    }

    @Override
    public void buildDough() {
        pizza.setDough("İnce hamur");
    }

    @Override
    public void buildSauce() {
        pizza.setSauce("Domates sosu");
    }

    @Override
    public void buildCheese() {
        pizza.setCheese("Mozzarella");
    }

    @Override
    public void addTopping(String topping) {
        // Margherita'nın ek malzemeleri yok
    }

    @Override
    public Pizza getResult() {
        return pizza;
    }
}

// Yönetici
class Cook {
    private PizzaBuilder pizzaBuilder;

    public void setPizzaBuilder(PizzaBuilder pb) {
        pizzaBuilder = pb;
    }

    public void constructPizza() {
        pizzaBuilder.buildDough();
        pizzaBuilder.buildSauce();
        pizzaBuilder.buildCheese();
        // Ekstra malzemeler burada eklenebilir
    }
}

// Müşteri kodu
public class PizzaShop {
    public static void main(String[] args) {
        Cook cook = new Cook();
        PizzaBuilder margheritaBuilder = new MargheritaPizzaBuilder();

        cook.setPizzaBuilder(margheritaBuilder);
        cook.constructPizza();

        Pizza pizza = margheritaBuilder.getResult();
        System.out.println(pizza);
    }
}

Uygulama durumları:

• Çok sayıda isteğe bağlı parametreye sahip karmaşık nesnelerin oluşturulması gerektiğinde.
• Nesne oluşturma sürecinin sıralı ve çok adımlı olduğu durumlarda.
• Aynı algoritmayı kullanarak farklı varyasyonlar oluşturulması gerektiğinde.
• Çok sayıda parametre içeren yapıcıların ("telescoping constructor") önlenmesi gerektiğinde.

Avantajlar:

• Kodun okunabilirliğini ve bakımını artırır.
• Nesne oluşturma esnekliği sağlar.
• Değiştirilemez nesnelerin oluşturulmasına imkan tanır.
• Çok sayıda yapıcıya olan ihtiyacı ortadan kaldırır.

Dezavantajlar:

• Projede sınıf sayısını artırabilir (her nesne tipi ve yapıcı için).
• Başlangıçta tasarım çabası gerektirir.