设计模式之复合模式

最新推荐文章于 2023-02-25 23:33:33 发布
最新推荐文章于 2023-02-25 23:33:33 发布
阅读量773 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 复合模式 编程 组合 合作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010392792/article/details/25609339
版权

使用模式最棒的方式，就是把他们从家里找出来同其他模式展开交互。这就是复合模式。

我们将重访SimUDuck鸭子模拟器中那些鸭子。

我们将从头重建我们的鸭子模拟器。

首先，创建一个Quackable接口：

public interface Quackable {
	public void quack();

}

某些鸭子实现此接口： 

public class MallardDuck implements Quackable{
	public void quack(){
		System.out.println("Quack");
	}

}


public class RedHeadDuck implements Quackable{
	public void quack(){
		System.out.println("Quack");
	}

}

public class DuckCall implements Quackable{
	public void quack(){
		System.out.println("Kwak");
	}

}

public class RubberDuck implements Quackable{
	public void quack(){
		System.out.println("Squeak");
	}

}


好了，有了鸭子，还需要一个模拟器： 

public class DuckSimulator {
	public static void main(String[]args){
		DuckSimulator simulator=new DuckSimulator();
		simulator.simulate();
	}
	
	void simulate(){
		Quackable mallardDuck=new MallardDuck();
		Quackable redHeadDUck=new RedHeadDuck();
		Quackable duckCall=new DuckCall();
		Quackable rubberDuck=new RubberDuck();
		
		System.out.println("\nDuck Simulator");
		
		simulate(mallardDuck);
		simulate(redHeadDUck);
		simulate(duckCall);
		simulate(rubberDuck);
	}
	
	void simulate(Quackable duck){
		duck.quack();
	}

}

结果： 

Duck Simulator
Quack
Quack
Kwak
Squeak


当鸭子出现在这里，鹅应该在附近：

public class Goose {
	public void honk(){
		System.out.println("Honk");
	}

}

把鸭子和鹅掺合在一起，需要鹅适配器： 

public class GooseAdapter implements Quackable{
	Goose goose;
	
	public GooseAdapter(Goose goose){
		this.goose=goose;
	}
	
	public void quack(){
		goose.honk();
	}

}

现在在模拟器中可以使用鹅了： 

public class DuckSimulator {
	public static void main(String[]args){
		DuckSimulator simulator=new DuckSimulator();
		simulator.simulate();
	}
	
	void simulate(){
		Quackable mallardDuck=new MallardDuck();
		Quackable redHeadDUck=new RedHeadDuck();
		Quackable duckCall=new DuckCall();
		Quackable rubberDuck=new RubberDuck();
		Quackable gooseDuck=new GooseAdapter(new Goose());//把goose包装成GooseAdapter
		
		System.out.println("\nDuck Simulator");
		
		simulate(mallardDuck);
		simulate(redHeadDUck);
		simulate(duckCall);
		simulate(rubberDuck);
		simulate(gooseDuck);
	}
	
	void simulate(Quackable duck){
		duck.quack();
	}

}

结果： 

Duck Simulator
Quack
Quack
Kwak
Squeak
Honk

呱呱叫学家想要不变化鸭子类的情况下，计算呱呱叫的次数，我们可以创建一个装饰者，通过把鸭子包装进装饰者对象，给鸭子一些新行为： 

public class QuackCounter implements Quackable{
	Quackable duck;
	static int numberOfQuacks;//静态变量跟踪所有呱呱叫次数
	
	public QuackCounter(Quackable duck){
		this.duck=duck;
	}
	
	public void quack(){
		duck.quack();
		numberOfQuacks++;
	}
	
	public static int getQuacks(){
		return numberOfQuacks;
	}

}

更新模拟器： 

public class DuckSimulator {
	public static void main(String[]args){
		DuckSimulator simulator=new DuckSimulator();
		simulator.simulate();
	}
	
	void simulate(){
		Quackable mallardDuck=new QuackCounter(new MallardDuck());
		Quackable redHeadDUck=new QuackCounter( new RedHeadDuck());
		Quackable duckCall=new QuackCounter(new DuckCall());
		Quackable rubberDuck=new QuackCounter(new RubberDuck());
		Quackable gooseDuck=new GooseAdapter(new Goose());//我们不装饰鹅
		
		System.out.println("\nDuck Simulator：with decorator");
		
		simulate(mallardDuck);
		simulate(redHeadDUck);
		simulate(duckCall);
		simulate(rubberDuck);
		simulate(gooseDuck);
		
		System.out.println("The ducks quacked "+QuackCounter.getQuacks()+" times");
	}
	
