设计模式是软件开发中经典而重要的概念。它们是解决常见问题的可服用的设计方案，可以帮助开发人员提高代码质量和可维护性。虽然设计模式有很多种类，但本文将介绍一些常用的设计模式。
1. 创建型模式
1.1 工厂模式
工厂模式是一种创建对象的模式，将对象的创建逻辑封装在一个工厂类中。通过工厂类，我们可以根据不同的条件创建不同的对象，实现了对象的解耦和灵活性。
示例：
public interface Animal {
void makeSound();
}
public class Dog implements Animal {
@Override
public void makeSound() {
System.out.println("Woof!");
}
}
public class Cat implements Animal {
@Override
public void makeSound() {
System.out.println("Meow!");
}
}
public class AnimalFactory {
public Animal createAnimal(String type) {
if (type.equals("dog")) {
return new Dog();
} else if (type.equals("cat")) {
return new Cat();
}
return null;
}
}
public class Main {
public static void main(String[] args) {
AnimalFactory factory = new AnimalFactory();
Animal dog = factory.createAnimal("dog");
Animal cat = factory.createAnimal("cat");
dog.makeSound(); // Output: Woof!
cat.makeSound(); // Output: Meow!
}
}
1.2 单例模式
单例模式是一种限制类的实例化为一个对象的模式，保证整个应用程序中只有一个实例存在。可以通过私有化构造函数和提供一个静态方法来实现单例模式。
示例：
public class Singleton {
private static Singleton instance;
private Singleton() {
// 私有化构造函数
}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
2. 结构型模式
2.1 适配器模式
适配器模式用于将一个类的接口适配成另一个类的接口，解决两个类之间的接口不兼容问题。通过适配器模式，可以使得不兼容的类能够一起工作。
示例：
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. Name: " + 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. Name: " + fileName);
}
}
public class MediaAdapter implements MediaPlayer {
AdvancedMediaPlayer advancedMediaPlayer;
public MediaAdapter(String audioType) {
if (audioType.equals("vlc")) {
advancedMediaPlayer = new VlcPlayer();
} else if (audioType.equals("mp4")) {
advancedMediaPlayer = new Mp4Player();
}
}
@Override
public void play(String audioType, String fileName) {
if (audioType.equals("vlc")) {
advancedMediaPlayer.playVlc(fileName);
} else if (audioType.equals("mp4")) {
advancedMediaPlayer.playMp4(fileName);
}
}
}
public class AudioPlayer implements MediaPlayer {
MediaAdapter mediaAdapter;
@Override
public void play(String audioType, String fileName) {
if (audioType.equals("mp3")) {
System.out.println("Playing mp3 file. Name: " + fileName);
} else if (audioType.equals("vlc") || audioType.equals("mp4")) {
mediaAdapter = new MediaAdapter(audioType);
mediaAdapter.play(audioType, fileName);
} else {
System.out.println("Invalid media. " + audioType + " format not supported");
}
}
}
public class Main {
public static void main(String[] args) {
AudioPlayer player = new AudioPlayer();
player.play("mp3", "song.mp3");
player.play("vlc", "song.vlc");
player.play("mp4", "song.mp4");
player.play("avi", "song.avi");
}
}
3. 行为型模式
3.1 观察者模式
观察者模式定义了对象之间的一对多依赖关系，当一个对象的状态发生变化时，其所有依赖的对象将自动收到通知并更新。
示例：
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);
}
@Override
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);
}
@Override
public void update() {
System.out.println("Octal String: " + Integer.toOctalString(subject.getState()));
}
}
public class HexaObserver extends Observer {
public HexaObserver(Subject subject) {
this.subject = subject;
this.subject.attach(this);
}
@Override
public void update() {
System.out.println("Hex String: " + Integer.toHexString(subject.getState()).toUpperCase());
}
}
public class Main {
public static void main(String[] args) {
Subject subject = new Subject();
new HexaObserver(subject);
new OctalObserver(subject);
new BinaryObserver(subject);
System.out.println("First state change: 15");
subject.setState(15);
System.out.println("Second state change: 10");
subject.setState(10);
}
}
以上是一些常用的设计模式，掌握了这些设计模式可以使你的代码更加灵活、可维护和可扩展。希望本文对你理解和应用设计模式有所帮助！
