深入浅出Java23种设计模式（二）

最新推荐文章于 2024-05-17 13:43:01 发布

一个Java小白

最新推荐文章于 2024-05-17 13:43:01 发布

阅读量311

点赞数

分类专栏： Java23种设计模式文章标签： java 设计模式

本文链接：https://blog.csdn.net/weixin_43844418/article/details/115328202

版权

Java23种设计模式专栏收录该内容

3 篇文章 0 订阅

订阅专栏

结构型模式

适配器模式

一、概述

将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

二、适用性

使用一个已经存在的类，而它的接口不符合你的需求。
创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作。
（仅适用于对象Adapter）使用一些已经存在的子类，但是不可能对每一个都进行子类化以匹配它们的接口。对象适配器可以适配它的父类接口。

三、参与者

Target定义Client使用的与特定领域相关的接口。
Client与符合Target接口的对象协同。
Adaptee定义一个已经存在的接口，这个接口需要适配。
Adapter对Adaptee的接口与Target接口进行适配

四、类图

在这里插入图片描述

五、示例

Target

package com.cz.Adaptermode.adapter;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 16:00
 * @Descripetion: 定义Target接口
 **/
public interface Target {

    void adapteeMethod();
    void adapterMethod();
}

Adaptee

package com.cz.Adaptermode.adapter;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 16:01
 * @Descripetion: 适配器类
 **/
public class Adaptee {
    public void adapteeMethod(){
        System.out.println("Adaptee method!");
    }
}

Adapter

package com.cz.Adaptermode.adapter;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 16:02
 * @Descripetion: Target的实现类
 **/
public class Adapter implements Target {

    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void adapteeMethod() {
        adaptee.adapteeMethod();
    }

    @Override
    public void adapterMethod() {
        System.out.println("Adapter method!");
    }
}

Client

package com.cz.Adaptermode.adapter;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 16:06
 * @Descripetion: 测试类
 **/
public class Test {
    public static void main(String[] args) {
        Target target = new Adapter(new Adaptee());
        target.adapteeMethod();
        target.adapterMethod();
    }
}

运行结果：

装饰模式

一、概述

动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。

二、适用性

在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。
处理那些可以撤消的职责。
当不能采用生成子类的方法进行扩充时。

三、参与者

Component 定义一个对象接口，可以给这些对象动态地添加职责。
ConcreteComponent 定义一个对象，可以给这个对象添加一些职责。
Decorator维持一个指向Component对象的指针，并定义一个与Component接口一致的接口。
ConcreteDecorator向组件添加职责。

四、类图

在这里插入图片描述

五、示例

Component

package com.cz.Adaptermode.decorator;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 16:10
 * @Descripetion: 定义Component接口Person
 **/
public interface Person {
    void eat();
}

ConcreteComponent

package com.cz.Adaptermode.decorator;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 16:11
 * @Descripetion: Person接口的实现类Man
 **/
public class Man implements Person {

    public void eat(){
        System.out.println("男人在吃");
    }
}

Decorator

package com.cz.Adaptermode.decorator;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 16:12
 * @Descripetion: Decorator抽象类实现Person接口
 **/
public abstract class Decorator implements Person {

    protected Person person;

    public void setPerson(Person person){
        this.person = person;
    }

    @Override
    public void eat() {
        person.eat();
    }
}

ConcreteDecorator

package com.cz.Adaptermode.decorator;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 16:14
 * @Descripetion: Decorator的子类
 **/
public class ManDecoratorA extends Decorator {

    public void eat(){
        super.eat();
        reEat();
        System.out.println("ManDecoratorA类");
    }

    public void reEat(){
        System.out.println("再吃一顿饭");
    }
}

package com.cz.Adaptermode.decorator;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 16:16
 * @Descripetion: Decorator的子类
 **/
public class ManDecoratorB extends Decorator {

    public void eat(){
        super.eat();
        System.out.println("=====================");
        System.out.println("ManDecoratorB类");
    }
}

Test

package com.cz.Adaptermode.decorator;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 16:17
 * @Descripetion: 测试类
 **/