	void simulate(Quackable duck){
		duck.quack();
	}

}

结果： 

Duck Simulator：with decorator
Quack
Quack
Kwak
Squeak
Honk
The ducks quacked 4 times

包装对象才有效果，没包装就没效果，我们可以将创建和装饰的部分包装起来，工厂模式： 

public abstract class AbstractDuckFactory {
	public abstract Quackable createMallardDuck();
	public abstract Quackable createRedHeadDuck();
	public abstract Quackable createDuckCall();
	public abstract Quackable createRubberDuck();

}

创建一个没有装饰者的工厂： 

public class DuckFactory extends AbstractDuckFactory{

	@Override
	public Quackable createMallardDuck() {
		// TODO Auto-generated method stub
		return new MallardDuck();
	}

	@Override
	public Quackable createRedHeadDuck() {
		// TODO Auto-generated method stub
		return new RedHeadDuck();
	}

	@Override
	public Quackable createDuckCall() {
		// TODO Auto-generated method stub
		return new DuckCall();
	}

	@Override
	public Quackable createRubberDuck() {
		// TODO Auto-generated method stub
		return new RubberDuck();
	}
	
//模拟器并不知道实际产品是什么，只知道实现了Quackable接口
}

创建我们想要的工厂： 

public class CountingDuckFactory extends AbstractDuckFactory{

	@Override
	public Quackable createMallardDuck() {
		// TODO Auto-generated method stub
		return new QuackCounter(new MallardDuck());
	}

	@Override
	public Quackable createRedHeadDuck() {
		// TODO Auto-generated method stub
		return new QuackCounter(new RedHeadDuck());
	}

	@Override
	public Quackable createDuckCall() {
		// TODO Auto-generated method stub
		return new QuackCounter(new DuckCall());
	}

	@Override
	public Quackable createRubberDuck() {
		// TODO Auto-generated method stub
		return new QuackCounter(new RubberDuck());
	}

}

设置模拟器： 

public class DuckSimulator {
	public static void main(String[]args){
		DuckSimulator simulator=new DuckSimulator();
		AbstractDuckFactory duckFactory=new CountingDuckFactory();
		simulator.simulate(duckFactory);
	}
	
	void simulate(AbstractDuckFactory duckFactory){
		Quackable mallardDuck=duckFactory.createMallardDuck();
		Quackable redHeadDUck=duckFactory.createRedHeadDuck();
		Quackable duckCall=duckFactory.createDuckCall();
		Quackable rubberDuck=duckFactory.createRubberDuck();
		Quackable gooseDuck=new GooseAdapter(new Goose());
		
		System.out.println("\nDuck Simulator：with abstract factory");
		
		simulate(mallardDuck);
		simulate(redHeadDUck);
		simulate(duckCall);
		simulate(rubberDuck);
		simulate(gooseDuck);
		
		System.out.println("The ducks quacked "+QuackCounter.getQuacks()+" times");
	}
	
	void simulate(Quackable duck){
		duck.quack();
	}

}

结果： 

Duck Simulator：with abstract factory
Quack
Quack
Kwak
Squeak
Honk
The ducks quacked 4 times

现在管理员想管理一群鸭子，而不是个别，我们可以用到组合模式: 

public class Flock implements Quackable{
	ArrayList quackers=new ArrayList<>();
	
	public void add(Quackable quacker){
		quackers.add(quacker);
	}
	
	public void quack(){
		Iterator iterator=quackers.iterator();//迭代器模式
		while(iterator.hasNext()){
			Quackable quacker=(Quackable)iterator.next();
			quacker.quack();
		}
	}
	

}

修改模拟器： 

public class DuckSimulator {
	public static void main(String[]args){
		DuckSimulator simulator=new DuckSimulator();
		AbstractDuckFactory duckFactory=new CountingDuckFactory();
		simulator.simulate(duckFactory);
	}
	
