Visitor Design Pattern (방문 자 디자인 모델)

Visitor Design Pattern (방문 자 디자인 모델) 실현 요점: 모든 방문 대상 은 accept (IVisitor) 방법 이 있 는 인 터 페 이 스 를 계승 해 야 합 니 다.방문 대상 의 accept 방법의 구체 적 인 실현: visitor. visit (this), 자신의 대상 을 visitor 에 노출;방문 대상 은 IVisitor 인 터 페 이 스 를 실현 하여 서로 다른 방문 대상 의 하위 클래스 를 서로 다른 조작 을 한다. 장점: 1. 서로 다른 하위 클래스 에 분 산 된 똑 같은 기능 은 일종 의 Visitor 류 에 집중 적 으로 관리 되 고 데이터 구조 와 조작 이 분리 된다.
2. 대량의 인 스 턴 스 of 를 사용 하지 않 으 면 각 피 드 류 에 대한 접근 을 완성 할 수 있 습 니 다.
더 많은 장점 은 아직 이해 하지 못 하고 발견 하지 못 했다.(생각 중)
 
구체 적 인 예 (component design pattern 포함)
VisitorDemo.java
 

package com.dp.visitor;

interface CarElementVisitor {
    void visit(Wheel wheel);
    void visit(Engine engine);
    void visit(Body body);
    void visit(Car car);
}
 
interface CarElement {
    void accept(CarElementVisitor visitor); // CarElements have to provide accept().
}
 
class Wheel implements CarElement {
    private String name;
 
    public Wheel(String name) {
        this.name = name;
    }
 
    public String getName() {
        return this.name;
    }
 
    public void accept(CarElementVisitor visitor) {
        visitor.visit(this);
    }
}
 
class Engine implements CarElement {
    public void accept(CarElementVisitor visitor) {
        visitor.visit(this);
    }
}
 
class Body implements CarElement {
    public void accept(CarElementVisitor visitor) {
        visitor.visit(this);
    }
}
 
class Car implements CarElement{
    CarElement[] elements;
 
    public CarElement[] getElements() {
        return elements.clone(); // Return a copy of the array of references.
    }
 
    public Car() {
        this.elements = new CarElement[]
          { new Wheel("front left"), new Wheel("front right"),
            new Wheel("back left") , new Wheel("back right"),
            new Body(), new Engine() };
    }
 
    public void accept(CarElementVisitor visitor) {	
        for(CarElement element : this.getElements()) {
            element.accept(visitor);
        }
        visitor.visit(this);	
    }
}
 
class CarElementPrintVisitor implements CarElementVisitor {
    public void visit(Wheel wheel) {      
        System.out.println("Visiting "+ wheel.getName()
                            + " wheel");
    }
 
    public void visit(Engine engine) {
        System.out.println("Visiting engine");
    }
 
    public void visit(Body body) {
        System.out.println("Visiting body");
    }
 
    public void visit(Car car) {      
        System.out.println("Visiting car");
    }
}
 
class CarElementDoVisitor implements CarElementVisitor {
    public void visit(Wheel wheel) {
        System.out.println("Kicking my "+ wheel.getName() + " wheel");
    }
 
    public void visit(Engine engine) {
        System.out.println("Starting my engine");
    }
 
    public void visit(Body body) {
        System.out.println("Moving my body");
    }
 
    public void visit(Car car) {
        System.out.println("Starting my car");
    }
}


public class VisitorDemo {

public static void main(String[] args) {
        Car car = new Car();
        car.accept(new CarElementPrintVisitor());
        System.err.println("
====================
");
        car.accept(new CarElementDoVisitor());
	}

}

 
더 많은 읽 기:
반사 간소화 double dispatch 의 시 뮬 레이 션 사용:
 In the Java language, two techniques have been documented that use reflection to simplify the mechanics of double dispatch simulation in the visitor pattern: getting rid of accept() methods (the Walkabout variation), and getting rid of extra visit() methods .
 
 
참고:
http://en.wikipedia.org/wiki/Visitor_pattern