java 应用能用的到的设计模式

Java 应用能用的到的设计模式

设计模式是一种被广泛应用于软件开发过程中的解决问题的方案。它们提供了一种可复用的解决方案，可以帮助开发人员解决一些常见的设计问题。在 Java 应用中，有许多设计模式可以用于不同的场景和需求。本文将介绍一些常见的设计模式，并给出相应的代码示例。

1. 单例模式

单例模式是一种保证类只有一个实例的设计模式。在 Java 应用中，单例模式常用于需要全局访问的对象，例如日志类、数据库连接池等。以下是一个简单的单例模式示例：

public class Singleton {
    private static Singleton instance;

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

    public static Singleton getInstance() {
        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("Drawing a circle");
    }
}

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

public class ShapeFactory {
    public static Shape createShape(String shapeType) {
        if (shapeType.equalsIgnoreCase("circle")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("rectangle")) {
            return new Rectangle();
        } else {
            return null;
        }
    }
}

3. 观察者模式

观察者模式是一种对象间一对多依赖关系的设计模式。它定义了一种一对多的依赖关系，使得当一个对象的状态发生变化时，其相关的依赖对象都会收到通知并自动更新。以下是一个简单的观察者模式示例：

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

public interface Observer {
    void update(String message);
}

public class User implements Observer {
    private String name;

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

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

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

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

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

    public void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}

4. 适配器模式

适配器模式是一种将一个类的接口转换成客户端所期望的另一种接口的设计模式。它常用于解决接口不兼容的问题，并且可以使得原本没有关联的类可以一起工作。以下是一个简单的适配器模式示例：

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 {
    @Override
    public void playVlc(String fileName) {
        System.out.println("Playing vlc file: " + fileName);
    }

    @Override
    public void playMp4(String fileName) {
        // do nothing
    }
}

public class Mp4Player implements AdvancedMediaPlayer {
    @Override
    public void playVlc(String fileName) {
        // do nothing
    }

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

public class MediaAdapter implements MediaPlayer {
    private AdvancedMediaPlayer advancedMediaPlayer;

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

    @Override