	void simulate(AbstractDuckFactory duckFactory){
		Quackable mallardDuck=duckFactory.createMallardDuck();
		Quackable redHeadDUck=duckFactory.createRedHeadDuck();
		Quackable duckCall=duckFactory.createDuckCall();
		Quackable rubberDuck=duckFactory.createRubberDuck();
		Quackable gooseDuck=new GooseAdapter(new Goose());
		
		System.out.println("\nDuck Simulator：with composite-flocks");
		
		Flock flockOfDucks=new Flock();
		
		flockOfDucks.add(redHeadDUck);
		flockOfDucks.add(rubberDuck);
		flockOfDucks.add(duckCall);
		flockOfDucks.add(gooseDuck);
		
		Flock flockOfMallards=new Flock();
		
		Quackable mallardOne=duckFactory.createMallardDuck();
		Quackable mallardTwo=duckFactory.createMallardDuck();
		Quackable mallardThree=duckFactory.createMallardDuck();
		Quackable mallardFour=duckFactory.createMallardDuck();
		
		flockOfMallards.add(mallardOne);
		flockOfMallards.add(mallardTwo);
		flockOfMallards.add(mallardThree);
		flockOfMallards.add(mallardFour);
		
		flockOfDucks.add(flockOfMallards);
		
		System.out.println("\nDuck Simulator:Whole Flock Simulation");
		simulate(flockOfDucks);//测试一整群
		
		System.out.println("\nDuck Simulator:Mallard Flock Simulation");
		simulate(flockOfMallards);//测试绿头鸭群
		
		System.out.println("The ducks quacked "+QuackCounter.getQuacks()+" times");
	}
	
	void simulate(Quackable duck){
		duck.quack();
	}

}

结果： 

Duck Simulator：with composite-flocks

Duck Simulator:Whole Flock Simulation
Quack
Squeak
Kwak
Honk
Quack
Quack
Quack
Quack

Duck Simulator:Mallard Flock Simulation
Quack
Quack
Quack
Quack
The ducks quacked 11 times

管理员又有新的要求了，需要跟踪个别的鸭子，我们可以用观察者模式：

首先需要一个Observable接口;（这里的Observable就是被观察者）

public interface QuackObservable {
	
	public void registerObserver(Observer observer);
	public void notifyObservers();

}

需要确定所有的quackable都实现此接口： 

public interface Quackable extends QuackObservable{
	public void quack();

}
确定所有实现Quackable的具体类都扮演QuackObservable的角色：

我们需要在每一个类中实现注册和通知，这次我们要用稍微不一样的做法：

我们要在另一个被称为Observable的类中封装注册和通知的代码，然后将它和QuackObservable组合在一起。

Observer辅助类：

import java.util.ArrayList;
import java.util.Iterator;


public class Observable implements QuackObservable{
	ArrayList observers=new ArrayList<>();
	QuackObservable duck;
	
	public Observable(QuackObservable duck){
		this.duck=duck;
	}
	
	public void registerObserver(Observer observer){
		observers.add(observer);
	}
	
	public void notifyObservers(){
		Iterator iterator=observers.iterator();
		while(iterator.hasNext()){
			Observer observer=(Observer)iterator.next();
			observer.update(duck);
		}
 	}


}

整合Observable辅助类和Quackable类：

下面是MallardDuck实现，其他一样

public class MallardDuck implements Quackable{
	Observable observable;
	
	public MallardDuck(){
		observable=new Observable(this);
	}
	
	public void quack(){
		System.out.println("Quack");
		notifyObservers();
	}

	@Override
	public void registerObserver(Observer observer) {
		// TODO Auto-generated method stub
		observable.registerObserver(observer);
	}

	@Override
	public void notifyObservers() {
		// TODO Auto-generated method stub
		observable.notifyObservers();
	}

}


QuackCOunter装饰者 

public class QuackCounter implements Quackable{
	Quackable duck;
	static int numberOfQuacks;//静态变量跟踪所有呱呱叫次数
	
	public QuackCounter(Quackable duck){
		this.duck=duck;
	}
	
	public void quack(){
		duck.quack();
		numberOfQuacks++;
	}
	
	public static int getQuacks(){
		return numberOfQuacks;
	}

	@Override
	public void registerObserver(Observer observer) {
		// TODO Auto-generated method stub
		duck.registerObserver(observer);
	}

	@Override
	public void notifyObservers() {
		// TODO Auto-generated method stub
		duck.notifyObservers();
	}

}

Observer端： 

public interface Observer {
	public void update(QuackObservable duck);

}

public class Quackologist implements Observer{
	public void update(QuackObservable duck){
		System.out.println("Quackologist: "+duck+" just quacked.");
	}

}

如果要观察整个群的话： 

public class Flock implements Quackable{
	ArrayList quackers=new ArrayList<>();
	
	public void add(Quackable quacker){
		quackers.add(quacker);
	}
	
	public void quack(){
		Iterator iterator=quackers.iterator();
		while(iterator.hasNext()){
			Quackable quacker=(Quackable)iterator.next();
			quacker.quack();
		}
	}

