Java设计模式——组合

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量118 收藏
点赞数
分类专栏： Java设计模式 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/warehouse_mouse/article/details/120135443
版权

Java 设计模式——组合模式

组合模式 是一种结构型设计模式，可以使用它将对象组合成
树状结构，并且能够像使用独立对象一样使用它们。

组合模式结构

  1. 组件 （Component）接口描述了树中简单项目和复杂项目所共有的操作

  2. 叶节点 （Leaf）是树的基本结构，它不包含子项目。

    一般情况下叶节点最终会完成大部分的实际工作，因为它们无法将工作指派给其他部分。

  3. 容器 （Container）——又名“组合（Composite）“——是包含叶节点或其他容器等子项目的单位。
    容器不知道其子项目所属的具体类，它只通过通用的组件接口与其子项目交互。

    容器接收到请求后会将工作分配给自己的子项目，处理中间结果，然后将最终结果返回给客户端。

  4. 客户端（Client）通过组件接口与所有项目交互。因此，客户端能以相同方式与树状结构中简单或复杂项目交互。
    在这里插入图片描述

代码

伪代码

在这里插入图片描述

具体实现

editor
  • ImageEditor
package com.wl.composite.editor;

import com.wl.composite.shapes.CompoundShape;
import com.wl.composite.shapes.Shape;

import javax.swing.*;
import javax.swing.border.Border;
import java.awt.*;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

/**
 * @author WL
 * @description: 形状编辑器
 * @date 2021/9/6 14:23
 */
public class ImageEditor {
	private EditorCanvas canvas;
	private CompoundShape allShapes = new CompoundShape();
	public ImageEditor(){
		canvas = new EditorCanvas();
	}
	public void loadShapes(Shape... shapes){
		allShapes.clear();
		allShapes.add(shapes);
		canvas.refresh();
	}

	private class EditorCanvas extends Canvas {
		JFrame frame;
		private static final int PADDING = 10;
		EditorCanvas(){
			createFrame();
			refresh();
			addMouseListener(new MouseAdapter() {
				@Override
				public void mousePressed(MouseEvent e) {
					allShapes.unSelect();
					allShapes.selectChildAt(e.getX(),e.getY());
					e.getComponent().repaint();
				}
			});
		}
		void createFrame(){
			frame = new JFrame();
			frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
			frame.setLocationRelativeTo(null);

			JPanel contentPanel = new JPanel();
			Border padding = BorderFactory.createEmptyBorder(PADDING,PADDING,PADDING,PADDING);
			contentPanel.setBorder(padding);
			frame.setContentPane(contentPanel);

			frame.add(this);
			frame.setVisible(true);
			frame.getContentPane().setBackground(Color.LIGHT_GRAY);
		}
		@Override
		public int getWidth(){
			return allShapes.getX() +allShapes.getWidth()+PADDING;
		}
		@Override
		public int getHeight(){
			return allShapes.getHeight()+ allShapes.getY()+PADDING;
		}
		void refresh(){
			this.setSize(getWidth(),getHeight());
			frame.pack();
		}
		@Override
		public void paint(Graphics graphics){
			allShapes.paint(graphics);
		}
	}
}
shapes
  • BaseShape
package com.wl.composite.shapes;

import java.awt.*;

/**
 * @author WL
 * @description: 提供基本功能的抽象形状
 * @date 2021/9/6 13:18
 */
public class BaseShape implements Shape{
	public int x;
	public int y;
	public Color color;
	private boolean select = false;

	BaseShape(int x, int y, Color color){
		this.x = x;
		this.y = y;
		this.color = color;
	}
	@Override
	public int getX() {
		return x;
	}

	@Override
	public int getY() {
		return y;
	}

	@Override
	public int getWidth() {
		return 0;
	}

	@Override
	public int getHeight() {
		return 0;
	}

	@Override
	public void move(int x, int y) {
		this.x += x;
		this.y += y;
	}

	@Override
	public boolean isInsideBounds(int x, int y) {
		return x > getX() && x < (getX() + getWidth()) &&
				y > getY() && y < (getY() + getHeight());
	}

	@Override
	public void select() {
		select = true;
	}

	@Override
	public void unSelect() {
		select = false;
	}

	@Override
	public boolean isSelect() {
		return select;
	}

