1、桥接模式:
package com.model.bridging;
//定义一个抽象类,作为桥的角色,它包含一个实现部分的接口对象。
public abstract class Abstraction {
protected Implementor implementor;
public void setImplementor(Implementor implementor) {
this.implementor = implementor;
}
public abstract void operation();
}
package com.model.bridging;
//定义一个具体的抽象类,继承自抽象类。
public class RefinedAbstraction extends Abstraction {
@Override
public void operation() {
// 调用实现部分的方法
implementor.operationImpl();
}
}
package com.model.bridging;
//定义一个实现部分的接口,它包含具体实现的方法。
public interface Implementor {
void operationImpl();
}
package com.model.bridging;
//定义一个具体的实现类,实现接口。
public class ConcreteImplementorA implements Implementor {
@Override
public void operationImpl() {
// 具体实现
}
}
package com.model.bridging;
//使用桥接模式
//实现桥接模式的关键在于将抽象与实现分离,使它们可以独立地变化。
public class Main {
public static void main(String[] args) {
Abstraction abstraction = new RefinedAbstraction();
Implementor implementor = new ConcreteImplementorA();
abstraction.setImplementor(implementor);
abstraction.operation();
}
}
2、适配器模式:
package com.model.adapter;
//定义一个目标接口,即客户端所期望的接口。
public interface Target {
void request();
}
package com.model.adapter;
//定义一个适配者类,它需要被适配成目标接口。
public class Adaptee {
public void specialRequest() {
// 做一些特殊的处理
}
}
package com.model.adapter;
//定义一个适配器类,实现目标接口并包装适配者类。
public class Adapter implements Target {
private Adaptee adaptee;
public Adapter(Adaptee adaptee) {
this.adaptee = adaptee;
}
@Override
public void request() {
// 调用适配者类的特殊方法
adaptee.specialRequest();
}
}
package com.model.adapter;
//使用适配器模式:
public class Main {
public static void main(String[] args) {
Adaptee adaptee = new Adaptee();
Target adapter = new Adapter(adaptee);
adapter.request();
}
}
3、装饰器模式:
package com.model.decorator;
//定义一个抽象组件接口,该接口定义了原有对象和装饰器对象的共同行为。
public interface Component {
void operation();
}
package com.model.decorator;
//定义一个具体组件类,即原有的对象。
public class ConcreteComponent implements Component {
@Override
public void operation() {
// 执行原有对象的操作逻辑
}
}
package com.model.decorator;
//定义一个抽象装饰器类,实现抽象组件接口,并持有一个抽象组件对象的引用。
public abstract class Decorator implements Component {
protected Component component;
public Decorator(Component component) {
this.component = component;
}
@Override
public void operation() {
// 调用原有对象的操作逻辑
component.operation();
}
}
package com.model.decorator;
//定义具体的装饰器类,继承抽象装饰器类,可以在原有的操作逻辑上新增额外的功能。
public class ConcreteDecorator extends Decorator {
public ConcreteDecorator(Component component) {
super(component);
}
@Override
public void operation() {
// 执行额外的功能
// 调用原有对象的操作逻辑
super.operation();
}
}
package com.model.decorator;
//使用装饰器模式
public class Main {
public static void main(String[] args) {
Component component = new ConcreteComponent();
Component decorator1 = new ConcreteDecorator(component);
decorator1.operation();
Component decorator2 = new ConcreteDecorator(decorator1);
decorator2.operation();
}
}
4、代理模式:
package com.model.agent;
//定义一个接口,该接口定义了目标对象和代理对象的共同行为。
public interface Subject {
void request();
}
package com.model.agent;
//定义一个目标对象,实现接口。
public class RealSubject implements Subject {
@Override
public void request() {
// 实现目标对象的操作逻辑
}
}
package com.model.agent;
//定义一个代理类,实现接口,并持有一个目标对象的引用。
public class Proxy implements Subject {
private Subject realSubject;
public Proxy(Subject realSubject) {
this.realSubject = realSubject;
}
@Override
public void request() {
// 可以在这里添加额外的功能或限制访问
realSubject.request();
}
}
package com.model.agent;
//使用代理模式
//代理模式用于控制访问对象。代理对象充当了客户端和目标对象之间的中介,在不直接访问目标对象的情况下,通过代理对象间接地访问目标对象。
//代理模式可以在目标对象的基础上添加额外的功能或限制访问,同时可以隐藏目标对象的具体实现。
public class Main {
public static void main(String[] args) {
Subject realSubject = new RealSubject();
Subject proxy = new Proxy(realSubject);
proxy.request();
}
}
5、外观模式:
package com.model.appearance;
//子系统A
public interface SubSystemA {
void operationA();
}
package com.model.appearance;
//子系统A的实现类。
public class SubSystemAImpl implements SubSystemA {
public void operationA() {
System.out.println("SubSystemA operation A");
}
}
package com.model.appearance;
//子系统B
public interface SubSystemB {
void operationB();
}
package com.model.appearance;
//子系统A的实现类。
public class SubSystemAImpl implements SubSystemA {
public void operationA() {
System.out.println("SubSystemA operation A");
}
}
package com.model.appearance;
//实现外观类,封装子系统的功能。
public class Facade {
private SubSystemA subSystemA;
private SubSystemB subSystemB;
public Facade() {
this.subSystemA = new SubSystemAImpl();
this.subSystemB = new SubSystemBImpl();
}
public void operation() {
System.out.println("Facade operation");
subSystemA.operationA();
subSystemB.operationB();
}
}
package com.model.appearance;
//客户端通过外观类进行调用。
public class Client {
public static void main(String[] args) {
Facade facade = new Facade();
facade.operation();
}
}
6、组合模式:
package com.model.combinatorial;
//定义组件的抽象类/接口。假设有一个组织机构,包括公司和部门,可以使用一个抽象类来表示组织机构的基础行为。
public abstract class OrganizationComponent {
protected String name;
public OrganizationComponent(String name) {
this.name = name;
}
public abstract void add(OrganizationComponent component);
public abstract void remove(OrganizationComponent component);
public abstract void display(int depth);
}
package com.model.combinatorial;
import java.util.ArrayList;
import java.util.List;
//实现容器类(继承自抽象类/接口)。假设公司和部门都是组织机构的容器节点。
public class Organization extends OrganizationComponent {
private List<OrganizationComponent> components;
public Organization(String name) {
super(name);
components = new ArrayList<>();
}
public void add(OrganizationComponent component) {
components.add(component);
}
public void remove(OrganizationComponent component) {
components.remove(component);
}
public void display(int depth) {
System.out.println("-".repeat(depth) + name);
for (OrganizationComponent component : components) {
component.display(depth + 1);
}
}
}
package com.model.combinatorial;
//实现叶子节点类(继承自抽象类/接口)。假设公司员工是组织机构的叶子节点。
public class Employee extends OrganizationComponent {
public Employee(String name) {
super(name);
}
public void add(OrganizationComponent component) {
// 叶子节点无法添加子节点,不需要实现该方法
}
public void remove(OrganizationComponent component) {
// 叶子节点无法删除子节点,不需要实现该方法
}
public void display(int depth) {
System.out.println("-".repeat(depth) + name);
}
}
package com.model.combinatorial;
//客户端可以通过组合方式构建组织机构,并操作组织机构。
public class Client {
public static void main(String[] args) {
OrganizationComponent ceo = new Organization("CEO");
OrganizationComponent hrDepartment = new Organization("HR Department");
OrganizationComponent financeDepartment = new Organization("Finance Department");
OrganizationComponent manager1 = new Employee("Manager1");
OrganizationComponent manager2 = new Employee("Manager2");
OrganizationComponent staff1 = new Employee("Staff1");
OrganizationComponent staff2 = new Employee("Staff2");
ceo.add(manager1);
ceo.add(manager2);
hrDepartment.add(staff1);
financeDepartment.add(staff2);
ceo.display(0);
}
}