	@Override
	public void registerObserver(Observer observer) {
		// TODO Auto-generated method stub
		Iterator iterator=quackers.iterator();
		while(iterator.hasNext()){
			Quackable duck=(Quackable)iterator.next();
			duck.registerObserver(observer);
		}
	}

	@Override
	public void notifyObservers() {
		// TODO Auto-generated method stub
		
	}

	
	

}

更新模拟器： 

public class DuckSimulator {
	public static void main(String[]args){
		DuckSimulator simulator=new DuckSimulator();
		AbstractDuckFactory duckFactory=new CountingDuckFactory();
		simulator.simulate(duckFactory);
	}
	
	void simulate(AbstractDuckFactory duckFactory){	
		
		System.out.println("\nDuck Simulator：with observer");
		
		Flock flockOfMallards=new Flock();
		
		Quackable mallardOne=duckFactory.createMallardDuck();
		Quackable mallardTwo=duckFactory.createMallardDuck();
		Quackable mallardThree=duckFactory.createMallardDuck();
		Quackable mallardFour=duckFactory.createMallardDuck();
		
		flockOfMallards.add(mallardOne);
		flockOfMallards.add(mallardTwo);
		flockOfMallards.add(mallardThree);
		flockOfMallards.add(mallardFour);
		
		
		Quackologist quackologist=new Quackologist();
		flockOfMallards.registerObserver(quackologist);
		simulate(flockOfMallards);
		
		System.out.println("The ducks quacked "+QuackCounter.getQuacks()+" times");
	}
	
	void simulate(Quackable duck){
		duck.quack();
	}

}

结果： 

Duck Simulator：with observer
Quack
Quackologist: duck.MallardDuck@4aa0b07b just quacked.
Quack
Quackologist: duck.MallardDuck@7ba28183 just quacked.
Quack
Quackologist: duck.MallardDuck@69e4fede just quacked.
Quack
Quackologist: duck.MallardDuck@3918d722 just quacked.
The ducks quacked 4 times




这个例子主要的目的是展示许多模式可以合作，真实的设计过程中，不会想要这么做，不然有点杀鸡用牛刀的赶脚。


MVC模式是一个典型的复合模式。

MVC，即model-view-controller，比如一个MP3播放器底层就是MVC模式。

1、你是用户，你和视图交互。视图是模型的窗口。

2、控制器要求模型状态改变。

3、控制器也有可能要求视图做改变。

4、模型状态改变时，模型会通知视图。

5、视图向模型询问状态。

最典型的MVC就是JSP + servlet + javabean的模式.

从设计模式看，模型利用观察者让控制器和视图可以随最新的状态改变而更新。另一方面，视图和控制器则实现了策略模式。控制器是视图的行为，如果你希望不同的行为，可以直接换一个控制器。视图内部使用组合模式来管理窗口、按钮以及其他显示组件。