	void enableSelectionStyle(Graphics graphics){
		graphics.setColor(Color.LIGHT_GRAY);

		Graphics2D g2 = (Graphics2D) graphics;
		float[] dash1 = {2.0f};
		g2.setStroke(new BasicStroke(1.0f,
				BasicStroke.CAP_BUTT,
				BasicStroke.JOIN_MITER,
				2.0f, dash1, 0.0f));
	}

	void disableSelectionStyle(Graphics graphics){
		graphics.setColor(color);
		Graphics2D g2 = (Graphics2D) graphics;
		g2.setStroke(new BasicStroke());
	}
	@Override
	public void paint(Graphics graphics) {
		if (isSelect()){
			enableSelectionStyle(graphics);
		} else {
			disableSelectionStyle(graphics);
		}
	}
}
  • Circle
package com.wl.composite.shapes;

import java.awt.*;

/**
 * @author WL
 * @description: 圆形
 * @date 2021/9/6 13:31
 */
public class Circle extends BaseShape{
	public int radius;

	public Circle(int x, int y, int radius, Color color) {
		super(x, y, color);
		this.radius = radius;
	}

	@Override
	public int getWidth() {
		return radius * 2;
	}

	@Override
	public int getHeight() {
		return radius * 2;
	}

	@Override
	public void paint(Graphics graphics) {
		super.paint(graphics);
		graphics.drawRect(x,y,getWidth() - 1,getHeight() - 1);
	}
}
  • CompoundShape
package com.wl.composite.shapes;

import java.awt.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @author WL
 * @description: 由其它形状对象组成的复合形状
 * @date 2021/9/6 13:42
 */
public class CompoundShape extends BaseShape{
	protected List<Shape> children = new ArrayList<>();
	public CompoundShape(Shape... components){
		super(0,0,Color.black);
		add(components);
	}
	public void add(Shape component){
		children.add(component);
	}
	public void add(Shape... components){
		children.addAll(Arrays.asList(components));
	}
	public void remove(Shape child) {
		children.remove(child);
	}
	public void remove(Shape... components){
		children.removeAll(Arrays.asList(components));
	}
	public void clear(){
		children.clear();
	}

	@Override
	public int getX() {
		if (children.size() == 0){
			return 0;
		}
		int x = children.get(0).getX();
		for (Shape child : children){
			if (child.getX() < x){
				x = child.getX();
			}
		}
		return x;
	}

	@Override
	public int getY() {
		if (children.size() == 0){
			return 0;
		}
		int y = children.get(0).getY();
		for (Shape child : children){
			if (child.getY() < y){
				y = child.getY();
			}
		}
		return y;
	}

	@Override
	public int getWidth() {
		int maxWidth = 0;
		int x = getX();
		for (Shape child : children){
			int childRelativeX = child.getX() - x;
			int childWidth = childRelativeX + child.getWidth();
			if (childWidth > maxWidth){
				maxWidth = childWidth;
			}
		}
		return maxWidth;
	}

	@Override
	public int getHeight() {
		int maxHeight = 0;
		int y = getY();
		for (Shape child : children){
			int childRelativeY = child.getY() - y;
			int childHeight = childRelativeY + child.getHeight();
			if (childHeight > maxHeight) {
				maxHeight = childHeight;
			}
		}
		return maxHeight;
	}

	@Override
	public void move(int x, int y) {
		for (Shape child : children){
			child.move(x,y);
		}
	}

	@Override
	public boolean isInsideBounds(int x, int y) {
		for (Shape child : children) {
			if (child.isInsideBounds(x,y)){
				return true;
			}
		}
		return false;
	}

	@Override
	public void unSelect() {
		super.unSelect();
		for (Shape child : children){
			child.unSelect();
		}
	}
	public boolean selectChildAt(int x, int y){
		for (Shape child : children) {
			if (child.isInsideBounds(x,y)){
				child.select();
				return true;
			}
		}
		return false;
	}

	@Override
	public void paint(Graphics graphics) {
		if (isSelect()){
			enableSelectionStyle(graphics);
			graphics.drawRect(getX() - 1,getY() - 1,getWidth() + 1,getHeight() + 1);
			disableSelectionStyle(graphics);
		}
		for (Shape child : children){
			child.paint(graphics);
		}
	}
}
  • Dot
package com.wl.composite.shapes;

import java.awt.*;

/**
 * @author WL
 * @description: 点
 * @date 2021/9/6 13:26
 */
public class Dot extends BaseShape{
	private final int DOT_SIZE = 3;
	public Dot(int x, int y, Color color){
		super(x,y,color);
	}

