六类常见的结构型模式

最新推荐文章于 2024-04-30 12:12:17 发布

沐风听雨_A

最新推荐文章于 2024-04-30 12:12:17 发布

阅读量509

点赞数 18

文章标签： java 开发语言

本文链接：https://blog.csdn.net/wehpd/article/details/137089522

版权

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);
    }
}