建造者模式

最新推荐文章于 2024-07-10 16:03:30 发布
最新推荐文章于 2024-07-10 16:03:30 发布
阅读量159 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_43774908/article/details/105478012
版权

建造者模式
问题的引入——建造 “小人’
用程序画一个小人，要求小人要有头、身体、两手、两脚。

  • 建造“小人”的过程是稳定的，都需要头身手脚。
  • 具体建造的细节不同，有胖瘦高矮等区别。

建造小人的第一种方法：

import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
public class Main extends Frame{
	public void paint(Graphics g) {
		Color c=g.getColor();
		g.setColor(Color.BLACK);
		g.fillOval(50,50,30,30);//头
		g.fillRect(60,80,10,50);//身体
		g.drawLine(60,80,40,130);//左手
		g.drawLine(70,80,90,130);//右手
		g.drawLine(60,130,45,180);//左腿
		g.drawLine(70,130,85,180);//左腿
		g.setColor(c);
		
	}
	public void lauchFrame() {
		this.setLocation(400,300);
		this.setSize(800,600);
		this.addWindowListener(new WindowAdapter()
		{
			public void windowClosing(WindowEvent e)
			{System.exit(0);}
		});
		this.setBackground(Color.WHITE);
		setVisible(true);
}		
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Main person=new Main();
		person.lauchFrame();
	
	}
}

建造小人的第二种方法：

//瘦小人类
class PersonThinBuilder{
	private Graphics g;
	public void PresonThinBuilder(Graphics g) {this.g=g;}
		public void build() {
			Color c=g.getColor();
			g.setColor(Color.BLACK);
			g.fillOval(50,50,30,30);//头
			g.fillRect(60,80,10,50);//身体
			g.drawLine(60,80,40,130);//左手
			g.drawLine(70,80,90,130);//右手
			g.drawLine(60,130,45,180);//左腿
			g.drawLine(70,130,85,180);//左腿
			g.setColor(c);
		}
}
//胖小人类
class PersonFatBuilder{
	private Graphics g;
	public void PresonFatBuilder(Graphics g) {this.g=g;}
		public void build() {
			Color c=g.getColor();
			g.setColor(Color.BLACK);
			g.fillOval(50,50,30,30);//头
			g.fillRect(45,80,40,50);//身体
			g.drawLine(60,80,40,130);//左手
			g.drawLine(70,80,90,130);//右手
			g.drawLine(60,130,45,180);//左腿
			g.drawLine(70,130,85,180);//左腿
			g.setColor(c);
		}
	}

public class Main extends Frame {
	public void paint(Graphics g) {
		PersonFatBuilder p=new PersonFatBuilder();
		p.build();
	}
	public void lauchFrame() {
		this.setLocation(400,300);
		this.setSize(800,600);
		this.addWindowListener(new WindowAdapter()
		{
			public void windowClosing(WindowEvent e)
			{System.exit(0);}
		});
		this.setBackground(Color.WHITE);
		setVisible(true);
}		
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Main person=new Main();
		person.lauchFrame();
}
}

这样达到了可以复用这两个画小人程序的目的。但规范化的问题依然没有解决。最好的办法是规定，凡是建造小人，都必须要有头和身体，以及两手两脚。

import java.awt.Color;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

abstract class PersonBuilder{
	protected Graphics g;
	public PersonBuilder(Graphics g)
	{
		this.g=g;
	}
	public abstract void builderHead();
	public abstract void builderBody();
	public abstract void builderArmLeft();
	public abstract void builderArmRight();
	public abstract void builderLegLeft();
	public abstract void builderLegRight();
}
//画瘦子类继承画人的抽象类
class PersonThinBuilder extends PersonBuilder{
	public PersonThinBuilder(Graphics g) {super(g);}

	@Override
	public void builderHead() {
		// TODO Auto-generated method stub
		g.fillOval(50, 50, 30, 30);
	}

