Gang of Four (GoF) Tasarım Desenleri: Oluşturucu, Yapısal ve Davranışsal Desenlerin Derinlemesine İncelenmesi

Gang of Four (GoF) Tasarım Desenleri: Oluşturucu, Yapısal ve Davranışsal Desenlerin Derinlemesine İncelenmesi

Yazılım geliştirmede karşılaşılan yaygın sorunlara zarif ve yeniden kullanılabilir çözümler sunan tasarım desenleri, modern yazılım mühendisliğinin temel taşlarından biridir. Bu desenler, deneyimli yazılımcıların yıllar içinde edindikleri bilgileri damıtarak, belirli bağlamlarda tekrar eden problemlere kanıtlanmış yaklaşımlar sunar. Tasarım desenleri, bir dil veya platforma özgü olmaktan ziyade, soyut kavramlar ve prensipler bütünüdür.

“Tasarım Desenleri: Yeniden Kullanılabilir Nesne Yönelimli Yazılımların Elemanları” (Design Patterns: Elements of Reusable Object-Oriented Software) adlı kitap, Erich Gamma, Richard Helm, Ralph Johnson ve John Vlissides (kısaca “Gang of Four” veya “GoF”) tarafından yazılmıştır. Bu çığır açan eser, 23 temel tasarım desenini üç ana kategoriye ayırarak yazılım dünyasına sunmuştur: Oluşturucu (Creational), Yapısal (Structural) ve Davranışsal (Behavioral). Bu makale, GoF desenlerinin bu üç kategorisini derinlemesine inceleyecek, her bir kategorideki önemli desenleri örneklerle açıklayacak ve yazılım mimarisindeki rollerini vurgulayacaktır.

Tasarım Desenlerinin Önemi ve Temel Kavramlar

Tasarım desenleri, kodun okunabilirliğini, sürdürülebilirliğini ve genişletilebilirliğini artırır. Ortak bir “tasarım sözlüğü” sağlayarak geliştiriciler arasındaki iletişimi kolaylaştırır. Bir desen uygulamak, genellikle belirli bir prensibi (örn. SOLID prensipleri) takip etmeyi gerektirir ve bu da daha sağlam ve esnek yazılım sistemleri oluşturmaya yardımcı olur. Desenler, bir çözümün “nasıl” uygulandığını değil, bir problemin “ne” olduğunu ve bu probleme yönelik genel bir çözüm stratejisini tanımlar.

Oluşturucu (Creational) Tasarım Desenleri

Oluşturucu desenler, nesne oluşturma mekanizmalarını soyutlayarak, istemcinin (client) somut sınıflardan bağımsız olmasını sağlar. Bu desenler, bir sistemin hangi somut sınıfları kullandığı hakkında bilgi edinme gereksinimini ortadan kaldırarak esneklik sunar.

Singleton Deseni

* Amaç: Bir sınıfın yalnızca tek bir örneğe sahip olmasını sağlamak ve bu örneğe küresel bir erişim noktası sunmaktır.
* Kullanım Alanları: Veritabanı bağlantı havuzları, yapılandırma yöneticileri, günlükleme (logging) mekanizmaları gibi kaynakların tek bir noktadan yönetilmesi gereken durumlar.
* Örnek:

class ConfigurationManager {
        private static ConfigurationManager instance;
        private ConfigurationManager() { / Private constructor / }

        public static ConfigurationManager getInstance() {
            if (instance == null) {
                instance = new ConfigurationManager();
            }
            return instance;
        }

        public void loadSettings() { / ... / }
    }

Factory Method Deseni

* Amaç: Bir nesne oluşturmak için bir arayüz tanımlamak, ancak hangi somut sınıfın örnekleneceğine alt sınıfların karar vermesine izin vermektir. Fabrika Yöntemi, bir sınıfın örneklendirme sorumluluğunu alt sınıflara devreder.
* Kullanım Alanları: Farklı türde ürünlerin (örneğin, farklı belge türleri: PDF, Word) oluşturulması gerektiğinde ve bu ürünlerin oluşturulma mantığının istemciden soyutlanması istendiğinde.
* Örnek:

