介绍
设计模式在软件开发中起着重要的作用，它们是经过反复验证的解决特定问题的经验总结。Java作为一门广泛应用于实际开发的编程语言，也有许多经典的设计模式被应用于Java的开发中。
框架设计则是在软件开发中，常常使用的一种模式集合，它提供了一套基础设施，使得开发者可以更加方便地编写代码，减少重复性工作。Java中也有许多成熟的框架，它们对设计模式的运用也非常深入。
本文将详细介绍Java中几个常用的设计模式，并展示如何将它们应用于框架设计中。
1. 单例模式
单例模式是一种保证一个类只有一个实例的设计模式。在很多场景中，我们只需要让一个类的实例在程序运行期间只存在一个即可。
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
单例模式的设计思想在Java中广泛应用，例如Spring框架中的Bean，默认情况下都是单例的，保证了在整个应用周期内只有一个实例。
2. 工厂模式
工厂模式是一种通过工厂类创建对象的设计模式。比如我们有多个实现了同一个接口的类，但在使用的时候我们并不关心具体实现类的细节，只需要通过工厂类获取实例即可。
public interface Animal {
void sound();
}
public class Dog implements Animal {
@Override
public void sound() {
System.out.println("汪汪汪");
}
}
public class Cat implements Animal {
@Override
public void sound() {
System.out.println("喵喵喵");
}
}
public class AnimalFactory {
public static Animal createAnimal(String type) {
if ("dog".equals(type)) {
return new Dog();
} else if ("cat".equals(type)) {
return new Cat();
}
return null;
}
}
工厂模式可以很好地解决对象创建的问题，避免了直接使用new关键字来创建对象的耦合性。
3. 观察者模式
观察者模式是一种对象之间的一对多依赖关系，当一个对象状态发生改变时，其依赖对象将自动收到通知并进行相应的处理。
public interface Observer {
void update(String message);
}
public class User implements Observer {
private String name;
public User(String name) {
this.name = name;
}
@Override
public void update(String message) {
System.out.println(name + "收到消息：" + message);
}
}
public interface Subject {
void attach(Observer observer);
void detach(Observer observer);
void notifyObservers(String message);
}
public class WeChatOfficialAccount implements Subject {
private List<Observer> observers = new ArrayList<>();
@Override
public void attach(Observer observer) {
observers.add(observer);
}
@Override
public void detach(Observer observer) {
observers.remove(observer);
}
@Override
public void notifyObservers(String message) {
for (Observer observer : observers) {
observer.update(message);
}
}
}
观察者模式在Java中被广泛应用，例如Swing框架中的事件处理机制，当用户进行某些操作时，通过注册相应的事件监听器，可以实现事件的触发和处理。
4. 代理模式
代理模式是一种在访问对象时引入一定程度的间接性，可以通过代理对象控制原始对象的访问。
public interface Image {
void display();
}
public class RealImage implements Image {
private String fileName;
public RealImage(String fileName) {
this.fileName = fileName;
loadFromDisk();
}
private void loadFromDisk() {
System.out.println("Loading image from disk: " + fileName);
}
@Override
public void display() {
System.out.println("Displaying image: " + fileName);
}
}
public 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();
}
}
代理模式可以实现对原始对象的一些额外功能的封装，例如懒加载、缓存等。
5. 桥接模式
桥接模式是一种把抽象部分与实现部分分离的设计模式，使得两部分可以独立变化。它通过组合的方式，将Abstraction和Implementor独立开来，从而可以独立扩展它们。
public interface Color {
void applyColor();
}
public class Red implements Color {
@Override
public void applyColor() {
System.out.println("Applying red color...");
}
}
public class Blue implements Color {
@Override
public void applyColor() {
System.out.println("Applying blue color...");
}
}
public abstract class Shape {
protected Color color;
public Shape(Color color) {
this.color = color;
}
abstract void applyColor();
}
public class Square extends Shape {
public Square(Color color) {
super(color);
}
@Override
void applyColor() {
System.out.print("Shape: square, ");
color.applyColor();
}
}
public class Triangle extends Shape {
public Triangle(Color color) {
super(color);
}
@Override
void applyColor() {
System.out.print("Shape: triangle, ");
color.applyColor();
}
}
桥接模式可以很好地应对多维度的扩展问题，例如在图形绘制的场景中，既要支持不同的颜色，又要支持不同的形状，这时可以使用桥接模式来解决。
总结
设计模式是软件开发中不可或缺的一部分，它们提供了一些经验总结和规范，帮助我们更好地解决问题。同时，框架设计也是一种重要的实践，它可以提供一套基础设施，让我们的开发工作更加高效。
在Java中，我们可以通过学习和应用设计模式，结合框架设计的实践，提高软件开发的质量和效率。
本文来自极简博客，作者：深夜诗人，转载请注明原文链接：Java中的设计模式与框架设计：深入理解与应用
