圖解Java設計模式之組合模式
編寫程序展示一個學校院系結構 ：需求是這樣，要在一個頁面中展示出學校的院系組成，一個學校有多個學院，一個學院有多個系。如圖 ：
1）將學院看做是學校的子類，系是學院的子類，這樣實際上是站在組織大小來進行分層次的
2）實際上我們的要求是 ：在一個頁面中展示出學校的院系組成，一個學校有多個學院，一個學院有多個系，因此這種方案，不能很好實現管理操作，比如學院、系的添加，刪除，遍歷等
3）解決方案 ：把學校、院、系是都看做是組織結構，他們之間沒有繼承的關系，而是一個樹形結構，可以更好的實現管理操作。
1）組合模式（Composite Pattern），又叫部分整體模式，它創建了對象組的樹形結構，將對象組合成樹狀結構以表示“整體-部分”的層次關系
2）組合模式依據樹形結構來組合對象，用來表示部分以及整體層次
3）這種類型的設計模式屬於結構型模式
4）組合模式使得用戶對單個對象和組合對象的訪問具有一致性，即 ：組合能讓客戶以一致的方式處理個別對象以及組合對象。
1）Component ：這是組合中對象聲明接口，在適當情況下，實現所有類共有的接口默認行為，用於訪問和管理Component子部件，Component可以是抽象類或者接口
2）Leaf ：在組合中表示葉子節點，葉子節點沒有子節點
3）Composite ：非葉子節點，用於存儲子部件，在Component接口中實現子部件的相關操作，比如增加（add），刪除。
package com.example.demo.composite;
public abstract class OrganizationComponent {
/**
* 名字
*/
private String name;
/**
* 說明
*/
private String des;
protected void add(OrganizationComponent organizationComponent) {
// 默認實現
throw new UnsupportedOperationException();
}
protected void remove(OrganizationComponent organizationComponent) {
// 默認實現
throw new UnsupportedOperationException();
}
public OrganizationComponent(String name, String des) {
super();
this.name = name;
this.des = des;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDes() {
return des;
}
public void setDes(String des) {
this.des = des;
}
/**
* 方法print，做成抽象的，子類都需要實現
*/
protected abstract void print();
}
package com.example.demo.composite;
import java.util.ArrayList;
import java.util.List;
/**
* University 就是 Composite，可以管理College
* @author zhaozhaohai
*
*/
public class University extends OrganizationComponent{
/**
* 構造器
* @param name
* @param des
*/
public University(String name, String des) {
super(name, des);
// TODO Auto-generated constructor stub
}
private List<OrganizationComponent> organizationComponents = new ArrayList<>();
@Override
protected void add(OrganizationComponent organizationComponent) {
// TODO Auto-generated method stub
organizationComponents.add(organizationComponent);
}
@Override
protected void remove(OrganizationComponent organizationComponent) {
// TODO Auto-generated method stub
organizationComponents.remove(organizationComponent);
}
@Override
public String getName() {
// TODO Auto-generated method stub
return super.getName();
}
@Override
public String getDes() {
// TODO Auto-generated method stub
return super.getDes();
}
@Override
protected void print() {
// TODO Auto-generated method stub
System.out.println("-----------" + getName() + "-------------");
// 遍歷 organizationComponents
for (OrganizationComponent organizationComponent : organizationComponents) {
organizationComponent.print();
}
}
}
package com.example.demo.composite;
public class Department extends OrganizationComponent{
public Department(String name, String des) {
super(name, des);
// TODO Auto-generated constructor stub
}
// add,remove就不用寫了，因為他是葉子節點
@Override
public String getName() {
// TODO Auto-generated method stub
return super.getName();
}
@Override
public String getDes() {
// TODO Auto-generated method stub
return super.getDes();
}
@Override
protected void print() {
// TODO Auto-generated method stub
System.out.println(getName());
}
}
package com.example.demo.composite;
import java.util.ArrayList;
import java.util.List;
public class College extends OrganizationComponent{
/**
* 構造器
* @param name
* @param des
*/
public College(String name, String des) {
super(name, des);
// TODO Auto-generated constructor stub
}
private List<OrganizationComponent> organizationComponents = new ArrayList<>();
@Override
protected void add(OrganizationComponent organizationComponent) {
// TODO Auto-generated method stub
organizationComponents.add(organizationComponent);
}
@Override
protected void remove(OrganizationComponent organizationComponent) {
// TODO Auto-generated method stub
organizationComponents.remove(organizationComponent);
}
@Override
public String getName() {
// TODO Auto-generated method stub
return super.getName();
}
@Override
public String getDes() {
// TODO Auto-generated method stub
return super.getDes();
}
@Override
protected void print() {
// TODO Auto-generated method stub
System.out.println("-----------" + getName() + "-------------");
// 遍歷 organizationComponents
for (OrganizationComponent organizationComponent : organizationComponents) {
organizationComponent.print();
}
}
}
package com.example.demo.composite;
public class Client {
public static void main(String[] args) {
// TODO Auto-generated method stub
//從大到小創建對象 學校
OrganizationComponent university = new University("清華大學", " 中國頂級大學 ");
//創建 學院
OrganizationComponent computerCollege = new College("計算機學院", " 計算機學院 ");
OrganizationComponent infoEngineercollege = new College("信息工程學院", " 信息工程學院 ");
//創建各個學院下面的系(專業)
computerCollege.add(new Department("軟件工程", " 軟件工程不錯 "));
computerCollege.add(new Department("網絡工程", " 網絡工程不錯 "));
computerCollege.add(new Department("計算機科學與技術", " 計算機科學與技術是老牌的專業 "));
infoEngineercollege.add(new Department("通信工程", " 通信工程不好學 "));
infoEngineercollege.add(new Department("信息工程", " 信息工程好學 "));
//將學院加入到 學校
university.add(computerCollege);
university.add(infoEngineercollege);
university.print();
infoEngineercollege.print();
}
}
說明 ：
1）Map就是一個抽象的構建（類似Component）
2）HashMap是一個中間的構建（Composite），實現/繼承了相關方法put/putAll
3）Node是HashMap的靜態內部類，類似Leaf葉子節點，這里就沒有put，putAll
static class Node<K,V> implements Map.Entry<K,V>
1）簡化客戶端操作，客戶端只需要面對一致的對象而不用考慮整體部分或者節點葉子的問題。
2）具有較強的擴展性。當我們要更改組合對象時，我們只需要調整內部的層次關系，客戶端不用做出任何改動。
3）方便創建出復雜的層次結構，客戶端不用理會組合里面的組成細節，容易添加節點或者葉子從而創建出復雜的樹形結構
4）需要遍歷組織結構，或者處理的對象具有樹形結構時，非常適合使用組合模式。
5）要求較高的抽象性，如果節點和葉子有很多差異性的話，比如很多方法和屬性都不一樣，不適合使用組合模式。