本文详细介绍了作为Java架构师必备的高级设计模式，包括工厂模式、单例模式、观察者模式、责任链模式和组合模式，通过实例展示了如何在实际开发中运用这些模式提升代码效率和可维护性。
作为一名Java架构师，掌握高级设计模式可以让我们在开发过程中更加得心应手，提高开发效率和代码质量。在本文中，我将介绍几种常见的高级设计模式，并附上相应的代码示例。
全套面试题已打包2024最全大厂面试题无需C币点我下载
1. 工厂模式
工厂模式是一种创建型设计模式，它通过提供一个通用的接口来创建对象，而不需要暴露对象的具体实现。在工厂模式中，我们需要定义一个工厂类，该类负责创建对象并返回它们的实例。
下面是一个简单的工厂模式示例，其中我们创建了一个名为Animal的接口和两个实现类Cat和Dog。我们还创建了一个AnimalFactory类，该类负责创建Animal对象的实例。
public interface Animal {
void eat();
}
public class Cat implements Animal {
@Override
public void eat() {
System.out.println("The cat is eating.");
}
}
public class Dog implements Animal {
@Override
public void eat() {
System.out.println("The dog is eating.");
}
}
public class AnimalFactory {
public static Animal createAnimal(String type) {
if ("cat".equalsIgnoreCase(type)) {
return new Cat();
} else if ("dog".equalsIgnoreCase(type)) {
return new Dog();
} else {
return null;
}
}
}
在这个示例中，我们定义了一个Animal接口，并创建了两个实现类。然后我们创建了一个AnimalFactory类，该类包含一个静态方法createAnimal，该方法根据传入的类型参数返回相应的Animal对象实例。使用这个工厂类，我们可以轻松地创建不同类型的Animal对象。
2. 单例模式
单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供全局访问点来访问该实例。在单例模式中，我们需要将类的构造函数私有化，以便其他类无法使用new操作符创建该类的实例。同时，我们还需要定义一个静态方法来返回单例实例。
下面是一个简单的单例模式示例，其中我们创建了一个名为Singleton的类。该类的构造函数被私有化，并且我们定义了一个静态方法getInstance来返回单例实例。
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
在这个示例中，我们使用了懒汉式单例模式。在该模式中，我们只在需要时才创建实例，而不是在程序启动时立即创建实例。为了确保线程安全，我们将getInstance方法设置为同步方法。
3. 观察者模式
观察者模式是一种行为型设计模式，它定义了对象之间的一对多依赖关系，当一个对象状态发生改变时，它的所有依赖对象都会收到通知并自动更新。在观察者模式中，我们需要定义两个接口：Subject和Observer。Subject接口定义了添加、删除和通知观察者的方法。Observer接口定义了更新方法，该方法在接收到通知时被调用。
下面是一个简单的观察者模式示例，其中我们创建了一个名为Subject的主题类和两个实现Observer接口的观察者类，即BinaryObserver和HexObserver。
import java.util.ArrayList;
import java.util.List;
public class Subject {
private List<Observer> observers = new ArrayList<>();
private int state;
public void attach(Observer observer) {
observers.add(observer);
}
public void detach(Observer observer) {
observers.remove(observer);
}
public int getState() {
return state;
}
public void setState(int state) {
this.state = state;
notifyAllObservers();
}
private void notifyAllObservers() {
for (Observer observer : observers) {
observer.update();
}
}
}
public abstract class Observer {
protected Subject subject;
public Observer(Subject subject) {
this.subject = subject;
this.subject.attach(this);
}
public abstract void update();
}
public class BinaryObserver extends Observer {
public BinaryObserver(Subject subject) {
super(subject);
}
@Override
public void update() {
System.out.println("Binary String: " + Integer.toBinaryString(subject.getState()));
}
}
public class HexObserver extends Observer {
public HexObserver(Subject subject) {
super(subject);
}
@Override
public void update() {
System.out.println("Hex String: " + Integer.toHexString(subject.getState()));
}
}
在这个示例中，我们定义了一个Subject类并创建了两个Observer实现类。我们还定义了一个attach方法来添加观察者，一个detach方法来删除观察者，一个getState方法来获取主题状态，以及一个setState方法来设置主题状态。当主题状态改变时，我们使用notifyAllObservers方法通知所有观察者。
4. 责任链模式
责任链模式是一种行为型设计模式，它将请求发送者和接收者解耦，并允许多个对象对请求进行处理。在责任链模式中，我们需要定义一个抽象处理器类，该类包含一个指向下一个处理器的引用。每个处理器类都应该实现处理请求的方法。如果处理器无法处理请求，则可以将请求传递给下一个处理器。
下面是一个简单的责任链模式示例，其中我们创建了一个名为AbstractLogger的抽象类和三个实现类ConsoleLogger、FileLogger和ErrorLogger。在这个示例中，我们通过链式方式处理不同类型的日志消息。
abstract class AbstractLogger {
public static int INFO = 1;
public static int DEBUG = 2;
public static int ERROR = 3;
protected int level;
protected AbstractLogger nextLogger;
public void setNextLogger(AbstractLogger nextLogger) {
this.nextLogger = nextLogger;
}
public void logMessage(int level, String message) {
if (this.level <= level) {
write(message);
}
if (nextLogger != null) {
nextLogger.logMessage(level, message);
}
}
abstract protected void write(String message);
}
class ConsoleLogger extends AbstractLogger {
public ConsoleLogger(int level) {
this.level = level;
}
@Override
protected void write(String message) {
System.out.println("Console Logger: " + message);
}
}
class FileLogger extends AbstractLogger {
public FileLogger(int level) {
this.level = level;
}
@Override
protected void write(String message) {
System.out.println("File Logger: " + message);
}
}
class ErrorLogger extends AbstractLogger {
public ErrorLogger(int level) {
this.level = level;
}
@Override
protected void write(String message) {
System.out.println("Error Logger: " + message);
}
}
在这个示例中，我们定义了一个AbstractLogger抽象类，并创建了三个实现类。我们还定义了一个setNextLogger方法来设置下一个处理器，一个logMessage方法来记录日志消息，以及一个write方法来输出日志消息。使用这些处理器，我们可以轻松地处理不同类型的日志消息。
5. 组合模式
组合模式是一种结构型设计模式，它将对象组合成树形结构，以表示部分-整体的层次结构。在组合模式中，我们需要定义一个抽象类来表示组件，该抽象类包含一些通用方法。然后我们可以创建两种不同类型的类：叶子节点和容器节点。叶子节点表示树的末端节点，而容器节点表示树的非末端节点。
下面是一个简单的组合模式示例，其中我们创建了一个名为Employee的抽象类和两个实现类Developer和Manager。Developer类表示叶子节点，而Manager类表示容器节点。
import java.util.ArrayList;
import java.util.List;
public abstract class Employee {
private String name;
private String department;
private int salary;
private List<Employee> subordinates = new ArrayList<>();
public Employee(String name, String department, int salary) {
this.name = name;
this.department = department;
this.salary = salary;
}
public void add(Employee employee) {
subordinates.add(employee);
}
public void remove(Employee employee) {
subordinates.remove(employee);
}
public List<Employee> getSubordinates() {
return subordinates;
}
public String toString() {
return "Name: " + name + ", Department: " + department + ", Salary: " + salary;
}
}
public class Developer extends Employee {
public Developer(String name, String department, int salary) {
super(name, department, salary);
}
}
public class Manager extends Employee {
public Manager(String name, String department, int salary) {
super(name, department, salary);
}
}
在这个示例中，我们定义了一个Employee抽象类，并创建了两个实现类。我们还定义了一个add方法来添加子节点，一个remove方法来删除子节点，以及一个getSubordinates方法来获取所有子节点。使用这些类，我们可以轻松地组合不同类型的员工。
总结
在本文中，我介绍了五种常见的高级设计模式：工厂模式、单例模式、观察者模式、责任链模式和组合模式。这些模式不仅可以提高代码质量和开发效率，还可以让我们更好地管理和组织代码。希望这篇文章对你有所帮助！
扫一扫
2252
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
