Java设计模式（建造者模式-适配器模式-桥接模式）

shallow丶十三

于 2021-04-28 17:31:44 发布

阅读量245

点赞数

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

本文链接：https://blog.csdn.net/m0_46212244/article/details/116238123

版权

java 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

Java设计模式Ⅲ

1.建造者模式
2.适配器模式
3.桥接模式
- 3.1 桥接模式概述
- 3.2 代码理解
4.装饰者模式

1.建造者模式

1.1 建造者模式概述

（1）基本介绍

a.建造者模式又称生成器模式，是一种对象构建模式，它可以将复杂
	对象的建造过程抽象出来，使这个抽象过程的不同实现方法可以构
	造出不同表现的对象

b.建造者模式是一步一步创建一个复杂的对象，它允徐用户通过指定
	复杂对象的类型和内容就可以构建他们，用户不需要知道内部的具
	体构建细节

(2) 建造者模式的四个角色

①Product(产品角色)：一个具体的产品对象

②Builder(抽象建造者)：创建一个Product对象的各个部件指定的接口。

③ConcreteBuilder(具体建造者)：实现接口，构建和装配各个部件

④Director (指挥者)：构建一个使用Builder接口的对象，它主要用于
	创建一个复杂的对象，主要有两个重用：一是隔离了客户与对象
	的生产过程，二是负责控制产品对象的生产过程。

1.2 建造者模式的注意事项和细节

(1) 建造者模式的注意事项和细节

①客户端不需要知道产品内部的组成细节，将产品本身与创建的过程
	进行解耦，使相同的创建过程可以创建不同的对象

②每一个具体的建造者相对独立，而与其他具体建造者无关，因此
	可以很方便的替换具体建造者或者新增具体建造者。用户使用不
	同的具体建造者即可得到不同的产品对象

③可以更加精细的控制产品的创建过程，将复杂产品的创建步骤分
	解在不同的方法，使得创建过程更加清晰，也更方便使用程序来
	控制创建过程

④增加新的具体建造者无需更改原有类库的代码，指挥者类针对
	抽象建造者编程，系统扩展方便，符合开闭原则

⑤建造者模式所创建的产品一般具有较多的共同点，其组成部分
	相似，如果产品之间的差异性很大，则不适合建造者模式，因
	此其使用范围受到一定限制。

⑥如果产品的内部变化复杂，可能会导致需要定义很多具体建造者
	类来实现这种变化，导致系统变得庞大，因此在这种情况下，是
	否需要考虑建造者模式

(2) 抽象工厂模式VS建造者模式：

1)抽象工厂模式实现对产品家族的创建，一个产品家族是一系列的这样
	的产品。具有不同分类维度的产品组合，采用抽象工厂模式不需要关
	心构建过程，只关心什么产品由什么工厂生产即可。

2)而建造者模式则是要求按照指定的蓝图建造产品，它的主要目的是
	通过组装零件而产生一个信产品。

PS:建造者模式在JDK中的StringBuilder中用到了
在这里插入图片描述

1.3 代码理解

1.Product类

package com.pattern.设计模式.建造者模式;


// Product
public class Car {

    private String tyre;
    private String steering;
    private String engine;
    private String log;

    public Car() {
    }

    public Car(String tyre, String steering, String engine, String log) {
        this.tyre = tyre;
        this.steering = steering;
        this.engine = engine;
        this.log = log;
    }

    public String getTyre() {
        return tyre;
    }

    public void setTyre(String tyre) {
        this.tyre = tyre;
    }

    public String getSteering() {
        return steering;
    }

    public void setSteering(String steering) {
        this.steering = steering;
    }

    public String getEngine() {
        return engine;
    }

    public void setEngine(String engine) {
        this.engine = engine;
    }

    public String getLog() {
        return log;
    }

    public void setLog(String log) {
        this.log = log;
    }

