组合在 Java 中的实现

最新推荐文章于 2024-08-21 15:17:10 发布
最新推荐文章于 2024-08-21 15:17:10 发布
阅读量489 收藏 1
点赞数
文章标签： 设计模式
原文链接：https://refactoringguru.cn/design-patterns/composite/java/example
版权

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

对于绝大多数需要生成树状结构的问题来说， 组合都是非常受欢迎的解决方案。 组合最主要的功能是在整个树状结构上递归调用方法并对结果进行汇总。

在 Java 中使用模式

复杂度：⭐⭐

流行度：⭐⭐

使用实例： 组合模式在 Java 代码中很常见,常用于表示与图形打交道的用户界面组件或代码的层次结构。

下面是一些来自 Java 标准程序库中的组合示例：

识别方法： 组合可以通过将同一抽象或接口类型的实例放入树状结构的行为方法来轻松识别。

shapes

 shapes/Shape.java: 通用形状接口

package refactoring_guru.composite.example.shapes;

import java.awt.*;

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 isSelected();
    void paint(Graphics graphics);
}

 shapes/BaseShape.java: 提供基本功能的抽象形状

package refactoring_guru.composite.example.shapes;

import java.awt.*;

abstract class BaseShape implements Shape {
    public int x;
    public int y;
    public Color color;
    private boolean selected = 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() {
        selected = true;
    }

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

    @Override
    public boolean isSelected() {
        return selected;
    }

    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 (isSelected()) {
            enableSelectionStyle(graphics);
        }
        else {
            disableSelectionStyle(graphics);
        }

        // ...
    }
}

 shapes/Dot.java: 点

package refactoring_guru.composite.example.shapes;

import java.awt.*;

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());
    }
}

 shapes/Circle.java: 圆形

package refactoring_guru.composite.example.shapes;

import java.awt.*;

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;
    }

    public void paint(Graphics graphics) {
        super.paint(graphics);
        graphics.drawOval(x, y, getWidth() - 1, getHeight() - 1);
    }
}

 shapes/Rectangle.java: 三角形

package refactoring_guru.composite.example.shapes;

import java.awt.*;

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.width = width;
        this.height = height;
    }

    @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);
    }
}

 shapes/CompoundShape.java: 由其他形状对象组成的复合形状

package refactoring_guru.composite.example.shapes;

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

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 childsRelativeX = child.getX() - x;
            int childWidth = childsRelativeX + child.getWidth();
            if (childWidth > maxWidth) {
                maxWidth = childWidth;
            }
        }
        return maxWidth;
    }

    @Override
    public int getHeight() {
        int maxHeight = 0;
        int y = getY();
        for (Shape child : children) {
            int childsRelativeY = child.getY() - y;
            int childHeight = childsRelativeY + 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 (isSelected()) {
            enableSelectionStyle(graphics);
            graphics.drawRect(getX() - 1, getY() - 1, getWidth() + 1, getHeight() + 1);
            disableSelectionStyle(graphics);
        }

        for (refactoring_guru.composite.example.shapes.Shape child : children) {
            child.paint(graphics);
        }
    }
}

 editor

 editor/ImageEditor.java: 形状编辑器

package refactoring_guru.composite.example.editor;

import refactoring_guru.composite.example.shapes.CompoundShape;
import refactoring_guru.composite.example.shapes.Shape;

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

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);
        }

        public int getWidth() {
            return allShapes.getX() + allShapes.getWidth() + PADDING;
        }

        public int getHeight() {
            return allShapes.getY() + allShapes.getHeight() + PADDING;
        }

        void refresh() {
            this.setSize(getWidth(), getHeight());
            frame.pack();
        }

        public void paint(Graphics graphics) {
            allShapes.paint(graphics);
        }
    }
}

 Demo.java: 客户端代码

package refactoring_guru.composite.example;

import refactoring_guru.composite.example.editor.ImageEditor;
import refactoring_guru.composite.example.shapes.Circle;
import refactoring_guru.composite.example.shapes.CompoundShape;
import refactoring_guru.composite.example.shapes.Dot;
import refactoring_guru.composite.example.shapes.Rectangle;

