Java中的设计模式及其在实际项目中的应用
在软件开发过程中，设计模式是一种被反复使用的、经过实践检验的解决方案。本文将介绍几种常见的设计模式及其在实际项目中的应用，帮助大家更好地理解和应用这些模式。
一、单例模式（Singleton Pattern）
单例模式确保一个类只有一个实例，并提供一个全局访问点。以下是单例模式的示例：
package cn.juwatech.designpatterns;
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
public void showMessage() {
System.out.println("Hello World!");
}
public static void main(String[] args) {
Singleton singleton = Singleton.getInstance();
singleton.showMessage();
}
}
在实际项目中，单例模式常用于日志记录、数据库连接等需要唯一实例的场景。
二、工厂模式（Factory Pattern）
工厂模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。以下是工厂模式的示例：
package cn.juwatech.designpatterns;
interface Shape {
void draw();
}
class Circle implements Shape {
@Override
public void draw() {
System.out.println("Inside Circle::draw() method.");
}
}
class Square implements Shape {
@Override
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}
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;
}
}
public class FactoryPatternDemo {
public static void main(String[] args) {
ShapeFactory shapeFactory = new ShapeFactory();
Shape shape1 = shapeFactory.getShape("CIRCLE");
shape1.draw();
Shape shape2 = shapeFactory.getShape("SQUARE");
shape2.draw();
}
}
在实际项目中，工厂模式常用于对象创建的场景，例如创建不同类型的日志记录器、解析器等。
三、观察者模式（Observer Pattern）
观察者模式定义对象间的一种一对多依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并自动更新。以下是观察者模式的示例：
package cn.juwatech.designpatterns;
import java.util.ArrayList;
import java.util.List;
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();
}
}
}
abstract class Observer {
protected Subject subject;
public abstract void update();
}
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()));
}
}
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 ObserverPatternDemo {
public static void main(String[] args) {
Subject subject = new Subject();
new HexaObserver(subject);
new BinaryObserver(subject);
System.out.println("First state change: 15");
subject.setState(15);
System.out.println("Second state change: 10");
subject.setState(10);
}
}
在实际项目中，观察者模式常用于事件处理系统，例如监听器、推送通知等。
四、装饰者模式（Decorator Pattern）
装饰者模式允许向一个现有的对象添加新的功能，同时又不改变其结构。以下是装饰者模式的示例：
package cn.juwatech.designpatterns;
interface Coffee {
String getDescription();
double getCost();
}
class SimpleCoffee implements Coffee {
@Override
public String getDescription() {
return "Simple Coffee";
}
@Override
public double getCost() {
return 2.0;
}
}
class MilkDecorator implements Coffee {
protected Coffee decoratedCoffee;
public MilkDecorator(Coffee coffee) {
this.decoratedCoffee = coffee;
}
@Override
public String getDescription() {
return decoratedCoffee.getDescription() + ", Milk";
}
@Override
public double getCost() {
return decoratedCoffee.getCost() + 0.5;
}
}
class SugarDecorator implements Coffee {
protected Coffee decoratedCoffee;
public SugarDecorator(Coffee coffee) {
this.decoratedCoffee = coffee;
}
@Override
public String getDescription() {
return decoratedCoffee.getDescription() + ", Sugar";
}
@Override
public double getCost() {
return decoratedCoffee.getCost() + 0.2;
}
}
public class DecoratorPatternDemo {
public static void main(String[] args) {
Coffee coffee = new SimpleCoffee();
System.out.println(coffee.getDescription() + " $" + coffee.getCost());
coffee = new MilkDecorator(coffee);
System.out.println(coffee.getDescription() + " $" + coffee.getCost());
coffee = new SugarDecorator(coffee);
System.out.println(coffee.getDescription() + " $" + coffee.getCost());
}
}
在实际项目中，装饰者模式常用于动态添加职责的场景，例如图形界面组件的装饰、日志记录的增强等。
五、策略模式（Strategy Pattern）
策略模式定义了一系列算法，并将每个算法封装起来，使得它们可以互换。以下是策略模式的示例：
package cn.juwatech.designpatterns;
interface Strategy {
int doOperation(int num1, int num2);
}
class AdditionStrategy implements Strategy {
@Override
public int doOperation(int num1, int num2) {
return num1 + num2;
}
}
class SubtractionStrategy implements Strategy {
@Override
public int doOperation(int num1, int num2) {
return num1 - num2;
}
}
class MultiplicationStrategy implements Strategy {
@Override
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 StrategyPatternDemo {
public static void main(String[] args) {
Context context = new Context(new AdditionStrategy());
System.out.println("10 + 5 = " + context.executeStrategy(10, 5));
context = new Context(new SubtractionStrategy());
System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
context = new Context(new MultiplicationStrategy());
System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
}
}
在实际项目中，策略模式常用于算法选择、行为变化的场景，例如支付方式选择、数据压缩算法选择等。
通过以上对几种常见设计模式的介绍和示例代码，相信大家对这些模式有了更深入的理解。在实际项目中，可以根据具体需求选择合适的设计模式，以提高代码的可维护性和可扩展性。
