Javaのデザインパターンで実現するパフォーマンス最適化の実践方法

public class Singleton {
    private static Singleton instance;

    // コンストラクタは外部からアクセスできないようにする
    private Singleton() {}

    // インスタンスが未作成の場合にのみ新規作成する
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

// 製品のインターフェース
interface Product {
    void create();
}

// 具体的な製品クラス
class ConcreteProductA implements Product {
    @Override
    public void create() {
        System.out.println("Product A is created");
    }
}

class ConcreteProductB implements Product {
    @Override
    public void create() {
        System.out.println("Product B is created");
    }
}

// ファクトリークラス
class ProductFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        }
        throw new IllegalArgumentException("Unknown product type");
    }
}

public class Main {
    public static void main(String[] args) {
        Product productA = ProductFactory.createProduct("A");
        productA.create();  // Output: Product A is created

        Product productB = ProductFactory.createProduct("B");
        productB.create();  // Output: Product B is created
    }
}

import java.util.HashMap;
import java.util.Map;

// フライウェイトインターフェース
interface Flyweight {
    void operation(String extrinsicState);
}

// 具体的なフライウェイトクラス
class ConcreteFlyweight implements Flyweight {
    private String intrinsicState;

    public ConcreteFlyweight(String intrinsicState) {
        this.intrinsicState = intrinsicState;
    }

    @Override
    public void operation(String extrinsicState) {
        System.out.println("Intrinsic State: " + intrinsicState + ", Extrinsic State: " + extrinsicState);
    }
}

// フライウェイトファクトリー
class FlyweightFactory {
    private static Map<String, Flyweight> flyweightPool = new HashMap<>();

    public static Flyweight getFlyweight(String key) {
        if (!flyweightPool.containsKey(key)) {
            flyweightPool.put(key, new ConcreteFlyweight(key));
        }
        return flyweightPool.get(key);
    }
}

public class Main {
    public static void main(String[] args) {
        Flyweight flyweight1 = FlyweightFactory.getFlyweight("A");
        flyweight1.operation("First Call");

        Flyweight flyweight2 = FlyweightFactory.getFlyweight("A");
        flyweight2.operation("Second Call");

        Flyweight flyweight3 = FlyweightFactory.getFlyweight("B");
        flyweight3.operation("First Call with B");
    }
}

Intrinsic State: A, Extrinsic State: First Call
Intrinsic State: A, Extrinsic State: Second Call
Intrinsic State: B, Extrinsic State: First Call with B

// 実際のリソース
interface Image {
    void display();
}

class RealImage implements Image {
    private String filename;

    public RealImage(String filename) {
        this.filename = filename;
        loadFromDisk();
    }

    private void loadFromDisk() {
        System.out.println("Loading " + filename);
    }

    @Override
    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;
    }

    @Override
    public void display() {
        // 遅延初期化：必要な時にのみ実際の画像をロード
        if (realImage == null) {
            realImage = new RealImage(filename);
        }
        realImage.display();
    }
}

public class Main {
    public static void main(String[] args) {
        Image image = new ProxyImage("test_image.jpg");

        // 初回の表示で画像がロードされる
        image.display();  // Output: Loading test_image.jpg
                          //         Displaying test_image.jpg

        // 2回目の表示ではロードをスキップ
        image.display();  // Output: Displaying test_image.jpg
    }
}

// ストラテジーのインターフェース
interface SortStrategy {
    void sort(int[] array);
}

// 具体的なストラテジークラス
class BubbleSort implements SortStrategy {
    @Override
    public void sort(int[] array) {
        System.out.println("Using Bubble Sort");
        // バブルソートの実装
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
}

class QuickSort implements SortStrategy {
    @Override
    public void sort(int[] array) {
        System.out.println("Using Quick Sort");
        quickSort(array, 0, array.length - 1);
    }

    private void quickSort(int[] array, int low, int high) {
        if (low < high) {
            int pi = partition(array, low, high);
            quickSort(array, low, pi - 1);
            quickSort(array, pi + 1, high);
        }
    }

    private int partition(int[] array, int low, int high) {
        int pivot = array[high];
        int i = (low - 1);
        for (int j = low; j < high; j++) {
            if (array[j] <= pivot) {
                i++;
                int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }
        int temp = array[i + 1];
        array[i + 1] = array[high];
        array[high] = temp;
        return i + 1;
    }
}

class SortContext {
    private SortStrategy strategy;

