1、单例模式
单例模式（Singleton Pattern）是一种创建型设计模式，它保证一个类只有一个实例，并提供全局访问点来访问该实例。
单例模式的主要特点是：
- 单例类只有一个实例对象。
- 对外提供一个全局访问点，使其他对象可以通过该访问点获取该实例。
- 单例模式常用于需要共享资源或控制某个全局状态的场景，例如数据库连接池、日志记录器、配置管理器等。
懒汉模式
public class SingleTon {
// 单例模式懒汉
private static SingleTon instance = null;
private SingleTon() {
}
//case 1:
public static SingleTon getInstance() {
if (instance == null) {
synchronized (SingleTon.class) {
if (instance == null) {
instance = new SingleTon();
}
}
}
return instance;
}
// case 2:
public static synchronized SingleTon getInstance() {
if (instance == null) {
instance = new SingleTon();
}
return instance;
}
}
饿汉模式
public class SingleTon {
// 单例模式饿汉
private static SingleTon instance = new SingleTon();
private SingleTon() {
}
public static SingleTon getInstance() {
return instance;
}
}
2、工厂模式
工厂模式（Factory Pattern）是一种创建型设计模式，它提供了一种创建对象的方式，将对象的创建过程封装在一个工厂类中，客户端通过调用工厂类的方法来获取所需的对象，而不需要直接实例化对象。
工厂模式主要解决了对象的创建过程复杂、耦合度高的问题，通过引入工厂类，将对象的创建逻辑和客户端代码解耦，使得客户端无需关心具体的创建细节，只需要通过工厂类获取对象即可。
工厂模式包括三种常见的变体：简单工厂模式、工厂方法模式和抽象工厂模式。
- 简单工厂模式（Simple Factory Pattern）：由一个工厂类根据客户端的请求，创建不同的产品对象。客户端只需要知道具体的产品名称或类型，无需关心产品的创建细节。
- 工厂方法模式（Factory Method Pattern）：定义一个用于创建对象的工厂方法接口，每个具体工厂类都实现该接口，用于创建特定类型的产品对象。客户端通过调用工厂方法来创建所需的产品对象，具体的产品创建由对应的具体工厂类来实现。
- 抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或相互依赖对象的接口，每个具体工厂类都实现了该接口，用于创建一组相关的产品对象。客户端通过调用抽象工厂的方法来创建所需的产品族，具体的产品创建由对应的具体工厂类来实现。
简单工厂
// 产品接口
interface Product {
void use();
}
// 具体产品A
class ConcreteProductA implements Product {
@Override
public void use() {
System.out.println("Using ConcreteProductA");
}
}
// 具体产品B
class ConcreteProductB implements Product {
@Override
public void use() {
System.out.println("Using ConcreteProductB");
}
}
// 简单工厂类
class SimpleFactory {
public static Product createProduct(String type) {
if (type.equalsIgnoreCase("A")) {
return new ConcreteProductA();
} else if (type.equalsIgnoreCase("B")) {
return new ConcreteProductB();
}
return null;
}
}
// 客户端代码
public class SimpleFactoryExample {
public static void main(String[] args) {
// 创建产品A
Product productA = SimpleFactory.createProduct("A");
productA.use(); // 输出：Using ConcreteProductA
// 创建产品B
Product productB = SimpleFactory.createProduct("B");
productB.use(); // 输出：Using ConcreteProductB
}
}
抽象工厂
// 抽象产品接口
interface Product {
void use();
}
// 具体产品A
class ConcreteProductA implements Product {
@Override
public void use() {
System.out.println("Using ConcreteProductA");
}
}
// 具体产品B
class ConcreteProductB implements Product {
@Override
public void use() {
System.out.println("Using ConcreteProductB");
}
}
// 抽象工厂接口
interface AbstractFactory {
Product createProduct();
}
// 具体工厂A
class ConcreteFactoryA implements AbstractFactory {
@Override
public Product createProduct() {
return new ConcreteProductA();
}
}
// 具体工厂B
class ConcreteFactoryB implements AbstractFactory {
@Override
public Product createProduct() {
return new ConcreteProductB();
}
}
// 客户端代码
public class AbstractFactoryExample {
public static void main(String[] args) {
// 创建工厂A
AbstractFactory factoryA = new ConcreteFactoryA();
Product productA = factoryA.createProduct();
productA.use(); // 输出：Using ConcreteProductA
// 创建工厂B
AbstractFactory factoryB = new ConcreteFactoryB();
Product productB = factoryB.createProduct();
productB.use(); // 输出：Using ConcreteProductB
}
}
工厂方法
// 抽象产品接口
interface Product {
void use();
}
// 具体产品A
class ConcreteProductA implements Product {
@Override
public void use() {
System.out.println("Using ConcreteProductA");
}
}
// 具体产品B
class ConcreteProductB implements Product {
@Override
public void use() {
System.out.println("Using ConcreteProductB");
}
}
// 抽象工厂接口
interface Factory {
Product createProduct();
}
// 具体工厂A
class ConcreteFactoryA implements Factory {
@Override
public Product createProduct() {
return new ConcreteProductA();
}
}
// 具体工厂B
class ConcreteFactoryB implements Factory {
@Override
public Product createProduct() {
return new ConcreteProductB();
}
}
// 客户端代码
public class FactoryMethodExample {
public static void main(String[] args) {
// 创建工厂A
Factory factoryA = new ConcreteFactoryA();
Product productA = factoryA.createProduct();
productA.use(); // 输出：Using ConcreteProductA
// 创建工厂B
Factory factoryB = new ConcreteFactoryB();
Product productB = factoryB.createProduct();
productB.use(); // 输出：Using ConcreteProductB
}
}
3、代理模式
代理模式（Proxy Pattern）是一种结构型设计模式，它提供了一个代理对象，用于控制对实际对象的访问。代理对象充当客户端和实际对象之间的中介，通过代理对象可以间接访问实际对象，并在访问过程中加入额外的逻辑或控制。
代理模式的主要目的是在不改变实际对象的情况下，对其进行扩展或控制。它可以实现一些常见的功能，如远程代理、虚拟代理、保护代理、缓存代理等。
public class Test {
public static void main(String[] args) {
Wedding proxyWedding = new ProxyWedding();
proxyWedding.one();
proxyWedding.two();
}
}
interface Wedding{
void one();
void two();
}
class RealWedding implements Wedding{
@Override
public void one() {
System.out.println("真实one");
}
@Override
public void two() {
System.out.println("真实two");
}
}
class ProxyWedding implements Wedding{
private RealWedding realWedding;
public ProxyWedding() {
this.realWedding = new RealWedding();
}
@Override
public void one() {
System.out.println("代理one");
realWedding.one();
}
@Override
public void two() {
System.out.println("代理two");
realWedding.two();
}
}
4、策略模式
策略模式（Strategy Pattern）是一种行为型设计模式，它定义了一系列算法，并使这些算法可以相互替换，使得算法可以独立于使用它的客户端而变化。
在策略模式中，算法被封装在各个具体的策略类中，每个策略类实现了一种具体的算法。客户端通过使用一个上下文对象，将具体的策略对象传递给上下文对象，从而在运行时决定使用哪种算法。这种方式可以在不修改客户端代码的情况下，动态切换和扩展不同的算法。
public class ZTest {
public static void main(String[] args) {
Strategy zfb = new Zfb();
Strategy wx = new Wx();
Strategy yhk = new Yhk();
StrategyManage strategyManage = new StrategyManage(zfb);
strategyManage.pay("100");
strategyManage.setStrategy(wx);
strategyManage.pay("200");
strategyManage.setStrategy(yhk);
strategyManage.pay("300");
}
}
interface Strategy{
void pay(String money);
}
class Zfb implements Strategy{
@Override
public void pay(String money) {
System.out.println("zfb 支付"+money);
}
}
class Wx implements Strategy{
@Override
public void pay(String money) {
System.out.println("wx 支付"+money);
}
}
class Yhk implements Strategy{
@Override
public void pay(String money) {
System.out.println("yhk 支付"+money);
}
}
class StrategyManage {
private Strategy strategy;
public StrategyManage(Strategy strategy) {
this.strategy = strategy;
}
public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}
public void pay(String money){
strategy.pay(money);
}
}
5、观察者模式
观察者模式（Observer Pattern）是一种行为型设计模式，它定义了一种一对多的依赖关系，使得多个观察者对象可以同时监听并被动地接收到主题对象的状态变化通知。当主题对象的状态发生变化时，所有依赖于它的观察者对象都会自动收到通知并进行相应的处理。
观察者模式包含以下几个关键角色：
- Subject（主题）：也称为被观察者或可观察者，它是一个抽象类或接口，定义了增加、删除和通知观察者的方法。
- ConcreteSubject（具体主题）：实现主题接口，维护观察者对象的列表，并在状态发生变化时通知观察者。
- Observer（观察者）：也称为订阅者或监听者，它是一个抽象类或接口，定义了接收通知并进行相应处理的方法。
- ConcreteObserver（具体观察者）：实现观察者接口，具体定义接收通知后的具体行为。
import java.util.ArrayList;
import java.util.List;
public class ZTest {
public static void main(String[] args) {
SubjectRealZ subjectZ = new SubjectRealZ();
new BinaryObeserve(subjectZ);
new OctalObeserve(subjectZ);
System.out.println("update to 10");
subjectZ.setState(10);
System.out.println("update to 20");
subjectZ.setState(20);
}
}
interface Obeserve {
void update(int state);
}
class BinaryObeserve implements Obeserve{
public BinaryObeserve(SubjectZ subjectZ) {
subjectZ.attach(this);
}
@Override
public void update(int state) {
System.out.println("Binary+;;;;"+Integer.toBinaryString(state));
}
}
class OctalObeserve implements Obeserve{
public OctalObeserve(SubjectZ subjectZ) {
subjectZ.attach(this);
}
@Override
public void update(int state) {
System.out.println("Octal+;;;;"+Integer.toOctalString(state));
}
}
interface SubjectZ{
void attach(Obeserve obeserve);
void notifyAllObeserve();
}
class SubjectRealZ implements SubjectZ{
private int state;
List<Obeserve> obeserves = new ArrayList<>();
public int getState() {
return state;
}
public void setState(int state) {
this.state = state;
notifyAllObeserve();
}
@Override
public void attach(Obeserve obeserve) {
obeserves.add(obeserve);
}
@Override
public void notifyAllObeserve() {
for (Obeserve o :
obeserves) {
o.update(state);
}
}
}
6、享元模式
享元模式（Flyweight Pattern）是一种结构型设计模式，旨在有效地支持大量细粒度的对象共享。它通过共享对象来减少内存使用和提高性能，特别适用于需要创建大量相似对象的情况。
核心思想是将对象分为可共享的内部状态（Intrinsic State）和不可共享的外部状态（Extrinsic State）。内部状态是对象的固有属性，可以被多个对象共享，而外部状态是对象的变化属性，每个对象都有自己的外部状态。
享元模式的关键角色如下：
- Flyweight（抽象享元）：定义了享元对象的接口，包含设置和获取外部状态的方法。
- ConcreteFlyweight（具体享元）：实现抽象享元接口，表示可共享的具体享元对象。
- FlyweightFactory（享元工厂）：负责创建和管理享元对象，维护一个享元池用于存储已经创建的享元对象。
- Client（客户端）：使用享元对象的客户端，通过享元工厂获取享元对象，并根据需要设置外部状态。
import java.awt.Color;
import java.util.HashMap;
import java.util.Map;
// 图形接口
interface Shape {
void draw(int x, int y);
}
// 圆形类
class Circle implements Shape {
private String color;
public Circle(String color) {
this.color = color;
}
@Override
public void draw(int x, int y) {
System.out.println("Drawing a " + color + " circle at position (" + x + ", " + y + ")");
}
}
// 图形工厂
class ShapeFactory {
private static final Map<String, Shape> shapeCache = new HashMap<>();
public static Shape getCircle(String color) {
Shape circle = shapeCache.get(color);
if (circle == null) {
circle = new Circle(color);
shapeCache.put(color, circle);
}
return circle;
}
}
// 客户端代码
public class GraphicsEditor {
public static void main(String[] args) {
Shape redCircle = ShapeFactory.getCircle("Red");
redCircle.draw(100, 100);
Shape blueCircle = ShapeFactory.getCircle("Blue");
blueCircle.draw(200, 200);
Shape redCircleAgain = ShapeFactory.getCircle("Red");
redCircleAgain.draw(300, 300);
}
}
7、责任链模式（常见场景有：过滤器，拦截器都是用的该模式）
责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，用于解耦发送者和接收者之间的关系。在责任链模式中，多个对象都有机会处理请求，直到其中一个对象处理请求为止。
核心思想是将请求沿着一个处理链传递，每个处理者（或称为节点）都有机会处理请求，如果当前节点无法处理该请求，则将其传递给下一个节点，直到找到能够处理请求的节点为止。
责任链模式的关键角色如下：
- Handler（处理者）：定义处理请求的接口，并持有下一个处理者的引用。
- ConcreteHandler（具体处理者）：实现处理请求的具体逻辑，如果自己无法处理该请求，则将其传递给下一个处理者。
- Client（客户端）：创建并组装责任链，将请求发送给第一个处理者。
// 处理者接口
interface Handler {
void setNextHandler(Handler nextHandler);
void handleRequest(String request);
}
// 具体处理者 A
class ConcreteHandlerA implements Handler {
private Handler nextHandler;
@Override
public void setNextHandler(Handler nextHandler) {
this.nextHandler = nextHandler;
}
@Override
public void handleRequest(String request) {
if (request.equalsIgnoreCase("A")) {
System.out.println("ConcreteHandlerA handles the request");
} else if (nextHandler != null) {
nextHandler.handleRequest(request);
}
}
}
// 具体处理者 B
class ConcreteHandlerB implements Handler {
private Handler nextHandler;
@Override
public void setNextHandler(Handler nextHandler) {
this.nextHandler = nextHandler;
}
@Override
public void handleRequest(String request) {
if (request.equalsIgnoreCase("B")) {
System.out.println("ConcreteHandlerB handles the request");
} else if (nextHandler != null) {
nextHandler.handleRequest(request);
}
}
}
// 客户端代码
public class Test {
public static void main(String[] args) {
Handler handlerA = new ConcreteHandlerA();
Handler handlerB = new ConcreteHandlerB();
handlerA.setNextHandler(handlerB);
handlerA.handleRequest("A");
handlerA.handleRequest("B");
handlerA.handleRequest("C");
}
}
8、模板模式
模板模式（Template Pattern）是一种行为型设计模式，用于定义一个算法的骨架，将一些步骤的实现延迟到子类中。在模板模式中，定义了一个模板方法，该方法包含了算法的骨架和一些步骤的抽象方法，子类可以通过重写抽象方法来实现具体的步骤，而算法的骨架保持不变。
模板模式的核心思想是将算法的通用部分提取出来，放在模板方法中，而将可变的部分留给子类实现。这样做的好处是可以确保算法的一致性，并且在不改变算法结构的情况下，允许子类对部分步骤进行个性化定制。
// 抽象模板类
abstract class AbstractClass {
public void templateMethod() {
commonStep1();
abstractStep();
commonStep2();
}
public void commonStep1() {
System.out.println("This is a common step 1.");
}
public void commonStep2() {
System.out.println("This is a common step 2.");
}
public abstract void abstractStep();
}
// 具体模板类 A
class ConcreteClassA extends AbstractClass {
@Override
public void abstractStep() {
System.out.println("This is an implementation of abstract step in ConcreteClassA.");
}
}
// 具体模板类 B
class ConcreteClassB extends AbstractClass {
@Override
public void abstractStep() {
System.out.println("This is an implementation of abstract step in ConcreteClassB.");
}
}
// 客户端代码
public class TemplatePatternExample {
public static void main(String[] args) {
AbstractClass templateA = new ConcreteClassA();
templateA.templateMethod();
AbstractClass templateB = new ConcreteClassB();
templateB.templateMethod();
}
}
1683
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