interface Product { void operation(); }
    class ConcreteProductA implements Product { public void operation() { System.out.println("Product A"); } }
    class ConcreteProductB implements Product { public void operation() { System.out.println("Product B"); } }

    abstract class Creator {
        public abstract Product factoryMethod();
        public void someOperation() {
            Product product = factoryMethod();
            product.operation();
        }
    }

    class ConcreteCreatorA extends Creator { public Product factoryMethod() { return new ConcreteProductA(); } }
    class ConcreteCreatorB extends Creator { public Product factoryMethod() { return new ConcreteProductB(); } }

Abstract Factory Deseni

* Amaç: Birbirine bağımlı veya ilgili nesne ailelerini, somut sınıflarını belirtmeden oluşturmak için bir arayüz sağlamaktır.
* Kullanım Alanları: Farklı işletim sistemleri için farklı kullanıcı arayüzü bileşenleri (düğmeler, metin kutuları) oluşturma veya farklı veritabanları için farklı bağlantı nesneleri ve sorgu oluşturucular sağlama gibi durumlarda.
* Örnek:

interface Button { void paint(); }
    interface Checkbox { void paint(); }

    class WinButton implements Button { public void paint() { System.out.println("Windows Button"); } }
    class MacButton implements Button { public void paint() { System.out.println("Mac Button"); } }

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

    class WinFactory implements GUIFactory {
        public Button createButton() { return new WinButton(); }
        public Checkbox createCheckbox() { return new WinCheckbox(); } // Assume WinCheckbox exists
    }
    // MacFactory similarly

Builder Deseni

* Amaç: Karmaşık bir nesnenin yapımını temsilinden ayırmak, böylece aynı yapım sürecinin farklı temsiller oluşturmasına olanak tanımaktır.
* Kullanım Alanları: Çok sayıda isteğe bağlı parametreye sahip, adım adım oluşturulması gereken nesneler için (örneğin, bir rapor oluşturucu, bir SQL sorgusu oluşturucu).
* Örnek:

class House {
        private String walls;
        private String roof;
        private String garden;
        // Getters for walls, roof, garden
        public House(String walls, String roof, String garden) {
            this.walls = walls; this.roof = roof; this.garden = garden;
        }
    }

    interface HouseBuilder {
        void buildWalls();
        void buildRoof();
        void buildGarden();
        House getHouse();
    }

    class ConcreteHouseBuilder implements HouseBuilder {
        private String walls; private String roof; private String garden;
        public void buildWalls() { this.walls = "Concrete Walls"; }
        public void buildRoof() { this.roof = "Tile Roof"; }
        public void buildGarden() { this.garden = "Small Garden"; }
        public House getHouse() { return new House(walls, roof, garden); }
    }

    class Director { // Orchestrates the building process
        public House construct(HouseBuilder builder) {
            builder.buildWalls();
            builder.buildRoof();
            builder.buildGarden();
            return builder.getHouse();
        }
    }

Prototype Deseni

* Amaç: Oluşturulacak nesne türlerini prototip bir örnek kullanarak belirtmek ve yeni nesneleri bu prototipi kopyalayarak oluşturmaktır.
* Kullanım Alanları: Bir nesnenin doğrudan new anahtar kelimesiyle oluşturulmasının maliyetli olduğu veya karmaşık olduğu durumlarda. Nesnelerin çok benzer olduğu ve küçük farklılıklarla çoğaltılabileceği durumlar.
* Örnek:

interface ClonableShape extends Cloneable {
        ClonableShape clone();
        void draw();
    }

    class Circle implements ClonableShape {
        private int radius;
        public Circle(int r) { this.radius = r; }
        public ClonableShape clone() { return new Circle(this.radius); }
        public void draw() { System.out.println("Drawing a circle with radius " + radius); }
    }
    // Rectangle similarly

Yapısal (Structural) Tasarım Desenleri

Yapısal desenler, sınıfların ve nesnelerin daha büyük yapılar oluşturmak üzere nasıl bir araya getirileceğini ele alır. Bu desenler, nesnelerin yapılarını ve ilişkilerini düzenleyerek sistemin esnekliğini ve verimliliğini artırır.

