디자인 모드 - 교체 기 모드 Interator

디자인 모드 - 교체 기 모드 Interator
개념: 용기 대상 의 각 요 소 를 방문 하고 그 대상 의 내부 디 테 일 을 드 러 내지 않 는 방법 을 제공 합 니 다.
교체 기 모드 의 사용 을 보 여 주 는 예 를 들 어 보 겠 습 니 다.
예 를 들 어 다음 과 같은 경우 가 있 습 니 다. 한 식당 에 요리사 가 두 명 있 습 니 다. 하 나 는 아침 을 책임 지고 하 나 는 점심 을 책임 집 니 다. 그런데 두 스승 은 모두 개성 이 있 습 니 다. 한 스승 의 메뉴 (BreakfastMenu) 는 집합 (List 로 표시 되 고 다른 스승 의 메뉴 (LunchMenu) 는 배열 (Menu Item []) 입 니 다. 이때 종업원 (Waitress) 이손님 에 게 메뉴 의 내용 을 보 여 줘 야 하 는 것 은 두 요리사 가 통일 되 지 않 는 한 매우 불편 합 니 다. 하지만 전에 말씀 드 렸 듯 이 스승 님 이 너무 개성 이 있 으 시 면 고치 지 않 겠 습 니 다. 그럼 코드 로 보 여 드 리 겠 습 니 다.
우선, 요리 종류:

public class MenuItem {
    private String name;
    private double price;
    public MenuItem(String name, double price) {
        this.name = name;
        this.price = price;
    }
    public String getName() {
        return name;
    }
    public double getPrice() {
        return price;
    }
    @Override
    public String toString() {
        return "MenuItem{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

아침 식 사 를 하 는 스승 님, 메뉴 는 집합 형식 으로 표 시 됩 니 다.

public class BreakfastMenu {
    private List<MenuItem> menuItems;
    public BreakfastMenu() {
        menuItems = new ArrayList<>();
        addItem("  ", 1.0);
        addItem("  ", 1.0);
        addItem("   ", 2.5);
        addItem("   ", 2.0);
    }
    private void addItem(String name, double price) {
        MenuItem item = new MenuItem(name, price);
        menuItems.add(item);
    }
    public List<MenuItem> getMenuItems() {
        return menuItems;
    }
}

점심 을 하 는 스승 님, 메뉴 는 배열 로 표시 합 니 다.

public class LunchMenu {
    private static final int MAX_ITEMS = 3;
    private MenuItem[] menuItems;
    private int index;
    public LunchMenu() {
        menuItems = new MenuItem[MAX_ITEMS];
        addItem("   ", 8.0);
        addItem("   ", 7.0);
        addItem("    ", 9.0);
    }
    private void addItem(String name, double price) {
        MenuItem item = new MenuItem(name, price);
        menuItems[index] = item;
        index++;
    }
    public MenuItem[] getMenuItems() {
        return menuItems;
    }
}

이때 종업원 의 방법 은 다음 과 같다.

public class Waitress {
    private BreakfastMenu breakfastMenu;
    private LunchMenu lunchMenu;
    public Waitress(BreakfastMenu breakfastMenu, LunchMenu lunchMenu) {
        this.breakfastMenu = breakfastMenu;
        this.lunchMenu = lunchMenu;
    }
  blic void printMenu(){
        printBreakfastMenu();
        printLunchMenu();
    }
    public void printBreakfastMenu(){
    System.out.println("---  ---");
        List<MenuItem> breakfast = breakfastMenu.getMenuItems();
        for (int i = 0; i < breakfast.size(); i++) {
            System.out.println(breakfast.get(i));
        }
    }
    public void printLunchMenu(){
        System.out.println("---  ---");
        MenuItem [] lunch = lunchMenu.getMenuItems();
        for (int i = 0; i < lunch.length; i++) {
            System.out.println(lunch[i]);
        }
    }
}

실행 프로그램 은 다음 과 같 습 니 다:

public class Hotel {
    public static void main(String[] args) {
        BreakfastMenu breakfastMenu = new BreakfastMenu();
        LunchMenu lunchMenu = new LunchMenu();
        Waitress waitress = new Waitress(breakfastMenu, lunchMenu);
        waitress.printMenu();
    }
}

종업원 (Waitress) 이 각각 두 가지 집합 을 옮 겨 다 니 는 것 을 볼 수 있 습 니 다. 그렇다면 개성 있 는 요리 사 를 추가 하면 요? Map 으로 저장 한 것 을 하나 더 써 야 하지 않 겠 습 니까?
다음은 교체 기 (Interator) 의 용법 을 소개 한다.
우선, 교체 기 인터페이스 만 들 기

public interface Iterator<T> {
    boolean hasNext();
    T next();
}

아침 메뉴 의 실현 유형 은 다음 과 같다.

public class BreakfastMenuIterator implements Iterator<MenuItem> {
    private List<MenuItem> items;
    private int index;
    public BreakfastMenuIterator(List<MenuItem> items) {
        this.items = items;
    }
    @Override
    public boolean hasNext() {
        if (index < items.size()) return true;
        return false;
    }
    @Override
    public MenuItem next() {
        return items.get(index++);
    }
}

점심 메뉴 구현 클래스 는 다음 과 같 습 니 다.

public class LunchMenuIterator implements Iterator<MenuItem> {
    private MenuItem [] items;
    private int index;

    public LunchMenuIterator(MenuItem[] items) {
        this.items = items;
    }
    @Override
    public boolean hasNext() {
        if (index < items.length) return true;
        return false;
    }
    @Override
    public MenuItem next() {
        MenuItem item = items[index++];
        return item;
    }
}

그리고 각각 BreakfastMenu 와 LunchMenu 류 아래 에 새로운 방법 을 발표 합 니 다. createInterator ()

public class BreakfastMenu {
    /**       ,   */
    public Iterator createIterator(){
        return new BreakfastMenuIterator(menuItems);
    }
}

마찬가지 로 LunchMenu

public class LunchMenu {
    /**       ,   */
    public Iterator createIterator(){
        return new LunchMenuIterator(menuItems);
    }
}

Waitree 클래스 수정

public class Waitress {
    private final Iterator breakfastIterator;
    private final Iterator dinerIterator;

    public Waitress(BreakfastMenu breakfastMenu, LunchMenu lunchMenu) {
        breakfastIterator = breakfastMenu.createIterator();
        dinerIterator = lunchMenu.createIterator();
    }
    public void printMenu(){
        printBreakfastMenu();
        printLunchMenu();
    }

    private void print(Iterator iterator){
        while (iterator.hasNext()){
            MenuItem item = (MenuItem) iterator.next();
            System.out.println(item.toString());
        }
    }

    public void printBreakfastMenu(){
        System.out.println("---  ---");
        print(breakfastIterator);
    }
    public void printLunchMenu(){
        System.out.println("---  ---");
        print(dinerIterator);
    }
}

프로그램 을 실행 하 는 코드 는 변경 되 지 않 았 습 니 다. 이 때 Waitree 류 는 메뉴 의 유형 을 전혀 고려 하지 않 고 교체 기의 인 터 페 이 스 를 실현 하 는 지 에 만 관심 을 가 집 니 다. 다른 메뉴 류 는 하나의 방법 만 추 가 했 을 뿐 요리사 에 게 그것 은 작은 일 입 니 다. 위 에는 우리 가 직접 교체 기 를 만 들 었 습 니 다. 실제로 자바 에 서 는 시스템 에 Interator 라 는 인터페이스 가 있 고 Li 가 있 습 니 다.st / map 등 집합 류 도 모두 직접적인 방법 으로 교체 기 를 제공 합 니 다. 예 를 들 어:

List<MenuItem> breakfastMenus = new ArrayList<>();
        java.util.Iterator listIterator = breakfastMenus.iterator();
        Map<String,MenuItem> map = new HashMap<>();
        java.util.Iterator mapIterator = map.values().iterator();