搜索
搜索

如何在Java中实现复合模式？

Peter Minesu 发表于 Dev
57
彼得·米内苏（Peter Minesu）

我想实现一个复合模式Java，以便映射一个软件开发组织。因此，假设有多个项目经理和多个开发人员。每个开发人员仅分配给一个项目经理，并且每个开发人员都可以使用各种编程语言进行编码。项目经理带领开发人员，并确切地知道他们的工作量。

我对这种设计模式不是百分百确定，但是我认为这是此方案的完美用例，不是吗？

结果应如下所示：

我想查询项目经理，以检查所有能够使用特定编程语言（例如）进行编码的开发人员的工作量Java。

这是我到目前为止的内容：

Employee.java：

public class Employee {

    private String name = null;

    public Employee() {
        name = "Noob";
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

ProgrammingLanguages.java：

public enum ProgrammingLanguages {
    JAVA,
    JAVASCRIPT,
    C,
    PHP,
    SWIFT,
    PYTHON
}

ProjectManager.java：

import java.util.ArrayList;
import java.util.List;

public class ProjectManager extends Employee {

private List<Employee> employeeList = null;

public ProjectManager() {
    employeeList = new ArrayList<Employee>();
}

public List<Employee> getEmployees() {
    return employeeList;
}

public void setEmployees(List<Employee> employees) {
    employeeList = employees;
}

public int getTotalWorkload() {
    int workload = 0;
    for (Employee employee : employeeList) {
        workload += employee.getWorkload(); // Error! Cannot resolve method 'getWorkload()'
    }
    return workload;
}
}

开发商：

import java.util.ArrayList;
import java.util.List;

public class Developer extends Employee {

private List<ProgrammingLanguages> languagesList = null;

private int workload = 0;

public Developer() {
    languagesList = new ArrayList<ProgrammingLanguages>();
}

public void setLanguagesList(List<ProgrammingLanguages> languagesList) {
    this.languagesList = languagesList;
}

public void addProgrammingLanguage(ProgrammingLanguages language) {
    languagesList.add(language);
}

public List<ProgrammingLanguages> getLanguagesList() {
    return languagesList;
}

public void setWorkload(int workload) {
    this.workload = workload;
}

public int getWorkload() {
    return workload;
}

}

不幸的是，我在ProjectManager类中遇到了一个编译器错误，为什么？

提前致谢。

马蒂亚斯·埃克哈特（Matthias A. Eckhart）

是的，如果要映射树结构，则复合模式确实是正确的选择。参考您的示例，复合设计模式意味着您的类Employee充当节点，该类ProjectManager充当分支，该类Developer充当叶子。在这种情况下，合成图案的主要优点是可以均匀地处理合成对象。结果，您可以使用此特定的GoF设计模式来表示实例的整个层次结构。

您需要以下参与者：

  1. 的abstract类Employee必须声明组合物的界面和实现公共行为在一定程度上。
  2. 本ProjectManager类扩展abstract类Employee并实现了行为治疗Employee，你的情况的孩子，IDProjectManager或Developer实例。
  3. 该Developer还扩展了abstract类Employee，并且表示没有任何孩子一片叶子。

我使用您的示例代码来演示复合模式。请注意，它可能与您期望的结果有所不同，但是您可以将其作为参考。

Employee.java （节点）：

package me.eckhart;

import java.util.List;

public abstract class Employee {

    private String name = null;
    public static final String OPERATION_NOT_SUPPORTED = "Operation not supported.";

    public String getName() {
        return name;
    }

    public Employee setName(String name) {
        if (name == null) throw new IllegalArgumentException("Argument 'name' is null.");
        this.name = name;
        return this;
    }

    public Employee addEmployee(Employee employee) {
        throw new UnsupportedOperationException(OPERATION_NOT_SUPPORTED);
    }

    public List<Employee> getEmployees() {
        throw new UnsupportedOperationException(OPERATION_NOT_SUPPORTED);
    }

    public Employee setEmployees(List<Employee> employees) {
        throw new UnsupportedOperationException(OPERATION_NOT_SUPPORTED);
    }

    public Employee setLanguagesList(List<ProgrammingLanguages> languagesList) {
        throw new UnsupportedOperationException(OPERATION_NOT_SUPPORTED);
    }

    public Employee addProgrammingLanguage(ProgrammingLanguages language) {
        throw new UnsupportedOperationException(OPERATION_NOT_SUPPORTED);
    }

    public List<ProgrammingLanguages> getLanguagesList() {
        throw new UnsupportedOperationException(OPERATION_NOT_SUPPORTED);
    }

    /* Composite operations. */

    public abstract int getWorkload(ProgrammingLanguages language);

    public abstract Employee setWorkload(int workload);

}

ProjectManager.java （分支）：

package me.eckhart;

import java.util.ArrayList;
import java.util.List;

public class ProjectManager extends Employee {

    private List<Employee> employeeList = null;

    public ProjectManager() {
        this.employeeList = new ArrayList<>();
    }

    @Override
    public Employee addEmployee(Employee employee) {
        if (employee == null) throw new IllegalArgumentException("Argument 'employee' is null.");
        this.employeeList.add(employee);
        return this;
    }

    @Override
    public List<Employee> getEmployees() {
        return this.employeeList;
    }

    @Override
    public Employee setEmployees(List<Employee> employeeList) {
        if (employeeList == null) throw new IllegalArgumentException("Argument 'employeeList' is null.");
        this.employeeList = employeeList;
        return this;
    }

    /* Composite operations. */

    public int getWorkload(ProgrammingLanguages language) {
        int workload = 0;
        for (Employee employee : employeeList) {
            workload += employee.getWorkload(language);
        }
        return workload;
    }

    public Employee setWorkload(int workload) {
        throw new UnsupportedOperationException(Employee.OPERATION_NOT_SUPPORTED);
    }

}

Developer.java （叶子）：

package me.eckhart;

import java.util.ArrayList;
import java.util.List;

public class Developer extends Employee {

    private List<ProgrammingLanguages> languagesList = null;

    private int workload = 0;

    public Developer() {
        this.languagesList = new ArrayList<>();
    }

    @Override
    public Employee setLanguagesList(List<ProgrammingLanguages> languagesList) {
        this.languagesList = languagesList;
        return this;
    }

    @Override
    public Employee addProgrammingLanguage(ProgrammingLanguages language) {
        this.languagesList.add(language);
        return this;
    }

    @Override
    public List<ProgrammingLanguages> getLanguagesList() {
        return this.languagesList;
    }

    /* Composite operations. */

    public Employee setWorkload(int workload) {
        if (workload < -1) throw new IllegalArgumentException("Workload cannot be negative.");
        this.workload = workload;
        return this;
    }

    public int getWorkload(ProgrammingLanguages language) {
        if (this.languagesList.contains(language)) return workload;
        return 0;
    }

}

ProgrammingLanguages.java （枚举）：

package me.eckhart;

public enum ProgrammingLanguages {
    JAVA,
    JAVASCRIPT,
    C,
    PHP,
    SWIFT,
    PYTHON
}

我创建了一个单元测试，以演示如何访问一种特定编程语言的工作负载。

EmployeeTest.java （JUnit 4.11）：

package me.eckhart;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

public class EmployeeTest {

    protected Employee projectManagerIt;

    @Before
    public void setUp() throws Exception {

        Employee webDevSr = new Developer();
        webDevSr.setName("Jane").addProgrammingLanguage(ProgrammingLanguages.JAVASCRIPT).addProgrammingLanguage(ProgrammingLanguages.PYTHON).setWorkload(10);
        Employee webDevJr = new Developer();
        webDevJr.setName("Alex").addProgrammingLanguage(ProgrammingLanguages.PHP).setWorkload(15);
        Employee projectManagerWebDev = new ProjectManager();
        projectManagerWebDev.setName("James").addEmployee(webDevSr).addEmployee(webDevJr);

        Employee softwareDevSr = new Developer();
        softwareDevSr.setName("Martin").addProgrammingLanguage(ProgrammingLanguages.C).addProgrammingLanguage(ProgrammingLanguages.JAVA).setWorkload(35);
        Employee softwareDevJr = new Developer();
        softwareDevJr.setName("John").addProgrammingLanguage(ProgrammingLanguages.JAVA).setWorkload(30);
        Employee projectManagerBackend = new ProjectManager();
        projectManagerBackend.setName("Tom").addEmployee(softwareDevSr).addEmployee(softwareDevJr);

        Employee freelanceSoftwareDev = new Developer();
        freelanceSoftwareDev.setName("Marco").addProgrammingLanguage(ProgrammingLanguages.JAVA).addProgrammingLanguage(ProgrammingLanguages.PYTHON).addProgrammingLanguage(ProgrammingLanguages.C).setWorkload(25);
        Employee freelanceWebDev = new Developer();
        freelanceWebDev.setName("Claudio").addProgrammingLanguage(ProgrammingLanguages.SWIFT).addProgrammingLanguage(ProgrammingLanguages.JAVASCRIPT).addProgrammingLanguage(ProgrammingLanguages.PHP).setWorkload(10);
        Employee freelanceProjectManager = new ProjectManager();
        freelanceProjectManager.setName("Angie").addEmployee(freelanceSoftwareDev).addEmployee(freelanceWebDev);

        projectManagerIt = new ProjectManager();
        projectManagerIt.setName("Peter").addEmployee(projectManagerWebDev).addEmployee(projectManagerBackend).addEmployee(freelanceProjectManager);

    }

    @Test
    public void testComposite() throws Exception {

        Assert.assertEquals(90, projectManagerIt.getWorkload(ProgrammingLanguages.JAVA));
        Assert.assertEquals(20, projectManagerIt.getWorkload(ProgrammingLanguages.JAVASCRIPT));
        Assert.assertEquals(60, projectManagerIt.getWorkload(ProgrammingLanguages.C));
        Assert.assertEquals(25, projectManagerIt.getWorkload(ProgrammingLanguages.PHP));
        Assert.assertEquals(10, projectManagerIt.getWorkload(ProgrammingLanguages.SWIFT));
        Assert.assertEquals(35, projectManagerIt.getWorkload(ProgrammingLanguages.PYTHON));

    }
}

UML类图如下所示：

UML_class_diagram_composite_design_pattern_GoF

setUp()方法中的代码EmployeeTest.java实现以下树结构：

Tree_structure_Composite_Pattern

组合设计模式的主要缺点是，您需要通过运行时检查来限制某些操作，因为客户端通常不知道他们是在处理ProjectManager（分支Developer）实例还是（叶子）实例。

本文收集自互联网，转载请注明来源。

如有侵权，请联系 [email protected] 删除。

编辑于
0

我来说两句

0 条评论
登录 后参与评论

相关文章

如何在Rails中实现复合主键

如何在Java中实现已检查的构建器模式

如何在Java 8中实现构建器模式？

如何在C ++中实现这种模式？

如何在Go中实现策略模式？

如何在Kotlin中实现Builder模式？

如何在SFSafariViewController中实现隐身模式

如何在sails中实现MVC模式？

如何在Java中实现可插拔适配器设计模式

如何在anyMatch（）Java 8流中应用复合BiPredicate

如何在PostgreSQL中实现多个嵌套复合类型的层次结构？

不确定如何在使用复合键的Spring Boot应用程序中实现serializble

如何在C ++中为复合容器类实现迭代器

如何在Java中使用泛型实现工厂模式？

如何在 Laravel 中实现存储库模式

如何在Kotlin中实现模板方法设计模式？

如何在Polymer 1.0中实现MVC模式？

如何在C＃中实现此模式

如何在Rust中实现观察者模式？

如何在 Rust 中实现 MongoDB 模式和业务逻辑？

如何在解析中实现Likes Post模式

如何在javascript中实现Decorator Design模式？

如何在 Cosmos DB 中实现发件箱模式

如何在Scala中实现懒链模式

如何在Solidity中实现自毁模式？

如何在Node JS中实现此模式？

如何在异步方法中实现InvokeRequired UI模式？

如何在.NET中实现正确的存储库模式

如何在 WPF 文本框中实现 (*) 符号模式

TOP 榜单

  1. 1

    隐藏发件人没有短信PHP

  2. 2

    材质UI垂直滑块。如何改变在垂直材料UI滑块导轨的厚度（反应）

  3. 3

    在Windows 7中无法删除文件（2）

  4. 4

    HttpClient中的角度变化检测

  5. 5

    Azure VM启动/停止日志

  6. 6

    如何在 Vb.net 中使用函数返回多个值

  7. 7

    Powerpoint-条形长度错误的堆积条形图

  8. 8

    最新歌剧断断续续的快速拨号和渲染错误

  9. 9

    Mac OS X更新后的GRUB 2问题

  10. 10

    需要公式以vlookup逗号分隔单个单元格中的值

  11. 11

    Hashchange事件侦听器在将事件处理程序附加到事件之前进行侦听

  12. 12

    ggplot：对齐多个分面图-所有大小不同的分面

  13. 13

    OS X-为什么我需要打开WiFi才能确定最近的位置

  14. 14

    用日期数据透视表和日期顺序查询

  15. 15

    Java Eclipse中的错误13，如何解决？

  16. 16

    如何在Django中使用UUID

  17. 17

    加载Microsoft Visual菜单时出现问题

  18. 18

    具有if条件的SQL UPDATE

  19. 19

    从JSON到JSONL的Python转换

  20. 20

    如何在Kod中更改字体？

  21. 21

    共享图像将路径放入地址

热门标签

归档