Adapter Deseni

* Amaç: Bir sınıfın arayüzünü, istemcinin beklediği başka bir arayüze dönüştürmektir. Adaptör, uyumsuz arayüzlere sahip sınıfların birlikte çalışmasını sağlar.
* Kullanım Alanları: Mevcut bir sınıfın arayüzünün (örneğin, eski bir kütüphane) yeni bir sisteme entegre edilmesi gerektiğinde.
* Örnek:

interface Target { void request(); }
    class Adaptee { public void specificRequest() { System.out.println("Adaptee's specific request"); } }

    class Adapter implements Target {
        private Adaptee adaptee;
        public Adapter(Adaptee a) { this.adaptee = a; }
        public void request() {
            adaptee.specificRequest(); // Adaptee's method is called through the Target interface
        }
    }

Bridge Deseni

* Amaç: Bir soyutlamayı uygulamasından ayırmak, böylece ikisinin bağımsız olarak değişebilmesini sağlamaktır.
* Kullanım Alanları: Farklı soyutlamaların (örneğin, farklı şekiller) ve farklı uygulamaların (örneğin, farklı çizim API’leri) olduğu durumlarda, alt sınıf patlamasını (subclass explosion) önlemek için.
* Örnek:

interface DrawingAPI {
        void drawCircle(int x, int y, int radius);
    }

    class DrawingAPI1 implements DrawingAPI {
        public void drawCircle(int x, int y, int radius) { System.out.println("API1.circle " + radius); }
    }
    class DrawingAPI2 implements DrawingAPI {
        public void drawCircle(int x, int y, int radius) { System.out.println("API2.circle " + radius); }
    }

    abstract class Shape {
        protected DrawingAPI drawingAPI;
        protected Shape(DrawingAPI api) { this.drawingAPI = api; }
        public abstract void draw();
    }

    class CircleShape extends Shape {
        private int x, y, radius;
        public CircleShape(int x, int y, int r, DrawingAPI api) {
            super(api); this.x = x; this.y = y; this.radius = r;
        }
        public void draw() { drawingAPI.drawCircle(x, y, radius); }
    }

Composite Deseni

* Amaç: Nesneleri ağaç yapılarına (part-whole hierarchies) birleştirmek, böylece istemcilerin bireysel nesneleri ve nesne kompozisyonlarını tekdüze bir şekilde ele almasını sağlamaktır.
* Kullanım Alanları: Dosya sistemleri (dosyalar ve klasörler), grafik editörleri (şekiller ve şekil grupları) gibi hiyerarşik yapıları temsil etmek için.
* Örnek:

interface Component { void operation(); }

    class Leaf implements Component { // Individual object
        private String name;
        public Leaf(String name) { this.name = name; }
        public void operation() { System.out.println("Leaf " + name + " operation"); }
    }

    class Composite implements Component { // Composition of objects
        private String name;
        private List children = new ArrayList<>();
        public Composite(String name) { this.name = name; }
        public void add(Component c) { children.add(c); }
        public void remove(Component c) { children.remove(c); }
        public void operation() {
            System.out.println("Composite " + name + " operation");
            for (Component c : children) { c.operation(); }
        }
    }

Decorator Deseni

* Amaç: Bir nesneye dinamik olarak ek sorumluluklar eklemektir. Dekoratörler, işlevselliği genişletmek için alt sınıflara ayırmanın esnek bir alternatifini sunar.
* Kullanım Alanları: Bir nesnenin davranışını çalışma zamanında değiştirmek veya geliştirmek istendiğinde (örneğin, bir kahveye süt, şeker eklemek veya bir metin akışına sıkıştırma/şifreleme eklemek).
* Örnek:

interface Coffee { String getDescription(); double getCost(); }

    class SimpleCoffee implements Coffee {
        public String getDescription() { return "Simple Coffee"; }
        public double getCost() { return 5.0; }
    }

    abstract class CoffeeDecorator implements Coffee {
        protected Coffee decoratedCoffee;
        public CoffeeDecorator(Coffee coffee) { this.decoratedCoffee = coffee; }
        public String getDescription() { return decoratedCoffee.getDescription(); }
        public double getCost() { return decoratedCoffee.getCost(); }
    }

    class MilkDecorator extends CoffeeDecorator {
        public MilkDecorator(Coffee coffee) { super(coffee); }
        public String getDescription() { return super.getDescription() + ", Milk"; }
        public double getCost() { return super.getCost() + 1.5; }
    }