public class Test {
    public static void main(String[] args) {
        Man man = new Man();
        ManDecoratorA mdA = new ManDecoratorA();
        ManDecoratorB mdB = new ManDecoratorB();

        mdA.setPerson(man);
        mdB.setPerson(mdA);
        mdB.eat();
    }
}

运行结果：

外观模式

一、概述

为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

二、适用性

当要为一个复杂子系统提供一个简单接口时。子系统往往因为不断演化而变得越来越复杂。大多数模式使用时都会产生更多更小的类。这使得子系统更具可重用性，也更容易对子系统进行定制，但这也给那些不需要定制子系统的用户带来一些使用上的困难。 Facade可以提供一个简单的缺省视图，这一视图对大多数用户来说已经足够，而那些需要更多的可定制性的用户可以越过facade层。
客户程序与抽象类的实现部分之间存在着很大的依赖性。引入facade将这个子系统与客户以及其他的子系统分离，可以提高子系统的独立性和可移植性。
当需要构建一个层次结构的子系统时，使用facade模式定义子系统中每层的入口点。如果子系统之间是相互依赖的，你可以让它们仅通过facade进行通讯，从而简化了它们之间的依赖关系。

三、参与者

Facade知道哪些子系统类负责处理请求。将客户的请求代理给适当的子系统对象。
Subsystemclasses 实现子系统的功能。处理由Facade对象指派的任务。没有facade的任何相关信息；即没有指向facade的指针。

四、类图

在这里插入图片描述

五、示例

Facade

package com.cz.Adaptermode.facade;

import com.sun.xml.internal.ws.wsdl.writer.document.Service;

import java.awt.*;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 18:26
 * @Descripetion: hapeFacede当做Shape各个子系统(Circle/Rectangle/Square)的门面
 **/
public class Facade {
    /**
     * 画圆子系统
     */
    private Shape circle;
    /**
     * 画矩形子系统
     */
    private Shape rectangle;
    /**
     * 画正方形子系统
     */
    private Shape square;

    public Facade() {
        circle = new Circle();
        rectangle = new Rectangle();
        square = new Square();
    }

    /**
     * 画圆
     */
    public void drawCircle(){
        circle.drawShape();;
    }

    /**
     * 画矩形
     */
    public void drawRectangle(){
        rectangle.drawShape();;
    }

    /**
     * 画正方形
     */
    public void drawSquare(){
        square.drawShape();;
    }

}

Subsystemclasses

package com.cz.Adaptermode.facade;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 18:57
 * @Descripetion: Shape系统
 **/
public abstract class Shape {
    abstract void drawShape();
}

class Circle extends Shape {
    @Override
    void drawShape() {
        System.out.println("Circle:Shape");
    }
}

class Rectangle extends Shape {
    @Override
    void drawShape() {
        System.out.println("Rectangle:Shape");
    }
}

class Square extends Shape {
    @Override
    void drawShape() {
        System.out.println("Square:Shape");
    }
}

Test

package com.cz.Adaptermode.facade;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 18:34
 * @Descripetion: 测试类
 **/
public class Test {
    public static void main(String[] args) {
        /*使用门面和各个子系统交互*/
        Facade facade = new Facade();
        facade.drawCircle();
        facade.drawRectangle();
        facade.drawSquare();
    }
}

运行结果：

代理模式

一、概述

为其他对象提供一种代理以控制对这个对象的访问。

二、适用性

远程代理（RemoteProxy）为一个对象在不同的地址空间提供局部代表。
虚代理（VirtualProxy）根据需要创建开销很大的对象。
保护代理（ProtectionProxy）控制对原始对象的访问。智能指引（SmartReference）取代了简单的指针，它在访问对象时执行一些附加操作。

三、参与者

Proxy 保存一个引用使得代理可以访问实体。若RealSubject和Subject的接口相同，Proxy会引用Subject。提供一个与Subject的接口相同的接口，这样代理就可以用来替代实体。控制对实体的存取，并可能负责创建和删除它。其他功能依赖于代理的类型：
RemoteProxy负责对请求及其参数进行编码，并向不同地址空间中的实体发送已编码的请求。
VirtualProxy可以缓存实体的附加信息，以便延迟对它的访问。
ProtectionProxy检查调用者是否具有实现一个请求所必需的访问权限。
Subject 定义RealSubject和Proxy的共用接口，这样就在任何使用RealSubject的地方都可以使用Proxy。
RealSubject定义Proxy所代表的实体