	@Override
	public void builderBody() {
		// TODO Auto-generated method stub
		g.fillRect(60, 80, 10, 50);
	}

	@Override
	public void builderArmLeft() {
		// TODO Auto-generated method stub
		g.drawLine(60, 80, 40, 130);
	}

	@Override
	public void builderArmRight() {
		// TODO Auto-generated method stub
		g.drawLine(70, 80, 90, 130);
	}

	@Override
	public void builderLegLeft() {
		// TODO Auto-generated method stub
		g.drawLine(60, 130, 45, 180);
	}

	@Override
	public void builderLegRight() {
		// TODO Auto-generated method stub
		g.drawLine(70, 130, 85, 180);
	}
}
//画胖子类继承画人的抽象类
class PersonFatBuilder extends PersonBuilder{
	public PersonFatBuilder(Graphics g) {super(g);}

	@Override
	public void builderHead() {
		// TODO Auto-generated method stub
		g.fillOval(50, 50, 30, 30);
	}

	@Override
	public void builderBody() {
		// TODO Auto-generated method stub
		g.fillRect(45, 80, 40, 50);
	}

	@Override
	public void builderArmLeft() {
		// TODO Auto-generated method stub
		g.drawLine(60, 80, 40, 130);
	}

	@Override
	public void builderArmRight() {
		// TODO Auto-generated method stub
		g.drawLine(70, 80, 90, 130);
	}

	@Override
	public void builderLegLeft() {
		// TODO Auto-generated method stub
		g.drawLine(60, 130, 45, 180);
	}

	@Override
	public void builderLegRight() {
		// TODO Auto-generated method stub
		g.drawLine(70, 130, 85, 180);
	}
}
//控制建造过程的类，隔离用户与建造过程的关联
class PersonDirector{
	private PersonBuilder pb;
	public PersonDirector(PersonBuilder pb) {
		this.pb=pb;
	}
	public void createPerson() {
		pb.builderHead();
		pb.builderBody();
		pb.builderArmLeft();
		pb.builderArmRight();
		pb.builderLegLeft();
		pb.builderLegRight();
	}
}
//客户端代码
public class Main extends Frame{
	public void paint(Graphics g) {
		Color c=g.getColor();
		g.setColor(Color.BLACK);
		PersonThinBuilder ptb=new PersonThinBuilder(g);
		PersonDirector pdThin=new PersonDirector(ptb);
		pdThin.createPerson();
		g.setColor(c);
	}
public void lauchFrame() {
	this.setLocation(400, 300);
	this.setSize(800, 600);
	this.addWindowListener(new WindowAdapter() {
		public void windowClosing(WindowEvent e) {
		System.exit(0);
		}
	});
	this.setBackground(Color.WHITE);
	setVisible(true);
}
public static void main(String[] args) {
	Main drawPerson=new Main();
	drawPerson.lauchFrame();
}
}

建造者( Builder)模式

  • 如果需要将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示时，需要应用建造者模式( Builder)，又叫生成器模式。
  • 建造者模式可以将一个产品的内部表示与产品的生产过程分割开来，从而可以使一个建造过程生成具有不同内部表示的产品对象。
  • 用了建造者模式，用户就就不需要知道具体建造的过程和细节，只需要指定需要建造的类型就可以得到它们。
  • 建造者模式( Builder)，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
    建造者模式的基本代码：
import java.util.ArrayList;
import java.util.List;
class Product{
	List<String>parts=new ArrayList<String>();
	public void Add(String part)//添加产品部件
	{
		parts.add(part);
	}
	public void Show()//列举产品部件
	{
		System.out.println("产品 创建---");
		for(String part:parts) {
			System.out.println(part);
		}
	}
}
abstract class Builder{
	public abstract void BuilderPartA();
	public abstract void BuilderPartB();
	public abstract Product GetResult();
}
class ConcreteBuilder1 extends Builder{
	private Product product=new Product();

	@Override
	public void BuilderPartA() {
		// TODO Auto-generated method stub
		product.Add("部件A");
	}