Facade Deseni

* Amaç: Bir alt sistemdeki bir dizi arayüze birleşik bir arayüz sağlamaktır. Facade, alt sistemi daha kolay kullanılabilir hale getiren üst düzey bir arayüz tanımlar.
* Kullanım Alanları: Karmaşık bir alt sistemin istemciler tarafından daha basit bir şekilde kullanılmasını sağlamak. Bir kütüphanenin veya API’nin karmaşıklığını gizlemek.
* Örnek:

class SubsystemA { public void operationA() { System.out.println("Subsystem A operation"); } }
    class SubsystemB { public void operationB() { System.out.println("Subsystem B operation"); } }
    class SubsystemC { public void operationC() { System.out.println("Subsystem C operation"); } }

    class Facade {
        private SubsystemA subA;
        private SubsystemB subB;
        private SubsystemC subC;

        public Facade() {
            subA = new SubsystemA();
            subB = new SubsystemB();
            subC = new SubsystemC();
        }

        public void complexOperation() {
            System.out.println("Facade starts complex operation:");
            subA.operationA();
            subB.operationB();
            subC.operationC();
            System.out.println("Facade ends complex operation.");
        }
    }

Proxy Deseni

* Amaç: Başka bir nesneye erişimi kontrol etmek için bir vekil veya yer tutucu sağlamaktır.
* Kullanım Alanları: Uzak nesneler için yerel temsilci (Remote Proxy), pahalı nesnelerin gecikmeli yüklenmesi (Virtual Proxy), erişim kontrolü (Protection Proxy) veya günlükleme gibi ek işlevler eklemek.
* Örnek:

interface Image { void display(); }

    class RealImage implements Image {
        private String filename;
        public RealImage(String filename) {
            this.filename = filename;
            loadFromDisk(filename);
        }
        private void loadFromDisk(String filename) { System.out.println("Loading " + filename); }
        public void display() { System.out.println("Displaying " + filename); }
    }

    class ProxyImage implements Image {
        private RealImage realImage;
        private String filename;
        public ProxyImage(String filename) { this.filename = filename; }
        public void display() {
            if (realImage == null) {
                realImage = new RealImage(filename); // Lazy loading
            }
            realImage.display();
        }
    }

Davranışsal (Behavioral) Tasarım Desenleri

Davranışsal desenler, nesneler arasındaki etkileşimleri ve sorumluluk dağılımını ele alır. Bu desenler, nesneler arasındaki iletişimi ve algoritma akışını iyileştirerek sistemin esnekliğini ve genişletilebilirliğini artırır.

Chain of Responsibility Deseni

* Amaç: Bir isteğin göndericisini alıcısından ayırarak, isteği işleme şansı olan birden fazla nesneye izin vermektir. İstek, zincirdeki bir nesne tarafından işlenene kadar zincir boyunca iletilir.
* Kullanım Alanları: Bir isteği işleyebilecek birden fazla işleyici olduğunda ve bu işleyicilerin sırası dinamik olarak değişebildiğinde (örneğin, bir olay işleme sistemi, bir onay iş akışı).
* Örnek:

abstract class Handler {
        protected Handler nextHandler;
        public void setNextHandler(Handler next) { this.nextHandler = next; }
        public abstract void handleRequest(int request);
    }

    class ConcreteHandler1 extends Handler {
        public void handleRequest(int request) {
            if (request >= 0 && request < 10) { System.out.println("Handler1 handled request " + request); }
            else if (nextHandler != null) { nextHandler.handleRequest(request); }
        }
    }
    // ConcreteHandler2 similarly

Command Deseni