四、类图

在这里插入图片描述

五、示例

Proxy

package com.cz.Adaptermode.proxy;



/**
 * @Author: zhang
 * @Date: 2021/3/30 - 19:04
 * @Descripetion: Proxy
 **/
public class ProxyObject implements Object {

    Object object;

    public ProxyObject(){
        System.out.println("这是代理类");
        object = new ObjectImpl();
    }

    public void action(){
        System.out.println("代理开始");
        object.action();
        System.out.println("代理结束");
    }
}

Subject

package com.cz.Adaptermode.proxy;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 19:07
 * @Descripetion: Subject
 **/
public interface Object {
    void action();
}

RealSubject

package com.cz.Adaptermode.proxy;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 19:08
 * @Descripetion: RealSubject
 **/
public class ObjectImpl implements Object {
    @Override
    public void action() {
        System.out.println("================");
        System.out.println("================");
        System.out.println("这是被代理的类");
        System.out.println("================");
        System.out.println("================");
    }
}

Test

package com.cz.Adaptermode.proxy;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 19:09
 * @Descripetion: 测试类
 **/
public class Test {
    public static void main(String[] args) {
        Object object = new ProxyObject();
        object.action();
    }
}

运行结果：

桥接模式

一、概述

将抽象部分与它的实现部分分离，使它们都可以独立地变化。

二、适用性

不希望在抽象和它的实现部分之间有一个固定的绑定关系。例如这种情况可能是因为，在程序运行时刻实现部分应可以被选择或者切换。
类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充。这时Bridge模式使你可以对不同的抽象接口和实现部分进行组合，并分别对它们进行扩充。
对一个抽象的实现部分的修改应对客户不产生影响，即客户的代码不必重新编译。
正如在意图一节的第一个类图中所示的那样，有许多类要生成。这样一种类层次结构说明你必须将一个对象分解成两个部分。
在多个对象间共享实现（可能使用引用计数），但同时要求客户并不知道这一点。

三、参与者

Abstraction
定义抽象类的接口。维护一个指向Implementor类型对象的指针。
RefinedAbstraction
扩充由Abstraction定义的接口。
Implementor
定义实现类的接口，该接口不一定要与Abstraction的接口完全一致。事实上这两个接口可以完全不同。一般来讲，Implementor接口仅提供基本操作，而Abstraction则定义了基于这些基本操作的较高层次的操作。
ConcreteImplementor
实现Implementor接口并定义它的具体实现。

四、类图

在这里插入图片描述

五、示例

Abstraction

package com.cz.Adaptermode.bridge;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 19:15
 * @Descripetion: 定义Abstraction Person类
 **/
public abstract class Person {

    private Clothing clothing;
    private String type;

    public Clothing getClothing(){
        return clothing;
    }

    public void setClothing(Clothing clothing){
        this.clothing = clothing;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public abstract void dress();
}

RefinedAbstraction

package com.cz.Adaptermode.bridge;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 19:18
 * @Descripetion: 定义RefinedAbstraction类Man
 **/
public class Man extends Person {

    public Man(){
        setType("猛男");
    }

    public void dress(){
        Clothing clothing = getClothing();
        clothing.personDressCloth(this);
    }
}

package com.cz.Adaptermode.bridge;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 19:20
 * @Descripetion: 定义RefinedAbstraction类Lady
 **/
public class Lady extends Person {

    public Lady(){
        setType("美女");
    }

    public void dress(){
        Clothing clothing = getClothing();
        clothing.personDressCloth(this);
    }
}

Implementor

package com.cz.Adaptermode.bridge;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 19:22
 * @Descripetion: 定义Implementor 类Clothing
 **/
public abstract class Clothing {

