Java设计模式实战指南

Java设计模式是软件开发中常用的一种设计思想，通过使用设计模式可以提供可重用性、可扩展性和可维护性的代码结构。本文将介绍一些常用的Java设计模式以及它们的实战应用。

1. 创建型模式

1.1. 单例模式

单例模式用于创建一个全局唯一的对象。在Java中，可以使用私有构造函数和静态方法来实现单例模式。以下是一个简单的单例模式的实现：

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

1.2. 工厂模式

工厂模式用于创建对象的实例，隐藏对象的实现细节。在Java中，可以使用工厂方法或抽象工厂来实现工厂模式。以下是一个简单的工厂模式的实现：

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 abstract class ShapeFactory {
    public abstract Shape createShape();
}

public class CircleFactory extends ShapeFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }
}

public class RectangleFactory extends ShapeFactory {
    @Override
    public Shape createShape() {
        return new Rectangle();
    }
}

2. 结构型模式

2.1. 适配器模式

适配器模式用于将一个类的接口转换成客户端所期望的另一个接口。在Java中，可以使用适配器类来实现适配器模式。以下是一个简单的适配器模式的实现：

public interface MediaPlayer {
    void play(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 player;

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

    @Override
    public void play(String fileName) {
        String fileExtension = fileName.substring(fileName.lastIndexOf(".") + 1);
        if (fileExtension.equalsIgnoreCase("vlc")) {
            player.playVlc(fileName);
        } else if (fileExtension.equalsIgnoreCase("mp4")) {
            player.playMp4(fileName);
        }
    }
}

2.2. 装饰器模式

装饰器模式用于在不改变现有对象结构的情况下，动态地扩展其功能。在Java中，可以使用装饰器类来实现装饰器模式。以下是一个简单的装饰器模式的实现：

public interface Car {
    void assemble();
}

public class BasicCar implements Car {
    @Override
    public void assemble() {
        System.out.println("Assembling basic car");
    }
}

public abstract class CarDecorator implements Car {
    protected Car car;

    public CarDecorator(Car car) {
        this.car = car;
    }

    @Override
    public void assemble() {
        car.assemble();
    }
}

public class SportsCar extends CarDecorator {
    public SportsCar(Car car) {
        super(car);
    }

    @Override
    public void assemble() {
        super.assemble();
        System.out.println("Adding features of a sports car");
    }
}

public class LuxuryCar extends CarDecorator {
    public LuxuryCar(Car car) {
        super(car);
    }

    @Override
    public void assemble() {
        super.assemble();
        System.out.println("Adding features of a luxury car");
    }
}

3. 行为型模式

3.1. 观察者模式

观察者模式用于在对象之间建立一种一对多的关系，当一个对象状态发生变化时，其相关对象会自动收到通知并更新。在Java中，可以使用观察者接口和主题对象来实现观察者模式。以下是一个简单的观察者模式的实现：

public interface Observer {
    void update();
}

public class ConcreteObserver implements Observer {
    @Override
    public void update() {
        System.out.println("Object is updated");
    }
}

public interface Subject {
    void addObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

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

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

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

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

3.2. 策略模式

策略模式用于在运行时选择算法的变体。在Java中，可以使用策略接口和具体策略类来实现策略模式。以下是一个简单的策略模式的实现：

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

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

public class SubtractStrategy implements Strategy {
    @Override
    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);
    }
}

总结

本文介绍了一些常用的Java设计模式以及它们的实战应用。这些设计模式可以帮助开发人员编写高效、模块化和可维护的代码。如果你对设计模式感兴趣，建议深入研究每个设计模式的实现方式和适用场景，以便更好地应用于实际项目中。

本文来自极简博客，作者：清风徐来，转载请注明原文链接：Java设计模式实战指南