Ay: Nisan 2024

Prototype Design Pattern: Mevcut bir nesnenin klonlanması ile yeni bir nesne oluşturmayı sağlar. Bu pattern, nesnelerin türetilmesi maliyetli veya zor olduğunda kullanışlıdır. Özellikle, büyük nesne oluşturma maliyeti varsa veya nesnelerin durumu dinamik olarak değişiyorsa kullanışlı olabilir.

Kısacası bir nesnenin kopyasını almak için kullanılır. Nesnelerin belirli bir durumunu koruyarak yeni nesneler oluşturmayı sağlar. Bu, nesnenin yapısını veya içeriğini bilmeden yeni bir nesne oluşturmak için kullanışlıdır. Örnek verecek olursak;

public interface ProtoType {
    ProtoType clone();
}

public class ConcretePrototype implements ProtoType {
    private Integer value;

    public ConcretePrototype(Integer value) {
        this.value = value;
    }

    public Integer getValue() {
        return value;
    }

    public void setValue(Integer value) {
        this.value = value;
    }

    @Override
    public ProtoType clone() {
        return new ConcretePrototype(this.value);
    }
}

   public static void main(String[] args) {
        // ProtoType Design Pattern
        protoTypeDesignPattern();
    }

    private static void protoTypeDesignPattern() {
        ConcretePrototype prototype = new ConcretePrototype(10);
        ConcretePrototype clone = (ConcretePrototype) prototype.clone();

        System.out.println("Original value : "+ prototype.getValue()); // output: 10
        System.out.println("Clone value : "+ clone.getValue()); // output: 10

        prototype.setValue(20);

        System.out.println("Original value after update : "+ prototype.getValue());  // output: 20
        System.out.println("Clone value after update : "+ clone.getValue());  // output: 10
    }

Örnekte, Prototype arayüzü, klonlama işlemini gerçekleştirmek için bir clone methodu içermektedir. ConcretePrototype classı, klonlanacak somut bir prototipi temsil eder ve clone methodunu çağırılır. Main sınıfında, bir prototip nesnesi oluşturup, bu nesnenin bir kopyası alınır. Ardından, orijinal ve kopya nesnelerin değerleri gösterir. Orijinal nesnenin değeri değiştirildiğinde, kopya nesnenin değeri değişmez çünkü kopya, orijinalin durumunu klonlama sırasında aldı. Bu örnek, Prototype design patternin nasıl çalıştığını göstermektedir.

Yorum Bırak

Builder Design Pattern: Karmaşık nesnelerin adım adım oluşturulmasını sağlar. Nesne oluşturma süreci, adım adım yönlendirilir ve nesne oluşturmayı karmaşık bir yapıdan ayırır. Builder design patterni, nesnelerin farklı bileşenlerinin aynı oluşturulma sürecini kullanarak farklı nesne varyasyonlarını oluşturmak için kullanışlıdır.

Örnek verecek olursak; bir bilgisayar nesnesi oluşturmak için Builder Design Patternini kullanalım. Bilgisayar classında, işlemci, RAM, depolama alanı gibi oluşturacak şekilde tasarlayalım.

public class Computer {

    private String processor;
    private Integer ram;
    private Integer storage;

    public void setProcessor(String processor) {
        this.processor = processor;
    }

    public void setRam(Integer ram) {
        this.ram = ram;
    }

    public void setStorage(Integer storage) {
        this.storage = storage;
    }

    public void show() {
        System.out.println("Processor: " + processor);
        System.out.println("RAM: " + ram + " GB");
        System.out.println("Storage : " + storage + " GB SSD");
    }
}

public interface ComputerBuilder {
    void buildProcessor();
    void buildRam();
    void buildStorage();
    Computer getResult();
}

public class DesktopBuilder implements ComputerBuilder {

    private Computer computer;

    public DesktopBuilder() {
        computer = new Computer();
    }

    @Override
    public void buildProcessor() {
        computer.setProcessor("Intel Core i7");
    }

    @Override
    public void buildRam() {
        computer.setRam(16);
    }

    @Override
    public void buildStorage() {
        computer.setStorage(512);
    }

    @Override
    public Computer getResult() {
        return computer;
    }
}

