青岛外贸出口公司联系电话_上海发布官网app下载_免费开网店免费供货_去除痘痘怎么有效果

---

前言

  本篇是关于设计模式中建造者模式、适配器模式（3种）、以及桥接模式的笔记。

---

一、建造者模式

  建造者模式是属于创建型设计模式，通过一步步构建一个复杂对象的方式，隐藏复杂的构造过程使得对象的创建过程更加灵活、易于扩展，同时不需要指定具体的构造方式。
  其组成部分有：

• 产品：表示被建造的对象。
• 抽象建造者：通常是抽象类或接口，定义了创建产品所需要的方法，由不同的子类去描述建造不同产品的具体步骤。
• 指挥者：组合了建造者对象，通常是将建造者对象作为其属性，提供方法控制建造的过程，指挥建造者完成特定的构建步骤。
• 具体建造者：继承/实现抽象建造者，重写其中的方法，描述不同产品的建造步骤。

  为什么要使用建造者模式？我们可以看一个例子，假设现在需要建一所房子，用一个实体类封装房子的属性：

/*** 不管是 高层，洋房，还是别墅 都有 固定的这些属性*/
public class House {private String basic;private String wall;private String roof;public House() {}public House(String basic, String wall, String roof) {this.basic = basic;this.wall = wall;this.roof = roof;}//....get set 方法
}

  客户端直接完成对房子的创建，这样做很明显是存在弊端的。因为房子的种类有很多种，每一种的建造过程也是不一样的，虽然都包含一些共有的属性：

public class Client {public static void main(String[] args) {House house = new House();house.setBasic("打地基");house.setWall("砌墙");house.setRoof("盖屋顶");//--------如果有不同的房子要建立呢？---------------// 伪代码
//        if (type.equals("别墅")){
//            house.setBasic("打别墅的地基");
//            house.setWall("砌别墅的墙");
//            house.setRoof("盖别墅的屋顶");
//        }else {
//            house.setBasic("打高层的地基");
//            house.setWall("砌高层的墙");
//            house.setRoof("盖高层的屋顶");
//        }//--------如果后续对于工序还有不同的要求呢？---------------}
}

  使用建造者模式改进：

1. 引入一个房子的建造者，定义了建不同房子都必须有的共有的工序：

/*** 房子的建造者*/
public abstract class CommonHouseBuilder {protected House house = new House();abstract void buildBasic();abstract void buildWalls();abstract void buildRoof();/*** 返回建造好的房子* @return*/public House getHouse() {return house;}}

2. 具体的产品实现类，代表建立不同类型的房子：

public class HighRise extends CommonHouseBuilder{@Overridevoid buildBasic() {System.out.println("高层地基");}@Overridevoid buildWalls() {System.out.println("高层砌墙");}@Overridevoid buildRoof() {System.out.println("高层封顶");}
}

public class Villa extends CommonHouseBuilder{@Overridevoid buildBasic() {house.setBasic("别墅打基础");}@Overridevoid buildWalls() {house.setWall("别墅砌墙");}@Overridevoid buildRoof() {house.setRoof("别墅封顶");}
}

3. 引入指挥者，指定建造的顺序：

/*** 建房子的指挥者*/
public class HouseBuildCommander {CommonHouseBuilder commonHouseBuilder;public HouseBuildCommander(CommonHouseBuilder commonHouseBuilder) {this.commonHouseBuilder = commonHouseBuilder;}public HouseBuildCommander() {}/*** 建造房子* @return*/public House constructHouse() {commonHouseBuilder.buildBasic();commonHouseBuilder.buildWalls();commonHouseBuilder.buildRoof();return commonHouseBuilder.getHouse();}}

4. 客户端只需要让指挥者去指挥建造需要的房子即可：

public class Client {public static void main(String[] args) {//让指挥者 建造别墅HouseBuildCommander houseBuildCommander = new HouseBuildCommander(new Villa());House house = houseBuildCommander.constructHouse();System.out.println(house);}
}

House{basic = 别墅打基础, wall = 别墅砌墙, roof = 别墅封顶}

  从改造后的案例，不难看出，建造者模式，一般适用于产品建造过程有较多共同点的情况，例如上面的案例，无论是建别墅，高层也好，都需要经过打基础，砌墙，封顶的过程，只是不同的房子具体的工艺不一样。如果产品之间建造过程差异很大，比如建房子和建桥，那么就不适合使用建造者模式。并且建造者模式，和抽象工厂模式的区别在于，建造者模式注重创建产品的过程，而抽象工厂模式，强调的是通过提供一个统一的接口来创建这些产品系列，而不关心具体实现。

• 如果你需要创建一组相关的产品，使用抽象工厂模式；
• 如果你需要按步骤创建一个复杂对象，使用建造者模式。

二、适配器模式

  适配器模式是一种结构型设计模式，适用于一个类的接口转换成客户端希望的另一个接口。通过适配器模式，可以让原本因接口不兼容而无法一起工作的类协同工作。
  也可以用生活中的一个案例说明，例如有些笔记本电脑是支持直接插入网线的：
  而有一些则没有网线接口，只有usb插槽，则需要在网线和usb插槽之间使用一个转接器：
  通过转接器，便可以实现有线上网的方式。这里的转接器就是适配器的体现（在网线和usb插槽之间作为缓冲层，对两者进行适配转换）。
  由此可知，适配器模式的主要角色有：

1. 目标接口：客户端希望使用的接口。
2. 源接口：需要被适配的接口，通常是一个现有的类或库，但它的接口与客户端不兼容。
3. 适配器：实现目标接口的类，它将源接口转化为目标接口。