import java.awt.*;

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)
                )
        );
    }
}

 OutputDemo.png: 执行结果

dingpeiqiang
关注
组合（Java实现）
a754112602的博客
07-19 2444
题目： 求解n个元素的组成的大小为m的组合 思路： 假设我们想在长度为n的字符串中求m个字符的组合。 我们先从头扫描字符串的第一个字符。 针对第一个字符，我们有两种选择： 一是把这个字符放到组合中去，接下来我们需要在剩下的n-1个字符中选取m-1个字符； 二是不把这个字符放到组合中去，接下来我们需要在剩下的n-1个字符中选择m个字符。这两种选择都很容易用递归实现。 思路讲完了，直接...
java 实现组合_用Java实现排列、组合算法
weixin_42360703的博客
02-12 1772
组合个数的计算公式如下：那么，计算排列或组合的数量，通过上面的公式就很容易就算出来了，其Java的实现如下：/*** 计算阶乘数，即n! = n * (n-1) * ... * 2 * 1* @param n* @return*/private static long factorial(int n) {return (n > 1) ? n * factorial(n - 1) : 1;}/...
Java排列组合算法分析和代码实现
10-02
本资源附带文档解释了排列组合算法的实现和原理。其中排列算法是基于递归实现的，组合算法是基于高效的位移法实现的。代码是使用Java版实现的。
java 组合代码_java实现Composite组合模式的实例代码
weixin_39704727的博客
02-16 161
//20210121写在前面：刚期末考试完，考了面向对象，里边儿有23个设计模式，我寻思着考完挨个儿实现一下，本文实现组合模式组合模式核心思想类似文件夹的概念，构件树形结构，树形有叶子结点和文件夹结点，文件夹结点可以包含叶子结点和文件夹结点分为两种模式- 透明型：所有节点构造全部相同，但是由于叶子结点没有下层结点，所以其有些方法为空，会不安全- 安全型：叶子结点和文件架节点构造不同，这样展示的时候...
用Java实现排列、组合算法
最新发布
杨海吉
08-21 173
2、有时候，我们不仅需要知道排列或组合的数量，而且需要知道有哪些排列或组合，并列举出所有的排列或组合，人工列举工作量大而且容易出错，那么，如何利用计算机帮忙列举出所有的这些排列或组合呢？那么，计算排列或组合的数量，通过上面的公式就很容易就算出来了，其Java的实现如下。经验证，输出的结果正确，同预期结果相符。（1）完整的测试代码如下。
java组合 合_组合（Java实现）
weixin_28837817的博客
02-20 535
题目：求解n个元素的组成的大小为m的组合思路：假设我们想在长度为n的字符串中求m个字符的组合。我们先从头扫描字符串的第一个字符。针对第一个字符，我们有两种选择：一是把这个字符放到组合中去，接下来我们需要在剩下的n-1个字符中选取m-1个字符；二是不把这个字符放到组合中去，接下来我们需要在剩下的n-1个字符中选择m个字符。这两种选择都很容易用递归实现。思路讲完了，直接上代码：public stati...
组合模式的Java实现
Young's Blog
08-31 786
组合模式composite 把部分和整体的关系用树形结构来表示，从而使客户端可以统一的方式处理部分对象和整体对象 组合模式核心： 抽象构建角色（component）：定义了叶子和容器构建的共同点 叶子构建角色（leaf）：无子节点 容器构建角色（composite）：有容器特征，可以包含子节点 注意：别将组合模式与继承中的组合混淆 组合模式工作流程分析： 1、组合模式为处理树形结构提供了完美的解决方案，描述了如何将容器和叶子进行递归组合，使得用户在使用时...
Java实现abc字符串排列组合
08-28
"Java实现abc字符串排列组合" 本文将详细介绍Java实现abc字符串的排列组合，主要包括可重复排列、全排列和组合三个部分。 可重复排列 在Java中，可以使用递归来实现abc字符串的可重复排列。可重复排列是指从abc三...
Java实现多个数组间的排列组合
08-28
在实际应用中，Java实现多个数组间的排列组合可以应用于各种领域，例如数据分析、机器学习、自然语言处理等。这些领域中，需要处理大量数据，并且这些数据之间存在复杂的关系，需要使用Java语言来实现这些关系。 ...
关于各种排列组合java算法实现方法
09-05
本文将探讨两种不同的Java实现方法，分别基于二进制状态法和递归思想，用于生成排列组合。 首先，我们来看第一种方法：**二进制状态法**。这种方法的核心思想是利用二进制数来表示每个排列，然后通过遍历所有可能的...
从n个数组中取出所有排列组合(Java实现)
05-22
这个Java实现会遍历所有可能的排列组合，并将结果存储在一个列表中。在实际应用中，可能需要对结果进行优化，例如使用Set避免重复，或者使用Stream API来简化代码。此外，对于大数据量的输入，还需要考虑性能优化，...
Java中类的组合概念
08-08
正所谓，道生一，一生二，二生三，三生万物，如果将二进制表示和运算看做一，将基本数据类型看做二，基本数据类型形成的类看做三，那么，类的组合以及下节介绍的继承则使得三生万物。
Java实现-组合
Narasimha_Karumanchi
06-17 245
组给出两个整数n和k，返回从1......n中选出的k个数的组合。 您在真实的面试中是否遇到过这个题？  Yes 样例 例如 n = 4 且 k = 2 返回的解为： [[2,4],[3,4],[2,3],[1,2],[1,3],[1,4]] public class Solution { /** * @param n:
【设计模式】用Java实现组合模式
分享Java硬核干货
06-30 9761
组合模式是一种结构型设计模式它允许将对象组合成树形结构以表示"部分-整体"的层次结构。这种模式能够让客户端统一对待单个对象和组合对象，使得用户在使用对象时不需要关心对象是单个还是组合的。在组合模式中，有两种主要的对象类型：叶节点（Leaf）和组合节点（Composite）。叶节点表示树结构中的最小单元，它们没有子节点。组合节点是由多个叶节点或其他组合节点组成的节点，它们可以包含子节点。需要表示对象的部分-整体层次结构：当对象具有树形结构，并且希望以统一的方式处理整体和部分时，可以使用组合模式。
java 实现组合_排列组合算法(JAVA实现)
weixin_33814002的博客
02-16 4205
组合算法实现从m个数里面取n个数的算法。最容易理解的就是递归，但是其效率太低。实现方法一：//组合算法//本程序的思路是开一个数组，其下标表示1到n个数，数组元素的值为1表示其下标//代表的数被选中，为0则没选中。//首先初始化，将数组前m个元素置1，表示第一个组合为前n个数。//然后从左到右扫描数组元素值的“10”组合，找到第一个“10”组合后将其变为//“01”组合，同时将其左边的...
java 实现 排列 组合
zqfddqr的专栏
02-06 917
import java.util.ArrayList; /** * * * permutation and combination * * @author Administrator */ public class Pac { Pac(String str) { this.str = str; } String str;//源字符串。
java组合_Java组合
weixin_36258891的博客
02-12 3284
java中的组合是在类中实现has-a关系的设计技术。可以在java中使用java继承或对象组合来重用代码。在Java编程中表现出来的就是：一个类使用另一个类作为它的成员。通过使用引用其他对象的实例变量来实现Java组合。例如，一个人(Person)有一份工作(Job)。看一下java组合示例代码。Java组合示例文件：Job.java// 工作类public class Job {private...
排列组合算法
qq_41250455的博客
09-14 428
import java.io.*; import java.util.Arrays; class test { /** * 计算阶乘数，即n! = n * (n-1) * ... * 2 * 1 */ private static long factorial(int n) { long sum = 1; while( n > 0 ) { sum = sum * n--; }
java组合
qq_24450637的博客
12-09 636
在一个新类的定义中使用其他对象---这就是组合(composition)。组合是在Java中实现程序复用(reusibility)的基本手段之一。 组合与"has-a" 一个对象是另一个对象的数据成员 class Battery {     public void chargeBattery(double p)     {         if (this.power
Java实现排列组合算法详解
"本资源主要讲解了如何使用Java实现排列组合算法，包括基于二进制状态法的两种不同实现，适用于理解和学习基本的排列组合计算。" 在编程中，排列组合是解决许多问题的基础，特别是在数据结构和算法领域。Java作为一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值