	@Override
	public int getWidth() {
		return DOT_SIZE;
	}

	@Override
	public int getHeight() {
		return DOT_SIZE;
	}

	@Override
	public void paint(Graphics graphics) {
		super.paint(graphics);
		graphics.fillRect(x - 1,y - 1,getWidth(),getHeight());
	}
}
  • Rectangle
package com.wl.composite.shapes;

import java.awt.*;

/**
 * @author WL
 * @description: 三角形
 * @date 2021/9/6 13:39
 */
public class Rectangle extends BaseShape{
	public int width;
	public int height;

	public Rectangle(int x, int y, int width, int height, Color color) {
		super(x, y, color);
		this.height = height;
		this.width = width;
	}

	@Override
	public int getWidth() {
		return width;
	}

	@Override
	public int getHeight() {
		return height;
	}

	@Override
	public void paint(Graphics graphics) {
		super.paint(graphics);
		graphics.drawRect(x,y,getWidth() - 1,getHeight() - 1);
	}
}
  • Shape
package com.wl.composite.shapes;

import java.awt.*;

/**
 * @author WL
 * @description: 通用形状接口
 * @date 2021/9/6 11:03
 */
public interface Shape {
	int getX();
	int getY();
	int getWidth();
	int getHeight();
	void move(int x, int y);
	boolean isInsideBounds(int x, int y);
	void select();
	void unSelect();
	boolean isSelect();
	void paint(Graphics graphics);
}
Demo
package com.wl.composite;

import com.wl.composite.editor.ImageEditor;
import com.wl.composite.shapes.Circle;
import com.wl.composite.shapes.CompoundShape;
import com.wl.composite.shapes.Dot;
import com.wl.composite.shapes.Rectangle;

import java.awt.*;

/**
 * @author WL
 * @description: 测试
 * @date 2021/9/6 14:39
 */
