广州哪里有外贸网站,网站建设需要的一些技术,企业网站网站设计,永州seo快速排名文章目录 #x1f3af;单例模式应用实现 #x1f3ed;工厂模式应用实现 ❓策略模式应用实现 #x1f9d1;⚖️代理模式应用实现 #x1f50d;观察者模式#xff08;发布订阅模式#xff09;应用实现 #x1f9f0;装饰器模式应用实现 #x1f4f0;模版方法模式应用实现… 文章目录 单例模式应用实现 工厂模式应用实现 ❓策略模式应用实现 ⚖️代理模式应用实现 观察者模式发布订阅模式应用实现 装饰器模式应用实现 模版方法模式应用实现 ⛓️责任链模式应用实现 单例模式
整个程序运行过程中类只有一个实例减少内存消耗
应用
资源管理需要共享的资源如数据库连接池、线程池等确保只有一个实例管理这些资源全局配置配置类日志记录器在多线程或分布式环境中确保日志记录器唯一性
实现 实现时注意 构造器私有化防止篡改只暴露一个公共的获取实例的方法是否线程安全 饿汉式线程安全类加载的时候就实例化 public class Singleton{private static final Singleton instance new Singleton();private Singleton(){}public static Singleton getInstance(){return instance;}
}懒汉式线程不安全使用到时再实例化 public class Singleton{private static Singleton instance ;private Singleton(){}public static Singleton getInstance(){if(instance null){instance new Singleton();}return instance;}
}双重检查锁懒汉式的优化线程安全使用volatile防止指令重排序 public class Singleton{private static volatile Singleton instance; //使用volatile防止指针重排序private Singleton(){}public static Singleton getInstance(){if(instance null){ //第一次检查synchronized(Singleton.class){if(instance null){ //第二次检查保证线程安全instance new Singleton();}}}}
}静态内部类利用类加载机制实现懒加载和线程安全 public class Singleton {private Singleton() {}private static class Holder {private static final Singleton INSTANCE new Singleton();}public static Singleton getInstance() {return Holder.INSTANCE;}
} 枚举单例简单且防止反射和序列化攻击 public enum Singleton{INSTANCE;
}Singleton instance Singleton.INSTANCE;防止反射入侵在构造器中添加一个判断如果对象存在则抛出异常 序列化和反序列化安全添加一个readResolve()方法在进行反序列化时会执行readResolve()方法确保只有一个实例存在 工厂模式
封装对象的创建逻辑减低耦合
应用
动态创建不同类型的对象
实现
产品接口、产品实现类、工厂类
// 产品接口
public interface Product {void use();
}// 具体产品A
public class ConcreteProductA implements Product {Overridepublic void use() {System.out.println(Using ConcreteProductA);}
}// 具体产品B
public class ConcreteProductB implements Product {Overridepublic void use() {System.out.println(Using ConcreteProductB);}
}// 简单工厂类
public class SimpleFactory {public static Product createProduct(String type) {switch (type) {case A:return new ConcreteProductA();case B:return new ConcreteProductB();default:throw new IllegalArgumentException(Unknown product type);}}
}// 客户端代码
public class Client {public static void main(String[] args) {Product productA SimpleFactory.createProduct(A);productA.use(); // Output: Using ConcreteProductAProduct productB SimpleFactory.createProduct(B);productB.use(); // Output: Using ConcreteProductB}
}
❓策略模式
封装不同的算法允许运行时选择不同的策略
应用
同一个业务使用不同的策略
支付系统数据压缩日志策略
实现
策略接口、策略实现类不同策略、上下文类
// 策略接口
interface Strategy {void execute();
}// 具体策略A
class ConcreteStrategyA implements Strategy {Overridepublic void execute() {System.out.println(Executing Strategy A);}
}// 具体策略B
class ConcreteStrategyB implements Strategy {Overridepublic void execute() {System.out.println(Executing Strategy B);}
}// 上下文类
class Context {private Strategy strategy;public void setStrategy(Strategy strategy) {this.strategy strategy;}public void executeStrategy() {if (strategy ! null) {strategy.execute();} else {System.out.println(No strategy set);}}
}// 客户端
public class Main {public static void main(String[] args) {Context context new Context();Strategy strategyA new ConcreteStrategyA();Strategy strategyB new ConcreteStrategyB();context.setStrategy(strategyA);context.executeStrategy(); // Output: Executing Strategy Acontext.setStrategy(strategyB);context.executeStrategy(); // Output: Executing Strategy B}
}
⚖️代理模式
代理对象控制对目标对象的访问
应用
在不修改原来代码的基础上实现对目标对象的控制和管理
权限验证性能优化通过代理实现缓存或延迟加载以提高系统性能远程访问客户端访问远程对象时通过代理封装远程调用细节日志记录在方法调用时添加日志记录功能
实现
接口、实现类、代理类静态代理
public interface Subject{void request();
}public RealSubject implements Subject{Overridepublic void request(){System.out.println(RealSubject request);}
}public class Proxy implements Subject{private RealSubject realSubject;Overridepublic void request(){if(realSubject null)realSubject new RealSubject();System.out.println(before);realSubject.request();System.out.println(after);}
}public class Main{public static void main(String[] args){Subject proxy new Proxy();proxy.request();}
}观察者模式发布订阅模式
一个对象状态变化时依赖它的对象会收到通知
应用
事件驱动系统用户操作界面通过监听事件触发响应系统间通信某个模块发生变化通知多个依赖模块订阅数据更新通知所有订阅者推送通知
实现
观察者接口、被观察者接口、观察者类、被观察者类
// 观察者接口
interface Observer {void update(String message);
}// 被观察者接口
interface Subject {void addObserver(Observer observer);void removeObserver(Observer observer);void notifyObservers();
}// 具体被观察者
class ConcreteSubject implements Subject {private ListObserver observers new ArrayList();private String state;Overridepublic void addObserver(Observer observer) {observers.add(observer);}Overridepublic void removeObserver(Observer observer) {observers.remove(observer);}Overridepublic void notifyObservers() {for (Observer observer : observers) {observer.update(state);}}public void setState(String state) {this.state state;notifyObservers();}
}// 具体观察者
class ConcreteObserver implements Observer {private String name;public ConcreteObserver(String name) {this.name name;}Overridepublic void update(String message) {System.out.println(name received update: message);}
}// 客户端
public class Main {public static void main(String[] args) {ConcreteSubject subject new ConcreteSubject();Observer observer1 new ConcreteObserver(Observer1);Observer observer2 new ConcreteObserver(Observer2);subject.addObserver(observer1);subject.addObserver(observer2);subject.setState(New State 1);subject.setState(New State 2);}
}
装饰器模式
不改变原始类在其基础上动态扩展功能
应用
动态扩展功能对现有对象添加功能但不希望通过继承方式不同功能的组合透明扩展客户端无需了解对象是否被装饰过
实现
组件接口、具体组件实现类、装饰器抽象类、具体装饰器
// 组件接口
interface Component {void operation();
}// 具体组件
class ConcreteComponent implements Component {Overridepublic void operation() {System.out.println(ConcreteComponent operation);}
}// 装饰器抽象类
abstract class Decorator implements Component {protected Component component;public Decorator(Component component) {this.component component;}Overridepublic void operation() {component.operation();}
}// 具体装饰器A
class ConcreteDecoratorA extends Decorator {public ConcreteDecoratorA(Component component) {super(component);}Overridepublic void operation() {super.operation();System.out.println(ConcreteDecoratorA added behavior);}
}// 具体装饰器B
class ConcreteDecoratorB extends Decorator {public ConcreteDecoratorB(Component component) {super(component);}Overridepublic void operation() {super.operation();System.out.println(ConcreteDecoratorB added behavior);}
}// 客户端
public class Main {public static void main(String[] args) {Component component new ConcreteComponent();Component decoratorA new ConcreteDecoratorA(component);Component decoratorB new ConcreteDecoratorB(decoratorA);decoratorB.operation();// Output:// ConcreteComponent operation// ConcreteDecoratorA added behavior// ConcreteDecoratorB added behavior}
}
模版方法模式
定义一个逻辑框架把具体的实现留给子类
应用
定义算法骨架复用公共逻辑
例抽象类、继承抽象类
不同支付渠道的流程都是一样的包括前置的参数检查、核心支付逻辑、后置的检查等可以抽象成一个模版方法抽象类不同支付渠道的实现类继承它并实现支付逻辑。
实现
抽象类、继承抽象类
// 抽象类
abstract class DataProcessor {// 模板方法public final void process() {readData();processData();writeData();}protected abstract void readData(); // 读取数据protected abstract void processData(); // 处理数据protected void writeData() { // 写入数据System.out.println(Writing data to output.);}
}// 具体实现类A
class CSVDataProcessor extends DataProcessor {Overrideprotected void readData() {System.out.println(Reading data from CSV file.);}Overrideprotected void processData() {System.out.println(Processing CSV data.);}
}// 具体实现类B
class JSONDataProcessor extends DataProcessor {Overrideprotected void readData() {System.out.println(Reading data from JSON file.);}Overrideprotected void processData() {System.out.println(Processing JSON data.);}
}// 客户端
public class Main {public static void main(String[] args) {DataProcessor csvProcessor new CSVDataProcessor();csvProcessor.process();DataProcessor jsonProcessor new JSONDataProcessor();jsonProcessor.process();}
}
⛓️责任链模式
将多个对象连接成一条链沿着这条链传递请求让每个对象都有机会处理请求请求会顺着链传递直到某个对象可以处理。
应用
不同级别处理
审批流程日志系统不同级别的日志记录
实现
抽象类、继承抽象类
// 处理器接口
abstract class Handler {protected Handler nextHandler;public void setNextHandler(Handler nextHandler) {this.nextHandler nextHandler;}public abstract void handleRequest(String request);
}// 具体处理器A
class ConcreteHandlerA extends Handler {Overridepublic void handleRequest(String request) {if (A.equals(request)) {System.out.println(ConcreteHandlerA handled request: request);} else if (nextHandler ! null) {nextHandler.handleRequest(request);} else {System.out.println(No handler for request: request);}}
}// 具体处理器B
class ConcreteHandlerB extends Handler {Overridepublic void handleRequest(String request) {if (B.equals(request)) {System.out.println(ConcreteHandlerB handled request: request);} else if (nextHandler ! null) {nextHandler.handleRequest(request);} else {System.out.println(No handler for request: request);}}
}// 客户端
public class Main {public static void main(String[] args) {Handler handlerA new ConcreteHandlerA();Handler handlerB new ConcreteHandlerB();handlerA.setNextHandler(handlerB);handlerA.handleRequest(A); // Output: ConcreteHandlerA handled request: AhandlerA.handleRequest(B); // Output: ConcreteHandlerB handled request: BhandlerA.handleRequest(C); // Output: No handler for request: C}
}
