Java中常见的设计模式及其实际应用
在软件开发中，设计模式是重要的指导原则，它们提供了解决特定问题的可重用方案。Java作为一种强大的编程语言，广泛应用了许多设计模式。让我们深入探讨几种常见的设计模式，并展示它们在实际Java应用中的用例。
1. 单例模式 (Singleton Pattern)
单例模式确保一个类只有一个实例，并提供一个全局访问点。
public class Singleton {
private static Singleton instance;
private Singleton() {} // 私有构造函数
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
// 在实际应用中的使用：
public class SingletonApp {
public static void main(String[] args) {
Singleton obj = Singleton.getInstance();
// 使用obj进行操作
}
}
2. 工厂模式 (Factory Pattern)
工厂模式用于创建对象，但将具体创建的逻辑封装在一个单独的类中。
interface Shape {
void draw();
}
class Circle implements Shape {
@Override
public void draw() {
System.out.println("画一个圆形");
}
}
class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("画一个矩形");
}
}
class ShapeFactory {
public Shape getShape(String shapeType) {
if (shapeType == null) {
return null;
} else if (shapeType.equalsIgnoreCase("CIRCLE")) {
return new Circle();
} else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
return new Rectangle();
}
return null;
}
}
// 在实际应用中的使用：
public class FactoryPatternApp {
public static void main(String[] args) {
ShapeFactory shapeFactory = new ShapeFactory();
Shape circle = shapeFactory.getShape("CIRCLE");
circle.draw(); // 输出：画一个圆形
Shape rectangle = shapeFactory.getShape("RECTANGLE");
rectangle.draw(); // 输出：画一个矩形
}
}
3. 观察者模式 (Observer Pattern)
观察者模式用于对象之间的一对多依赖关系，当一个对象状态改变时，其依赖对象会得到通知并自动更新。
import java.util.ArrayList;
import java.util.List;
interface Observer {
void update();
}
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();
}
}
}
class BinaryObserver implements Observer {
private Subject subject;
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 ObserverPatternApp {
public static void main(String[] args) {
Subject subject = new Subject();
new BinaryObserver(subject);
subject.setState(10); // 输出：Binary String: 1010
}
}
4. 装饰器模式 (Decorator Pattern)
装饰器模式允许向现有对象动态地添加新功能，它是继承的替代方案。
interface Shape {
void draw();
}
class Circle implements Shape {
@Override
public void draw() {
System.out.println("画一个圆形");
}
}
class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("画一个矩形");
}
}
abstract class ShapeDecorator implements Shape {
protected Shape decoratedShape;
public ShapeDecorator(Shape decoratedShape) {
this.decoratedShape = decoratedShape;
}
public void draw() {
decoratedShape.draw();
}
}
class RedShapeDecorator extends ShapeDecorator {
public RedShapeDecorator(Shape decoratedShape) {
super(decoratedShape);
}
@Override
public void draw() {
decoratedShape.draw();
setRedBorder(decoratedShape);
}
private void setRedBorder(Shape decoratedShape) {
System.out.println("边框颜色：红色");
}
}
// 在实际应用中的使用：
public class DecoratorPatternApp {
public static void main(String[] args) {
Shape circle = new Circle();
Shape redCircle = new RedShapeDecorator(new Circle());
Shape redRectangle = new RedShapeDecorator(new Rectangle());
circle.draw(); // 输出：画一个圆形
redCircle.draw();
// 输出：
// 画一个圆形
// 边框颜色：红色
redRectangle.draw();
// 输出：
// 画一个矩形
// 边框颜色：红色
}
}
5. 策略模式 (Strategy Pattern)
策略模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，使得算法可独立于使用它的客户而变化。
interface Strategy {
int doOperation(int num1, int num2);
}
class OperationAdd implements Strategy {
public int doOperation(int num1, int num2) {
return num1 + num2;
}
}
class OperationSubtract implements Strategy {
public int doOperation(int num1, int num2) {
return num1 - num2;
}
}
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 StrategyPatternApp {
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));
}
}
6. 原型模式 (Prototype Pattern)
原型模式用于创建对象的一种方式，通过复制现有对象来生成新对象，避免了构造函数的执行。
import java.util.HashMap;
import java.util.Map;
abstract class Shape implements Cloneable {
protected String type;
abstract void draw();
public String getType() {
return type;
}
public Object clone() {
Object clone = null;
try {
clone = super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return clone;
}
}
class Circle extends Shape {
public Circle() {
type = "Circle";
}
@Override
void draw() {
System.out.println("画一个圆形");
}
}
class Rectangle extends Shape {
public Rectangle() {
type = "Rectangle";
}
@Override
void draw() {
System.out.println("画一个矩形");
}
}
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.draw();
shapeMap.put(circle.getType(), circle);
Rectangle rectangle = new Rectangle();
rectangle.draw();
shapeMap.put(rectangle.getType(), rectangle);
}
}
// 在实际应用中的使用：
public class PrototypePatternApp {
public static void main(String[] args) {
ShapeCache.loadCache();
Shape clonedShape1 = ShapeCache.getShape("Circle");
System.out.println("Shape : " + clonedShape1.getType());
Shape clonedShape2 = ShapeCache.getShape("Rectangle");
System.out.println("Shape : " + clonedShape2.getType());
}
}
7. 适配器模式 (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);
}
}
}
class AudioPlayer implements MediaPlayer {
MediaAdapter mediaAdapter;
@Override
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 AdapterPatternApp {
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");
}
}
8. 桥接模式 (Bridge Pattern)
桥接模式将抽象部分与它的实现部分分离，以便两者能够独立地变化。
interface DrawAPI {
void drawCircle(int radius, int x, int y);
}
class RedCircle implements DrawAPI {
@Override
public void drawCircle(int radius, int x, int y) {
System.out.println("Drawing Circle[ color: red, radius: " + radius + ", x: " + x + ", y: " + y + "]");
}
}
class GreenCircle implements DrawAPI {
@Override
public void drawCircle(int radius, int x, int y) {
System.out.println("Drawing Circle[ color: green, radius: " + radius + ", x: " + x + ", y: " + y + "]");
}
}
abstract class Shape {
protected DrawAPI drawAPI;
protected Shape(DrawAPI drawAPI) {
this.drawAPI = drawAPI;
}
public abstract void draw();
}
class Circle extends Shape {
private int x, y, radius;
public Circle(int x, int y, int radius, DrawAPI drawAPI) {
super(drawAPI);
this.x = x;
this.y = y;
this.radius = radius;
}
public void draw() {
drawAPI.drawCircle(radius, x, y);
}
}
// 在实际应用中的使用：
public class BridgePatternApp {
public static void main(String[] args) {
Shape redCircle = new Circle(100, 100, 10, new RedCircle());
Shape greenCircle = new Circle(100, 100, 10, new GreenCircle());
redCircle.draw();
greenCircle.draw();
}
}
9. 建造者模式 (Builder Pattern)
建造者模式用于构建复杂对象，将对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。
class Meal {
private String drink;
private String mainCourse;
private String side;
public void setDrink(String drink) {
this.drink = drink;
}
public void setMainCourse(String mainCourse) {
this.mainCourse = mainCourse;
}
public void setSide(String side) {
this.side = side;
}
public void showItems() {
System.out.println("Drink: " + drink);
System.out.println("Main Course: " + mainCourse);
System.out.println("Side: " + side);
}
}
interface MealBuilder {
void buildDrink();
void buildMainCourse();
void buildSide();
Meal getMeal();
}
class VegMealBuilder implements MealBuilder {
private Meal meal = new Meal();
public void buildDrink() {
meal.setDrink("Water");
}
public void buildMainCourse() {
meal.setMainCourse("Salad");
}
public void buildSide() {
meal.setSide("Bread");
}
public Meal getMeal() {
return meal;
}
}
class MealDirector {
public Meal createMeal(MealBuilder mealBuilder) {
mealBuilder.buildDrink();
mealBuilder.buildMainCourse();
mealBuilder.buildSide();
return mealBuilder.getMeal();
}
}
// 在实际应用中的使用：
public class BuilderPatternApp {
public static void main(String[] args) {
MealBuilder vegMealBuilder = new VegMealBuilder();
MealDirector mealDirector = new MealDirector();
Meal meal = mealDirector.createMeal(vegMealBuilder);
meal.showItems();
}
}