    public abstract void personDressCloth(Person person);
}

ConcreteImplementor

package com.cz.Adaptermode.bridge;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 19:23
 * @Descripetion: 定义ConcreteImplementor类Jacket
 **/
public class Jacket extends Clothing {

    @Override
    public void personDressCloth(Person person) {
        System.out.println(person.getType() + "是西装暴徒");
    }
}

package com.cz.Adaptermode.bridge;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 19:25
 * @Descripetion: 定义ConcreteImplementor类 Trouser
 **/
public class Trouser extends Clothing {

    @Override
    public void personDressCloth(Person person) {
        System.out.println(person.getType() + "劫富济贫");
    }
}

Test

package com.cz.Adaptermode.bridge;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 19:26
 * @Descripetion: 测试类
 **/
public class Test {
    public static void main(String[] args) {
        Person man = new Man();
        Person lady = new Lady();

        Clothing jacket = new Jacket();
        Clothing trouser = new Trouser();

        jacket.personDressCloth(man);
        trouser.personDressCloth(man);

        jacket.personDressCloth(lady);
        trouser.personDressCloth(lady);
    }
}

运行结果：

组合模式

一、概述

将对象组合成树形结构以表示"部分-整体”的层次结构。"Composite使得用户对单个对象和组合对象的使用具有一致性。

二、适用性

表示对象的部分-整体层次结构。
希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。

三、参与者

Component 为组合中的对象声明接口。在适当的情况下，实现所有类共有接口的缺省行为。声明一个接口用于访问和管理Component的子组件。 (可选)在递归结构中定义一个接口，用于访问一个父部件，并在合适的情况下实现它。
Leaf 在组合中表示叶节点对象，叶节点没有子节点。在组合中定义节点对象的行为。
Composite 定义有子部件的那些部件的行为。存储子部件。在Component接口中实现与子部件有关的操作。
Client通过Component接口操纵组合部件的对象。

四、类图

在这里插入图片描述

五、示例

Component

package com.cz.Adaptermode.composite;

import java.util.List;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 19:31
 * @Descripetion: 定义Component 类Employer
 **/
public abstract class Employer {

    private String name;

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public abstract void add(Employer employer);

    public abstract void delete(Employer employer);

    public List<Employer> employers;

    public void printInfo(){
        System.out.println(name);
    }

    public List<Employer> getEmployers(){
        return this.employers;
    }
}

Leaf

package com.cz.Adaptermode.composite;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 19:36
 * @Descripetion: 定义Leaf类Programmer
 **/
public class Programmer extends Employer {

    public Programmer(String name){
        setName(name);
        employers = null;//程序员, 表示没有下属了
    }


    @Override
    public void add(Employer employer) {
        
    }

    @Override
    public void delete(Employer employer) {

    }
}

package com.cz.Adaptermode.composite;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 19:38
 * @Descripetion: 定义Leaf类ProjectAssistant
 **/
public class ProjectAssistant extends Employer {

    public ProjectAssistant(String name){
        setName(name);
        employers = null;//项目助理, 表示没有下属了
    }


    @Override
    public void add(Employer employer) {
        
    }

    @Override
    public void delete(Employer employer) {

    }
}

Composite

package com.cz.Adaptermode.composite;

import java.util.ArrayList;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 19:39
 * @Descripetion: 定义Composite类ProjectManager类
 **/
public class ProjectManager extends Employer{

    public ProjectManager(String name){
        setName(name);
        employers = new ArrayList<Employer>();
    }


    @Override
    public void add(Employer employer) {
        employers.add(employer);
    }

