java设计模式之结构型模式

星辰小赞

已于 2023-08-25 17:35:07 修改

阅读量146

点赞数

文章标签： java 设计模式

于 2023-08-14 10:16:19 首次发布

本文链接：https://blog.csdn.net/qq_53799708/article/details/132270526

版权

结构型模式：

结构型模式描述如何将类型或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式，前者采用继承机制来组织接口和类，后者采用组合或聚合来组合对象。
由于组合和聚合关系比继承关系耦合度低，满足合成复用原则，所以对象结构型模式比类结构型模式具有更大的灵活性。
结构型模式分为7种：
代理模式、适配器模式、装饰者模式、桥接模式、外观模式、组合模式、享元模式

一、享元模式

定义：

运用共享技术来有效的支持大量细粒度对象的复用，它通过共享已经存在的对象来大幅度减少需要创建的对象数量，避免大量相似对象的开销从而提高系统资源利用率。

结构：

内部状态：即不会随着环境的改变而改变的可共享部分
外部状态：指环境改变而改变的不可共享的部分，享元模式的实现要领就是区分应用中的这两种状态，并将外部状态外部化

享元模式的主要有以下角色：

抽象享元角色：通常是一个接口或抽象类，在抽象享元类中声明了具体享元类公共的方法，这些方法可以向外界提供享元对象的内部数据（内部状态），同时也可以通过这些方法来设置外部数据（外部状态）。
具体享元角色：它实现了抽象享元类，成为享元对象，在具体享元类中为内部状态提供了存储空间，通常我们可以结合单例模式来设计具体享元类，为每一个具体享元类提供唯一享元对象。
非享元角色：并不是所有的抽象享元类的子类都需要被共享，不能被共享的子类可设计为非共享具体享元类，当需要一个非共享具体享元类的对象时可以直接通过实例化创建。

优点：

极大的减少内存中相似或相同对象的数量，节约系统资源，提供系统性能
享元模式中外部状态相对独立，且不影响内部状态。

缺点：

为了使对象可以共享，需要将享元对象的部分状态外部化，分离内部状态和外部状态，使程序逻辑复杂

使用场景：

一个系统有大量相同或相似的对象，造成内存大量耗费
对象的大部分状态都可以外部化，可以将这些外部状态传入对象中
在使用享元模式时需要维护一个存储享元对象的享元池，而这需要耗费一定的系统资源，因此，应当在需要多次重复使用享元对象时才值得使用享元模式。

例子：

public abstract class AbstractBox {
    public abstract String getShape();

    public void display(String color) {
        System.out.println("方块形状：" + getShape() + ", 颜色：" + color);
    }
}

public class IBox extends AbstractBox{
    @Override
    public String getShape() {
        return "I";
    }
}

public class LBox extends AbstractBox{
    @Override
    public String getShape() {
        return "L";
    }
}

public class OBox extends AbstractBox{
    @Override
    public String getShape() {
        return "O";
    }
}

public class BoxFactory {
    private HashMap<String, AbstractBox> map;
    private static BoxFactory factory = new BoxFactory();

    private BoxFactory(){
        map = new HashMap<>();
        map.put("I", new IBox());
        map.put("L", new LBox());
        map.put("O", new OBox());
    }

    public static BoxFactory getInstance() {
        return factory;
    }

    public AbstractBox getShape(String name){
        return map.get(name);
    }
}

public class test {
    public static void main(String[] args) {
        AbstractBox i = BoxFactory.getInstance().getShape("I");
        i.display("紫色");

        AbstractBox o = BoxFactory.getInstance().getShape("O");
        o.display("紫色");

        AbstractBox l = BoxFactory.getInstance().getShape("L");
        l.display("紫色");
    }
}

二、代理模式

概述：

由于某些原因需要给某对象提供一个代理以控制对该对象的访问，这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之前的中介。
JAVA中的代理按照代理类生成时机不同又分为静态代理和动态代理。静态代理代理类在编译期就生成，而动态代理类则是在java运行时动态生成，动态代理又有JDK代理和CGlib代理两种

结构：

抽象主题类：通过接口或者抽象类声明真实主题和代理对象实现的业务方法
真实主题类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象
代理类：提供了与真实主题相同的接口，其内部含有对真实主题的引用，他可以访问、控制或扩展真实主题的功能。

优点：

代理模式在客户端与目标对象之间起到了一个中介的作用和保护目标对象的作用
代理对象可以扩展目标对象的功能
代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度