	@Override
	public void BuilderPartB() {
		// TODO Auto-generated method stub
		product.Add("部件B");
	}

	@Override
	public Product GetResult() {
		// TODO Auto-generated method stub
		return product;
	}
	
}
class ConcreteBuilder2 extends Builder{
	private Product product=new Product();

	@Override
	public void BuilderPartA() {
		// TODO Auto-generated method stub
		product.Add("部件1");
	}

	@Override
	public void BuilderPartB() {
		// TODO Auto-generated method stub
		product.Add("部件2");
	}

	@Override
	public Product GetResult() {
		// TODO Auto-generated method stub
		return product;
	}
	
}
class Director{
	public void Construct(Builder builder) {
		builder.BuilderPartA();
		builder.BuilderPartB();
	}
}
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Director director=new Director();
		Builder b1=new ConcreteBuilder1();
		Builder b2=new ConcreteBuilder2();
		director.Construct(b1);
		Product p1=b1.GetResult();
		p1.Show();
		director.Construct(b2);
		Product p2=b2.GetResult();
		p2.Show();
		
	}

}

在什么情况下使用建造者模式

  • 相同的方法，不同的执行顺序，产生不同的事件结果时，可以采用建造者模式，需要生成的产品对象的属性相互依赖，建造者模式可以强迫生成顺序。
  • 多个部件或零件都可以装配到一个对象中，但是产生的运行结果又不相同时，则可以使用该模式。
  • 产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候使用建造者模式是非常合适。

本质：分离整体构建算法和部件构造

