Java函数中常见的设计模式
设计模式是一些常见的解决问题的方案，是程序员经过多年的实践总结出来的一些经验。在 Java 中，设计模式被广泛应用于函数的设计和开发中。本文将对 Java 函数中常见的设计模式进行介绍。
一、单例模式
单例模式是一种创建型设计模式，它保证一个类只有一个实例，并且提供了全局访问点。在 Java 函数中，单例模式常用于创建 的对象，例如数据库连接池、线程池等。
举例：下面是一个线程池的单例实现：
public class ThreadPool {
private static final ThreadPool INSTANCE = new ThreadPool();
private ThreadPool() {}
public static ThreadPool getInstance() {
return INSTANCE;
}
}
二、工厂模式
工厂模式是一种创建性设计模式，它将对象的创建隐藏在一个工厂类中，对调用者暴露一个接口来获取所需对象。在 Java 函数中，工厂模式通常用来生成不同类型的对象。
举例：下面是一个简单的工厂模式实现：
public interface Shape {
void draw();
}
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Inside Rectangle::draw() method.");
}
}
public class Square implements Shape {
@Override
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}
public class ShapeFactory {
public Shape getShape(String shapeType){
if(shapeType == null){
return null;
}
if(shapeType.equalsIgnoreCase("RECTANGLE")){
return new Rectangle();
} else if(shapeType.equalsIgnoreCase("SQUARE")){
return new Square();
}
return null;
}
}
public class FactoryPatternDemo {
public static void main(String[] args) {
ShapeFactory shapeFactory = new ShapeFactory();
//获取 Rectangle 对象，并调用其 draw 方法
Shape shape1 = shapeFactory.getShape("RECTANGLE");
//调用 Rectangle 的 draw 方法
shape1.draw();
//获取 Square 对象，并调用其 draw 方法
Shape shape2 = shapeFactory.getShape("SQUARE");
//调用 Square 的 draw 方法
shape2.draw();
}
}
三、观察者模式
观察者模式是一种行为型模式，它允许对象间建立一种一对多的关系，被观察对象的状态发生变化时，会通知所有观察者。在 Java 函数中，观察者模式通常用于事件监听，例如按钮点击事件、菜单选择事件等。
举例：下面是一个简单的观察者模式实现：
public interface Observer {
void update(String message);
}
public class ConcreteObserver implements Observer {
private String name;
public ConcreteObserver(String name) {
this.name = name;
}
@Override
public void update(String message) {
System.out.println(name + " receive message : " + message);
}
}
public interface Subject {
void addObserver(Observer observer);
void removeObserver(Observer observer);
void notifyObservers(String message);
}
public class ConcreteSubject implements Subject {
private List<Observer> observers = new ArrayList<>();
@Override
public void addObserver(Observer observer) {
observers.add(observer);
}
@Override
public void removeObserver(Observer observer) {
observers.remove(observer);
}
@Override
public void notifyObservers(String message) {
for (Observer observer : observers) {
observer.update(message);
}
}
}
public class ObserverPatternDemo {
public static void main(String[] args) {
Observer observer1 = new ConcreteObserver("Observer1");
Observer observer2 = new ConcreteObserver("Observer2");
Observer observer3 = new ConcreteObserver("Observer3");
Subject subject = new ConcreteSubject();
subject.addObserver(observer1);
subject.addObserver(observer2);
subject.addObserver(observer3);
subject.notifyObservers("Hello World");
}
}
四、装饰器模式
装饰器模式是一种结构型设计模式，它允许向一个对象添加功能而不改变对象的类。在 Java 函数中，装饰器模式常用于为已有类增加新的功能。
举例：下面是一个简单的装饰器模式实现：
public interface Component {
void operation();
}
public class ConcreteComponent implements Component {
@Override
public void operation() {
System.out.println("ConcreteComponent operation");
}
}
public class Decorator implements Component {
private Component component;
public Decorator(Component component) {
this.component = component;
}
@Override
public void operation() {
component.operation();
}
}
public class ConcreteDecoratorA extends Decorator {
public ConcreteDecoratorA(Component component) {
super(component);
}
private void addFunction() {
System.out.println("ConcreteDecoratorA addFunction");
}
@Override
public void operation() {
super.operation();
addFunction();
}
}
public class ConcreteDecoratorB extends Decorator {
public ConcreteDecoratorB(Component component) {
super(component);
}
private void addFunction() {
System.out.println("ConcreteDecoratorB addFunction");
}
@Override
public void operation() {
super.operation();
addFunction();
}
}
public class DecoratorPatternDemo {
public static void main(String[] args) {
Component component = new ConcreteComponent();
component.operation();
Component decoratorA = new ConcreteDecoratorA(component);
decoratorA.operation();
Component decoratorB = new ConcreteDecoratorB(decoratorA);
decoratorB.operation();
}
}
总结
本文介绍了 Java 函数中常见的单例模式、工厂模式、观察者模式和装饰器模式四种设计模式的应用和实现。这些设计模式已经被广泛应用于 Java 的设计和开发中，希望本文能对读者有所帮助。