设计模式：访问者模式代码示例

示例1

访问者模式可以类比为一个旅游团访问一个城市，城市中有多个不同的景点。而旅游团中有不同类型的游客，比如摄影师、美食家等。每种类型的游客访问相同的景点都可能有不同的行为。摄影师可能会拍照，美食家可能会寻找当地美食。访问者模式允许我们在不改变景点的情况下，为不同类型的游客添加不同的行为。

生活场景类比

• 景点：对应于元素（Element），它们构成了对象结构，每个景点都可以接待访问者。
• 游客：对应于访问者（Visitor），不同的游客对相同的景点有不同的行为。
• 访问行为：对应于访问者对元素的操作，不同类型的游客访问相同景点时的具体行为。

示例代码

首先，定义表示景点的元素接口和具体元素类：

// 景点接口
interface Place {
    void accept(Visitor visitor);
}

// 博物馆
class Museum implements Place {
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

// 餐馆
class Restaurant implements Place {
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

然后，定义访问者接口和具体访问者：

// 访问者接口
interface Visitor {
    void visit(Museum museum);
    void visit(Restaurant restaurant);
}

// 摄影师
class Photographer implements Visitor {
    @Override
    public void visit(Museum museum) {
        System.out.println("摄影师在博物馆拍摄古代艺术品。");
    }

    @Override
    public void visit(Restaurant restaurant) {
        System.out.println("摄影师在餐馆拍摄美食。");
    }
}

// 美食家
class Foodie implements Visitor {
    @Override
    public void visit(Museum museum) {
        System.out.println("美食家在博物馆寻找附近的特色餐馆。");
    }

    @Override
    public void visit(Restaurant restaurant) {
        System.out.println("美食家在餐馆品尝当地美食。");
    }
}

最后，用客户端代码模拟旅游团的访问过程：

public class CityTour {
    public static void main(String[] args) {
        List<Place> places = Arrays.asList(new Museum(), new Restaurant());
        Visitor photographer = new Photographer();
        Visitor foodie = new Foodie();
        
        // 摄影师访问所有景点
        System.out.println("摄影师的城市之旅：");
        for (Place place : places) {
            place.accept(photographer);
        }
        
        // 美食家访问所有景点
        System.out.println("\n美食家的城市之旅：");
        for (Place place : places) {
            place.accept(foodie);
        }
    }
}

在这个例子中，每个景点都不需要知道访问者的具体类型，它们只需要提供一个接待访问者的方法。访问者根据自己的类型对景点进行不同的访问操作。如果我们需要添加新的访问者类型（比如历史学家），我们只需要添加一个新的访问者类，而不需要修改景点类。

总结与建议

通过类比日常生活场景，我们可以看到访问者模式的核心在于将数据结构和操作解耦，使得我们可以在不改变数据结构的前提下，为元素添加新的操作。在设计系统时，如果遇到类似的需求，可以考虑使用访问者模式。不过，需要注意的是，如果系统中的元素种类经常发生变化，那么这种模式可能会带来维护上的不便。在使用访问者模式时，应该仔细权衡其带来的好处和潜在的复杂性。

示例2

让我们通过一个更具体的例子来深入理解访问者模式：假设我们正在开发一个计算机硬件检测软件，该软件需要对计算机的各个部分（如CPU、内存、硬盘等）进行检测，并且根据检测类型（如性能检测、健康检测）对这些部件执行不同的操作。

示例代码

首先，定义表示计算机部件的元素接口和具体元素类：

// 计算机部件接口
interface ComputerPart {
    void accept(ComputerPartVisitor visitor);
}

// CPU
class CPU implements ComputerPart {
    @Override
    public void accept(ComputerPartVisitor visitor) {
        visitor.visit(this);
    }
}

// 内存
class Memory implements ComputerPart {
    @Override
    public void accept(ComputerPartVisitor visitor) {
        visitor.visit(this);
    }
}

// 硬盘
class HardDrive implements ComputerPart {
    @Override
    public void accept(ComputerPartVisitor visitor) {
        visitor.visit(this);
    }
}

接下来，定义访问者接口和具体访问者：

// 访问者接口
interface ComputerPartVisitor {
    void visit(CPU cpu);
    void visit(Memory memory);
    void visit(HardDrive hardDrive);
}

// 性能检测访问者
class PerformanceVisitor implements ComputerPartVisitor {
    @Override
    public void visit(CPU cpu) {
        System.out.println("检测CPU性能。");
    }

    @Override
    public void visit(Memory memory) {
        System.out.println("检测内存性能。");
    }

    @Override
    public void visit(HardDrive hardDrive) {
        System.out.println("检测硬盘性能。");
    }
}

// 健康检测访问者
class HealthVisitor implements ComputerPartVisitor {
    @Override
    public void visit(CPU cpu) {
        System.out.println("检测CPU健康状态。");
    }

    @Override
    public void visit(Memory memory) {
        System.out.println("检测内存健康状态。");
    }

    @Override
    public void visit(HardDrive hardDrive) {
        System.out.println("检测硬盘健康状态。");
    }
}

最后，使用客户端代码模拟检测过程：

public class Computer {
    ComputerPart[] parts;

    public Computer() {
        parts = new ComputerPart[] {new CPU(), new Memory(), new HardDrive()};
    }

    public void accept(ComputerPartVisitor visitor) {
        for (ComputerPart part : parts) {
            part.accept(visitor);
        }
        visitor.visit(this); // 访问整个计算机
    }

    // 访问整个计算机的方法
    public void visit(Computer computer) {
        System.out.println("检测计算机。");
    }

    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.accept(new PerformanceVisitor()); // 执行性能检测
        System.out.println();
        computer.accept(new HealthVisitor()); // 执行健康检测
    }
}

在这个例子中，Computer、CPU、Memory和HardDrive类代表了不同的计算机部件，它们都实现了ComputerPart接口，允许访问者访问。PerformanceVisitor和HealthVisitor是两种不同的操作，分别代表性能检测和健康检测。通过访问者模式，我们可以轻松地为计算机部件添加新的检测操作，而无需修改部件类的实现。

总结与建议

通过这个例子，我们可以看到访问者模式能够有效地将数据结构（计算机部件）和操作（检测）分离，使得在不修改已有元素的情况下，可以轻松地添加新的操作。这种模式特别适用于数据结构相对稳定，而操作经常变化的场景。然而，如果需要经常添加新的元素，则每次都需要更新所有访问者的实现，这可能会导致维护成本增加。因此，在决定使用访问者模式时，应该仔细考虑系统的需求和未来的变化。