缺点：

增加了系统的复杂度

使用场景：

远程代理：
本地服务通过网络请求远程服务，为了实现本地到远程的通信，我们需要实现网络通信，处理其中可能的异常。为良好的代码设计和可维护性，我们将网络通信的部分隐藏起来，只暴露给本地服务一个接口，通过该接口即可访问远程服务提供的功能，而不必多关心通信部分的细节。
防火墙代理：
当浏览器配置成使用代理功能时，防火墙就将你的浏览器的请求转给互联网，当互联网返回响应时，代理服务器再把它转给你的浏览器
保护代理：
控制一个对象的访问，如果需要，可以给不同的用户提供不同级别的使用权限。

（1）静态代理

public interface SellTickets {
    void sell();
}

public class TrainStation implements SellTickets{
    @Override
    public void sell() {
        System.out.println("火车站卖票");
    }
}

public class ProxyPoint implements SellTickets{
    private TrainStation trainStation = new TrainStation();

    @Override
    public void sell() {
        System.out.println("代理点收取一些费用");
        trainStation.sell();
    }
}

public class test {
    public static void main(String[] args) {
        ProxyPoint proxyPoint = new ProxyPoint();
        proxyPoint.sell();
    }
}

（2）CGlib动态代理

如果没SellTickets接口，只定义了TrainStation类，JDK代理就无法使用，因为JDK动态代理要求必须定义接口，对接口进行代理。
CGLLB是一个功能强大、高性能的代码生成包，它为没有实现接口的类提供代理，为JDK动态代理提供了很好的补充

public class TrainStation {

    public void sell() {
        System.out.println("火车站卖票");
    }
}

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class ProxyFactory implements MethodInterceptor {
    private TrainStation trainStation;
    public TrainStation getProxyObject(){
    // 创建Enhancer对象，类似JDK代理中的Proxy类
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(TrainStation.class);
        enhancer.setCallback(this);
        return (TrainStation) enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        return method.invoke(trainStation, objects);
    }
}

public class test {
    public static void main(String[] args) {
        ProxyFactory proxyFactory = new ProxyFactory();
        TrainStation proxyObject = proxyFactory.getProxyObject();
        proxyObject.sell();
    }
}

（3）JDK动态代理

Java中提供了一个动态代理类Proxy，Proxy并不是我们上述所说的代理对象的类，而是提供了一个创建代理对象的静态方法来获取代理对象。
执行流程：

在测试类中通过代理对象调用sell方法
根据多态的特性，执行的是代理类（&Proxy0）中的sell方法
代理类（&Proxy0）中的sell方法又调用了InvocationHandler接口的子实现类对象的invoke方法
invoke方法通过反射执行了真实对象所属类（TrainStation）中的sell方法

public interface SellTickets {
    void sell();
}

public class TrainStation implements SellTickets {
    @Override
    public void sell() {
        System.out.println("火车站卖票");
    }
}

public class ProxyFactory {
    private TrainStation trainStation = new TrainStation();
    public SellTickets getProxyObject(){
        return (SellTickets) Proxy.newProxyInstance(
                trainStation.getClass().getClassLoader(),
                trainStation.getClass().getInterfaces(),
                (proxy, method, args) -> method.invoke(trainStation)
        );
    }
}

public class test {
    public static void main(String[] args) {
        ProxyFactory proxyFactory = new ProxyFactory();
        SellTickets proxyObject = proxyFactory.getProxyObject();
        proxyObject.sell();
    }
}

三、外观模式

定义：

又名门面模式，是一种通过为多个复杂的子系统提供一个一致的接口，而使这些子系统更加容易被访问的模式。该模式对外有个统一接口，外部应用程序不用关心内部子系统的具体的细节，这样会大大降低应用程序的复杂度，提高程序的可维护性。外观模式，是迪米特法则的典型应用。

结构：

外观角色：为多个子系统提供一个共同的接口。
子系统角色：实现系统的部分功能，客户可以通过外观角色访问它。

好处：

降低了子系统与客户端之间的耦合，使得子系统的变化不会影响他的客户类
对客户屏蔽了子系统组件，减少了客户处理的对象数目，并使得子系统使用起来更加容易

缺点：

不符合开闭原则，修改麻烦

使用场景：

对分层结构系统构建时，使用外观模式定义子系统中每层的入口点可以简化子系统之间的依赖关系
当一个复杂系统的子系统很多时，外观模式可以为系统设计一个简单的接口供外界访问。
当客户端与多个子系统之间存在很大的联系时，引入外观模式可以将他们分离，从而提高子系统的独立性和可移植性