public class ComputerAssembler {

    private ComputerBuilder builder;
    public ComputerAssembler(ComputerBuilder builder) {
        this.builder = builder;
    }

    public void assembleComputer() {
        builder.buildProcessor();
        builder.buildRam();
        builder.buildStorage();
    }
}

    public static void main(String[] args) {
        // Builder Design Pattern
        builderDesignPatter();
    }

     private static void builderDesignPatter() {
        ComputerBuilder desktopBuilder = new DesktopBuilder();
        ComputerAssembler assembler = new ComputerAssembler(desktopBuilder);
        assembler.assembleComputer();

        Computer desktop = desktopBuilder.getResult();
        desktop.show();
    }

Bu örnekte, Computer sınıfı, oluşturulacak bilgisayar nesnesini temsil etmektedir.. ComputerBuilder arayüzü, bu nesnenin parçalarını oluşturmak için methodları tanımladık. DesktopBuilder sınıfı, masaüstü parçalarını oluşturan somut bir builder sınıfıdır. ComputerAssembler sınıfı, builder nesnesini kullanarak bilgisayar nesnesinin nasıl oluşturulacağını gösterir. Main classında, builder design pattern kullanarak bir masaüstü bilgisayar oluşturup, sonuç gösteriyor. Bu örnek, builder design patternin karmaşık nesnelerin oluşturulması için nasıl kullanılabileceğini göstermiş olduk.

Yorum Bırak

Abstract Factory Design Pattern: Bir nesne ailesi oluşturmak için soyut bir arayüz sağlar. Ardından, bu arayüzü uygulayan farklı fabrika sınıfları, farklı nesne ailelerini oluşturabilir. Bu pattern ile ilgili nesne gruplarının bir arada kullanılması gerektiği durumlarda kullanılır ve sistemlerin daha kolay genişletilmesini sağlar.

Örnek olarak; bir mobilya üretim uygulamasını düşünelim. Bu uygulamada, farklı mobilya parçalarının üretimi için Abstract Factory Design Patterni kullanabiliriz.

public interface Chair {
    void sitOn();
}

public class WoodenChair implements Chair{
    @Override
    public void sitOn() {
        System.out.println("Ahşap sandelyeye oturdu.");
    }
}

public class MetalChair implements Chair {
    @Override
    public void sitOn() {
        System.out.println("Metal sandelyeye oturdu.");
    }
}

public interface Table {
    void putOn();
}

public class WoodenTable implements Table {
    @Override
    public void putOn() {
        System.out.println("Ahşap masaya bir şey koydu.");
    }
}

 public class MetalTable implements Table {
    @Override
    public void putOn() {
        System.out.println("Metal masaya bir şey koydu.");
    }
}

public interface FurnitureFactory {
    Chair createChair();
    Table createTable();
}

public class WoodenFurnitureFactory implements FurnitureFactory {
    @Override
    public Chair createChair() {
        return new WoodenChair();
    }

    @Override
    public Table createTable() {
        return new WoodenTable();
    }
}

public class MetalFurnitureFactory implements FurnitureFactory{
    @Override
    public Chair createChair() {
        return new MetalChair();
    }

    @Override
    public Table createTable() {
        return new MetalTable();
    }
}

private static void createFurniture(FurnitureFactory factory) {
        Chair chair = factory.createChair();
        Table table = factory.createTable();

        chair.sitOn();
        table.putOn();
    }
private static void abstractFactoryDesignPatter(){
        createFurniture(new WoodenFurnitureFactory());
        createFurniture(new MetalFurnitureFactory());
    }

public static void main(String[] args) {
        // Abstract Factory Design Pattern
        abstractFactoryDesignPatter();
    }

Bu örnekte, Chair ve Table arayüzleri iki farklı mobilya parçasını temsil ediyor. Ahşap ve metal için farklı somut mobilya parçaları bu arayüzlere uyguladık. FurnitureFactory arayüzü, bu mobilya parçalarını oluşturmak için gerekli methodları tanımladık. WoodenFurnitureFactory ve MetalFurnitureFactory gibi classlarda, belirli bir malzeme tipi için ilgili mobilya parçalarını oluşturduk. En son adımda, Main sınıfında, farklı malzeme tipleri için mobilya setleri oluşturmak için soyut fabrika desenini kullanarak bu desenin nasıl kullanılacağını göstermiş olduk.

