Java implements Visitor pattern
The Visitor pattern is a behavioral design pattern that allows you to define a new operation without changing the class of the element being operated. Using the Visitor pattern can separate the logic of the algorithm from the operation of traversing a data structure.
Applicable scenarios include:
1. When each element in an object structure has different operation modes, and these operation modes may need to be changed frequently, the Visitor pattern can be used. For example, different products in a shopping mall may require different discount methods.
2. When the structure of the element class in an object structure rarely changes, but new operations are often needed in the element class, the Visitor pattern can be used.
The benefits of using the Visitor pattern include:
1. Decouple the data structure and operations, making it convenient to add new operations without modifying the original code.
2. It is easy to add new operations without changing the class of the element, thereby improving the scalability of the code.
The following is an example code of the Visitor pattern implemented in Java:
//Element Interface
interface Element {
void accept(Visitor visitor);
}
//Specific Element A
class ConcreteElementA implements Element {
@Override
public void accept(Visitor visitor) {
visitor.visitElementA(this);
}
public void operationA() {
System. out. println ("Operation of specific element A");
}
}
//Specific Element B
class ConcreteElementB implements Element {
@Override
public void accept(Visitor visitor) {
visitor.visitElementB(this);
}
public void operationB() {
System. out. println ("Operation of specific element B");
}
}
//Visitor Interface
interface Visitor {
void visitElementA(ConcreteElementA elementA);
void visitElementB(ConcreteElementB elementB);
}
//Specific Visitor Class
class ConcreteVisitor implements Visitor {
@Override
public void visitElementA(ConcreteElementA elementA) {
System. out. println ("Specific visitor access element A");
elementA.operationA();
}
@Override
public void visitElementB(ConcreteElementB elementB) {
System. out. println ("Specific visitor accessing element B");
elementB.operationB();
}
}
//Object Structure Class
class ObjectStructure {
private List<Element> elements = new ArrayList<>();
public void addElement(Element element) {
elements.add(element);
}
public void removeElement(Element element) {
elements.remove(element);
}
public void accept(Visitor visitor) {
for (Element element : elements) {
element.accept(visitor);
}
}
}
//Client code
public class Main {
public static void main(String[] args) {
ObjectStructure objectStructure = new ObjectStructure();
objectStructure.addElement(new ConcreteElementA());
objectStructure.addElement(new ConcreteElementB());
Visitor visitor = new ConcreteVisitor();
objectStructure.accept(visitor);
}
}
In the above example, the Visitor pattern is used to implement specific operations through the Visitor interface, and the specific operations are encapsulated in the ConcreteVisitor class. The element interface defines the accept method, which is used to delegate specific operations to the visitor for execution. The concrete element class implements the Element interface, and calls the corresponding method of the visitor in the accept method to perform specific operations.
By using the Visitor pattern, you can easily implement different operations on different elements, while improving the scalability and maintainability of the code.