  如果体现在代码中，适配器模式分为类适配器，对象适配器，接口适配器三种体现，其中类适配器的适配器类，是使用继承被适配类，实现适配类的形式，不够灵活，所以不再记录。

2.1、对象适配器

  目前笔记本电脑有一个usb，无法直接插上网线：

public class Usb {public String outputUsb(){String type = "usb接口";System.out.println("向外提供"+type);return type;}
}

  网线接口：

public interface NetworkCable {String outputNetworkCable();
}

  通过适配器，使网线可以通过usb接口正常工作：

public class Adapt implements NetworkCable{private Usb usb;public Adapt(Usb usb) {this.usb = usb;}@Overridepublic String outputNetworkCable() {String usb = this.usb.outputUsb();System.out.println("将usb接口转接为网线接口");return "网线接口";}
}

public class Computer {public void connectInternet(NetworkCable networkCable){if (networkCable.outputNetworkCable().equals("网线接口")){System.out.println("连接互联网");}else {System.out.println("不能有线上网！");}}
}

  电脑的使用者，只需要在连接网络时，通过适配器连上电脑的usb接口，再将网线插到适配器上，即可实现有线上网：

public class Client {public static void main(String[] args) {Computer computer = new Computer();computer.connectInternet(new Adapt(new Usb()));}
}

2.2、接口适配器

  接口适配器，通常运用在某个具体的实现类，只想实现接口中部分方法的情况：
  接口中有五个方法：

public interface Inter {void method1();void method2();void method3();void method4();void method5();}

  但是某个实现类只想实现其中的部分方法，可以引入一个抽象类作为中间层，实现所有的方法：

public abstract class AbsClass implements Inter{@Overridepublic void method1() {}@Overridepublic void method2() {}@Overridepublic void method3() {}@Overridepublic void method5() {}@Overridepublic void method4() {}
}

  具体的实现类只需要继承该抽象类即可自由选择需要实现的方法：

public class BusinessClass extends AbsClass{@Overridepublic void method1() {System.out.println("只用到了method1");}
}

三、桥接模式

  桥接模式是一种结构型设计模式，引入桥接对象来解耦抽象部分和具体实现部分，使抽象部分与实现部分分离。
  其主要角色有：

1. 抽象类：定义了抽象的接口，并持有一个对实现类对象的引用。抽象类的实现通常依赖于实现类。
2. 扩展抽象类：是抽象类的具体子类，提供了具体的功能实现。
3. 实现类接口：定义了实现类的接口，通常是一个抽象类或者接口，提供了具体实现类的基本方法。
4. 具体实现类：实现了实现类接口的具体类，负责实现具体的功能。

  如果举一个生活中的案例，例如手机有不同的款式，比如翻盖式，折叠式，不同的式样又有不同的品牌。假设需要新增一个样式，那么需要在新的样式下加上所有的品牌。（反之也一样，在所有的品牌下都加上新样式）。
  引入桥接模式解决这样的问题，则可以将品牌设置为一个接口，并定义所有品牌手机都具有的功能（开机，关机，打电话）：

/*** 品牌* 所有品牌的手机都有开机关机，打电话的功能*/
public interface Brand {void open();void close();void call();
}

  不同品牌的手机实现品牌接口，重写其中的方法：

public class VivoPhone implements Brand {@Overridepublic void open() {System.out.println("vivo 手机 开机");}@Overridepublic void close() {System.out.println("vivo 手机 关机");}@Overridepublic void call() {System.out.println("vivo 手机 打电话");}
}

public class XiaomiPhone implements Brand{@Overridepublic void open() {System.out.println("小米手机 开机");}@Overridepublic void close() {System.out.println("小米手机 关机");}@Overridepublic void call() {System.out.println("小米手机 打电话");}
}

  将手机设置为抽象类，组合了品牌，同时引用了不同品牌共有的方法：

public abstract class Phone {private Brand brand;public Phone(Brand b) {this.brand = b;}public void open(){brand.open();}public void close(){brand.close();}public void call(){brand.call();}}

  不同样式的手机，只需要继承手机抽象类即可：

public class FoldedPhone extends Phone{public FoldedPhone(Brand b) {super(b);}@Overridepublic void open() {super.open();System.out.println("折叠式 手机开机");}@Overridepublic void close() {super.close();System.out.println("折叠式 手机关机");}@Overridepublic void call() {super.call();System.out.println("折叠式 手机打电话");}
}

  创建一个折叠式的小米手机：

public class Client {public static void main(String[] args) {FoldedPhone foldedPhone = new FoldedPhone(new XiaomiPhone());foldedPhone.call();foldedPhone.open();foldedPhone.close();}
}

小米手机 打电话
折叠式 手机打电话
小米手机 开机
折叠式 手机开机
小米手机 关机
折叠式 手机关机

  如果后续需要增加品牌或者样式，只需要实现品牌接口，或者继承手机抽象类即可。从这个案例不难看出，当一个系统有多个维度需要变化时，桥接模式可以把这些维度分开，避免创建大量的子类和多重继承

---