Yorum Bırak

Factory Method Design Pattern: Bir arayüz sağlar ve alt sınıfların bu arayüzü uygulayarak nesneleri oluşturmasını sağlar. Bu sayede, nesne oluşturma işlemi istemciden gizlenir. Böylelikle alt sınıfların nesne oluşturma mantığını değiştirmesi kolaylaşır. Factory Method, nesnelerin oluşturulmasıyla ilgili kararların alt sınıflara devredilmesi gerektiği durumlarda kullanılır.

Bir senaryo için bir örnek düşünelim: bir e-ticaret uygulaması. Bu uygulamada, farklı ürün kategorileri için ürün oluşturma işlemlerini Factory Method tasarım deseni ile gerçekleştirebiliriz.

public interface Product {
    void display();
}

public class Laptop implements Product{
    @Override
    public void display() {
        System.out.println("Laptop: Dell Precision 3520");
    }
}

public class Phone implements Product{
    @Override
    public void display() {
        System.out.println("Telefon: Iphone 15 Prox Max");
    }
}

public abstract class ProductFactory {
    abstract Product createProduct();

    public void processOrder() {
        Product product = createProduct();
        product.display();
    }
}

public class LaptopFactory extends ProductFactory{
    @Override
    Product createProduct() {
        return new Laptop();
    }
}

public class PhoneFactory extends ProductFactory{
    @Override
    Product createProduct() {
        return new Phone();
    }
}

public class Main {
    public static void main(String[] args) {
        // Factory Method Design Pattern
        factoryMethodDesignPattern();
    }
  
    private static void factoryMethodDesignPattern() {
        ProductFactory phoneFactory = new PhoneFactory();
        ProductFactory laptopFactory = new LaptopFactory();
        phoneFactory.processOrder();
        laptopFactory.processOrder();
    }
}

Bu örnekte, Product arayüzü telefon ve laptop ürünlerini temsil ettik. Phone ve Laptop ürünler için arayüzü uyguladık. ProductFactory sınıfından, Factory Method (createProduct) oluşturup, bu sınıfın alt sınıflarına (PhoneFactory ve LaptopFactory) bu methodları uyguladık. Ana işlem processOrder metodu, Factory Method’u çağırarak bir ürün oluşturup ve onunla ilgili bilgileri gösterdik. Main sınıfında, farklı ürünleri sipariş ederek ve bilgileri görüntüleyerek bu desenin nasıl kullanılacağını görmüş olduk.

Yorum Bırak

