一、迭代器模式
提供一种方法顺序访问一个聚合对象中的各个对象
迭代器模式
二、示例
餐馆合并菜单：有一个中餐厅和一个西餐厅合并了，因此服务员服务的时候需要对菜单进行合并，可是
- 1.西餐厅的菜单是用数组实现的
- 2.中餐厅的菜单使用ArrayList实现的
用传统的面向对象的模式方式实现菜单的组合：
1.定义菜单对象
/**
* 菜单对象
*/
public class MenuItem {
private String name,description;
private boolean vegetable;
private float price;
public MenuItem(String name,String description,boolean vegetable,float price)
{
this.name=name;
this.description=description;
this.vegetable=vegetable;
this.price=price;
}
public String getName()
{
return name;
}
public String getDescription()
{
return description;
}
public float getPrice()
{
return price;
}
public boolean isVegetable()
{
return vegetable;
}
}
2.定义西餐厅的菜单
/**
* 面向对象模式，西餐厅对象，直接返回整个菜单的集合list
*/
public class CakeHouseMenu {
private ArrayList<MenuItem> menuItems;
public CakeHouseMenu() {
menuItems = new ArrayList<MenuItem>();
addItem("KFC Cake Breakfast","boiled eggs&toast&cabbage",true,3.99f);
addItem("MDL Cake Breakfast","fried eggs&toast",false,3.59f);
addItem("Stawberry Cake","fresh stawberry",true,3.29f);
addItem("Regular Cake Breakfast","toast&sausage",true,2.59f);
}
private void addItem(String name, String description, boolean vegetable,
float price) {
MenuItem menuItem = new MenuItem(name, description, vegetable, price);
menuItems.add(menuItem);
}
public ArrayList<MenuItem> getMenuItems() {
return menuItems;
}
//其他功能代码
}
3.定义中餐厅的菜单
/**
* 面向对象模式，中餐厅对象，直接返回菜单的数组对象
*/
public class DinerMenu {
private final static int Max_Items=5;
public int numberOfItems=0;
private MenuItem[] menuItems;
public DinerMenu()
{
menuItems=new MenuItem[Max_Items] ;
addItem("vegetable Blt","bacon&lettuce&tomato&cabbage",true,3.58f);
addItem("Blt","bacon&lettuce&tomato",false,3.00f);
addItem("bean soup","bean&potato salad",true,3.28f);
addItem("hotdog","onions&cheese&bread",false,3.05f);
}
private void addItem(String name, String description, boolean vegetable,
float price) {
MenuItem menuItem = new MenuItem(name, description, vegetable, price);
if(numberOfItems>=Max_Items)
{
System.err.println("sorry,menu is full!can not add another item");
}else{
menuItems[numberOfItems]=menuItem;
numberOfItems++;
}
}
public MenuItem[] getMenuItems() {
return menuItems;
}
}
4.服务员输出所有菜单
/**
* 面向对象模式，服务员对象，负责提供菜单
*/
public class Waitress {
private CakeHouseMenu mCakeHouseMenu;
private DinerMenu mDinerMenu;
private ArrayList<MenuItem> cakeitems;
private MenuItem[] dineritems;
public Waitress() {
mCakeHouseMenu = new CakeHouseMenu();
cakeitems = mCakeHouseMenu.getMenuItems();
mDinerMenu = new DinerMenu();
dineritems = mDinerMenu.getMenuItems();
}
/**
* 传统模式，遍历两个菜单的循环，输出所有的菜单对象
*/
public void printMenu() {
MenuItem menuItem;
for (int i = 0, len = cakeitems.size(); i < len; i++) {
menuItem = cakeitems.get(i);
System.out.println(menuItem.getName() + "***"
+ menuItem.getPrice() + "***" + menuItem.getDescription());
}
for (int i = 0, len = mDinerMenu.numberOfItems; i < len; i++) {
menuItem = dineritems[i];
System.out.println(menuItem.getName() + "***"
+ menuItem.getPrice() + "***" + menuItem.getDescription());
}
}
}
缺点：直接将集合数据暴露在外面使用，安全性较差；对象与对象之间的耦合度较高；并且不利于拓展新的类型。
三、迭代器模式
自定义一个迭代器接口，每个集合对象实现迭代方法，获取集合数据时则统一操作迭代器即可
1.定义迭代器接口
/**
* 自定义迭代器接口
*/
public interface Iterator {
public boolean hasNext();
public Object next();
}
2.中西餐厅分别实现迭代方法
/**
* 自定义迭代器对象，西餐厅实现迭代方法
*/
class CakeHouseIterator implements Iterator {
private int position = 0;
public CakeHouseIterator() {
position = 0;
}
@Override
public boolean hasNext() {
if (position < menuItems.size()) {
return true;
}
return false;
}
@Override
public Object next() {
MenuItem menuItem = menuItems.get(position);
position++;
return menuItem;
}
}
/**
* 自定义迭代器对象，实现遍历数组的方法
*/
class DinerIterator implements Iterator {
private int position;
public DinerIterator() {
position = 0;
}
@Override
public boolean hasNext() {
if (position < numberOfItems) {
return true;
}
return false;
}
@Override
public Object next() {
MenuItem menuItem = menuItems[position];
position++;
return menuItem;
}
}
3.输出时只需遍历迭代器即可
/**
* 迭代器模式，服务员对象
*/
public class Waitress {
private ArrayList<Iterator> iterators = new ArrayList<Iterator>();
public Waitress() {
}
public void addIterator(Iterator iterator) {
iterators.add(iterator);
}
/**
* 只需要遍历迭代器即可遍历添加进来的集合数据
*/
public void printMenu() {
Iterator iterator;
MenuItem menuItem;
for (int i = 0, len = iterators.size(); i < len; i++) {
iterator = iterators.get(i);
while (iterator.hasNext()) {
menuItem = (MenuItem) iterator.next();
System.out.println(menuItem.getName() + "***"
+ menuItem.getPrice() + "***" + menuItem.getDescription());
}
}
}
}
/**
* 迭代器模式，自定义迭代器接口
* 实现迭代器的遍历方法后即可将不同类型的集合数据统一遍历输出
*/
public class MainTest {
public static void main(String[] args) {
Waitress mWaitress=new Waitress();
CakeHouseMenu mCakeHouseMenu = new CakeHouseMenu();
DinerMenu mDinerMenu = new DinerMenu();
// 添加集合对象到迭代器的集合中
mWaitress.addIterator(mCakeHouseMenu.getIterator());
mWaitress.addIterator(mDinerMenu.getIterator());
mWaitress.printMenu();
}
}
四、Java内置的迭代器
Java提供了内置的迭代器Iterator
1.ArrayList已经集成了内部的迭代器，可直接使用
2.数组没有集成迭代器，则需要重新实现迭代器的方法
/**
* 实现Java内部的迭代器，重写迭代方法
*/
class DinerIterator implements Iterator {
private int position = 0;
@Override
public boolean hasNext() {
if (position < numberOfItems) {
return true;
}
position = 0;
return false;
}
@Override
public Object next() {
MenuItem menuItem = menuItems[position];
position++;
return menuItem;
}
@Override
public void remove() {
}
}
3.若添加一种新的集合类型只要实现了迭代器方法，也可用统一的方式进行遍历
五、单一责任原则
一个类，应该只有一个引起它变化的原因。应该只有一个职责。每一个职责都是变化的一个轴线，如果一个类有一个以上的职责，这些职责就耦合在了一起。这会导致脆弱的设计。当一个职责发生变化时，可能会影响其它的职责。另外，多个职责耦合在一起，会影响复用性。
例如：要实现逻辑和界面的分离。
Java设计模式所有示例代码，持续更新中