* Amaç: Bir isteği bir nesne olarak kapsüllemektir, böylece istemcileri farklı isteklerle parametreleyebilir, istekleri kuyruğa alabilir veya günlüğe kaydedebilir ve geri alınabilir işlemleri destekleyebilirsiniz.
* Kullanım Alanları: Geri alma/yineleme işlevselliği, makrolar, işlem günlükleri, GUI düğmeleri gibi eylemlerin soyutlanması gereken durumlar.
* Örnek:

interface Command { void execute(); void undo(); }

    class Light { // Receiver
        public void turnOn() { System.out.println("Light is ON"); }
        public void turnOff() { System.out.println("Light is OFF"); }
    }

    class TurnOnLightCommand implements Command {
        private Light light;
        public TurnOnLightCommand(Light l) { this.light = l; }
        public void execute() { light.turnOn(); }
        public void undo() { light.turnOff(); }
    }

    class RemoteControl { // Invoker
        private Command command;
        public void setCommand(Command cmd) { this.command = cmd; }
        public void pressButton() { command.execute(); }
    }

Iterator Deseni

* Amaç: Bir toplu nesnenin (aggregate object) öğelerine, temel temsilini açığa vurmadan sıralı bir şekilde erişmek için bir yol sağlamaktır.
* Kullanım Alanları: Farklı koleksiyon yapıları (liste, ağaç, hash tablosu) üzerinde tekdüze bir gezinme mekanizması sağlamak.
* Örnek:

interface Iterator {
        boolean hasNext();
        Object next();
    }

    interface Aggregate {
        Iterator createIterator();
    }

    class ConcreteAggregate implements Aggregate {
        private List items = new ArrayList<>();
        public void add(String item) { items.add(item); }
        public Iterator createIterator() { return new ConcreteIterator(this); }

        private class ConcreteIterator implements Iterator {
            private ConcreteAggregate aggregate;
            private int currentIndex = 0;
            public ConcreteIterator(ConcreteAggregate agg) { this.aggregate = agg; }
            public boolean hasNext() { return currentIndex < aggregate.items.size(); }
            public Object next() {
                if (hasNext()) { return aggregate.items.get(currentIndex++); }
                return null;
            }
        }
    }

Mediator Deseni

* Amaç: Bir dizi nesnenin nasıl etkileşim kurduğunu kapsülleyen bir nesne tanımlamaktır. Mediator, nesnelerin birbirlerine açıkça başvurmasını engelleyerek gevşek bağlantıyı teşvik eder ve etkileşimlerini bağımsız olarak değiştirmeye olanak tanır.
* Kullanım Alanları: Çok sayıda nesnenin birbirleriyle doğrudan iletişim kurduğu ve bu iletişimin karmaşık hale geldiği durumlar (örneğin, bir sohbet odası, GUI diyalogları).
* Örnek:

interface Mediator {
        void sendMessage(String message, Colleague colleague);
    }

    abstract class Colleague {
        protected Mediator mediator;
        public Colleague(Mediator m) { this.mediator = m; }
        public void send(String message) { mediator.sendMessage(message, this); }
        public abstract void receive(String message);
    }

    class ConcreteColleague1 extends Colleague {
        public ConcreteColleague1(Mediator m) { super(m); }
        public void receive(String message) { System.out.println("Colleague1 Received: " + message); }
    }
    // ConcreteColleague2 similarly

    class ConcreteMediator implements Mediator {
        private ConcreteColleague1 colleague1;
        private ConcreteColleague2 colleague2; // Assume ConcreteColleague2 exists

        public void setColleague1(ConcreteColleague1 c1) { this.colleague1 = c1; }
        public void setColleague2(ConcreteColleague2 c2) { this.colleague2 = c2; }

        public void sendMessage(String message, Colleague sender) {
            if (sender == colleague1) { colleague2.receive(message); }
            else { colleague1.receive(message); }
        }
    }

Memento Deseni

* Amaç: Kapsüllemeyi ihlal etmeden, bir nesnenin içsel durumunu yakalamak ve harici hale getirmek, böylece nesnenin daha sonra bu duruma geri yüklenebilmesini sağlamaktır.
* Kullanım Alanları: Geri alma (undo) mekanizmaları, oyunlardaki kayıt noktaları gibi bir nesnenin durumunu geri yükleme ihtiyacı olduğunda.
* Örnek:

