设计模式之结构型模式

最新推荐文章于 2024-09-19 21:45:47 发布
最新推荐文章于 2024-09-19 21:45:47 发布
阅读量3.2k 收藏
点赞数
分类专栏： Java 文章标签： 适配器模式 Java静态代理 Java动态代理 外观模式 组合模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zping0808/article/details/89479842
版权

一、简介

结构型模式(Structural Pattern)描述如何将类或者对 象结合在一起形成更大的结构，就像搭积木，可以通过 简单积木的组合形成复杂的、功能更为强大的结构。

  • 适配器模式 Adapter Pattern ：一个适配允许通常因为接口不兼容而不能在一起工作的类工作在一起，做法是将类自己的接口包裹在一个已存在的类中。
    使用频率：★★★★☆

  • 桥接模式 Bridge Pattern ：是将抽象部分与它的实现部分分离，使它们都可以独立地变化。
    使用频率： ★★★☆☆

  • 组合模式 Composite Pattern ：将对象组合成树形结构以表示“部分-整体”的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。
    使用频率：★★★★☆

  • 装饰模式 Decorator Pattern ：是在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。
    使用频率：★★★☆☆

  • 外观模式 Facade Pattern ：外部与一个子系统的通信必须通过一个统一的外观对象进行，为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
    使用频率：★★★★★

  • 享元模式 Flyweight Pattern：它使用共享物件，用来尽可能减少内存使用量以及分享资讯给尽可能多的相似物件；它适合用于只是因重复而导致使用无法令人接受的大量内存的大量物件。
    使用频率：★☆☆☆☆

  • 代理模式 Proxy Pattern：是指一个类别可以作为其它东西的接口。代理者可以作任何东西的接口：网上连接、存储器中的大对象、文件或其它昂贵或无法复制的资源。
    使用频率：★★★★☆

二、适配器模式

2.1、类适配器

定义接口

//目标接口
public interface Target {
    void request();
}

定义实现

//目标类具体实现
public class ConcreteTarget implements Target {
    @Override
    public void request() {
        System.out.println("普通功能");
    }
}

//具有特殊功能的类 适配者
public class Adaptee {
    public void specificRequest() {
        System.out.println("特殊功能");
    }
}

//类适配器 适配具有特殊功能
public class Adapter extends Adaptee implements Target {
    @Override
    public void request() {
        super.specificRequest();
    }
}

测试类

//只使用普通功能
Target concreteTarget = new ConcreteTarget();
concreteTarget.request();//普通功能
/*------------------类适配器-------------------*/
//使用特殊功能 使用适配类
Target adapter = new Adapter();
adapter.request();//特殊功能

2.2、对象适配器

定义接口

//目标接口
public interface Target {
    void request();
}

定义实现

//具有特殊功能的类 适配者
public class Adaptee {
    public void specificRequest() {
        System.out.println("特殊功能");
    }
}

//具有特殊功能的类 适配者
public class Adaptee {
    public void specificRequest() {
        System.out.println("特殊功能");
    }
}

//对象适配器 直接关联适配者对象
public class Adapter2 implements Target {
    private final Adaptee adaptee;
    //通过构造函数传入适配者对象
    public Adapter2(Adaptee adaptee) {
        this.adaptee=adaptee;
    }
    @Override
    public void request() {
        //通过被关联的适配者对象调用适配者中方法
        adaptee.specificRequest();
    }
}

测试类

/*------------------对象适配器-------------------*/
Target adapter2 = new Adapter2(new Adaptee());
adapter2.request();//特殊功能

2.3、接口适配器

当使用电脑时，监听电脑USB接口使用情况，可以设置电脑USB接口使用监听，可以用接口适配器模式只设置需要USB接口的监听

场景实体定义

//电脑USB接口监听
public interface Listener {
    //usb接口1回调
    void onUSB1();
    //usb接口2回调
    void onUSB2();
    //usb接口3回调
    void onUSB3();
}