java实现建造者模式（Builder Pattern）
08-26
java实现建造者模式（Builder Pattern） java实现建造者模式（Builder Pattern）是一种软件设计模式，旨在解决软件系统中创建复杂对象的问题。建造者模式可以将复杂对象的创建过程分解为多个简单的对象一步一步构建...
[Python设计模式] 第13章 造小人——建造者模式
weixin_34037173的博客
08-06 217
github地址:https://github.com/cheesezh/python_design_patterns 题目1 用程序模拟一个画小人的过程，要求小人要有头，身子，左手，右手，左脚，右脚。 基础代码 class PersonDrawer(): def draw(self): print("画头") print("画身子") ...
设计模式之建造者模式
weixin_30470857的博客
07-20 121
题目：用程序画一个小人，简单点，要求是小人要有头、身体、两手、两脚就可以了。 第一版： 先造一支笔 public class Pen { private String color; public Pen(String color){ this.color = color; } public String getColor() { ...
设计模式之-建造者模式
weixin_30462049的博客
06-27 96
转自大话设计模式： part1：画一个游戏里面的小人，要求有头，有身体，有2手，2脚。 颜色类: 钢笔类： //制图类: 测试1: 如果我要画2个不同的人，一个胖子一个瘦子，但是都有相同的部位，因为有可能遗忘，所以导致第二个实例化对象缺胳膊少腿。显然是不符合的。part2进行改进 part2: 将一个复杂的对象的建造过程与他的表示进行分离，使得同样的构建过程可以创造出...
java建造者模式
weixin_47796247的博客
11-16 744
（1）建造模式是将复杂的内部创建封装在内部，对于外部调用的人来说，只需要传入建造者和建造工具，对于内部是如何建造成成品的，调用者无需关心，良好的封装性是建造者模式的优点之一。（2）需要生产的产品的属性相互依赖，这些属性的赋值顺序比较重要时（因为在调用ConcreteBuilder的赋值方法时是有先后顺序的）。这个接口规定要实现复杂对象的哪些部分的创建，并不涉及具体的对象部件的创建，一般由子类具体实现。，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。
设计模式——建造者模式
最新发布
weixin_46073538的博客
07-10 1673
建造者模式(Builder Pattern)又叫生成器模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出来(抽象类别)，使这个抽象过程的不同实现方法可以构造出不同表现(属性)的对象。建造者模式 是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们.用户不需要知道内部的具体构建细节。
java设计模式【之】建造者模式【源码】【场景：车辆组装】
03-24
java设计模式【之】建造者模式【源码】【场景：车辆组装】 将复杂的对象构建，与对象的使用进行分离 用户只需要通过简单流程即可创建出对象 方法调用顺序，步骤的不同实现 优点：封装性号，创建和使用分离，扩展性...
设计模式之建造者模式代码示例
08-20
建造者模式（Builder Pattern）是软件工程中一种用于创建对象的抽象工厂方法，它将复杂的构建过程分解为一系列步骤，使得构建过程可以独立于其表示进行。这种模式允许客户端使用相同的构建过程创建不同表现形式的...
建造者模式c++实现
05-10
建造者模式是一种设计模式，它将复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。在C++中实现建造者模式，我们可以遵循以下步骤： 首先，我们需要定义一个抽象建造者（Builder）类，它声明了一...
第一次使用processon画图——UML类图
qq_43774908的博客
03-03 3480
首先直接搜索processon打开就可以或者使用下面的链接进入https://www.processon.com/ 进入之后可以注册自己的账号，然后就可以开始画图了。
设计模式七大原则之合成/聚合复用原则(CARP)
qq_43774908的博客
03-31 546
合成/聚合复用原则(CARP) 问题的提出： 如果有类A和类B，类A有方法opertion1()、 opertion2() 和 opertion3()，类B需要用类A的方法opertion2() ，如何做？ 法1： 让类B继承类A，则类B可以使用类A的所有方法，当 然包括opertion2() 。 分析： 1、暴露了类A的另外2个方法,虽然类B不需要使用， 但是破坏封装。 2、如果类A的实现发生...
详细介绍一下UML类图
qq_43774908的博客
03-10 538
下面详细的介绍一下UML类图 注释(comment) 注释就是对类图的补充说明，可以附加在任何元素上，用右上角有折角的矩形来表示，其内放置说明文字，通过虚线连接被注释的元素。 类（Class) 在面向对象（OO) 编程中，类是对现实世界中一组具有相同特征的物体的抽象。在UML类图中，类使用包含类名、属性(field) 和方法(method) 且带有分割线的矩形来表示： 类的属性的完整表示方式：...
职责链( Chain of Responsibility)模式
qq_43774908的博客
06-14 338
职责链( Chain of Responsibility)模式 职责链模式动机(Motivation) ➢在软件构建过程中，一个请求可能被多个对象处理，但是每个请求在运行时只能有一个接受者，如果显式指定，将必不可少地带来请求发送者与接受者的紧耦合。 ➢如何使请求的发送者不需要指定具体的接受者?让请求的接受者自己在运行时决定来处理请求，从而使两者解耦。 模式定义 使多个对象都有机会处理请求，从而避免请求的发送者和.接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。 问
设计模式七大原则之开放-封闭原则
qq_43774908的博客
03-20 334
开放-封闭原则 1.基本介绍 1)开闭原则(Open Closed Principle)是编程中最基础、 最重要的设计原则——面向对象设计的终极目标。 2)一个软件实体如类，模块和函数应该对扩展开放 (对提供方)，对修改关闭(对使用方)。用抽象构建 框架，用实现扩展细节。 3)当软件需要变化时，尽量通过扩展软件实体的行 为来实现变化，而不是通过修改已有的代码来实现 变化。 4)编程中遵循其它原则，...
为别人做嫁衣——代理模式
qq_43774908的博客
04-28 290
代理模式 场景描述 前提:卓贾易喜欢娇娇,但是，娇娇并不认识卓贾易: 1.卓贾易给娇娇送花，送巧克力,送洋娃娃 2.卓贾易也可以找一个人，让这个人把鲜花，巧克力和洋娃娃送给娇娇。 这是两种方式，但达到的目的是一样的。 下面看看这两个代码的实现。 没有代理的代码 //追求者类 class Pursuit{ SchoolGirl mm; public Pursuit(SchoolGirl mm) ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值