    @Override
    public void delete(Employer employer) {
        employers.remove(employer);
    }
}

Client

package com.cz.Adaptermode.composite;

import java.util.List;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 19:41
 * @Descripetion: 测试类
 **/
public class Test {
    public static void main(String[] args) {
        Employer pm = new ProjectManager("项目经理");
        Employer pa = new ProjectAssistant("项目助理");
        Employer programmer1 = new Programmer("程序员一");
        Employer programmer2 = new Programmer("程序员二");

        pm.add(pa);//为项目经理添加项目助理
        pm.add(programmer2);//为项目经理添加程序员

        List<Employer> ems = pm.getEmployers();
        for (Employer em :ems){
            System.out.println(em.getName());
        }
    }
}

运行结果：

享元模式

一、概述

运用共享技术有效地支持大量细粒度的对象。

二、适用性

当都具备下列情况时，使用Flyweight模式：

一个应用程序使用了大量的对象。
完全由于使用大量的对象，造成很大的存储开销。
对象的大多数状态都可变为外部状态。
如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象。
应用程序不依赖于对象标识。由于Flyweight对象可以被共享，对于概念上明显有别的对象，标识测试将返回真值。

三、参与者

Flyweight描述一个接口，通过这个接口flyweight可以接受并作用于外部状态。
ConcreteFlyweight实现Flyweight接口，并为内部状态（如果有的话）增加存储空间。ConcreteFlyweight对象必须是可共享的。它所存储的状态必须是内部的；即，它必须独立于ConcreteFlyweight对象的场景。
UnsharedConcreteFlyweight 并非所有的Flyweight子类都需要被共享。Flyweight接口使共享成为可能，但它并不强制共享。在Flyweight对象结构的某些层次，UnsharedConcreteFlyweight对象通常将ConcreteFlyweight对象作为子节点。
FlyweightFactory创建并管理flyweight对象。确保合理地共享flyweight。当用户请求一个flyweight时，FlyweightFactory对象提供一个已创建的实例或者创建一个（如果不存在的话）。

四、类图

在这里插入图片描述

五、示例

Flyweight

package com.cz.Adaptermode.flyweight;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 19:48
 * @Descripetion: Flyweight
 **/
public interface Flyweight {
    void action(int arg);
}

ConcreteFlyweight

package com.cz.Adaptermode.flyweight;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 19:48
 * @Descripetion: ConcreteFlyweight
 **/
public class FlyweightImpl implements Flyweight {

    @Override
    public void action(int arg) {
        System.out.println("参数值: " + arg);
    }
}

FlyweightFactory

package com.cz.Adaptermode.flyweight;

import java.util.HashMap;
import java.util.Map;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 19:49
 * @Descripetion: FlyweightFactory
 **/
public class FlyweightFactory {

    private static Map flyweights = new HashMap();

    public FlyweightFactory(String arg){
        flyweights.put(arg, new FlyweightImpl());
    }

    public static Flyweight getFlyweight(String key){
        if (flyweights.get(key) == null){
            flyweights.put(key, new FlyweightImpl());
        }
        return (Flyweight) flyweights.get(key);
    }

    public static int getSize(){
        return flyweights.size();
    }
}

Test

package com.cz.Adaptermode.flyweight;

/**
 * @Author: zhang
 * @Date: 2021/3/30 - 19:53
 * @Descripetion: 测试类
 **/
public class Test {
    public static void main(String[] args) {
        Flyweight fly1 = FlyweightFactory.getFlyweight("a");
        fly1.action(1);

        Flyweight fly2 = FlyweightFactory.getFlyweight("a");
        System.out.println(fly1 == fly2);

        Flyweight fly3 = FlyweightFactory.getFlyweight("b");
        fly3.action(2);

        Flyweight fly4 = FlyweightFactory.getFlyweight("c");
        fly4.action(3);

        Flyweight fly5 = FlyweightFactory.getFlyweight("d");
        fly4.action(4); 
        System.out.println(FlyweightFactory.getSize());
    }
}

运行结果：

一个Java小白

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
深入浅出Java23种设计模式（二）

文章目录结构型模式适配器模式一、概述二、适用性三、参与者四、类图五、示例装饰模式一、概述二、适用性三、参与者四、类图五、示例外观模式一、概述二、适用性三、参与者四、类图五、示例代理模式一、概述二、适用性三、参与者四、类图五、示例桥接模式一、概述二、适用性三、参与者四、类图五、示例组合模式一、概述二、适用性三、参与者四、类图五、示例享元模式一、概述二、适用性三、参与者四、类图五、示例结构型模式适配器模式一、概述将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一
复制链接

扫一扫