一般的に使用される 7 つの Java 設計パターンを深く理解します。

Java 設計パターンを理解する: 一般的に使用される 7 つの設計パターンの紹介、特定のコード例が必要です

Java 設計パターンは、ソフトウェア設計の問題に対する普遍的な解決策です。広く受け入れられている一連の設計思想と行動規範。デザイン パターンは、コード構造をより適切に整理および計画するのに役立ち、コードをより保守しやすく、読みやすく、拡張しやすくします。この記事では、Java で一般的に使用される 7 つの設計パターンを紹介し、対応するコード例を示します。

1. シングルトン パターン:
   シングルトン パターンは、クラスにインスタンスが 1 つだけ存在することを保証し、グローバル アクセス ポイントを提供します。これは、リソースを共有する必要がある場合やオブジェクトの数が制限されている場合に役立ちます。以下は、シングルトン パターンのコード例です。

public class Singleton {

    private static Singleton instance;

    private Singleton() {
        // 私有构造函数，防止外部实例化
    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

2. ファクトリ パターン:
   ファクトリ パターンは、ファクトリ クラスを通じてオブジェクトを作成し、オブジェクト作成プロセスをカプセル化します。これにより、オブジェクトの特定の実装の詳細が非表示になり、クライアント コードがより簡潔になり、拡張可能になります。以下は、ファクトリ パターンのコード例です:

public interface Shape {
    void draw();
}

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Circle::draw()");
    }
}

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Rectangle::draw()");
    }
}

public class ShapeFactory {
    public Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
            return new Rectangle();
        }
        return null;
    }
}

3. オブザーバー パターン:
   オブザーバー パターンは、1 対多の依存関係を定義します。それに依存する他のオブジェクトは自動的に更新されます。これは、イベント駆動型、パブリッシュ/サブスクライブ、および GUI 開発で役立ちます。以下はオブザーバー パターンのコード例です:

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

public class Subject {
    private List<Observer> observers = new ArrayList<>();
    private int state;

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
        notifyAllObservers();
    }

    public void attach(Observer observer) {
        observers.add(observer);
    }

    public void notifyAllObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

public abstract class Observer {
    protected Subject subject;
    public abstract void update();
}

public class BinaryObserver extends Observer {
    public BinaryObserver(Subject subject) {
        this.subject = subject;
        this.subject.attach(this);
    }

    public void update() {
        System.out.println("Binary String: " + Integer.toBinaryString(subject.getState()));
    }
}

public class OctalObserver extends Observer {
    public OctalObserver(Subject subject) {
        this.subject = subject;
        this.subject.attach(this);
    }

    public void update() {
        System.out.println("Octal String: " + Integer.toOctalString(subject.getState()));
    }
}

public class HexObserver extends Observer {
    public HexObserver(Subject subject) {
        this.subject = subject;
        this.subject.attach(this);
    }

    public void update() {
        System.out.println("Hex String: " + Integer.toHexString(subject.getState()));
    }
}

public class ObserverPatternDemo {
    public static void main(String[] args) {
        Subject subject = new Subject();
        new BinaryObserver(subject);
        new OctalObserver(subject);
        new HexObserver(subject);

        System.out.println("First state change: 15");
        subject.setState(15);
        System.out.println("Second state change: 10");
        subject.setState(10);
    }
}

4. ビルダー パターン (ビルダー パターン):
   ビルダー パターンは、オブジェクトの構築プロセスを分離することで、同じ構築プロセスを作成できます。さまざまな表現を作成するために使用されます。これにより、コードの柔軟性と読みやすさが向上し、ビルド パラメーターが多すぎる問題が回避されます。以下は、ビルダー パターンのコード例です。

public class Computer {
    private String cpu;
    private String memory;
    private String disk;
    // 省略其他属性和方法
}

public interface ComputerBuilder {
    ComputerBuilder setCpu(String cpu);
    ComputerBuilder setMemory(String memory);
    ComputerBuilder setDisk(String disk);
    Computer build();
}

public class BasicComputerBuilder implements ComputerBuilder {
    private Computer computer;

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

    public ComputerBuilder setCpu(String cpu) {
        computer.setCpu(cpu);
        return this;
    }

    public ComputerBuilder setMemory(String memory) {
        computer.setMemory(memory);
        return this;
    }

    public ComputerBuilder setDisk(String disk) {
        computer.setDisk(disk);
        return this;
    }

    public Computer build() {
        return computer;
    }
}

public class Director {
    private ComputerBuilder computerBuilder;

    public Director(ComputerBuilder computerBuilder) {
        this.computerBuilder = computerBuilder;
    }

    public Computer construct() {
        return computerBuilder
                .setCpu("i5")
                .setMemory("8GB")
                .setDisk("1TB")
                .build();
    }
}

public class BuilderPatternDemo {
    public static void main(String[] args) {
        ComputerBuilder computerBuilder = new BasicComputerBuilder();
        Director director = new Director(computerBuilder);
        Computer computer = director.construct();

        System.out.println(computer.toString());
    }
}

5. プロトタイプ パターン:
   プロトタイプ パターンは、既存のオブジェクトを再作成するのではなく、コピーすることによって新しいオブジェクトを作成します。これにより、特にオブジェクトの初期化プロセスが複雑な場合に、オブジェクト作成の効率が向上します。以下は、プロトタイプ パターンのコード例です。

public abstract class Shape implements Cloneable {
    private String id;
    protected String type;
    
    abstract void draw();

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
    
    public Object clone() {
        Object clone = null;
        try {
            clone = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return clone;
    }
}

public class Circle extends Shape {
    public Circle() {
        type = "Circle";
    }