public class Demo {
	public static void main(String[] args) {
		ImageEditor editor = new ImageEditor();
		editor.loadShapes(
				new Circle(10,10,10, Color.blue),
				new CompoundShape(
						new Circle(110,110,50,Color.RED),
						new Dot(160,160,Color.red)
				),
				new CompoundShape(
						new Rectangle(250,250,100,100,Color.GREEN),
						new Dot(240,240,Color.GREEN),
						new Dot(240,360,Color.GREEN),
						new Dot(360,360,Color.GREEN),
						new Dot(360,240,Color.GREEN)
				)
		);
	}
}
warehouse_mouse
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
24种设计模式以及混合设计模式
11-09
24中设计模式 混合设计模式 设计模式实际应用案例 费了很多时间和精力整理的
设计模式 - 混合使用
qq_39552758的博客
11-24 391
IF-ELSE 写法 String noDesign() { String name = "张三"; if (name.equals("张三")) { // 业务逻辑B return "张三完成任务BBB"; } else if (name.equals("李四")) { // 业务逻辑B return "李四完成任务BBB"; } else if (name.equals("王五")) { // 业务逻辑B return "王五完成任务BBB
Java 设计模式之【组合】学习与掌握
活在当下！输出快乐！
11-01 135
文章目录定义优点缺点组合模式的结构与实现模式的结构模式的实现应用场景 定义 将对象组合成树状层次结构，使用户对单个对象和组合对象具有一致的访问性。 组合模式一般用来描述整体与部分的关系，它将对象组织到树形结构中，顶层的节点被称为根节点，根节点下面可以包含树枝节点和叶子节点，树枝节点下面又可以包含树枝节点和叶子节点 #mermaid-svg-mNbznDSDAYofUiPR .label{font-family:'trebuchet ms', verdana, arial;font-family:va
设计模式之组合模式（Java实现）
qq_46234643的博客
06-15 284
组合模式
Java设计模式-结构型模式设计模式-组合模式
Fatter$hday的博客
05-31 449
Java设计模式-结构型模式设计模式-组合模式
《java设计模式》课后习题模拟试题解答——刘伟.zip
12-26
本资料“《java设计模式》课后习题模拟试题解答——刘伟.zip”主要涵盖了Java设计模式的学习与应用，特别是针对刘伟教授的相关课程的课后习题及模拟试题的解答。 设计模式分为三大类：创建型、结构型和行为型模式。...
JAVA设计模式学习10——组合模式
04-21
总之，JAVA设计模式中的组合模式提供了一种优雅的方式来处理对象的树形结构，使得我们可以在处理单个对象和整个集合时保持代码的简洁和一致性。通过理解和熟练运用这种模式，开发者可以更好地设计和维护复杂的软件...
设计模式——建造者模式
08-15
建造者模式是一种结构型设计模式，它允许我们分步骤创建复杂对象，而无需暴露构建过程的内部细节。这种模式在Java编程中非常常见，尤其是在处理需要多种构建方式或需要隔离对象构造过程的场景。 建造者模式的核心...
《Java设计模式》刘伟 课后习题及模拟试题答案.rar
08-24
《Java设计模式》是刘伟老师的一本经典教材，它深入浅出地讲解了软件设计中的重要概念——设计模式。设计模式是经验丰富的开发者在解决常见问题时总结出的通用解决方案，是软件开发中的智慧结晶。这本书的课后习题和...
Java设计模式之组合模式(UML类图分析+代码详解)
m0_51750419的博客
10-13 2933
组合模式（Composite Pattern），又叫部分整体模式，它创建了对象组的树形结 构，将对象组合成树状结构以表示“整体-部分”的层次关系。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式。组合模式使得用户对单个对象和组合对象的访问具有一致性，即：组合能让客 户以一致的方式处理个别对象以及组合对象组合模式原理类图Composite是管理者，叶子结点Leaf是被管理者。
Java实现分组汇总
清风
01-29 1674
//数据 ArrayList<Main02> list = new ArrayList(); list.add(new Main02("0001","202001",new BigDecimal(10))); list.add(new Main02("0003","202001",new BigDecimal(30))); list.add(new Main02("0003","202001",new BigDeci...
设计模式的混合使用
weixin_45613955的博客
01-14 2671
设计模式的混合使用
Java 中的组合
Draper的博客
12-04 1799
写在前面在 Java 中，复用代码有两种方法分别是组合和继承，两种方式可以减少我们写代码的工作。 组合 在新类中创建现有类的对象，由于新类是由现有类的对象所组成，所以被称为组合 继承 以现有类的的类型来创建心累，无需改变现有类的形式并在其中添加新的代码 而在一些场合中使用组合相较于继承将会更加的灵活
java/web/springboot数据修改历史记录设计
天空之城的博客
10-12 2287
java/web/springboot数据修改历史记录设计 在一些领域，记录数据的变更历史是非常重要的。比如人力资源系统… 需要记录个人的成长历史。再比如一些非常注重安全的系统，希望在必要时可以对所有的历史操作追根溯源，有据可查。 1.前言 比如，修改一个人的姓名从“张三”变为了“李四”，那么在进行记录的时候，记录的信息可能如下： 姓名：（张三）=>（李四）； 1 这样就很好的体现出了修改了哪个字段，修改前后的数据分别是什么。 关键的信息无论怎么修改都会有据可查，时间、人物、修改数据前后信息等。 2
[原创]JAVA中的组合设计模式
csdn785029689的博客
03-26 118
到百度搜了一下，发现讲JAVA中的组合模式不少，但是发现基本都是代码讲解，说不清楚组合模式的真正意思，正好趁这段时间没什么事情，把书上说的结合自己的观点给大家用文字来说明一下。如果有不足之处还请大家给出意见。下面就开始讲讲JAV...
花了30天才肝出来，史上最全面Java设计模式总结，看完再也不会忘
Tom弹架构
11-26 3729
本文所有内容均节选自《设计模式就该这样学》 序言 Design Patterns: Elements of Reusable Object-Oriented Software（以下简称《设计模式》），一书由Erich Gamma、Richard Helm、Ralph Johnson和John Vlissides合著（Addison-Wesley，1995）。这四位作者常被称为“四人组（Gang of Four）”，而这本书也就被称为“四人组（或 GoF）”书。他们首次给我们总结出一套软件开发可以反复.
java实现分组
ranAge_miao的博客
06-23 1880
public class GroupBy { public static void main(String[] args) { List> data= new ArrayList>(); Map map = new HashMap(); map.put("hostDepartmentName", "综合部"); map.put("contractCode", "KG12
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 561
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
《看小说学设计模式》——Java设计模式解析
"看小说学设计模式pdf版" 是一本以轻松的小故事方式解释Java设计模式的书籍，适合不同层次的开发者，从初级到高级，甚至系统分析师都能从中获益。书中涵盖了25种常见的设计模式，包括策略模式、代理模式、单例模式等...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值