package org.design.patterns;
import java.util.ArrayList;
import java.util.List;
/**
*迭代器模式:
*提供一种方法顺序访问一个聚合对象中的各个元素,而不暴露其内部的表示。
*
*/
//下面以java.uitil.Iterator为例进行说明
public interface Iterator<E> {
boolean hasNext();
E next();
void remove();
}
/*
* 以下是java.util.AbstractList,其中有对Iterator的实现,java的集合类中还有很多类似的实现,这里不再一一举例
*/
abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
protected AbstractList() {
}
public boolean add(E e) {
add(size(), e);
return true;
}
abstract public E get(int index);
public E set(int index, E element) {
throw new UnsupportedOperationException();
}
public void add(int index, E element) {
throw new UnsupportedOperationException();
}
public E remove(int index) {
throw new UnsupportedOperationException();
}
......
// Iterators
public Iterator<E> iterator() {
return new Itr();
}
private class Itr implements Iterator<E> {
int cursor = 0;
int lastRet = -1;
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size();
}
public E next() {
checkForComodification();
try {
E next = get(cursor);
lastRet = cursor++;
return next;
} catch (IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
public void remove() {
if (lastRet == -1)
throw new IllegalStateException();
checkForComodification();
try {
AbstractList.this.remove(lastRet);
if (lastRet < cursor)
cursor--;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
......
}
*/
//====================================================================
/**
*组合模式:
*允许将对象组合成树形结构类表现"整体/部分"层次结构。
*组合能让客户以一致的方式处理个别对象以及对象组合 ,
*"忽略"单个对象和组合对象的差别。
*
*/
//顶层抽象类
abstract class Component{
abstract void operation();
void add(Component component){
throw new UnsupportedOperationException();
}
void remove(Component component){
throw new UnsupportedOperationException();
}
Component getChild(int i){
throw new UnsupportedOperationException();
}
}
//个体实现
class Leaf extends Component{
@Override
void operation() {
System.out.println("Leaf.operation()");
}
}
//组合实现
class Composite extends Component{
List<Component> comList;
public Composite() {
comList=new ArrayList<Component>();
}
@Override
void add(Component component) {
comList.add(component);
}
@Override
void remove(Component component) {
comList.remove(component);
}
@Override
Component getChild(int i) {
return comList.get(i);
}
@Override
void operation() {
System.out.println("Composite.operation()");
// for(Component com:comList){
// com.operation();
// }
//用迭代器的方式(该迭代器是java.util的)
java.util.Iterator<Component> iterator = comList.iterator();
while(iterator.hasNext()){
Component component=iterator.next();
component.operation();
}
}
}
//这样,Leaf和Composite都是Component对象,具有相同的接口
//菜单Menu和菜单项MenuItem是使用组合很好的例子
//=========================================================
/*
*相关模式比较:
* 策略: 封装可互换的行为(算法),并使用委托决定使用哪一个
*
* 适配器: 改变一个或多个类的接口
*
* 迭代器: 提供一个方式遍历集合,而无须暴露集合的实现
*
* 外观: 简化一群类的接口
*
* 组合: 客户可以将对象的集合以及个别的对象一视同仁
*
* 观察者: 当某个状态改变时,允许一群对象被通知到
*/
分享到:
相关推荐
结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、...
适配器模式、装饰者模式、代理模式、外观模式、桥接模式、组合模式、享元模式观察者模式、策略模式、模板模式、责任链模式、解析器模式、迭代子模式 命令模式、状态模式、备忘录模式、访问者模式、中介者模式
组合模式 装饰模式 外观模式 享元模式 代理模式 行为模式(类行为模式) 解释器模式 模板方法模式 行为模式(对象行为模式) 策略模式 观察者模式 状态模式 导入模式 迭代器模式 命令模式 职责链模式 进来者模式 ...
内容包括设计模式概述、面向对象设计原则、简单工厂模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式、单例模式、适配器模式、桥接模式、组合模式、装饰模式、外观模式、享元模式、代理模式、职责链模式、...
5.4 ITERATOR(迭代器)—对象行为型 模式 171 5.5 MEDIATOR(中介者)—对象行为型 模式 181 5.6 MEMENTO(备忘录)—对象行为型 模式 188 5.7 OBSERVER(观察者)—对象行为型 模式 194 5.8 STATE(状态)—对象...
java之23中常用设计模式详解 总体来说设计模式分为三大类: 创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观...
10,迭代器模式:提供一种方法,顺序访问一个聚合对象中的各个元素,而又不暴露其内部的表示。 11,组合模式:允许你将对象组合成树形结构来表现“整体/部分”层次结构。组合能让客户以一致的方式处理个别对象已经...
十几个设计模式实例 包含常用的设计模式 抽象工厂模式、装饰者模式、观察者模式、代理模式、模板方法模式、策略模式、工厂方法模式、原型模式、外观模式、适配器、迭代器、组合模式等
浅析java常用的设计模式(doc 23页) 1、工厂模式:客户类和工厂类分开。消费者任何时候需要某种产品,只需向工厂请求即 可。消费者无须修改就可以接纳新产品。缺点是当产品修改时,工厂类也要做相应的修 改。如:如何...
常用设计模式和算法,练习用。 一、设计模式: 创建型模式:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式 结构型模式:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式 ...
工厂模式、适配器模式、桥接模式、建造者模式、命令模式、组合模式、装饰模式、外观模式、工厂方法模式、迭代器模式、观察者模式、代理模式、单例模式、状态模式、策略模式、模版方法模式、访问者模式
6、组合模式【Composite】 7、享元模式【Flyweight】 三、行为型模式 1、模板方法模式【Template Method】 2、观察者模式【Observer】 3、状态模式【State】 4、策略模式【Strategy】 5、职责链模式【Chain of ...
该文档是自己在学习设计模式时整理的常用设计模式pdf文档,包括源码,包括装饰模式,代理模式,责任链模式,命令模式,解释器模式,迭代器模式,备忘录模式,观察者模式,工厂模式,建造者模式,适配器模式,桥梁...
阅读标签 【】【】【】【】【】 【】【】【】【】【】 ...Java描述设计模式:迭代器模式 14 Java描述设计模式:解释器模式 15 Java描述设计模式:责任链模式 16 Java描述设计模式:代理模式 17 Java描述设计模式:
设计模式之 Iterator(迭代器) 这个模式已经被整合入Java的Collection.在大多数场合下无需自己制造一个Iterator,只要将对象装入Collection中, 直接使用 Iterator 进行对象遍历。 设计模式之 Template(模板方法) ...
4.行为型设计模式:策略、责任链、模板方法、状态常用,观察者、迭代器会使用已封装好的,备忘录、中介者、命令、访问者不常用,解释器一般用不到。 设计原则 开闭原则 一个软件实体,如类、模块、方法对扩展开放,...
26.2 一些GRASP原则是对其他设计模式的归纳 26.3 设计中发现的“分析”:领域模型 26.4 工厂(Factory) 26.5 单实例类(GoF) 26.6 具有不同接口的外部服务问题的结论 26.7 策略(GoF) 26.8 组合(GoF)和...
26.2 一些GRASP原则是对其他设计模式的归纳 26.3 设计中发现的“分析”:领域模型 26.4 工厂(Factory) 26.5 单实例类(GoF) 26.6 具有不同接口的外部服务问题的结论 26.7 策略(GoF) 26.8 组合(GoF)和...