设计模式建造者模式-适配器模式

最新推荐文章于 2024-07-12 19:11:36 发布

冰山丶

最新推荐文章于 2024-07-12 19:11:36 发布

阅读量216

点赞数

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

本文链接：https://blog.csdn.net/weixin_44877218/article/details/105179164

版权

Java设计模式专栏收录该内容

10 篇文章 0 订阅

订阅专栏

设计模式建造者模式-适配器模式

建造者模式

基本介绍：
- 又叫生成器模式，是一种对象构建模式。他可以将复杂对象的构建过程抽象出来（抽象类别），使这个抽象过程的不同实现方式可以构造出不同表现的对象
- 建造者模式是一步一步创建一个复杂的对象，他允许用户只通过指定复杂对象的类型和内容就可以构建他们，用户不需要知道内部的具体构建细节。
建造者模式的四个角色：
- Product（产品角色）:一个具体的产品对象
- Builder（抽象建造者）：创建一个Product对象的各个部件指定的接口
- ConcretebBuilder(具体建造者)：实现接口，构建和装配各个部件。
- Director（指挥者）：构建一个使用Builder接口的对象。它主要是用于创建一个复杂的对象。它主要有两个作用，一是：隔离了客户与对象的生产过程。二是：负责控制产品对象的生产过程。

代码

  public class House {
  	private String basic;
  	private String wall;
  	private String roofed;
  	public String getBasic() {
  		return basic;
  	}
  	public void setBasic(String basic) {
  		this.basic = basic;
  	}
  	public String getWall() {
  		return wall;
  	}
  	public void setWall(String wall) {
  		this.wall = wall;
  	}
  	public String getRoofed() {
  		return roofed;
  	}
  	public void setRoofed(String roofed) {
  		this.roofed = roofed;
  	}
  	@Override
  	public String toString() {
  		return "House [basic=" + basic + ", wall=" + wall + ", roofed=" + roofed + "]";
  	}
  }
  /**
   * 抽象的建造者
   * @author Administrator
   *
   */
  public abstract class HouseBuilder {
  	protected House house=new House();
  	//将建造的流程写好
  	public abstract void builderBasic();
  	public abstract void builderWalls();
  	public abstract void roofed();
  	//建造好房子之后将房子返回
  	public House buildHouse() {
  		return house;
  	}
  }
  public class CommonHouse extends HouseBuilder{
  	@Override
  	public void builderBasic() {
  		house.setBasic("5米");
  		System.out.println("普通房子打地基");
  	}
  
  	@Override
  	public void builderWalls() {
  		house.setWall("10cm");
  		System.out.println("普通房子砌墙");
  	}
  
  	@Override
  	public void roofed() {
  		house.setRoofed("普通房子的房顶");
  		System.out.println("普通房子封顶");
  	}
  }
  public class HighBuilding extends HouseBuilder{
  	@Override
  	public void builderBasic() {
  		System.out.println("高楼打地基");
  	}
  
  	@Override
  	public void builderWalls() {
  		System.out.println("高楼房子砌墙");
  	}
  
  	@Override
  	public void roofed() {
  		System.out.println("高楼房子封顶");
  	}
  }
  /**
   * 指挥者去指挥制作流程
   * @author Administrator
   *
   */
  public class HouseDirector {
  	HouseBuilder houseBuilder;
  	//通过构造器传入 houseBuilder
  	public HouseDirector(HouseBuilder houseBuilder) {
  		this.houseBuilder = houseBuilder;
  	}
  	//通过setter方法传入 houseBuilder
  	public void setHouseBuilder(HouseBuilder houseBuilder) {
  		this.houseBuilder = houseBuilder;
  	}
  	//如何处理建造房子流程，交给指挥者
  	public House constructHouse() {
  		houseBuilder.builderBasic();
  		houseBuilder.builderWalls();
  		houseBuilder.roofed();
  		return houseBuilder.buildHouse();
  	}
  }
  public class Client {
  
  	public static void main(String[] args) {
  		//准备要盖的房子
  		CommonHouse commonHouse=new CommonHouse();
  		//准备创建房子的指挥者
  		HouseDirector houseDirector=new HouseDirector(commonHouse);
  		//创建房子
  		House house = houseDirector.constructHouse();
  		System.out.println(house);
  		HighBuilding highBuilding=new HighBuilding();
  		houseDirector.setHouseBuilder(highBuilding);
  		house=houseDirector.constructHouse();
  		System.out.println(house);
  	}
  }

建造者模式的注意事项和细节
- 客户端（使用程序）不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦使得相同的创建过程可以创建不同的产品对象
- 每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可以得到不同的产品对象
- 可以更加精细地控制产品的创建过程，将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。
- 增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符号“开闭原则”
- 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。
- 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变化的很庞大，因此在这种情况下，要考虑是否选择建造者模式。
抽象工厂模式VS建造者模式
- 抽象工厂模式实现对产品家族的创建，一个产品家族是这样的一系列产品：具有不同分类维度的产品组合，采用抽象工厂模式不需要关心构建过程，只关心什么产品由什么工厂生产即可。而建造者模式则是要求按照指定的蓝图建造产品，它主要的目的是通过组装零配件而产生一个新产品。

适配器模式
- 基本介绍
  - 适配器模式将某个类的接口转换成客户端期望的另一个接口表示，主的目的是兼容性，让原本因接口不能不匹配不能一起工作的两个类可以协同工作。其别名为包装器。
  - 适配器模式属于结构行模式
  - 主要分为三类：类适配器模式、对象适配器模式、接口适配器模式