    public void draw() {
        System.out.println("Inside Circle::draw() method.");
    }
}

public class Rectangle extends Shape {
    public Rectangle() {
        type = "Rectangle";
    }

    public void draw() {
        System.out.println("Inside Rectangle::draw() method.");
    }
}

public class ShapeCache {
    private static Map<String, Shape> shapeMap = new HashMap<>();

    public static Shape getShape(String shapeId) {
        Shape cachedShape = shapeMap.get(shapeId);
        return (Shape) cachedShape.clone();
    }

    public static void loadCache() {
        Circle circle = new Circle();
        circle.setId("1");
        shapeMap.put(circle.getId(), circle);

        Rectangle rectangle = new Rectangle();
        rectangle.setId("2");
        shapeMap.put(rectangle.getId(), rectangle);
    }
}

public class PrototypePatternDemo {
    public static void main(String[] args) {
        ShapeCache.loadCache();

        Shape clonedShape1 = ShapeCache.getShape("1");
        System.out.println("Shape: " + clonedShape1.getType());

        Shape clonedShape2 = ShapeCache.getShape("2");
        System.out.println("Shape: " + clonedShape2.getType());
    }
}

6. アダプター パターン (アダプター パターン):
   アダプター パターンは、クラスのインターフェイスを、クライアントが予期する別のインターフェイスに変換します。 。これにより、既存のコードを変更せずに、互換性のないインターフェイスが連携して動作する機能が提供されます。以下は、アダプター パターンのコード例です。

public interface MediaPlayer {
    void play(String audioType, String fileName);
}

public interface AdvancedMediaPlayer {
    void playVlc(String fileName);

    void playMp4(String fileName);
}

public class VlcPlayer implements AdvancedMediaPlayer {
    public void playVlc(String fileName) {
        System.out.println("Playing vlc file. Name: " + fileName);
    }

    public void playMp4(String fileName) {
        // 空实现
    }
}

public class Mp4Player implements AdvancedMediaPlayer {
    public void playVlc(String fileName) {
        // 空实现
    }

    public void playMp4(String fileName) {
        System.out.println("Playing mp4 file. Name: " + fileName);
    }
}

public class MediaAdapter implements MediaPlayer {
    AdvancedMediaPlayer advancedMediaPlayer;

    public MediaAdapter(String audioType) {
        if (audioType.equalsIgnoreCase("vlc")) {
            advancedMediaPlayer = new VlcPlayer();
        } else if (audioType.equalsIgnoreCase("mp4")) {
            advancedMediaPlayer = new Mp4Player();
        }
    }

    public void play(String audioType, String fileName) {
        if (audioType.equalsIgnoreCase("vlc")) {
            advancedMediaPlayer.playVlc(fileName);
        } else if (audioType.equalsIgnoreCase("mp4")) {
            advancedMediaPlayer.playMp4(fileName);
        }
    }
}

public class AudioPlayer implements MediaPlayer {
    MediaAdapter mediaAdapter;

    public void play(String audioType, String fileName) {
        if (audioType.equalsIgnoreCase("mp3")) {
            System.out.println("Playing mp3 file. Name: " + fileName);
        } else if (audioType.equalsIgnoreCase("vlc") || audioType.equalsIgnoreCase("mp4")) {
            mediaAdapter = new MediaAdapter(audioType);
            mediaAdapter.play(audioType, fileName);
        } else {
            System.out.println("Invalid media. " + audioType + " format not supported");
        }
    }
}

public class AdapterPatternDemo {
    public static void main(String[] args) {
        AudioPlayer audioPlayer = new AudioPlayer();
        audioPlayer.play("mp3", "beyond_the_horizon.mp3");
        audioPlayer.play("mp4", "alone.mp4");
        audioPlayer.play("vlc", "far_far_away.vlc");
        audioPlayer.play("avi", "mind_me.avi");
    }
}

7. 戦略パターン:
   戦略パターンは、一連のアルゴリズムを定義し、相互に交換できるように各アルゴリズムをカプセル化します。これにより、コードの他の部分に影響を与えることなく、アルゴリズムを切り替えたり、新しいアルゴリズムを拡張したりすることが簡単になります。以下は、戦略パターンのコード例です。

public interface Strategy {
    int doOperation(int num1, int num2);
}

public class OperationAdd implements Strategy {
    public int doOperation(int num1, int num2) {
        return num1 + num2;
    }
}

public class OperationSubtract implements Strategy {
    public int doOperation(int num1, int num2) {
        return num1 - num2;
    }
}

public class OperationMultiply implements Strategy {
    public int doOperation(int num1, int num2) {
        return num1 * num2;
    }
}

public class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public int executeStrategy(int num1, int num2) {
        return strategy.doOperation(num1, num2);
    }
}

public class StrategyPatternDemo {
    public static void main(String[] args) {
        Context context = new Context(new OperationAdd());
        System.out.println("10 + 5 = " + context.executeStrategy(10, 5));

        context = new Context(new OperationSubtract());
        System.out.println("10 - 5 = " + context.executeStrategy(10, 5));

        context = new Context(new OperationMultiply());
        System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
    }
}

上記のコード例を通じて、Java で一般的に使用される 7 つの設計パターンを簡単に紹介します。各デザイン パターンにはさまざまなシナリオと用途があり、さまざまなプロジェクトで活用できます。この記事が、デザイン パターンを理解して適用し、コードの品質と開発効率を向上させるのに役立つことを願っています。

以上が一般的に使用される 7 つの Java 設計パターンを深く理解します。の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。