    @Override
    public String toString() {
        return "Car{" +
                "tyre='" + tyre + '\'' +
                ", steering='" + steering + '\'' +
                ", engine='" + engine + '\'' +
                ", log='" + log + '\'' +
                '}';
    }
}

2.抽象的建造者类

package com.pattern.设计模式.建造者模式;

// 抽象的建造者
public abstract class AbstractCar {

    // 使用组合的方式
    protected Car car = new Car();

    // 制作流程的抽象方法
    public abstract void abstractTyre();
    public abstract void abstractSteering();
    public abstract void abstractEngine();
    public abstract void abstractLog();

    // 制作汽车 然后返回
    public Car getCar(){
        return car;
    }

}

3.具体建造者类（可增加）

package com.pattern.设计模式.建造者模式;

// 这是具体建造者
public class BenzCar extends AbstractCar{
    @Override
    public void abstractTyre() {
        System.out.println("这是奔驰的轮胎");
    }

    @Override
    public void abstractSteering() {
        System.out.println("这是奔驰的方向盘");
    }

    @Override
    public void abstractEngine() {
        System.out.println("这是奔驰的引擎");
    }

    @Override
    public void abstractLog() {
        System.out.println("这是奔驰的车标");
    }
}

4.指挥者类

package com.pattern.设计模式.建造者模式;

// 指挥者
public class CarDirector {

    AbstractCar abstractCar = null;

    // 聚合方法-构造器传入
    public CarDirector(AbstractCar abstractCar){
        this.abstractCar = abstractCar;

    }

    // setter传入
    public void setAbstractCar(AbstractCar abstractCar){
        this.abstractCar = abstractCar;
    }

    // 指挥者决定按什么流程制作汽车
    public Car getDirectorCar(){
        abstractCar.abstractTyre();
        abstractCar.abstractSteering();
        abstractCar.abstractEngine();
        abstractCar.abstractLog();
        return abstractCar.getCar();
    }
}

5.测试类（宝马类自行增加）

package com.pattern.设计模式.建造者模式;

public class Test {
    public static void main(String[] args) {
        // 宝马
        BmwCar bmwCar = new BmwCar();
        // 指挥者制作宝马
        CarDirector carDirector = new CarDirector(bmwCar);
        // 制作完返回
        Car directorCar = carDirector.getDirectorCar();

        System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>");
        // 宝马
        BenzCar benzCar = new BenzCar();
        // 利用setter方法重置要制作的汽车
        carDirector.setAbstractCar(benzCar);
        carDirector.getDirectorCar();


    }
}

2.适配器模式

2.1 类适配器模式

（1）基本介绍

①适配器（Adapter）模式将某个类的接口转变为客户端想要的另一个
	接口表示，主要目的是兼容性，让原本因接口不配配不能一起工作
	的两个类可以协同工作，其别名为包装器（wrapper）

②适配器模式属于结构型模式

③主要分为三类：类适配器模式，对象适配器模式，接口适配器模式

（2）代码类图
在这里插入图片描述
(3)类适配器模式注意事项和细节

2.1.1 代码理解

1.接口

package com.pattern.设计模式.设配器模式.类适配器模式;

public interface Voltage4V {
    public int getVoltage4V();
}

2.220V类

package com.pattern.设计模式.设配器模式.类适配器模式;

public class Voltage220V {

    public int getVoltage220V(){
        int voltage = 220;
        return voltage;
    }
}

package com.pattern.设计模式.设配器模式.类适配器模式;

public class VoltageAdapter extends Voltage220V implements Voltage4V {
    @Override
    public int getVoltage4V() {
        int voltage = getVoltage220V();
        int voltageAdapter = voltage / 55;
        return voltageAdapter;
    }
}

package com.pattern.设计模式.设配器模式.类适配器模式;

public class Bluetooth {

