考勤系统有个子系统，叫加班子考勤系统。
我们不仅要支持多个系统，甚至还要支持子系统。
我们不能把加班考勤子系统加入到系统数组，因为类型不一样。
使用组合模式就可以解决这个问题
组合模式：允许你将对象组合成树形结构来表现“整体/部分”层次结构。
组合能让客户以一致的方式处理个别对象以及对象组合。
提供一个接口，让个别对象和对象组合共同使用，能够用统一的做法来处理个别对象和对象组合。
这样程序员就可以使用统一的做法来遍历人员和子系统。
package com.ez.biz;
import java.util.ArrayList;
import java.util.List;
import com.ez.SystemComponent;
/**
* @author 窗外赏雪（EZ编程网）
*/
public class Test {
public static void main(String[] args) {
SystemComponent ps = new PerformanceSystem();
SystemComponent ss = new SalarySystem();
SystemComponent as = new AttendanceSystem();
List<SystemComponent> applicationSystem=new ArrayList<SystemComponent>();
applicationSystem.add(ps);
applicationSystem.add(ss);
applicationSystem.add(as);
Programmer programmer = new Programmer(applicationSystem);
System.out.println("======列出所有系统的人员列表，包括子系统=====");
programmer.comparePeople();
}
}
package com.ez.biz;
import java.util.Iterator;
import java.util.List;
import com.ez.SystemComponent;
/**
* 程序员需要列出所有系统的人员信息
* @author 窗外赏雪（EZ编程网）
*/
public class Programmer {
private List<SystemComponent> systemComponent;
public Programmer(List<SystemComponent> systemComponent) {
this.systemComponent = systemComponent;
}
public void comparePeople() {
printPeople(systemComponent.iterator());
}
private void printPeople(Iterator<SystemComponent> iterator) {
while (iterator.hasNext()) {
SystemComponent systemComponent = (SystemComponent) iterator.next();
systemComponent.show();
}
}
}
package com.ez.biz;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import com.ez.ApplicationSystem;
import com.ez.SystemComponent;
/**
* 加班考勤子系统
* @author 窗外赏雪（EZ编程网）
*/
public class AttendanceChildSystem extends SystemComponent implements ApplicationSystem {
private List<SystemComponent> peoples;
private String name;
public AttendanceChildSystem() {
name="加班子考勤系统";
peoples=new ArrayList<SystemComponent>();
peoples.add(new People("李四",19,false));
peoples.add(new People("王五",24,true));
peoples.add(new People("赵六",13,false));
peoples.add(new People("孙七",42,false));
}
public Iterator<SystemComponent> createIterator(){
return peoples.iterator();
}
public String getName() {
return name;
}
@Override
public void show() {
System.out.println("======系统信息=====");
System.out.println("名称："+getName());
System.out.println("====================");
//把系统下面的所有人员信息show出来，如果还有子系统，会递归把所有子系统的人员信息show出来。
Iterator<SystemComponent> iterator=createIterator();
while(iterator.hasNext()){
SystemComponent systemComponent=iterator.next();
systemComponent.show();
}
}
}
package com.ez.biz;
import java.util.Hashtable;
import java.util.Iterator;
import com.ez.ApplicationSystem;
import com.ez.SystemComponent;
/**
* 考勤系统包含员工列表和加班考勤子系统。
* @author 窗外赏雪（EZ编程网）
*/
public class AttendanceSystem extends SystemComponent implements ApplicationSystem{
private Hashtable<String,SystemComponent> peoples;
private String name;
public AttendanceSystem() {
name="考勤系统";
peoples=new Hashtable<String,SystemComponent>();
peoples.put("李四",new People("李四",19,false));
peoples.put("王五",new People("王五",24,true));
peoples.put("赵六",new People("赵六",13,false));
peoples.put("孙七",new People("孙七",42,false));
//考勤系统有个子系统
peoples.put("加班子考勤系统", new AttendanceChildSystem());
}
public Iterator<SystemComponent> createIterator(){
return peoples.values().iterator();
}
public String getName() {
return name;
}
@Override
public void show() {
System.out.println("======系统信息=====");
System.out.println("名称："+getName());
System.out.println("====================");
//把系统下面的所有人员信息show出来，如果还有子系统，会递归把所有子系统的人员信息show出来。
Iterator<SystemComponent> iterator=createIterator();
while(iterator.hasNext()){
SystemComponent systemComponent=iterator.next();
systemComponent.show();
}
}
}
package com.ez.biz;
import java.util.Iterator;
import com.ez.ApplicationSystem;
import com.ez.SystemComponent;
import com.ez.impl.ArrayIterator;
/**
* 绩效系统
* 实现创建迭代器，返回数组迭代器。
* SystemComponent可以是人员，也可以是系统。
* @author 窗外赏雪（EZ编程网）
*/
public class PerformanceSystem extends SystemComponent implements ApplicationSystem{
static final int MAX_COUNT=10;
private SystemComponent[] peoples;
private String name;
public PerformanceSystem() {
name="绩效系统";
peoples=new SystemComponent[MAX_COUNT];
peoples[0]=new People("李四",19,false);
peoples[1]=new People("王五",24,true);
peoples[2]=new People("赵六",13,false);
peoples[3]=new People("孙七",42,false);
}
public Iterator<SystemComponent> createIterator(){
return new ArrayIterator<SystemComponent>(peoples);
}
public String getName() {
return name;
}
@Override
public void show() {
System.out.println("======系统信息=======");
System.out.println("名称："+getName());
System.out.println("====================");
//把系统下面的所有人员信息show出来，如果还有子系统，会递归把所有子系统的人员信息show出来。
Iterator<SystemComponent> iterator=createIterator();
while(iterator.hasNext()){
SystemComponent systemComponent=iterator.next();
systemComponent.show();
}
}
}
package com.ez.biz;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import com.ez.ApplicationSystem;
import com.ez.SystemComponent;
/**
* 工资系统
* SystemComponent可以是人员，也可以是系统。
* @author 窗外赏雪（EZ编程网）
*/
public class SalarySystem extends SystemComponent implements ApplicationSystem{
private List<SystemComponent> peoples;
private String name;
public SalarySystem() {
name="工资系统";
peoples=new ArrayList<SystemComponent>();
peoples.add(new People("李四",19,false));
peoples.add(new People("王五",24,true));
peoples.add(new People("赵六",13,false));
peoples.add(new People("孙七",42,false));
}
public Iterator<SystemComponent> createIterator(){
return peoples.iterator();
}
public String getName() {
return name;
}
@Override
public void show() {
System.out.println("======系统信息=====");
System.out.println("名称："+getName());
System.out.println("====================");
//把系统下面的所有人员信息show出来，如果还有子系统，会递归把所有子系统的人员信息show出来。
Iterator<SystemComponent> iterator=createIterator();
while(iterator.hasNext()){
SystemComponent systemComponent=iterator.next();
systemComponent.show();
}
}
}
package com.ez.biz;
import com.ez.SystemComponent;
/**
* @author 窗外赏雪（EZ编程网）
*/
public class People extends SystemComponent{
private String name;
private int age;
private boolean partyMember;
public String getName() {
return name;
}
public int getAge() {
return age;
}
public boolean isPartyMember() {
return partyMember;
}
public People(String name, int age, boolean partyMember) {
this.name = name;
this.age = age;
this.partyMember=partyMember;
}
public void show(){
System.out.println("**********人员信息**********");
System.out.println("姓名："+getName()+" ，年龄："+getAge());
if(isPartyMember()){
System.out.println("是否党员：是");
}else{
System.out.println("是否党员：否");
}
}
}
package com.ez;
/**
* 让个别对象和对象组合共同使用，能够用统一的做法来处理个别对象和对象组合。
* SystemComponent可以是人员，也可以是系统。
* @author 窗外赏雪（EZ编程网）
*/
public abstract class SystemComponent {
public void show(){
throw new UnsupportedOperationException();
}
public String getName() {
throw new UnsupportedOperationException();
}
public int getAge() {
throw new UnsupportedOperationException();
}
public boolean isPartyMember() {
throw new UnsupportedOperationException();
}
}
package com.ez;
import java.util.Iterator;
/**
* 使用迭代器系统接口
* @author 窗外赏雪（EZ编程网）
*/
public interface ApplicationSystem {
Iterator<SystemComponent> createIterator();
}
package com.ez.impl;
import java.util.Iterator;
/**
* 专门用于迭代数组类型，实现java.util的迭代器接口。
* @author 窗外赏雪（EZ编程网）
* @param <T>
*/
public class ArrayIterator<T> implements Iterator<T> {
private T[] peoples;
private int position = 0;
public ArrayIterator(T[] peoples) {
this.peoples = peoples;
}
@Override
public boolean hasNext() {
if (position >= peoples.length || peoples[position] == null) {
return false;
} else {
return true;
}
}
@Override
public T next() {
T people = peoples[position];
position++;
return people;
}
@Override
public void remove() {
}
}
相关推荐
组合模式是一种对象结构型设计模式，它允许我们创建表示部分-整体层次结构的树形对象。在空军指挥系统中，这种模式的应用可以帮助我们构建一个灵活、可扩展的组织架构，其中每个部分（如飞机、飞行编队或基地）都...
java常用设计模式-组合模式 组合模式（Composite Pattern）是一种结构型设计模式，它允许你将对象组合成树形结构以表示“部分-整体”的层次结构。这种模式使得客户端可以统一对待单个对象和对象组合。在组合模式中...
组合模式是一种对象结构型设计模式，它允许我们以树形结构来表示部分-整体关系，使得我们可以像处理单个对象一样处理整个集合。在五子棋游戏的实现中，组合模式的应用尤为关键，因为它帮助我们将棋盘上的棋子和棋盘...
### 设计模式实验报告——组合模式 #### 实验目的与背景 本次实验旨在通过实践学习设计模式中的组合模式，理解其工作原理及应用场景。组合模式（Composite Pattern）是一种结构型设计模式，它允许用户将对象组合成...
组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的...
组合模式是一种软件设计模式，属于结构型模式，它允许我们以树形结构来表示部分与整体的关系，使得我们可以像处理单个对象一样处理整个集合。在iOS开发中，这种模式非常有用，特别是在处理数据结构或者UI组件时，...
组合模式是一种设计模式，它属于结构型模式，主要目的是为了将对象组织成树形结构，使得用户可以统一地处理单个对象和对象集合。在Java中，组合模式可以帮助我们实现部分与整体的层次结构，使得客户端代码可以一致地...
组合模式是一种行为设计模式，属于面向对象设计中的结构型模式，其主要目的是为了建立一种对象树形结构，这种结构能够使客户端代码以统一的方式处理单个对象和对象的组合。在组合模式中，我们通常会定义一个基类，...
组合模式是一种设计模式，它将对象组织成树形结构，使得用户可以统一处理单个对象和对象集合。在本实验中，我们将深入探讨组合模式的原理、实现方式以及其在实际编程中的应用。 首先，我们要理解组合模式的核心概念...
在这个主题中，我们主要探讨了如何利用组合模式（Composite Pattern）构建二叉树，并通过迭代器模式（Iterator Pattern）来实现对树的遍历，包括前序、中序和后序遍历。这些是设计模式中的经典应用，对于理解和掌握...
组合模式(Composite)，将对象组合成树形结构以表示‘部分－整体’的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。 组合模式的适用场合是，一般当你发现需求中是体现部分与整体层次的结构时，...
组合模式是一种结构型设计模式，它允许我们使用树形结构来表示部分-整体关系，使得我们能够像处理单个对象一样处理整个集合。在Java中，这种模式的应用可以帮助我们简化对复杂对象层次结构的操作，同时保持接口的...
组合模式是一种结构型设计模式，它允许我们使用树形结构来表示部分-整体关系，使得我们能够以统一的方式处理单个对象和对象集合。在C++中，组合模式的应用可以帮助我们构建灵活且易于操作的对象层次结构，使得客户端...
组合模式是一种结构型设计模式，它允许我们使用树形结构来表示部分与整体的关系，使得我们可以在统一的接口下处理单个对象和对象的组合。在C#中，这种模式常用于处理对象集合，尤其在文件系统、组织结构或者树形菜单...
组合模式是一种设计模式，属于结构型模式，它允许我们以统一的方式处理单个对象和对象集合。在C#中，组合模式的应用可以帮助我们构建树形结构，并以一致的方法处理叶子节点（基本元素）和树枝节点（包含其他节点的...
组合模式是一种设计模式，它将对象组织成树形结构，使得用户可以对单个对象和对象集合进行统一处理。在“最简单的实现组合模式”中，我们关注的是如何以最直观、最少依赖的方式体现这种模式的核心思想。 组合模式的...
使用组合模式有如下的好处： l 定义了饱含基本对象和组合对象的类层次结构,基本对象可以被组合成更复杂的组合对象，而这个组合对象有可以被组合。 简化客户代码 客户可以一直地使用组合结构和单个对象，通常用户不...
组合模式是一种结构型设计模式，它允许我们使用树形结构来表示部分与整体的关系，使得我们能够以统一的方式来处理单个对象和对象的组合。在组合模式中，单个对象和组合对象都被视为同一类型，这使得客户端代码可以对...
java设计模式【之】组合模式【源码】【场景：遍历目录树】 * 组合模式 * 将对象组合成树结构，表示 “部分与整体” 的关系 * 要求 部分与整体，具备相同的父类 * * 代码实现 * 输出当前目录下，全部目录层级...
**Android组合模式简单Demo** 在Android开发中，设计模式是一种重要的编程思想，它能帮助我们构建更加优雅、可维护的代码结构。其中，组合模式（Composite Pattern）是一种结构型设计模式，它允许我们以树形结构来...