//电脑实体类
public class Computer {
    private Listener listener;
    //设置USB接口监听监听
    public void setListener(Listener listener){
        this.listener=listener;
    }
    //使用电脑
    public void use(){
        if(listener!=null){
            //usb1被使用
            listener.onUSB1();
            //usb2被使用
            listener.onUSB2();
            //usb3被使用
            listener.onUSB3();
        }
    }
}

//接口适配器类，实现接口并复写方法
public class AdapterListener implements Listener {
    @Override
    public void onUSB1() {}
    @Override
    public void onUSB2() {}
    @Override
    public void onUSB3() {}
}

测试类

/*-------------------接口适配器------------------*/
Computer computer=new Computer();
//只监听USB1监听，可使用接口适配器模式实现
computer.setListener(new AdapterListener(){
    @Override
    public void onUSB1() {
        super.onUSB1();
        System.out.println("接口1被使用");
    }
});
//使用电脑
computer.use();//接口1被使用

三、桥接模式

3.1、定义抽象类与接口

//人类抽象类
public abstract class Person {
    //持有水果的引用
    protected Fruits fruits;
    //设置吃的水果
    public void setFruits(Fruits fruits){
        this.fruits=fruits;
    }
    //吃
    protected abstract void eat();
}

//水果接口
public interface Fruits {
    //水果名称
    String name();
}

3.2、定义具体实现

//中国人实体
public class Chinese extends Person {
    @Override
    protected void eat() {
        if(fruits!=null){
            System.out.println("中国人吃"+fruits.name());
        }
    }
}

//美国人
public class American extends Person {
    @Override
    public void eat() {
        if (fruits != null) {
            System.out.println("美国人吃" + fruits.name());
        }
    }
}

//苹果实体类
public class Apple implements Fruits {
    @Override
    public String name() {
        return "苹果";
    }
}

//葡萄实体类
public class Grape implements Fruits {
    @Override
    public String name() {
        return "葡萄";
    }
}

3.2、使用桥接模式

//创建中国人 吃苹果
Person chinese=new Chinese();
chinese.setFruits(new Apple());
chinese.eat();//中国人吃苹果

//创建美国人 吃葡萄
Person american=new American();
american.setFruits(new Grape());
american.eat();//美国人吃葡萄

四、组合模式

4.1、组合模式案例

创建员工类

// 员工类
public class Employee {
    //姓名
    private String name;
    //部门
    private String dept;
    //薪水
    private int salary;
    private List<Employee> subordinates;

    public Employee(String name, String dept, int salary) {
        this.name = name;
        this.dept = dept;
        this.salary = salary;
        this.subordinates = new ArrayList<Employee>();
    }
    public void add(Employee e) {
        subordinates.add(e);
    }
    public void remove(Employee e) {
        subordinates.remove(e);
    }
    //获取下属集合
    public List<Employee> getSubordinates(){
        return subordinates;
    }
}

4.2、使用组合模式

一个公司有一个CEO，CEO手下有销售主管、营销主管，销售主管手下有2个销售员，营销主管手下有2个营销人员。可以使用组合模式构建：

Employee CEO = new Employee("张三", "CEO", 30000);
Employee headSales = new Employee("李四", "销售主管", 20000);
Employee headMarketing = new Employee("李五", "营销主管", 20000);
Employee clerk1 = new Employee("王五", "营销员", 10000);
Employee clerk2 = new Employee("赵六", "营销员", 10000);
Employee salesExecutive1 = new Employee("王五", "销售员", 10000);
Employee salesExecutive2 = new Employee("王芳", "销售员", 10000);
CEO.add(headSales);
CEO.add(headMarketing);

headSales.add(salesExecutive1);
headSales.add(salesExecutive2);

headMarketing.add(clerk1);
headMarketing.add(clerk2);