- 工作原理
  - 将一个类的接口转换成另一个接口，让原本接口不兼容的类可以兼容。
  - 从用户的角看不到被适配者，是解耦的
  - 用户调用适配器转化出来的目标接口方法，适配器再调用被适配者的相关接口方法
  - 用户收到反馈结果，感觉只是和目标接口交互
- 类适配
  - 基本介绍： Adapter类，通过继承src类，实现dst接口，完成src->dst的适配
  - 类适配器代码
```
  public class Voltage220 {
  	public int output220() {
  		int src=220;
  		System.out.println("电源的电压"+src+"伏");
  		return src;
  	}
  }
  //适配接口
  public interface Voltage5 {
  	public int output5();
  }
  //适配器类
  public class VoltageAdapter extends Voltage220 implements Voltage5 {
  
  	@Override
  	public int output5() {
  		//获取适配器的220电压
  		int srcv=output220();
  		int dstv=srcv/44;
  		return dstv;
  	}
  }
  public class Phone {
  	public void charging(Voltage5 voltage5) {
  		if(voltage5.output5()==5) {
  			System.out.println("手机正在充电");
  		}else {
  			System.out.println("电压不符不能充电");
  		}
  	}
  }
  public class Client {
  
  	public static void main(String[] args) {
  		System.out.println("适配器模式");
  		Phone phone=new Phone();
  		phone.charging(new VoltageAdapter());
  	}		
  }
```
  - 类适配器的注意事项和细节
    - java是单继承机制，所以类适配器需要继承src类这一点算是一个缺点，因为这要求dst必须是一个接口，有一定的局限性；
    - src类的方法在Adapter中都会暴露出来，也增加了使用成本。
    - 由于基于其继承了src类，所以它可以根据需求重写src类的方法，使得Adapter的灵活性增强了。
- 对象适配器
  - 基本介绍：
    - 基本思路和类适配器的模式相同，只是将Adapter类做修改，不是继承src类，而是持有src类的实例，以解决兼容性问题。即：持有src类，实现dst类接口，完成src->dst的适配。
    - 根据“合成复用原则”，在系统中尽量使用关联关系来替代继承关系，因此大部分结构型模型都是对象结构型模型
    - 对象适配器模式适配器模式常用的一种。
  - 代码
```
  public class Voltage220 {
  	public int output220() {
  		int src=220;
  		System.out.println("电源的电压"+src+"伏");
  		return src;
  	}
  }
  //适配接口
  public interface Voltage5 {
  	public int output5();
  }
  //适配器类
  public class VoltageAdapter implements Voltage5 {
  	private Voltage220 voltage220;
  	@Override
  	public int output5() {
  		//获取适配器的220电压
  		int dstv=0;
  		if(null!=voltage220) {
  			System.out.println("使用对象适配器进行适配");
  			int srcv=voltage220.output220();
  			dstv=srcv/44;
  		}
  		return dstv;
  	}
  	public VoltageAdapter(Voltage220 voltage220) {
  		this.voltage220 = voltage220;
  	}
  }
  public class Phone {
  	public void charging(Voltage5 voltage5) {
  		if(voltage5.output5()==5) {
  			System.out.println("手机正在充电");
  		}else {
  			System.out.println("电压不符不能充电");
  		}
  	}
  }
  public class Client {
  
  	public static void main(String[] args) {
  		System.out.println("对象适配器模式");
  		Phone phone=new Phone();
  		phone.charging(new VoltageAdapter(new Voltage220()));
  	}		
  }
```
  - 对象适配器模式的注意事项和细节
    - 对象适配器和类适配器其实算是同一种思想，只不过实现方式不同。根据合成复用原则，使用组合替代继承，所以它解决了类适配器必须继承src的局限性问题，也不在要求dst必须是接口。
    - 使用成本更低，更灵活。
- 接口适配器模式
  - 基本介绍：
    - 一些书籍称为适配器模式或者缺省适配器模式。
    - 当不需要全部实现接口提供的方法时，可先设计一个抽象类实现接口，并为该接口中每个方法提供一个默认的实现（空方法），那么该抽象类的子类可以有选择的覆盖父类的某些方法来实现需求。
    - 适用于一个接口不想使用其所有的方法的情况。
  - 代码
```
  public interface Interface4 {
  	public void m1();
  	public void m2();
  	public void m3();
  	public void m4();
  }
  public abstract class AbsDefault implements Interface4 {
  	@Override
  	public void m1() {}
  	@Override
  	public void m2() {}
  	@Override
  	public void m3() {}
  	@Override
  	public void m4() {}
  }
  public class Client {
  	public static void main(String[] args) {
  		new AbsDefault() {
  			@Override
  			public void m1() {
  				System.out.println("使用了m1方法");
  			}
  		};
  	}
  }
```
- 适配者模式的注意事项和细节
  - 三种命名方式，是根据src是以怎样的形式给到Adapter（在Adapter）里的形式来命名的。
  - 类适配器：以类给到，在Adapter里就是将src当做类，继承
  - 对象适配器：以对象给到，在Adapter里，将src作为一个对象，持有
  - 接口适配器：以接口给到，在Adapter里，将src作为一个接口，实现
  - Adapter模式最大的作用还是将原本不兼容的接口融合在一起工作。
  - 实际开发中，实现起来不拘泥于上面的三种经典形式。