    // ストラテジーを動的に設定
    public void setSortStrategy(SortStrategy strategy) {
        this.strategy = strategy;
    }

    public void sortArray(int[] array) {
        strategy.sort(array);
    }
}

public class Main {
    public static void main(String[] args) {
        SortContext context = new SortContext();

        int[] array = {64, 34, 25, 12, 22, 11, 90};

        // バブルソートを使用
        context.setSortStrategy(new BubbleSort());
        context.sortArray(array);

        // クイックソートを使用
        context.setSortStrategy(new QuickSort());
        context.sortArray(array);
    }
}

Using Bubble Sort
Using Quick Sort

import java.util.ArrayList;
import java.util.List;

// サブジェクト（観測対象）
interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

// 具体的なサブジェクト（ニュース発行者）
class NewsPublisher implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String latestNews;

    public void setNews(String news) {
        this.latestNews = news;
        notifyObservers();
    }

    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(latestNews);
        }
    }
}

// オブザーバー
interface Observer {
    void update(String news);
}

// 具体的なオブザーバー（ユーザー）
class NewsSubscriber implements Observer {
    private String name;

    public NewsSubscriber(String name) {
        this.name = name;
    }

    @Override
    public void update(String news) {
        System.out.println(name + " received news: " + news);
    }
}

public class Main {
    public static void main(String[] args) {
        NewsPublisher publisher = new NewsPublisher();

        // オブザーバー（購読者）を登録
        Observer user1 = new NewsSubscriber("Alice");
        Observer user2 = new NewsSubscriber("Bob");

        publisher.registerObserver(user1);
        publisher.registerObserver(user2);

        // ニュースを発行し、オブザーバーに通知
        publisher.setNews("Breaking News: Design Patterns in Java!");

        // Bobが購読解除
        publisher.removeObserver(user2);

        // 新しいニュースを発行
        publisher.setNews("Latest Update: Observer Pattern Explained!");
    }
}

Alice received news: Breaking News: Design Patterns in Java!
Bob received news: Breaking News: Design Patterns in Java!
Alice received news: Latest Update: Observer Pattern Explained!

public class DatabaseConnection {
    private static DatabaseConnection instance;
    private Connection connection;

    private DatabaseConnection() {
        try {
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "user", "password");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

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

    public Connection getConnection() {
        return connection;
    }
}

// リクエスト処理のインターフェース
interface RequestHandler {
    void handle();
}

// 具体的なリクエスト処理クラス
class SearchRequestHandler implements RequestHandler {
    @Override
    public void handle() {
        System.out.println("Handling search request");
    }
}

class OrderRequestHandler implements RequestHandler {
    @Override
    public void handle() {
        System.out.println("Handling order request");
    }
}

// リクエストハンドラーファクトリー
class RequestHandlerFactory {
    public static RequestHandler getRequestHandler(String requestType) {
        if (requestType.equals("search")) {
            return new SearchRequestHandler();
        } else if (requestType.equals("order")) {
            return new OrderRequestHandler();
        }
        throw new IllegalArgumentException("Unknown request type");
    }
}

// フライウェイト製品クラス
class Product {
    private String name; // 共通データ
    private String description; // 共通データ
    private double price; // 共通データ
    private String userSpecificData; // 個別データ

    public Product(String name, String description, double price) {
        this.name = name;
        this.description = description;
        this.price = price;
    }

    public void setUserSpecificData(String userSpecificData) {
        this.userSpecificData = userSpecificData;
    }

    public void display() {
        System.out.println("Product: " + name + ", " + description + ", Price: " + price + ", User Data: " + userSpecificData);
    }
}

// フライウェイトファクトリー
class ProductFactory {
    private static final Map<String, Product> productPool = new HashMap<>();

    public static Product getProduct(String name) {
        Product product = productPool.get(name);
        if (product == null) {
            product = new Product(name, "Default Description", 99.99);
            productPool.put(name, product);
        }
        return product;
    }
}

interface APIService {
    String fetchData();
}

class RealAPIService implements APIService {
    @Override
    public String fetchData() {
        // 実際のAPI呼び出し
        return "API Response";
    }
}

class APIServiceProxy implements APIService {
    private RealAPIService realAPIService;
    private String cachedData;

    @Override
    public String fetchData() {
        if (cachedData == null) {
            realAPIService = new RealAPIService();
            cachedData = realAPIService.fetchData();
        }
        return cachedData;
    }
}