//打印该组织的所有员工
System.out.println(CEO);
for (Employee headEmployee : CEO.getSubordinates()) {
    System.out.println(headEmployee);
    for (Employee employee : headEmployee.getSubordinates()) {
        System.out.println(employee);
    }
}
//        Employee{name='张三', dept='CEO', salary=30000}
//        Employee{name='李四', dept='销售主管', salary=20000}
//        Employee{name='王五', dept='销售员', salary=10000}
//        Employee{name='王芳', dept='销售员', salary=10000}
//        Employee{name='李五', dept='营销主管', salary=20000}
//        Employee{name='王五', dept='营销员', salary=10000}
//        Employee{name='赵六', dept='营销员', salary=10000}

五、装饰模式

5.1、定义抽象类与接口

定义接口

//基础接口类
public interface Component {
    void say();
}

定义抽象装饰类

//装饰类
public abstract class Decorator implements Component {
    private Component component;
    public Decorator(Component component) {
        this.component = component;
    }
    @Override
    public void say() {
        this.component.say();
    }
}

5.2、定义具体实现

//具体实现类
public class ConcreteComponent implements Component {
    @Override
    public void say() {
        System.out.println("你好！");
    }
}

//具体装饰类
public class ConcreteDecorator extends Decorator{
    public ConcreteDecorator(Component component) {
        super(component);
    }
    @Override
    public void say() {
        System.out.println("敬礼！");
        super.say();
    }
}

5.3、使用装饰模式

//未使用装饰类
ConcreteComponent concretComponent = new ConcreteComponent();
concretComponent.say();//你好！

//使用装饰器
Component component = new ConcreteDecorator(new ConcreteComponent());
component.say();//敬礼！ 你好！

六、外观模式

一台电脑有CPU、内存、硬盘等组件组成，可以使用外观模式描述：

6.1、定义组件

//电脑CPU组件对象
public class CPU {
    public void start() {System.out.println("CPU已开启");}
    public void shutdown() {System.out.println("CPU已关闭");}
}
//电脑硬盘组件对象
public class Disk {
    public void start() {System.out.println("硬盘已开启");}
    public void shutdown() {System.out.println("硬盘已关闭");}

}
//电脑内存组件对象
public class Memory {
    public void start() {System.out.println("内存已开启");}
    public void shutdown() {System.out.println("内存已关闭");}

}

6.2、定义外观对象类

将组件组合使用：

//电脑实体（外观类）
public class Computer {
	private final CPU cpu;
    private final Memory memory;
    private final Disk disk;
    public Computer() {
        cpu = new CPU();
        memory = new Memory();
        disk = new Disk();
    }
    public void startup() {
        System.out.println("正在打开电脑");
        disk.start();
        memory.start();
        cpu.start();
        System.out.println("电脑打开完成");
    }
    public void shutdown() {
        System.out.println("正在关闭电脑");
        cpu.shutdown();
        memory.shutdown();
        disk.shutdown();
        System.out.println("电脑关闭完成");
    }
}

6.3、使用外观模式

Computer computer=new  Computer();
//打开电脑
computer.startup();//正在打开电脑 硬盘已开启 内存已开启 CPU已开启 电脑打开完成
//关闭电脑
computer.shutdown();//正在关闭电脑 CPU已关闭 内存已关闭 硬盘已关闭 电脑关闭完成

七、享元模式

7.1、定义接口与实现

//人类接口
public interface Human {
    //吃
    void eat();
}