Singleton Design Pattern: Bir sınıfın yalnızca bir örneğinin oluşturulmasını sağlar ve bu örneğe genel bir erişim noktası sunar. Singleton design pattern, bir uygulamada yalnızca bir örneğin olması gerektiği durumlarda sıklıkla kullanılır. Örneğin bir sistemde sadece bir dosya yöneticisi olmasını istediğinizi varsayalım. Bu dosya yöneticisi, dosya oluşturma, okuma, yazma gibi işlemleri gerçekleştirecek. İşte bu senaryoda Singleton deseni kullanabiliriz.

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class FileManager {
    private static FileManager instance;
    private File file;

    // Constructor private tanımlayıp, örnek yaparken bir dosya oluşturuyoruz
    private FileManager() {
        try {
            this.file = new File("singleton_design_pattern.txt");
            if (!this.file.exists()) {
                this.file.createNewFile();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // Singleton örneğini döndüren method
    public static FileManager getInstance() {
        if (instance == null) {
            instance = new FileManager();
        }
        return instance;
    }

    // Dosyaya yazma methodu
    public void writeToFile(String content) {
        try (FileWriter writer = new FileWriter(this.file, true)) {
            writer.write(content + "\n");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // Dosya okuma methodu
    public String readFromFile() {
        // Burada dosyadan okuma işlemi gerçekleştirilebilir. Örneği basitleştirmek için metin döndürüyoruz.
        return "Bu dosyadan okunan bir metin.";
    }
}

Aşağıda ise Main classından Dosya Yönetcisini çağırabiliriz.

public class Main {
    public static void main(String[] args) {

        // Singleton Design Pattern
        singletonDesignPattern();
    }

    private static void singletonDesignPattern() {
        // singleton design pattern için dosya yöneticisi örneğini alma
        FileManager fileManager1 = FileManager.getInstance();
        FileManager fileManager2 = FileManager.getInstance();

        // İki dosya yöneticisi örneği aynı mı kontrolü
        System.out.println("İki dosya yöneticisi örneği aynı mı : " + (fileManager1 == fileManager2));  // Çıktı: true

        // Dosyaya yazma ve okuma işlemleri
        fileManager1.writeToFile("Dosya yazma test metni.");
        String content = fileManager2.readFromFile();
        System.out.println("Dosyadan okunan içerik : " + content);
    }
}

Bu örnekte, FileManager sınıfı, dosya oluşturma, yazma ve okuma işlemleri için kullanılabilir. Singleton design pattern, yalnızca bir dosya yöneticisi örneğine izin verir ve bu örneğe global bir erişim sağlar. Bu sayede uygulama içinde dosya işlemleri için tek bir noktadan yönetim sağlanır.

Yorum Bırak

Creational Patterns (Yaratıcı Desenler) bahsedecek olursak, yeni nesnelerin(objects) nasıl oluşturulacağına ve başlatılacağına ilişkin problemleri ele alır. Bu desenler, nesnelerin oluşturulmasını, başlatılmasını ve yönetilmesini daha esnek ve modüler hale getirerek, uygulamanın yapısını geliştirilmesini benimser. Kullanılan creational patternler:

1. Singleton Design Pattern (Tekil Örnek Tasarım Deseni): Bir sınıfın yalnızca bir örneğinin oluşturulmasını sağlar ve bu örneğe genel bir erişim noktası sunar. Singleton design pattern, bir uygulamada yalnızca bir örneğin olması gerektiği durumlarda sıklıkla kullanılır.
2. Factory Method Design Pattern (Fabrika Yöntemi Tasarım Deseni): Bu pattern, bir arayüz sağlar ve alt sınıfların bu arayüzü uygulayarak nesneleri oluşturmasını sağlar. Bu sayede, nesne oluşturma işlemi istemciden gizlenir. Böylelikle alt sınıfların nesne oluşturma mantığını değiştirmesi kolaylaşır. Factory Method, nesnelerin oluşturulmasıyla ilgili kararların alt sınıflara devredilmesi gerektiği durumlarda kullanılır.
3. Abstract Factory Design Pattern (Soyut Fabrika Tasarım Deseni): Bir nesne ailesi oluşturmak için soyut bir arayüz sağlar. Ardından, bu arayüzü uygulayan farklı fabrika sınıfları, farklı nesne ailelerini oluşturabilir. Bu pattern ile ilgili nesne gruplarının bir arada kullanılması gerektiği durumlarda kullanılır ve sistemlerin daha kolay genişletilmesini sağlar.
4. Builder Design Pattern (Oluşturucu Tasarım Deseni): Karmaşık nesnelerin adım adım oluşturulmasını sağlar. Nesne oluşturma süreci, adım adım yönlendirilir ve nesne oluşturmayı karmaşık bir yapıdan ayırır. Builder design patterni, nesnelerin farklı bileşenlerinin aynı oluşturulma sürecini kullanarak farklı nesne varyasyonlarını oluşturmak için kullanışlıdır.
5. Prototype Design Pattern (Prototip Tasarım Deseni): Mevcut bir nesnenin klonlanması ile yeni bir nesne oluşturmayı sağlar. Bu pattern, nesnelerin türetilmesi maliyetli veya zor olduğunda kullanışlıdır. Özellikle, büyük nesne oluşturma maliyeti varsa veya nesnelerin durumu dinamik olarak değişiyorsa kullanışlı olabilir.

Bu creational design patternler ile nesne oluşturma sürecini daha modüler ve esnek hale getirir, böylece kodun daha okunabilir, bakımı daha kolay ve yeniden kullanılabilir olmasını sağlar.

Yorum Bırak