BugsAroundMe
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
复合模式(Compound Pattern)
biangu1486的博客
08-15 2360
什么是复合模式 模式通常被一起使用，并被组合在同一个设计解决方案中。复合模式在一个解决方案中结合两个或多个模式，已解决一般或重复发生的问题。 模式合作 在实际工作中，可以采用不同的设计模式解决各种问题，下面是一个例子： 首先要创建一群呱呱叫的鸭子类，让他们实现接口Quackable： public interface Quackable { public void qua...
Design Pattern学习笔记之组合模式（Compound Patterns）
wqh807020的专栏
12-19 645
Design Pattern学习笔记之组合模式（Compound Patterns） 1.    引子--Whois？ 我们之前介绍过很多设计模式，我们力图从各个角度辨析各种模式的异同，找到某种模式存在的理由。简言之，我们尽力识别模式的不同，在解决具体问题时，一般使用单一模式解决问题。其实之前介绍的例子，都是为了帮助理解设计模式，在现实的世界里，有更多更复杂的问题要处理，很多非常好的OO设计都
设计模式-复合模式
最新发布
贾欣晓的博客
02-25 468
如何使用设计模式？
鸭子与设计模式的故事（多种设计模式配合使用案例）
我思故我在
04-29 401
代码：https://download.csdn.net/download/u010191034/85242829 uml图 介绍 1 Quackable 是鸭子叫的接口，有四种实现 2 GooseAdapter是适配器，可以将鹅叫适配到Quackable 上从而达到统一处理的目的 3 Flock组合模式 可以管理一堆鸭子 4 装饰者QuackCounter用于装饰鸭子，为鸭子添加扩展计数功能 5 工厂 生产鸭子，生产两套，一个套没有装饰的，一套有装饰的 6 观察者比较复杂，所有的都要实
Java 设计模式 -- 复合模式之一
小鱼的专栏
05-12 3388
关于复合模式： 在形式上，复合模式确实是多个模式的组合，但满足了这一条并不一定是复合模式，注意它的定义：将多个模式结合起来形成一个“框架”，以解决一般性问题             一提到“框架”，可能最容易联想到的就是MVC吧，不过MVC确实是一个经典的复合模式 在进去MVC模式之前 先看一个简单的例子： 例子来自Headfrist 设计模式中的经典鸭鸣：有四种鸭
设计模式之组合模式
Baron
05-13 559
  1. 主要优点      组合模式的主要优点如下：      (1) 组合模式可以清楚地定义分层次的复杂对象，表示对象的全部或部分层次，它让客户端忽略了层次的差异，方便对整个层次结构进行控制。      (2) 客户端可以一致地使用一个组合结构或其中单个对象，不必关心处理的是单个对象还是整个组合结构，简化了客户端代码。      (3) 在组合模式中增加新的容器构件和叶子构件都很方便，无须对现...
Java设计模式之复合模式篇
02-27
自从J2EE出现以来，就大大简化了在Java下的企业级开发。但是随着J2EE越来越普遍地被应用到各个领域中，开发者们渐渐意识到需要一种方法来标准化应用程序的开发过程，他们采用的方法是标准化应用程序的结构层。...
深入浅出设计模式之复合模式
11-19
根据提供的信息，我们可以了解到本文主要关注的是《Head First 设计模式》一书中关于“复合模式”的相关内容。虽然未提供具体章节的内容，但基于标题、描述和标签，我们可以深入探讨复合模式的基本概念、应用场景...
C++设计模式之组合模式
09-04
组合模式是一种设计模式，属于结构型模式，它在C++中的应用主要体现在构建对象的树形结构，以表达部分与整体的层次关系。通过组合模式，用户可以对单个对象和由多个对象组成的复合对象进行相同的操作，实现了操作的...
C++ 设计模式(复合)
02-19
vs2013工程的设计模式，根据《head first设计模式》改写的一个多模式协作的例子。结合着 http://download.csdn.net/detail/ustb_atrx/9434958 一起看比较好。
程序员必知的23种设计模式之策略模式
ECHO的博客
05-26 457
文章目录1. 模式引入--鸭子项目2. 传统方案解决鸭子问题3. 传统方式解决鸭子问题分析和解决方案4. 策略模式基本介绍4.1 策略模式的原理类图4.2 说明5. 策略模式解决鸭子问题6. 策略模式的注意事项和细节 1. 模式引入–鸭子项目 具体要求如下: 有各种鸭子(比如 野鸭、北京鸭、水鸭等， 鸭子有各种行为，比如 叫、飞行等) 显示鸭子的信息 2. 传统方案解决鸭子问题 定义一个抽象类，其中实现了叫和飞的功能，显示的方法设置为抽象，交给子类实现 3. 传统方式解决鸭子问题分析和解决方案
设计模式入门——复合模式（携手合作）
阿泽的学习笔记
08-11 326
模式通常会被一起使用，并被组合在同一个设计解决方案中。 复合模式在一个解决方案中结合两个或多个模式，以解决一般或者重复发生的问题。 一、 首先我们想建立一个鸭子模拟器 1. 首先我们创建一个Quackable接口： // 接口 public interface Quackable { public void quack(); } 2. 其次我们再实现某些鸭子： // 标准绿头鸭...
设计模式之工厂模式
这个人叫楼猪
04-24 703
1、jiandan 某比萨店订单可能是这么样的： Pizza orderPizza(String type){ Pizza pizza; if(type.equals("cheese")) pizza=new CheezePizza(); else if(type.equals("clam")) pizza=new ClamPizza(); else if(
设计模式之代理模式
这个人叫楼猪
05-11 665
还是那个糖果机，CEO想要获得对糖果机的远程监控，获取机器状态，库存等。
设计模式之命令模式
这个人叫楼猪
04-25 625
我们都知道餐厅是怎么样工作的：顾客下订单，z
设计模式之适配器模式&外观模式
这个人叫楼猪
05-08 525
OO适配器将一个接口转换为另一个接口
设计模式之单件模式
这个人叫楼猪
04-25 475
有一些对象我们只需要yige
Java设计模式：变压器模式详解
实例结构模式则涉及对象的动态组合，如代理模式、复合模式、装饰模式等。 2. 变压器模式（Adapter模式） Transformer模式的主要作用是将一个类的接口转换成客户端期望的另一个接口，使得原本无法协作的类能够协同...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值