在Java开发中，设计模式是解决问题的一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。它们可以帮助开发者设计出更加灵活、可维护、可扩展的代码。以下是一些常见的Java设计模式及其例子：
1. 单例模式 (Singleton Pattern)
单例模式确保一个类只有一个实例，并提供一个全局访问点。
public class Singleton {
// 私有静态实例，防止外部直接new
private static Singleton instance;
// 私有构造函数，防止外部通过new创建实例
private Singleton() {}
// 提供一个全局的静态方法
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
2. 工厂模式 (Factory Pattern)
工厂模式提供了一种创建对象的方式，而无需指定具体的类。
interface Shape {
void draw();
}
class Circle implements Shape {
@Override
public void draw() {
System.out.println("Drawing Circle");
}
}
class Square implements Shape {
@Override
public void draw() {
System.out.println("Drawing Square");
}
}
class ShapeFactory {
public Shape getShape(String shapeType) {
if (shapeType == null) {
return null;
}
if (shapeType.equalsIgnoreCase("CIRCLE")) {
return new Circle();
} else if (shapeType.equalsIgnoreCase("SQUARE")) {
return new Square();
}
return null;
}
}
3. 观察者模式 (Observer Pattern)
观察者模式定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。
import java.util.ArrayList;
import java.util.List;
interface Observer {
void update(String message);
}
class ConcreteObserver implements Observer {
private String name;
public ConcreteObserver(String name) {
this.name = name;
}
@Override
public void update(String message) {
System.out.println(name + " received message: " + message);
}
}
class Subject {
private List<Observer> observers = new ArrayList<>();
private String message;
public void addObserver(Observer observer) {
observers.add(observer);
}
public void removeObserver(Observer observer) {
observers.remove(observer);
}
public void notifyObservers() {
for (Observer observer : observers) {
observer.update(message);
}
}
public void setMessage(String message) {
this.message = message;
notifyObservers();
}
}
4. 装饰器模式 (Decorator Pattern)
装饰器模式允许向一个现有的对象添加新的功能，同时又不改变其结构。
interface Coffee {
double cost();
String description();
}
class SimpleCoffee implements Coffee {
@Override
public double cost() {
return 1;
}
@Override
public String description() {
return "Simple Coffee";
}
}
abstract class CoffeeDecorator implements Coffee {
protected Coffee decoratedCoffee;
public CoffeeDecorator(Coffee coffee) {
this.decoratedCoffee = coffee;
}
public double cost() {
return decoratedCoffee.cost();
}
public String description() {
return decoratedCoffee.description();
}
}
class MilkDecorator extends CoffeeDecorator {
public MilkDecorator(Coffee coffee) {
super(coffee);
}
@Override
public double cost() {
return super.cost() + 0.5;
}
@Override
public String description() {
return super.description() + ", Milk";
}
}
5. 策略模式（Strategy Pattern）
策略模式定义了一系列算法，并将每个算法封装起来，使它们可以互换。
interface PaymentStrategy {
void pay(int amount);
}
class CreditCardPayment implements PaymentStrategy {
@Override
public void pay(int amount) {
System.out.println("Paid with credit card: " + amount);
}
}
class PayPalPayment implements PaymentStrategy {
@Override
public void pay(int amount) {
System.out.println("Paid with PayPal: " + amount);
}
}
class ShoppingCart {
private PaymentStrategy paymentStrategy;
public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
this.paymentStrategy = paymentStrategy;
}
public void checkout(int amount) {
paymentStrategy.pay(amount);
}
}
6. 适配器模式 (Adapter Pattern)
将一个类的接口转换成客户端所期待的另一种接口形式，使接口不兼容的那些类可以一起工作。
interface MediaPlayer {
void play(String audioType, String fileName);
}
interface AdvancedMediaPlayer {
void playVlc(String fileName);
void playMp4(String fileName);
}
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
}
}
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);
}
}
class MediaAdapter implements MediaPlayer {
AdvancedMediaPlayer advancedMusicPlayer;
public MediaAdapter(String audioType) {
if (audioType.equalsIgnoreCase("vlc")) {
advancedMusicPlayer = new VlcPlayer();
} else if (audioType.equalsIgnoreCase("mp4")) {
advancedMusicPlayer = new Mp4Player();
}
}
@Override
public void play(String audioType, String fileName) {
if (audioType.equalsIgnoreCase("vlc")) {
advancedMusicPlayer.playVlc(fileName);
} else if (audioType.equalsIgnoreCase("mp4")) {
advancedMusicPlayer.playMp4(fileName);
}
}
}
7. 外观模式 (Facade Pattern)
外观模式为复杂的子系统提供了一个简单的接口。
class CPU {
public void start() {
System.out.println("CPU started");
}
public void shutdown() {
System.out.println("CPU shutdown");
}
}
class Memory {
public void load() {
System.out.println("Memory loaded");
}
public void unload() {
System.out.println("Memory unloaded");
}
}
class HardDrive {
public void read() {
System.out.println("HardDrive read");
}
public void write() {
System.out.println("HardDrive write");
}
}
class ComputerFacade {
private CPU cpu;
private Memory memory;
private HardDrive hardDrive;
public ComputerFacade() {
this.cpu = new CPU();
this.memory = new Memory();
this.hardDrive = new HardDrive();
}
public void start() {
cpu.start();
memory.load();
hardDrive.read();
}
public void shutdown() {
cpu.shutdown();
memory.unload();
hardDrive.write();
}
}
8. 代理模式 (Proxy Pattern)
代理模式为其他对象提供了一个代理以控制对这个对象的访问。
interface Image {
void display();
}
class RealImage implements Image {
private String fileName;
public RealImage(String fileName) {
this.fileName = fileName;
loadFromDisk(fileName);
}
@Override
public void display() {
System.out.println("Displaying " + fileName);
}
private void loadFromDisk(String fileName) {
System.out.println("Loading " + 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();
}
}
9. 原型模式 (Prototype Pattern)
原型模式通过复制现有对象来创建新对象，而不是通过实例化类来创建。
class Shape implements Cloneable {
private String type;
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
@Override
public Shape clone() {
try {
return (Shape) super.clone();
} catch (CloneNotSupportedException e) {
return null;
}
}
}
class Circle extends Shape {
public Circle() {
setType("Circle");
}
}
class Square extends Shape {
public Square() {
setType("Square");
}
}
评论区