    public void charge(Voltage4V v){
        if (v.getVoltage4V() == 4){
            System.out.println("正在充电");
        }else {
            System.out.println("电压过高，不宜充电");

        }
    }
}

5.测试

package com.pattern.设计模式.设配器模式.类适配器模式;

public class Test {
    public static void main(String[] args) {
        Bluetooth bluetooth = new Bluetooth();
        bluetooth.charge(new VoltageAdapter());

    }
}

2.2 对象适配器模式

(1) 基本介绍

①基本思路和类的适配器相同，只是将Adapter类作修改
	不是继承src类，而是持有src类的实例，已解决兼容性的问题

②根据 合成复用原则，在系统中尽量使用关联关系来替代继承关系

③对象适配器是适配器模式常用的一种

(2)对象适配器模式的注意事项和细节
在这里插入图片描述

2.2.1 代码理解

package com.pattern.设计模式.设配器模式.对象适配器模式;

public interface Voltage4V {
    public int getVoltage4V();
}

package com.pattern.设计模式.设配器模式.对象适配器模式;

public class Voltage220V {

    public int getVoltage220V(){
        int voltage = 220;
        return voltage;
    }
}

package com.pattern.设计模式.设配器模式.对象适配器模式;

public class VoltageAdapter implements Voltage4V{

    private Voltage220V v;

    public VoltageAdapter(Voltage220V v){
        this.v = v;
    }

    @Override
    public int getVoltage4V() {
        int voltage = 0;
        if (v != null){
            int voltage220 = v.getVoltage220V();

            voltage = voltage220 / 55;

        }
        return voltage;
    }
}

package com.pattern.设计模式.设配器模式.对象适配器模式;

public class Bluetooth {
    public void charge(Voltage4V voltage4V){
        if (voltage4V.getVoltage4V() == 4){
            System.out.println("开始充电");
        }else {
            System.out.println("电压过大，不宜充电");

        }

    }
}

5.测试

package com.pattern.设计模式.设配器模式.对象适配器模式;

public class Test {
    public static void main(String[] args) {
        Bluetooth bluetooth = new Bluetooth();
        bluetooth.charge(new VoltageAdapter(new Voltage220V()));
    }
}

2.3 接口适配器模式

（1）基本介绍

①接口适配器模式也叫做适配器模式或者缺省适配器模式

②当不需要全部实现接口提供的方法时，可以先设计一个抽象类
	实现接口，并为该接口每个方法提供一个默认实现（即空方法），
	那么该抽象类的子类可以选择地覆盖父类的某些方法来实现需求

③适用于一个接口不想使用其所有的方法的情况

（2）代码类图
在这里插入图片描述
PS：适配器模式在springMVC框架中的HandlerAdapter用到了

（3）适配器注意事项和细节

2.3.1 代码理解

package com.pattern.设计模式.设配器模式.接口适配器模式;

public interface InterfaceAdapter {

    void a1();
    void a2();
    void a3();
    void a4();
}

package com.pattern.设计模式.设配器模式.接口适配器模式;

public class AbstractAdapter implements InterfaceAdapter{

    // 将接口里的所有方法默认实现
    @Override
    public void a1() {

    }

    @Override
    public void a2() {

    }

    @Override
    public void a3() {

    }

    @Override
    public void a4() {

    }
}

3.测试

package com.pattern.设计模式.设配器模式.接口适配器模式;

public class Test {
    public static void main(String[] args) {
        AbstractAdapter abstractAdapter = new AbstractAdapter(){
            @Override
            public void a1() {
                System.out.println("接口适配器模式--使用了a1的方法");
            }
        };
        abstractAdapter.a1();
    }
}

3.桥接模式

3.1 桥接模式概述

(1)基本介绍

①桥接（Bridge）模式是指:将实现与抽象放在两个不同的类层次中，使
	两个层次可以独立改变

②是一种结构型设计模式

