0Pricing
Clean Architecture & Design Patterns in Practice · Ders

Tekil ve Fabrika Metodu

Benzersiz örnekler için Tekil kalıbını, esnek nesne oluşturma için Fabrika Metodunu uygulayın.

Tekil ve Fabrika Metodu, CoddyKit'te ücretsiz bir Clean Architecture & Design Patterns in Practice dersidir. Bu, 4 dersinin 1. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Clean Architecture & Design Patterns in Practice öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Clean Architecture & Design Patterns in Practice kursu toplamda 4 dersten oluşur.

Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.

Intro to Creational Patterns

Welcome to our lesson on Creational Design Patterns! These patterns are all about how objects are created.

They help us manage object instantiation in a way that makes our systems more flexible and robust. Instead of directly creating objects everywhere, we use patterns to control this process.

Singleton: One Instance Only

The Singleton pattern ensures that a class has only one instance and provides a global point of access to that instance.

  • It's useful for resources that should be unique, like a configuration manager or a logger.
  • To achieve this, the class typically has a private constructor and a static method that returns the single instance.

Building a Basic Singleton

Here's a simple example of a Singleton. Notice the private constructor and the static getInstance() method.

The getInstance() method checks if an instance already exists; if not, it creates one. Otherwise, it returns the existing one.

public class SimpleLogger {
  private static SimpleLogger instance;

  // Private constructor to prevent direct instantiation
  private SimpleLogger() {
    System.out.println("SimpleLogger instance created!");
  }

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

  public void log(String message) {
    System.out.println("LOG: " + message);
  }
}

public class Main {
  public static void main(String[] args) {
    SimpleLogger logger1 = SimpleLogger.getInstance();
    logger1.log("Application starting up.");

    SimpleLogger logger2 = SimpleLogger.getInstance();
    logger2.log("Processing user request.");

    if (logger1 == logger2) {
      System.out.println("Both logger references point to the same instance!");
    }
  }
}

Singleton: Thread-Safe Access

The basic Singleton can have issues in multi-threaded environments. If multiple threads call getInstance() at the same time when instance is null, more than one instance could be created.

We can make it thread-safe by using the synchronized keyword on the getInstance() method. This ensures only one thread can execute it at a time.

public class ThreadSafeLogger {
  private static ThreadSafeLogger instance;

  private ThreadSafeLogger() {
    System.out.println("ThreadSafeLogger instance created!");
  }

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

  public void log(String message) {
    System.out.println("TS_LOG: " + message);
  }
}

public class Main {
  public static void main(String[] args) {
    // In a real app, threads would access this concurrently.
    // Here, we just show it works correctly sequentially.
    ThreadSafeLogger tsLogger1 = ThreadSafeLogger.getInstance();
    tsLogger1.log("Task A completed.");

    ThreadSafeLogger tsLogger2 = ThreadSafeLogger.getInstance();
    tsLogger2.log("Task B started.");

    if (tsLogger1 == tsLogger2) {
      System.out.println("Thread-safe instances are the same!");
    }
  }
}

Singleton Use Cases

When should you consider using the Singleton pattern?

  • Configuration Manager: To hold application settings, ensuring all parts of the app use the same settings.
  • Logger: For a single logging service to write application events.
  • Database Connection Pool: To manage a limited set of database connections efficiently across the application.

The Problem: Hardcoded Creation

Now, let's look at the Factory Method pattern. Imagine you have code that creates objects directly, like new Car() or new Truck().

What happens if you need to add a new vehicle type, or change how a Car is created? You'd have to find and update every place in your code that creates these objects. This makes your code rigid and hard to maintain!

Factory Method: Abstracting Creation

The Factory Method pattern solves this by defining an interface or abstract class for creating an object, but letting subclasses decide which class to instantiate.

  • It delegates object creation to specialized 'factory' methods.
  • This promotes loose coupling by allowing client code to work with interfaces instead of concrete classes.

Building with Factory Method

Let's create a system for different types of transport. We define a Transport interface, concrete transport classes, and then a TransportFactory with a factory method.

Each specific factory (e.g., CarFactory) knows how to create its specific product.

// Product Interface
interface Transport {
  void deliver();
}

// Concrete Products
class Truck implements Transport {
  @Override
  public void deliver() {
    System.out.println("Deliver by land in a truck.");
  }
}

class Ship implements Transport {
  @Override
  public void deliver() {
    System.out.println("Deliver by sea in a ship.");
  }
}

// Creator Interface (with Factory Method)
abstract class Logistics {
  public void planDelivery() {
    Transport t = createTransport();
    t.deliver();
  }

  // The Factory Method
  public abstract Transport createTransport();
}

// Concrete Creators
class RoadLogistics extends Logistics {
  @Override
  public Transport createTransport() {
    return new Truck();
  }
}

class SeaLogistics extends Logistics {
  @Override
  public Transport createTransport() {
    return new Ship();
  }
}

public class Main {
  public static void main(String[] args) {
    Logistics roadLogistics = new RoadLogistics();
    roadLogistics.planDelivery(); // Outputs: Deliver by land in a truck.

    Logistics seaLogistics = new SeaLogistics();
    seaLogistics.planDelivery(); // Outputs: Deliver by sea in a ship.
  }
}

Advantages of Factory Method

The Factory Method pattern brings several key benefits to your software design:

  • Loose Coupling: Your client code interacts only with the Logistics interface, not specific Truck or Ship classes.
  • Extensibility: You can easily add new transport types (e.g., AirLogistics with Plane) without changing existing Logistics or client code.
  • Single Responsibility: The responsibility of creating objects is moved to dedicated factory classes/methods.

Check Your Knowledge

Let's test your understanding of the Singleton and Factory Method patterns.

Recap: Singleton & Factory

Great job! In this lesson, we explored two powerful creational design patterns:

  • Singleton: Ensures a class has only one instance and provides a global access point. Remember to consider thread-safety!
  • Factory Method: Delegates object creation to subclasses, promoting loose coupling and making your code more extensible.

These patterns are fundamental for building flexible and maintainable software. Next, we'll dive into more creational patterns like Abstract Factory and Builder!

Sıkça Sorulan Sorular

“Tekil ve Fabrika Metodu” dersi ücretsiz mi?

Evet — “Tekil ve Fabrika Metodu” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Clean Architecture & Design Patterns in Practice kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Clean Architecture & Design Patterns in Practice kursu toplamda 4 dersten oluşur.

“Tekil ve Fabrika Metodu” dersinde ne öğreneceğim?

Benzersiz örnekler için Tekil kalıbını, esnek nesne oluşturma için Fabrika Metodunu uygulayın. Clean Architecture & Design Patterns in Practice ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Clean Architecture & Design Patterns in Practice öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Clean Architecture & Design Patterns in Practice, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 1. dersidir.

“Tekil ve Fabrika Metodu” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Clean Architecture & Design Patterns in Practice dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Clean Architecture & Design Patterns in Practice dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. Tekil ve Fabrika Metodu
  2. Soyut Fabrika ve Oluşturucu
  3. Prototip ve Nesne Havuzu
  4. Nesne Oluşturma Tekniği Olarak Bağımlılık Enjeksiyonu
← Clean Architecture & Design Patterns in Practice Sayfasına Dön