public class Light {
    public void on(){
        System.out.println("打开电灯。。。");
    }

    public void off(){
        System.out.println("关闭电灯。。。");
    }
}

public class AirCondition {
    public void on(){
        System.out.println("打开空调。。。");
    }

    public void off(){
        System.out.println("关闭空调。。。");
    }
}

public class TV {
    public void on(){
        System.out.println("打开电视机。。。");
    }

    public void off(){
        System.out.println("关闭电视机。。。");
    }
}


public class SmartAppliancesFacade {
    private Light light;
    private TV tv;
    private AirCondition airCondition;

    public SmartAppliancesFacade(){
        light = new Light();
        tv = new TV();
        airCondition = new AirCondition();
    }

    public void say(String message) {
        if (message.contains("打开")) {
            on();
        } else if (message.contains("关闭")) {
            off();
        } else {
            System.out.println("我还听不懂");
        }
    }

    private void on(){
        light.on();;
        tv.on();
        airCondition.on();
    }

    private void off(){
        light.off();;
        tv.off();
        airCondition.off();
    }
}

public class test {
    public static void main(String[] args) {
        SmartAppliancesFacade smartAppliancesFacade = new SmartAppliancesFacade();
        smartAppliancesFacade.say("打开家电");
        System.out.println("-----------");
        smartAppliancesFacade.say("关闭家电");
    }
}

四、桥接模式

定义：

将抽象与实现分离，使他们可以独立变化，它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变纬度的耦合度

结构：

抽象化角色：定义抽象类，并包含一个对实现化对象的引用
扩展抽象化角色：是抽象化角色的子类，实现父类中的业务方法，并通过组合关系调用实现化角色中的业务方法
实现化角色：定义实现化角色的接口，供扩展抽象化角色调用。
具体实现化角色：给出实现化角色接口的具体实现。

好处：

桥接模式提高了系统的可扩充性，在两个变化纬度中任意扩展一个纬度，都不需要修改原有的系统，如：如果现在还有一种视频文件类型wmv，我们只需要再定义一个类实现videoFile接口即可，其他类不需要改变
实现细节对客户透明

使用场景：

当一个类存在两个独立变化的纬度，且这两个纬度都需要进行扩展时
当一个系统不希望使用继承或者因为多层次继承导致系统类的个数急剧增加时
当一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性，避免在两个层次之间建立静态的继承联系，通过桥接模式可以使它们在抽象层建立一个关联关系。

/*
* 抽象化角色
* */
public abstract class OperationSystem {
    protected VideoFile videoFile;

    public OperationSystem(VideoFile videoFile) {
        this.videoFile = videoFile;
    }

    public abstract void play(String fileName);
}

/*
* 扩展抽象化角色
* */
public class Mac extends OperationSystem{
    public Mac(VideoFile videoFile) {
        super(videoFile);
    }

    @Override
    public void play(String fileName) {
        videoFile.decode(fileName);
    }
}

/*
* 扩展抽象化角色
* */
public class Mac extends OperationSystem{
    public Mac(VideoFile videoFile) {
        super(videoFile);
    }

    @Override
    public void play(String fileName) {
        videoFile.decode(fileName);
    }
}

/*
* 实现化角色
* */
public interface VideoFile {
    void decode(String fileName);
}

/*
* 具体的实现化角色
* */
public class AviFile implements VideoFile {
    @Override
    public void decode(String fileName) {
        System.out.println("avi视频文件：" + fileName);
    }
}

/*
* 具体的实现化角色
* */
public class RmvbFile implements VideoFile {
    @Override
    public void decode(String fileName) {
        System.out.println("rmvb视频文件：" + fileName);
    }
}

public class test {
    public static void main(String[] args) {
        OperationSystem operationSystem = new Mac(new AviFile());
        operationSystem.play("战狼");
        System.out.println("---------");

        OperationSystem windows = new Windows(new AviFile());
        windows.play("玉骨遥");
    }
}

五、组合模式

定义：

又名部分整体模式，是用于把一组相似的对象当作一个单一的对象，组合模式依据树形结构来组合对象，用来表示部分以及整体层次，这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。

结构：

抽象根节点：定义系统各层次对象的共有方法和属性，可以预先定义一些默认行为和属性。
树枝节点：定义树枝节点的行为，存储子节点，组合树枝节点和叶子节点形成一个树形结构。
叶子节点：叶子节点对象，其下再无分支，是系统层次遍历的最小单位。