class Memento { // Stores the internal state of the Originator
        private String state;
        public Memento(String s) { this.state = s; }
        public String getState() { return state; }
    }

    class Originator { // Creates and restores Memento objects
        private String state;
        public void setState(String s) { this.state = s; }
        public Memento saveStateToMemento() { return new Memento(state); }
        public void getStateFromMemento(Memento memento) { this.state = memento.getState(); }
        public String getState() { return state; }
    }

    class Caretaker { // Manages Memento objects
        private List mementoList = new ArrayList<>();
        public void add(Memento m) { mementoList.add(m); }
        public Memento get(int index) { return mementoList.get(index); }
    }

Observer Deseni

* Amaç: Nesneler arasında bire çok bağımlılık tanımlamaktır, böylece bir nesne durumunu değiştirdiğinde, tüm bağımlıları otomatik olarak bilgilendirilir ve güncellenir.
* Kullanım Alanları: GUI bileşenleri (düğme tıklamaları), olay işleme sistemleri, haber bülteni abonelikleri gibi bir nesnenin durumundaki değişikliklerin diğer nesneler tarafından izlenmesi gerektiğinde.
* Örnek:

interface Subject {
        void attach(Observer o);
        void detach(Observer o);
        void notifyObservers();
    }

    interface Observer {
        void update();
    }

    class ConcreteSubject implements Subject {
        private List observers = new ArrayList<>();
        private int state;
        public int getState() { return state; }
        public void setState(int s) { this.state = s; notifyObservers(); }
        public void attach(Observer o) { observers.add(o); }
        public void detach(Observer o) { observers.remove(o); }
        public void notifyObservers() { for (Observer o : observers) { o.update(); } }
    }

    class ConcreteObserver implements Observer {
        private ConcreteSubject subject;
        public ConcreteObserver(ConcreteSubject s) { this.subject = s; }
        public void update() { System.out.println("Observer updated. Subject state: " + subject.getState()); }
    }

State Deseni

* Amaç: Bir nesnenin içsel durumu değiştiğinde davranışını değiştirmesine izin vermektir. Nesne, sınıfını değiştirmiş gibi görünür.
* Kullanım Alanları: Bir nesnenin davranışının durumuna göre önemli ölçüde değiştiği ve çok sayıda if-else veya switch ifadesinin kullanıldığı karmaşık durum makinelerini yönetmek.
* Örnek:

interface State {
        void handle(Context context);
    }

    class ConcreteStateA implements State {
        public void handle(Context context) {
            System.out.println("Handling in State A, changing to State B");
            context.setState(new ConcreteStateB());
        }
    }
    // ConcreteStateB similarly

    class Context {
        private State state;
        public Context() { this.state = new ConcreteStateA(); } // Initial state
        public void setState(State s) { this.state = s; }
        public void request() { state.handle(this); }
    }

Strategy Deseni

* Amaç: Bir algoritma ailesi tanımlamak, her birini kapsüllemek ve onları değiştirilebilir hale getirmektir. Strateji, algoritmanın onu kullanan istemcilerden bağımsız olarak değişmesine izin verir.
* Kullanım Alanları: Bir görevi gerçekleştirmenin birden fazla yolu olduğunda ve bu yolların çalışma zamanında seçilmesi gerektiğinde (örneğin, farklı sıralama algoritmaları, farklı ödeme yöntemleri).
* Örnek:

interface Strategy {
        int execute(int a, int b);
    }

    class AddStrategy implements Strategy {
        public int execute(int a, int b) { return a + b; }
    }
    class SubtractStrategy implements Strategy {
        public int execute(int a, int b) { return a - b; }
    }

    class ContextStrategy {
        private Strategy strategy;
        public void setStrategy(Strategy s) { this.strategy = s; }
        public int executeStrategy(int a, int b) { return strategy.execute(a, b); }
    }

Template Method Deseni

