22.Visitor-访问者模式

Visitor 访问者模式

• Visitor模式:
  提供一个做用于某对象结构中的各元素的操做表示，它使咱们能够在不改变各元素的类的前提下定义做用于这些元素的新操做。
  访问者模式是一种将算法与对象结构分离的软件设计模式。访问者模式是一种对象行为型模式。

• 结构图:
  

• 示例类图:
  

• 示例代码:

// Visitor
public interface ComputerPartVisitor {
    public void visit(Computer computer);
    public void visit(Mouse mouse);
    public void visit(Keyboard keyboard);
    public void visit(Monitor monitor);
}

// ConcreteVisitor
public class ComputerPartDisplayVisitor implements ComputerPartVisitor {
    @Override
    public void visit(Computer computer) {
        System.out.println("Displaying " + computer.getPart());
    }

    @Override
    public void visit(Mouse mouse) {
        System.out.println("Displaying " + mouse.getPart());
    }

    @Override
    public void visit(Keyboard keyboard) {
        System.out.println("Displaying " + keyboard.getPart());
    }

    @Override
    public void visit(Monitor monitor) {
        System.out.println("Displaying " + monitor.getPart());
    }
}

// Element
public abstract class ComputerPart {
    protected String part;

    public ComputerPart(String part) {
        this.part = part;
    }

    public abstract void accept(ComputerPartVisitor computerPartVisitor);

    public String getPart() {
        return part;
    }
}

// ConcreteElement
public class Keyboard extends ComputerPart {

    public Keyboard(String part) {
        super(part);
    }

    @Override
    public void accept(ComputerPartVisitor computerPartVisitor) {
        computerPartVisitor.visit(this);
    }
}
public class Monitor extends ComputerPart {

    public Monitor(String part) {
        super(part);
    }

    @Override
    public void accept(ComputerPartVisitor computerPartVisitor) {
        computerPartVisitor.visit(this);
    }
}
public class Mouse extends ComputerPart {

    public Mouse(String part) {
        super(part);
    }

    @Override
    public void accept(ComputerPartVisitor computerPartVisitor) {
        computerPartVisitor.visit(this);
    }
}

// ObjectStructure
public class Computer extends ComputerPart {
    private ComputerPart[] parts;

    public Computer(String part) {
        super(part);
        this.parts = new ComputerPart[] { new Mouse("Mouse"), new Keyboard("Keyboard"), new Monitor("Monitor") };
    }

    @Override
    public void accept(ComputerPartVisitor computerPartVisitor) {
        for (int i = 0; i < parts.length; i++) {
            parts[i].accept(computerPartVisitor);
        }
        computerPartVisitor.visit(this);
    }
}

// 测试
public class VisitorTest {

    public static void main(String[] args) {
        ComputerPart computer = new Computer("Computer");
        ComputerPartVisitor visitor = new ComputerPartDisplayVisitor();

        computer.accept(visitor);
    }
}

• 角色:

  1. Vistor(抽象访问者):
     抽象访问者为对象结构中每个具体元素类ConcreteElement声明一个访问操做，
     从这个操做的名称或参数类型能够清楚知道须要访问的具体元素的类型，具体访问者须要实现这些操做方法，定义对这些元素的访问操做。

  2. ConcreteVisitor(具体访问者):
     具体访问者实现了每一个由抽象访问者声明的操做，每个操做用于访问对象结构中一种类型的元素。

  3. Element(抽象元素):
     抽象元素通常是抽象类或者接口，它定义一个accept()方法，该方法一般以一个抽象访问者做为参数。

  4. ConcreteElement(具体元素):
     具体元素实现了accept()方法，在accept()方法中调用访问者的访问方法以便完成对一个元素的操做。

  5. ObjectStructure(对象结构):
     对象结构是一个元素的集合，它用于存放元素对象，而且提供了遍历其内部元素的方法。它能够结合组合模式来实现，
     也能够是一个简单的集合对象，如一个List对象或一个Set对象。

• 缺点:

  1. 增长新的元素类很困难,在访问者模式中，每增长一个新的元素类都意味着要在抽象访问者角色中增长一个新的抽象操做，
     并在每个具体访问者类中增长相应的具体操做，违背了“开闭原则”的要求。

  2. 破坏封装,当采用访问者模式的时候，就会打破组合类的封装。