//人类具体实现
public class Per implements Human {
    private String name;
    private String country;
    public Per(String country) {
        this.country = country;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public void eat() {
        System.out.println(country + "人" + name + "吃饭");
    }
}

7.2、定义工厂类

//创建人类工厂类
public class PerFactory {
    private static final Map<String, Per> pers = new HashMap<String, Per>();
    public static Per getPer(String country) {
        Per per = pers.get(country);
        if (per == null) {
            per = new Per(country);
            pers.put(country, per);
        }
        return per;
    }
    public static int getSize() {
        return pers.size();
    }
}

7.3、使用享元模式

String[] tags = {"中国", "美国"};
for (int i = 0; i < tags.length; i++) {
    for (int j = 0; j < 2; j++) {
        Per per = PerFactory.getPer(tags[i]);
        per.setName((i == 0 ? "张三" : "Tom") + j);
        per.eat();
        System.out.println("对象池中对象个数" + PerFactory.getSize());
    }
}
//中国人张三0吃饭
//对象池中对象个数1
//中国人张三1吃饭
//对象池中对象个数1
//美国人Tom0吃饭
//对象池中对象个数2
//美国人Tom1吃饭
//对象池中对象个数2

八、代理模式

8.1、静态代理

定义接口与具体实现

//接口
public interface IUserDao {
    //保存数据
    void save();
}

//具体实现
public class UserDao implements IUserDao {
    @Override
    public void save() {
        System.out.println("保存数据");
    }
}

定义代理对象

//代理对象 静态代理
public class UserDaoProxy {
    private IUserDao tag;
    public UserDaoProxy(IUserDao tag) {
        this.tag = tag;
    }
    public void save(){
        System.out.println("开始事物");
        tag.save();//执行目标对象中方法
        System.out.println("提交事物");
    }
}

使用静态代理