* Amaç: Bir algoritmanın iskeletini bir işlemde tanımlamak, bazı adımları alt sınıflara bırakmaktır. Şablon Yöntemi, alt sınıfların algoritmanın yapısını değiştirmeden belirli adımları yeniden tanımlamasına olanak tanır.
* Kullanım Alanları: Bir algoritmanın genel yapısının sabit olduğu, ancak belirli adımlarının alt sınıflar tarafından özelleştirilebildiği durumlar (örneğin, bir derleme süreci, bir veri işleme akışı).
* Örnek:

abstract class Game {
        protected abstract void initialize();
        protected abstract void startPlay();
        protected abstract void endPlay();

        // Template method
        public final void play() {
            initialize();
            startPlay();
            endPlay();
        }
    }

    class Chess extends Game {
        protected void initialize() { System.out.println("Chess Init"); }
        protected void startPlay() { System.out.println("Chess Start"); }
        protected void endPlay() { System.out.println("Chess End"); }
    }
    // Monopoly similarly

Visitor Deseni

* Amaç: Bir nesne yapısının öğeleri üzerinde gerçekleştirilecek bir işlemi temsil etmektir. Visitor, üzerinde çalıştığı öğelerin sınıflarını değiştirmeden yeni bir işlem tanımlamanıza olanak tanır.
* Kullanım Alanları: Farklı türdeki nesnelerden oluşan karmaşık bir nesne yapısı üzerinde yeni işlemler eklemek gerektiğinde ve bu işlemlerin nesne sınıflarına doğrudan eklenmesi istenmediğinde.
* Örnek:

interface CarElement {
        void accept(CarElementVisitor visitor);
    }

    class Wheel implements CarElement {
        private String name;
        public Wheel(String name) { this.name = name; }
        public void accept(CarElementVisitor visitor) { visitor.visit(this); }
        public String getName() { return name; }
    }
    // Engine, Body similarly

    class Car implements CarElement {
        CarElement[] elements;
        public Car() {
            this.elements = new CarElement[] { new Wheel("front left"), new Wheel("front right") };
        }
        public void accept(CarElementVisitor visitor) {
            for (CarElement elem : elements) { elem.accept(visitor); }
            visitor.visit(this);
        }
    }

    interface CarElementVisitor {
        void visit(Wheel wheel);
        void visit(Engine engine); // Assume Engine exists
        void visit(Car car);
    }

    class CarElementPrintVisitor implements CarElementVisitor {
        public void visit(Wheel wheel) { System.out.println("Visiting " + wheel.getName() + " wheel"); }
        public void visit(Engine engine) { System.out.println("Visiting engine"); }
        public void visit(Car car) { System.out.println("Visiting car"); }
    }

Sonuç ve Gelecek

Gang of Four tasarım desenleri, yazılım mühendisliğinde kalıcı bir etki bırakmıştır. Bu desenler, yalnızca belirli sorunlara çözümler sunmakla kalmaz, aynı zamanda nesne yönelimli tasarımın temel prensiplerini (örneğin, kapsülleme, soyutlama, kalıtım, polimorfizm) ve SOLID prensiplerini (Tek Sorumluluk, Açık/Kapalı, Liskov Yerine Geçme, Arayüz Ayrımı, Bağımlılık Tersine Çevirme) somutlaştırır.

Desenleri ezberlemek yerine, altında yatan prensipleri ve hangi bağlamda hangi desenin uygun olacağını anlamak çok daha önemlidir. Her desenin kendi avantajları ve dezavantajları vardır ve yanlış uygulandığında kodun karmaşıklığını artırabilir. Bir desen, bir problemi çözmek için bir araçtır, her derde deva bir çözüm değildir.

Yazılım geliştiricilerin bu desenleri öğrenmesi, daha sürdürülebilir, esnek ve genişletilebilir sistemler tasarlamalarına yardımcı olur. Ayrıca, ortak bir dil ve problem çözme yaklaşımı sağlayarak ekip içinde iletişimi güçlendirir. Yazılım evrimi devam ettikçe, yeni desenler ortaya çıkacak ve mevcut desenler farklı bağlamlarda yeniden yorumlanacaktır. Ancak GoF desenleri, yazılım mimarisi ve tasarımı alanındaki temel bilgilerin paha biçilmez bir parçası olmaya devam edecektir.