组合模式的分类：
在使用组合模式时，根据抽象构件类的定义形式，我们可将组合模式分为透明组合模式和安全组合模式两种形式。

透明组合模式：
透明组合模式中，抽象根结点角色中声明了所有用于管理成员对象的方法，比如示例中MenuComponent声明了add、remove、getChild方法，这样做的好处是确保所有的构件类都有相同的接口，透明组合模式也是组合模式的标准形式。透明组合模式的缺点是不够安全，因为叶子对象和容器对象在本质上是有区别的，叶子对象不可能有下一层次的对象，即不可能包含成员对象，因此，提供add remove等方法是没有意义的，这在编译阶段不会出错，但在运行阶段如果调用这些方法可能会出错
安全组合模式：
在安全组合模式中，在抽象构件角色中没有声明任何用于管理成员对象的方法，而是在树枝节点Menu类中声明并实现这些方法，安全组合模式的缺点是不够透明，因为叶子构件和容器构件具有不同的方法，且容器构件中那些用于管理成员对象的方法没有在抽象构件类中定义，因此客户端不能完全针对抽象编程，必须有区别的对待叶子构件和容器构件。

优点：

组合模式可以清晰的定义分层次的复杂对象，表示对象的全部或部分层次，它让客户端忽略了层次的差异，方便对整个层次结构进行控制
客户端可以一致地使用一个组合结构或其中单个对象，不必关心处理的是单个对象还是整个组合结构，简化了客户端代码
在组合模式中增加新的树枝节点和叶子节点都很方便，无须对现有类库进行修改，符合开闭原则
组合模式为树形结构的面向对象实现了一种灵活的解决方案，通过叶子节点和树枝节点的递归组合，可以形成复杂的树形结构，但对树形结构的控制却非常简单。

使用场景：

组合模式正是应树形结构而生，所以组合模式的使用场景就是出现树形结构的地方，比如：文件目录显示，多级目录呈现等树形结构的操作。

/*
* 抽象根节点
* */
public abstract class ManuComponent {
    protected String name;
    protected int level;

    public void add(ManuComponent manuComponent){
        throw new UnsupportedOperationException();
    }

    public void remove(ManuComponent manuComponent) {
        throw new UnsupportedOperationException();
    }

    public ManuComponent getChild(int index) {
        throw new UnsupportedOperationException();
    }

    public String getName(){
        return name;
    }

    public abstract void print();

}

public class ManuItem extends ManuComponent{
    public ManuItem(String name, int level){
        this.name = name;
        this.level = level;
    }
    @Override
    public void print() {
        for (int i = 0; i < level; i++) {
            System.out.print("--");
        }
        System.out.println(name);
    }
}


import java.awt.*;
import java.util.ArrayList;
import java.util.List;

/*
* 树枝节点
* */
public class Menu extends ManuComponent {
    private List<ManuComponent> manuComponentList = new ArrayList<>();

    public Menu(String name, int level) {
        this.name = name;
        this.level = level;
    }

    @Override
    public void add(ManuComponent manuComponent) {
        manuComponentList.add(manuComponent);
    }

    @Override
    public void remove(ManuComponent manuComponent) {
       manuComponentList.remove(manuComponent);
    }

    @Override
    public ManuComponent getChild(int index) {
        return manuComponentList.get(index);
    }

    @Override
    public void print() {
        for (int i = 0; i < level; i++) {
            System.out.print("--");
        }
        System.out.println(name);

        for (ManuComponent manuComponent : manuComponentList) {
            manuComponent.print();
        }
    }
}


public class test {
    public static void main(String[] args) {
        ManuComponent menu1 = new Menu("菜单管理", 2);
        menu1.add(new ManuItem("页面访问", 3));
        menu1.add(new ManuItem("展开菜单", 3));
        menu1.add(new ManuItem("编辑菜单", 3));
        menu1.add(new ManuItem("删除菜单", 3));
        menu1.add(new ManuItem("新增菜单", 3));

        ManuComponent menu2 = new Menu("权限管理", 2);
        menu2.add(new ManuItem("页面访问", 3));
        menu2.add(new ManuItem("提交保存", 3));

        ManuComponent menu3 = new Menu("角色管理", 2);
        menu3.add(new ManuItem("页面访问", 3));
        menu3.add(new ManuItem("新增角色", 3));
        menu3.add(new ManuItem("修改角色", 3));

        ManuComponent manuComponent = new Menu("系统管理", 1);
        manuComponent.add(menu1);
        manuComponent.add(menu2);
        manuComponent.add(menu3);

        manuComponent.print();
    }
}