 //目标对象
IUserDao userDao = new UserDao();
//代理对象，把目标对象传入代理对象中，建立代理关系
UserDaoProxy userDaoProxy = new UserDaoProxy(userDao);
userDaoProxy.save();//开始事物 保存数据 提交事物

8.2、动态代理

定义接口与具体实现

//接口
public interface IUserDao {
    //保存数据
    void save();
}

//具体实现
public class UserDao implements IUserDao {
    @Override
    public void save() {
        System.out.println("保存数据");
    }
}

定义代理对象

//动态代理Handler
public class UserDaoProxyHandler implements InvocationHandler {
    //维护一个目标对象
    private Object object;
    public UserDaoProxyHandler(Object object){
        this.object=object;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("开始事务");
        //执行目标对象方法
        Object returnValue = method.invoke(object, args);
        System.out.println("提交事务");
        return returnValue;
    }
}

使用动态代理

//目标对象
IUserDao userDao2 = new UserDao();
//指定当前目标对象使用类加载器,获取加载器的方法是固定的
ClassLoader classLoader = userDao2.getClass().getClassLoader();
//目标对象实现的接口的类型,使用泛型方式确认类型
Class<?>[] interfaces = userDao2.getClass().getInterfaces();
//事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入
UserDaoProxyHandler userDaoProxyHandler = new UserDaoProxyHandler(userDao2);
//代理对象 给目标对象创建代理对象 代理对象不需要实现接口,但是目标对象一定要实现接口,否则不能用动态代理
IUserDao proxy = (IUserDao) Proxy.newProxyInstance(classLoader, interfaces, userDaoProxyHandler);
//执行代理对象中方法
proxy.save();//开始事物 保存数据 提交事物
zping0808
关注
专栏目录
Java设计模式之结构型模式源码以及文档
08-01
今天我们要探讨的是“Java设计模式之结构型模式”。结构型模式主要关注如何组织类和对象，以达到良好的架构，提升代码的可读性和可维护性。在这个主题中，我们将深入理解并讨论这些模式的原理、应用场景及其实现。 ...
模式设计（八）Composite
weixin_33869377的博客
05-08 149
组合模式可以构建部分-整体层次结构或构建数据的树形表示。总之，组合就是对象的集合，其中每个对象既可以是一个组合，也可以是简单的对象。对于树结构来说，有分支节点和叶子节点之说。 总体上来说合成模式应该说是一种应用范围非常广的模式，最常见的莫过于树视图了，每个树视图的节点都可以添加子节点，不断重复就可以构成非常复杂的系统，常用的应用有菜单系统，文件系统都是基于树状结构的。Co...
Java常用设计模式————组合模式
Morty的技术乐园
06-25 383
引言 组合模式，是一种类似递归算法的结构性设计模式，通过以简单的 List ，组合本类对象，实现树状对象结构的“部分、整体”的层次。 它可以让调用程序不需要关心复杂对象与简单对象的区别，而统一地实现处理逻辑。 对于个体与整体存在一定共性的数据场景的展示非常有帮助，比如省市区的树状结构，领导与员工、校院系等。 一、组合模式的类图结构 用套娃形容组合模式非常贴切，其编码核心其实就是用数组来组合下级对象，而下级对象本身也属于此类实例。一般就是用于描述某种极具共性的实体类，如省、市、区；领导、员工等。
java组合模式_组合模式
weixin_42518334的博客
02-12 85
PHP 实现：/*** Class Employee* 雇员类*/class Employee{private $_name;private $_dept;//部门private $_salary;//薪水private $_subordinates;//下属public function __construct(string $name, string $dept, int $sal){$thi...
设计模式--组合模式
li_unit的博客
03-10 141
组合模式：又叫部分整体模式，属于结构型模式。 基本原理：以树形的结构将相似的对象组合起来。 主要流程： 1.创建对象 2.在对象中设置用来存放下一级相似对象的数据结构。 3.在对象中设置增删改查等功能。 注意：这种模式和数据结构中的树形结构相似 #include <iostrea...
[CF729E] Subordinates（贪心）
weixin_33835690的博客
11-21 170
E. Subordinates There arenworkers in a company, each of them has a unique id from1ton.Exacltyone of them is a chief, his id iss. Each worker except the chief has exactly one imm...
设计模式 - 结构型设计模式小结
热门推荐
了解➔熟悉➔掌握➔精通
02-02 6万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net Definition Specify the kind of objects to create using a prototypical instance, and create new objects by copying this prot...
设计模式 组合模式
心有猛虎细嗅蔷薇
01-08 179
目录   组合模式 介绍 实现 步骤 1 Employee.java 步骤 2 CompositePatternDemo.java 步骤 3 总结 组合模式 组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的树...
设计模式——外观模式
程序猿进阶
03-25 2149
外观模式（Facade Pattern）：隐藏系统的复杂性，并向客户端提供了一个可以访问系统的接口。这种类型的设计属于结构型模式，它向现有的系统添加一个接口，来隐藏系统的复杂性。这种模式涉及到一个单一的类，该类提供了客户端请求的简化方法和对现有系统方法的委托调用。现实生活中，常常存在很多复杂的例子，例如：去医院看病，可能要去挂号、门诊、化验、开药、取药，让患者家属觉得很复杂，如果有提供接待人员，只让接待人员来处理，就很方便。或者 Java 的三层开发模式等等。软件设计也是如此，当一个系统的功能越来越强，子.
java 门面模式_java设计模式之外观模式（门面模式）
weixin_35599933的博客
02-12 122
针对外观模式，在项目开发和实际运用中十分频繁，但是其极易理解，下面就简要介绍一下。一、概念介绍外观模式(Facade),他隐藏了系统的复杂性，并向客户端提供了一个可以访问系统的接口。这种类型的设计模式属于结构性模式。为子系统中的一组接口提供了一个统一的访问接口，这个接口使得子系统更容易被访问或者使用。二、角色及使用场景简单来说，该模式就是把一些复杂的流程封装成一个接口供给外部用户更简单的使用。这个...
设计模式之组合模式——Java语言描述
贰拾壹
01-11 198
组合模式又叫做部分整体模式，适用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次 介绍 意图 将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性 优点 高层模块调用简单 节点自由增加 缺点 在使用组合模式时，其叶子和树枝的声明都是实现类，而不是接口类，违反了依赖导致的原则 实现 创建一个Em...
设计模式之适配器模式
最新发布
一个老Java开发的自白
09-19 618
适配器模式是一种非常有用的设计模式，它允许我们将不兼容的接口进行适配，使得原本不能一起工作的类可以一起工作。在软件开发中，我们经常会遇到接口不兼容的问题，使用适配器模式可以很好地解决这些问题。然而，我们也需要注意到适配器模式的缺点，避免过度使用导致系统变得复杂和难以理解。
二十三种设计模式之适配器模式
apple_64847327的博客
09-15 1302
适配器模式是一种结构型设计模式，它允许将一个类的接口转换成客户端期望的另一个接口。适配器让那些接口不兼容的类可以一起工作，从而提高了类的复用性。最常见的比喻是电源适配器。当你出国旅行时，可能会遇到电源插座与你的电子设备充电器不匹配的情况。这时，你需要一个电源适配器来转换插头的形状和电压，使得你的充电器能够适应当地的电源插座。目标接口：是你电子设备的充电器接口。被适配者：是目的地国家的电源插座。适配器：是实际的电源适配器，它连接了两者。
Python编码系列—Python适配器模式：无缝集成的桥梁
u013889591的专栏
09-16 951
在软件开发中，我们经常会遇到需要集成不同接口或系统的情况。适配器模式提供了一种优雅的方式来解决接口不兼容的问题，使得原本不兼容的接口能够协同工作。本文将深入探讨Python中的适配器模式，包括其背景、原理、使用场景、代码实现和实际应用案例。适配器模式是一种结构型设计模式，它允许将不兼容的接口转换为一个可以使用的兼容接口。这种模式在系统集成、插件开发和第三方库集成等场景中非常有用。适配器模式是一种非常实用的设计模式，它通过创建一个适配器类来解决接口不兼容的问题，使得原本不兼容的接口能够协同工作。
Python编码系列—Python外观模式：简化复杂系统的快捷方式
u013889591的专栏
09-17 1052
在现代软件架构中，系统往往由多个子系统或组件构成，这些子系统可能具有复杂的接口。对于客户端来说，直接与这些复杂的子系统交互可能会非常困难。外观模式（Facade Pattern）提供了一个简化的接口，使得客户端可以通过一个统一的接口与整个子系统交互，而无需关心子系统内部的复杂性。本文将深入探讨Python中的外观模式，包括其背景、原理、使用场景、代码实现和实际应用案例。外观模式是一种结构型设计模式，它为子系统中的一组接口提供一个统一的高层接口。外观模式定义了一个高级接口，让子系统更容易使用。
设计模式 组合模式（Composite Pattern）
ling_zhi_xin的博客
09-17 1171
这种结构通常包含多个层次，每个层次上的对象可以是一个独立的实体（叶节点），也可以是一个包含其他对象的容器（组合节点）。组合模式提供了一种优雅的方式来组织和操作层次结构中的对象，使得客户端可以在不知道对象具体类型的情况下操作对象集合。当希望在不同类型的对象之间提供一致的接口时，组合模式可以确保所有的对象（无论是叶子还是组合节点）都遵循相同的接口定义。当客户端代码需要以一致的方式处理单个对象和组合对象时，组合模式可以让客户端无需关心处理的是单个对象还是组合对象。客户端可以一致地对待单个对象和组合对象。
【结构型】树形结构的应用王者，组合模式
学Java，找哪吒
09-19 996
在 java.awt 包中，Component 类和 Container 类使用了组合模式。Container 代表可以包含子组件的对象，而 Component 是一个抽象组件，代表所有的 GUI 元素。Container 既可以是单个组件（叶子），也可以是组合组件（容器），从而形成了一个树形的 GUI 组件层次结构。组合模式在 JDK 中的应用主要体现在处理层次结构、递归结构的场景。AWT 中的 Component 和 Container 类，集合框架中的 List 接口及其实现，都采用了组合模式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值