设计模式(Java)----建造者（生成器）模式Builder

最新推荐文章于 2024-10-06 09:57:54 发布
最新推荐文章于 2024-10-06 09:57:54 发布
阅读量122 收藏
点赞数
文章标签： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiahuier/article/details/105415320
版权

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
①一个对象会有一些重要的性质，在它没有恰当的值之前，对象不能作为一个完整的产品使用。
②一个对象的一些性质必须按照某个顺序赋值才有意义。
一、用程序画一个小人，要求小人有头、身体、两手、两脚。

基本代码

import java.awt.*;
import java.awt.event.*;
class DrawPerson extends Frame{
	public void paint(Graphics g) {//从Frame中继承的paint方法在程序运行时会自动调用
		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 class Main{
	public static void main(String[] args){
		DrawPerson person=new DrawPerson();
		person.lauchFrame();
	}
}

画一个身体比较胖的小人，将身体的参数改一下就可以了。
二、现在的代码全写在窗体里面，要是需要在别的地方用这些画小人的程序怎么办？

import java.awt.*;
import java.awt.event.*;


class PersonThinBuilder{//画瘦小人
	private Graphics g;
	public PersonThinBuilder(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 PersonFatBuilder(Graphics g)
	{
		this.g=g;
	}
	public void build()
	{
		Color c=g.getColor();
		g.setColor(Color.BLACK);
		g.fillOval(50, 50, 30, 30);//头
		g.fillOval(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);
	}
}
class DrawPerson extends Frame{
	public void paint(Graphics g) {
		PersonFatBuilder p=new PersonFatBuilder(g);
		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 class Main{
	public static void main(String[] args){
		DrawPerson drawperson=new DrawPerson();
		drawperson.lauchFrame();
	}
}

三、画小人要有头有手有脚，要先不遗忘任何一个，如何做到不遗忘呢？

需要建一个抽象的构造人类的。

import java.awt.*;
import java.awt.event.*;
//画人的抽象类
abstract class PersonBuilder{
	protected Graphics g;
	public PersonBuilder(Graphics g) {
		this.g=g;
	}
	public abstract void buildHead();
	public abstract void buildBody();
	public abstract void buildArmLeft();
	public abstract void buildArmRight();
	public abstract void buildLegLeft();
	public abstract void buildLegRight();
}
class PersonThinBuilder extends PersonBuilder{
	public PersonThinBuilder(Graphics g)
	{
		super(g);
	}

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

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

	@Override
	public void buildArmLeft() {
		// TODO Auto-generated method stub
		g.drawLine(60, 80, 40, 130);//左手 四个数确定两个点
	}

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

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

	@Override
	public void buildLegRight() {
		// 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.buildHead();
		pb.buildBody();
		pb.buildArmLeft();
		pb.buildArmRight();
		pb.buildLegLeft();
		pb.buildLegRight();
	}
}
class DrawPerson extends Frame{
	public void paint(Graphics g) {
		Color c=g.getColor();
		g.setColor(Color.BLACK);
		PersonThinBuilder p=new PersonThinBuilder(g);
		PersonDirector pdThin=new PersonDirector(p);
		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 class Main{
	public static void main(String[] args){
		DrawPerson drawperson=new DrawPerson();
		drawperson.lauchFrame();
	}
}

四、建造者模式的基本代码

建造者( Builder)角色:定义创建一个Product对象所需的各个部件的操作。
具体建造者(Concrete Builder)角色:实现Builder角色提供的接口，一步步完成创建产品实例的过程。在建造过程完成后，提供产品的实例。
指导者( Director)角色:主要用来使用Builder接口，以一个统一的过程来构建所需要的Product对象。
产品(Product) 角色:产品便是建造中的复杂对象。
 

 

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 BuildPartA();
	public abstract void BuildPartB();
	public abstract Product GetResult();

}
class ConcreteBuilder1 extends Builder{//具体建造者类1
	private Product product=new Product();

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

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

	@Override
	public Product GetResult() {
		// TODO Auto-generated method stub
		return product;
	}
}
class ConcreteBuilder2 extends Builder{//具体建造者类2
	private Product product=new Product();

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

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

	@Override
	public Product GetResult() {
		// TODO Auto-generated method stub
		return product;
	}
}
class Director{//指挥类
	public void Construct(Builder builder) {
		builder.BuildPartA();
		builder.BuildPartB();
	}
}
public class Main{
	public static void main(String[] args){
		Director director=new Director();//指导者
		Builder b1=new ConcreteBuilder1();//具体建造者
		Builder b2=new ConcreteBuilder2();//具体建造者
		director.Construct(b1);//指挥者用Builder1构建产品
		Product p1=b1.GetResult();//获取构建的产品
		p1.Show();
		director.Construct(b2);//指挥者用Builder2构建产品
		Product p2=b2.GetResult();//获取构建的产品
		p2.Show();
		
	}
}

在什么情况下可以使用建造者模式？
①相同的方法，不同的执行顺序，产生不同的事件结果。
②多个部件或零件都可以装配到一个对象中，但是产生的运行结果又不相同。
③产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能。

软耳.
关注
Java创建型设计模式-建造者模式
欢迎拜读我的作品，喜欢的领域请给我留言
08-10 1939
以上就是关于建造者模式的详细介绍，你学会了吗？从建造者模式的产生背景，原理，以及代码示例、优缺点分析等多维度进行了阐述。相信通过本文的学习，大家对建造者模式有了更加深入的认识！工厂模式抽象工厂模式。
设计模式-建造者模式在Java中使用示例
BADAO_LIUMANG_QIZHI的博客
07-13 2296
没有人买车会只买一个轮胎或者方向盘，大家买的都是一辆包含轮胎、方向盘和发动机等多个部件的完整汽车。如何将这些部件组装成一辆完整的汽车并返回给用户，这是建造者模式需要解决的问题。建造者模式又称为生成器模式，它是一种较为复杂、使用频率也相对较低的创建型模式。建造者模式为客户端返回的不是一个简单的产品，而是一个由多个部件组成的复杂产品。建造者模式是较为复杂的创建型模式，它将客户端与包含多个组成部分（或部件）的复杂对象的创建过程分离，
Java设计模式——构建器模式【Builder Pattern】（一）
热门推荐
scorpio的博客
10-11 1万+
Java设计模式——变种的构建器模式
类的组合
weixin_43690603的博客
07-09 149
定义一个人的类，人有头、躯干、手、脚等属性，这几个属性又可以是通过一个个类实例化的对象，这就是组合 class Person: def __init__(self, id_num, name, hand, foot, trunk, head): self.id_num = id.num self.name = name self.hand =...
设计模式（十一）建造者模式
Maggie的博客
09-24 750
用程序画一个小人，这在游戏程序里非常常见。现在简单一点，要求是小人要有头、身体、两手、两脚就可以了。 第一版  Pen p = new Pen (Color.Yellow); Graphics gThin = pictureBox1.CreateGraphics(); gThin.DrawEllipse(p,50,20,30,30); // 头 gThin.DrawRectang...
Java设计模式-建造者模式(Builder）
qq_37400096的博客
09-19 561
将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。
设计模式-生成器模式/建造者模式Builder
ZSS1753936255的博客
10-02 646
图文说明：距离相同的构建过程 得出不同的展示。此时就用两个类（文本生成器，XML生成器） 用来展示。说明：此刻存在Builder的必要性就是玩多态。实现的时候吧，还是通过指导器传入对应的构建器对象。来是现在不同的展示。尽管都是director.construct()相同的构造方法。但是构造出来不同的实现。构建起模式：将一个复杂类的表示与其构造分离，使得相同的构建过程能够得出不同的表示。（建造者其实和工厂模式差不多）
JAVA设计模式--创建型模式--建造者模式
qq_42264638的博客
09-01 232
JAVA设计模式--创建型模式--建造者模式
设计模式-生成器模式(建造者模式)-(Builder)
zhao_kang_cheng的专栏
09-23 939
是一种创建型设计模式， 使你能够分步骤创建复杂对象。该模式允许你使用相同的创建代码生成不同类型和形式的对象。就像流水线的组装机器人一样，一件产品 组装分成好几部，每一个 工位组装不同的内容。问题：譬如你开了一家公司，专门承接私人建房，建房有的人要求：自带车库的房子、带游泳池的房子、装饰豪华的房子和带花园的房子等等。如果你基于这些创建了一个构造函数：拥有大量输入参数的构造函数也有缺陷：这些参数也不是每次都要全部用上.通常情况下，绝大部分的参数都没有使用，这使得对于构造函数的调用十分不简介。
Java设计模式-建造者模式Builder
老徐的博客只有干货
01-09 1126
建造者模式（Builder Pattern） 又叫生成器模式，是一种对象构建模式。它可以 将复杂对象的建造过程抽象出来（抽象类别），使这个抽象过程的不同实现方 法可以构造出不同表现（属性）的对象。建造者模式 是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象 的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。
design-patterns-builder:生成器设计模式
04-16
生成器设计模式是一种软件设计模式，它允许我们分步骤创建复杂对象，而无需暴露其构建过程。这种模式在Java和其他面向对象语言中广泛应用于解决对象组装的问题，特别是当构造过程需要多个步骤，或者构造过程与对象...
【设计模式】- 生成器模式(Builder)（csdn）————程序.pdf
12-04
生成器模式，也称为建造者模式，是一种设计模式，用于创建复杂对象，它允许你按照一系列步骤来构造对象，而这些步骤可以通过不同的实现来产生不同形式的对象。生成器模式的核心在于分离了对象的构造过程和表示细节，...
.NET设计模式（4）：建造者模式（BuilderPattern）
03-03
在软件系统中，有时候面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的... 生成器模式将复杂对象的构建与对象的表现分离开来，这样使得同样的构建过程可以创建出不同的表现。这种模式用于快餐店
Prototype(原型模式)
TimerSea的博客
10-06 516
本篇介绍了原型设计模式基础与实现示例
设计模式-模版方法模式
ZSS1753936255的博客
10-04 630
模版方法模式(Template Method):定义一个操作中的算法骨架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构即可重新定义算法的某些定义步骤。抽象类：负责实现一个算法的骨架，他是由一个final修饰的模版方法和若干个基本方法组成的。
设计模式-适配器模式
最新发布
m0_45164511的博客
10-06 567
适配器模式（Adapter Pattern）属于结构型设计模式，它的作用是。适配器让原本由于接口不兼容而不能一起工作的类可以协同工作。适配器模式包括三个角色：目标抽象类（Target）、适配器类（Adapter）和被适配者类（Adaptee）。适配器模式在实际开发中非常常见，比如我们经常需要连接各种不同的数据库，每种数据库都有自己独特的接口和方法。如果我们希望写出一段通用的代码，能够连接到任何一种数据库并执行相同的操作，那么适配器模式就非常适合解决这个问题。
设计模式之原型模式(通俗易懂--代码辅助理解【Java版】）
qq_45929019的博客
10-04 1117
创建型模式：工厂方法、抽象方法、建造者、原型、单例。结构型模式有：适配器、桥接、组合、装饰器、外观、享元、代理。行为型模式有：责任链、命令、解释器、迭代器、中介、备忘录、观察者、状态、策略、模板方法、访问者。常用设计模式：单例模式、工厂模式、代理模式、策略模式&模板模式、门面模式、责任链模式、装饰器模式、组合模式、builder模式。这种情况就是浅拷贝，java只拷贝你指定的对象，至于你指定的对象里面的别的对象，它不拷贝，还是把引用给你，共享变量，这是一种非常不安全的方式，需要特别注意。
设计模式-原型模式
ZSS1753936255的博客
10-02 602
设计模式
设计模式-工厂模式
ZSS1753936255的博客
10-02 785
工厂方法模式非常符合“开闭原则”，当需要增加一个新的产品时，我们只需要增加一个具体的产品类和与之对应的具体工厂即可，无须修改原有系统。同时在工厂方法模式中用户只需要知道生产产品的具体工厂即可，无须关系产品的创建过程，甚至连具体的产品类名称都不需要知道。由此发现：都是先创建工厂，然后在使用工厂实例获取产品。此时只有一个工厂，那么只能创建一类型的产品。当系统中加入新产品时，除了需要提供新的产品类之外，还要提供与其对应的具体工厂类。而工厂子类则负责生成具体的产品对象，即通过不同的工厂子类来创建不同的产品对象。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值