③桥接模式基于类的最小设计原则，通过使用封装，聚合以及继承等行
	为让不同的类承担不同的责任。它的主要特点是把抽象与行为实现分
		离开来，从而可以保持各部分的独立性以及应对他们的功能扩展

（2）桥接模式的原理图
在这里插入图片描述
PS：JDBC中使用了桥接模式（Driver接口）

(3)桥接模式的注意事项和细节

3.2 代码理解

1.接口

package com.pattern.设计模式.桥接模式;

public interface Brand {

    void open();
    void close();
    void call();
}

package com.pattern.设计模式.桥接模式;

public class FoldedPhone extends Phone{

    // 构造器
    public FoldedPhone(Brand brand) {
        super(brand);
    }

    public void open(){
        super.open();
        System.out.println("折叠式手机开机");
    }

    public void close(){
        super.close();
        System.out.println("折叠式手机关机");
    }

    public void call(){
        super.call();
        System.out.println("折叠式手机打电话");
    }
}

package com.pattern.设计模式.桥接模式;

public class UpRightPhone extends Phone{
    public UpRightPhone(Brand brand) {
        super(brand);
    }

    public void open(){
        super.open();
        System.out.println("直立式手机开机");
    }

    public void close(){
        super.close();
        System.out.println("直立式手机关机");
    }

    public void call(){
        super.call();
        System.out.println("直立式手机打电话");
    }
}

package com.pattern.设计模式.桥接模式;

public class XiaoMi implements Brand{
    @Override
    public void open() {
        System.out.println("小米手机开机");
    }

    @Override
    public void close() {
        System.out.println("小米手机关机");

    }

    @Override
    public void call() {
        System.out.println("小米手机打电话");

    }
}

package com.pattern.设计模式.桥接模式;

public abstract class Phone {
    // 组合Brand
    private Brand brand;

    public Phone(Brand brand){
        super();
        this.brand = brand;

    }

    protected void open(){
        this.brand.open();
    }

    protected void close(){
        this.brand.close();
    }
    
    protected void call(){
        this.brand.call();
    }
}

package com.pattern.设计模式.桥接模式;

public class Oppo implements Brand{
    @Override
    public void open() {
        System.out.println("Oppo手机开机");
    }

    @Override
    public void close() {
        System.out.println("Oppo手机关机");

    }

    @Override
    public void call() {
        System.out.println("Oppo手机打电话");

    }
}

package com.pattern.设计模式.桥接模式;

public class Test {
    public static void main(String[] args) {

        // 获取折叠式手机(即 品牌 + 样式) 小米手机
        Phone phone = new FoldedPhone(new XiaoMi());
        phone.open();
        phone.close();
        phone.call();

        System.out.println(">>>>>>>>>>>>>>>>>>>>>");
        // 获取直立式 小米手机
        Phone phone1 = new UpRightPhone(new XiaoMi());
        phone1.open();
        phone1.close();
        phone1.call();

        System.out.println("<<<<<<<<<<<<<<<<<<<<<<");
        // 获取Oppo手机
        Phone phone2 = new FoldedPhone(new Oppo());
        phone2.open();
        phone2.close();
        phone2.call();
    }
}

4.装饰者模式

装饰者模式等等

shallow丶十三

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java设计模式（建造者模式-适配器模式-桥接模式）

这里写目录标题1.建造者模式1.1 建造者模式概述1.2 建造者模式的注意事项和细节1.3 代码理解2.适配器模式2.1 类适配器模式2.1.1 代码理解2.2 对象适配器模式2.2.1 代码理解2.3 接口适配器模式2.3.1 代码理解3.桥接模式3.1 桥接模式概述3.2 代码理解1.建造者模式1.1 建造者模式概述（1）基本介绍a.建造者模式又称生成器模式，是一种对象构建模式，它可以将复杂对象的建造过程抽象出来，使这个抽象过程的不同实现方法可以构造出不同表现的对象b.建造者模式是一
复制链接

扫一扫