六、装饰者模式

定义：

指在不改变现有对象结构的情况下，动态的给对象增加一些职责（即增加其额外功能）的模式。

结构：

抽象构件角色：定义一个抽象接口以规范准备接受附加责任的对象
具体构件角色：实现抽象构件，通过装饰角色为其添加一些职责。
抽象装饰角色：继承或实现抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件功能。
具体装饰角色：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任。

好处：

装饰者模式可以带来比继承更加灵活的扩展功能，使用更加方便，可以通过组合不同的装饰者对象来获取具有不同行为状态的多样化的结果，装饰者模式比继承更具有良好的扩展性，完美的遵循开闭原则。继承是静态的附加责任，装饰者则是动态的附加责任。
装饰类和被装饰类可以独立发展，不会互相耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。

使用场景：

当不能采用继承的方式对系统进行扩充或采用继承不利于系统扩展和维护时，不能采用继承的情况主要有两类：
- 第一类是系统中存在大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长。
- 第二类是因为类定义不能继承（如final类）
在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责
当对象的功能要求可以动态的添加，可以再动态的撤销

代理和装饰者模式的区别：
静态代理和装饰者模式的区别：

相同点：
- 都要实现与目标相同的业务接口
- 在两个类中都要声明目标对象
- 都可以在不修改目标类的前提下增强目标方法
不同点：
- 目的不同：
  装饰者是为了增强目标对象
  静态代理是为了保护和隐藏目标对象
- 获取目标对象的构件方式不同
  装饰者是由外界传送进来，可以通过构造方法传递
  静态代理是在代理类内部创建，以此来隐藏目标对象

/*
* 抽象构件角色
* */
@NoArgsConstructor
@AllArgsConstructor
@Data
public abstract class FastFood {
    private float price;
    private String desc;

    public abstract float cost();
}

/*
* 具体构件角色
* */
public class FriedRice extends FastFood{
    public FriedRice(){
        super(10, "炒饭");
    }

    @Override
    public float cost() {
        return getPrice();
    }
}

/*
* 具体构件类
* */
public class FriedNoodles extends FastFood{
    public FriedNoodles(){
        super(12, "炒面");
    }

    @Override
    public float cost() {
        return getPrice();
    }
}


/*
* 抽象装饰者角色
* */
@Data
public abstract class Garnish extends FastFood{
    private FastFood fastFood;

    public Garnish(FastFood fastFood, float price, String desc){
        super(price, desc);
        this.fastFood = fastFood;
    }
}

/*
* 具体的装饰者
* */
public class Bacon extends Garnish{

    public Bacon(FastFood fastFood) {
        super(fastFood, 1, "培根");
    }

    @Override
    public float cost() {
        return getPrice() + getFastFood().cost();
    }

    @Override
    public String getDesc() {
        return super.getDesc() + getFastFood().getDesc();
    }
}

/*
* 具体的装饰者
* */
public class Egg extends Garnish{

    public Egg(FastFood fastFood) {
        super(fastFood, 1, "鸡蛋");
    }

    @Override
    public float cost() {
        return getPrice() + getFastFood().cost();
    }

    @Override
    public String getDesc() {
        return super.getDesc() + getFastFood().getDesc();
    }
}

public class test {
    public static void main(String[] args) {
        FastFood food = new FriedRice();
        System.out.println(food.getDesc() + "-" + food.cost() + "元");
        System.out.println("---------");

        food = new Egg(food);
        System.out.println(food.getDesc() + "-" + food.cost() + "元");
        System.out.println("---------");

        food = new Egg(food);
        System.out.println(food.getDesc() + "-" + food.cost() + "元");

        food = new Bacon(food);
        System.out.println(food.getDesc() + "-" + food.cost() + "元");
    }
}

七装饰者模式

（1）对象适配器模式

实现方式：
对象适配器模式可采用将现有组件库中已经实现的组件引入适配器类中，该类同时实现当前系统的业务接口

/*
* 目标接口
* */
public interface SDCard {
    String readSD();
    void writeSD(String msg);
}

/*
* 具体的SD卡类
* */
public class SDCardImpl implements SDCard {
    @Override
    public String readSD() {
        return "SDCard read msg：hello word SD";
    }

    @Override
    public void writeSD(String msg) {
        System.out.println("SDCard write msg：" + msg);
    }
}

/*
* 适配者接口
* */
public interface TFCard {
    String readTF();
    void writeTF(String msg);
}

/*
适配器类
* */
public class SDAdapterTF implements SDCard {
    private TFCard tfCard;

    public SDAdapterTF(TFCard tfCard) {
        this.tfCard = tfCard;
    }

    @Override
    public String readSD() {
        System.out.println("adapter read tf card");
        return tfCard.readTF();
    }

    @Override
    public void writeSD(String msg) {
        System.out.println("adapter write tf card");
        tfCard.writeTF(msg);
    }
}

/*
* 适配者类
* */
public class TFCardImpl implements TFCard {
    @Override
    public String readTF() {
        return "TFCard read msg: hello world TFCard";
    }

    @Override
    public void writeTF(String msg) {
        System.out.println("TFCard write msg:" + msg);
    }
}

public class Computer {
    public String readSD(SDCard sdCard) {
        if (sdCard == null) {
            throw new NullPointerException("SD card is not null");
        }
        return sdCard.readSD();
    }

}

public class test {
    public static void main(String[] args) {
        Computer computer = new Computer();
        String s = computer.readSD(new SDCardImpl());
        System.out.println(s);

        SDAdapterTF sdAdapterTF = new SDAdapterTF(new TFCardImpl());
        String s1 = computer.readSD(sdAdapterTF);
        System.out.println(s1);

    }
}

（2）类适配器模式

定义：

将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能在一起工作的那些类能一起工作。
适配器模式分为类适配器和对象适配器模式，前者类之间的耦合度比后者高，且要求程序员了解现有组件库中的相关组件的内部结构，所以应用相对较少。

结构：

目标接口：当前系统业务所期待的接口，他可以时抽象类或接口
适配者类：他是被访问和适配的现存组件库中的组件接口
适配器类：他是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者

缺点：

类适配器模式违背了合成复用原则，类适配其是客户类中有一个接口规范的情况下可以用，反之不可以

/*
* 目标接口
* */
public interface SDCard {
    String readSD();
    void writeSD(String msg);
}

/*
* 具体的SD卡类
* */
public class SDCardImpl implements SDCard {
    @Override
    public String readSD() {
        return "SDCard read msg：hello word SD";
    }

    @Override
    public void writeSD(String msg) {
        System.out.println("SDCard write msg：" + msg);
    }
}

/*
* 适配者接口
* */
public interface TFCard {
    String readTF();
    void writeTF(String msg);
}

/*
* 适配者类
* */
public class TFCardImpl implements TFCard {
    @Override
    public String readTF() {
        return "TFCard read msg: hello world TFCard";
    }

    @Override
    public void writeTF(String msg) {
        System.out.println("TFCard write msg:" + msg);
    }
}

/*
适配器类
* */
public class SDAdapterTF extends TFCardImpl implements SDCard{
    @Override
    public String readSD() {
        System.out.println("adapter read tf card");
        return readTF();
    }

    @Override
    public void writeSD(String msg) {
        System.out.println("adapter write tf card");
        writeTF(msg);
    }
}

public class Computer {
    public String readSD(SDCard sdCard) {
        if (sdCard == null) {
            throw new NullPointerException("SD card is not null");
        }
        return sdCard.readSD();
    }

}

public class test {
    public static void main(String[] args) {
        Computer computer = new Computer();
        String s = computer.readSD(new SDCardImpl());
        System.out.println(s);

        System.out.println("-----");
        String s1 = computer.readSD(new SDAdapterTF());
        System.out.println(s1);
    }
}

星辰小赞

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
java设计模式之结构型模式

在安全组合模式中，在抽象构件角色中没有声明任何用于管理成员对象的方法，而是在树枝节点Menu类中声明并实现这些方法，安全组合模式的缺点是不够透明，因为叶子构件和容器构件具有不同的方法，且容器构件中那些用于管理成员对象的方法没有在抽象构件类中定义，因此客户端不能完全针对抽象编程，必须有区别的对待叶子构件和容器构件。在使用组合模式时，根据抽象构件类的定义形式，我们可将组合模式分为透明组合模式和安全组合模式两种形式。对象适配器模式可采用将现有组件库中已经实现的组件引入适配器类中，该类同时实现当前系统的业务接口。
复制链接

扫一扫