Java设计模式之访问者模式

定义

结构

案例

优点

定义

封装一些作用于某种数据结构中的各元素的操作，它可以在不改变这个数据结构的前提下定义作用于这些元素的新的操作。

结构

访问者模式包含以下主要角色:

抽象访问者角色：定义了对每一个元素（Element）访问的行为，它的参数就是可以访问的元素，它的方法个数理论上来讲与元素类个数（Element的实现类个数）是一样的，从这点不难看出，访问者模式要求元素类的个数不能改变。
具体访问者角色：给出对每一个元素类访问时所产生的具体行为。
抽象元素角色：定义了一个接受访问者的方法（accept），其意义是指，每一个元素都要可以被访问者访问。
具体元素角色：提供接受访问方法的具体实现，而这个具体的实现，通常情况下是使用访问者提供的访问该元素类的方法。
对象结构角色：定义当中所提到的对象结构，对象结构是一个抽象表述，具体点可以理解为一个具有容器性质或者复合对象特性的类，它会含有一组元素（Element），并且可以迭代这些元素，供访问者访问。

案例

抽象访问类

java 复制代码

//(参数为要访问的元素，且有几个元素就有几个方法)
public interface Person {
    //可以将feed方法名改为visit主要就是为了访问元素，具体实现可以在子类中实现
    void feed(Dog dog);
    void feed(Cat cat);
}

抽象元素类

java 复制代码

//(只定义一个被访问的方法即可)
public interface Animal {
    void accept(Person person);
}

具体元素类

java 复制代码

public class Dog implements Animal {
    @Override
    public void accept(Person person) {
        person.feed(this);
        System.out.println("修勾接受了食物");
    }
}


public class Cat implements Animal{
    @Override
    public void accept(Person person) {
        person.feed(this);
        System.out.println("修猫接受了食物");
    }
}

具体访问类

java 复制代码

public class Owner implements Person{
    @Override
    public void feed(Dog dog) {
        System.out.println("主人投喂食物");
    }

    @Override
    public void feed(Cat cat) {
        System.out.println("主人投喂食物");
    }
}


public class Someone implements Person{
    @Override
    public void feed(Dog dog) {
        System.out.println("陌生人投喂了食物");
    }

    @Override
    public void feed(Cat cat) {
        System.out.println("陌生人投喂了食物");
    }
}

对象结构角色

java 复制代码

public class Home {
    private List<Animal> animals = new ArrayList<>();

    public void action(Person person){
        for (Animal animal : animals) {
            animal.accept(person);
        }
    }

    public void addAnimal(Animal animal){
        animals.add(animal);
    }
}

测试

java 复制代码

public class Client {
    public static void main(String[] args) {
        Home home = new Home();
        home.addAnimal(new Dog());
        home.addAnimal(new Cat());

        home.action(new Owner());
    }
}

主人投喂食物

修勾接受了食物

主人投喂食物

修猫接受了食物

通过对象结构角色来访问具体元素。而访问者通过参数来控制。访问具体元素后调用访问者对应的方法。实现了访问者通过访问不同元素有不同的行为。

优点

扩展性好。在不修改对象结构中的元素的情况下，为对象结构中的元素添加新的功能。（在案例中即Owner与Someone通过实现Person类重写了不同的功能）
复用性好。通过访问者来定义整个对象结构通用的功能，从而提高复用程度。
分离无关行为。通过访问者来分离无关的行为，把相关的行为封装在一起，构成一个访问者，这样每一个访问者的功能都比较单一。

缺点

对象结构变化很困难。在访问者模式中，每增加一个新的元素类，都要在每一个具体访问者类中增加相应的具体操作，这违背了"开闭原则"。
违反了依赖倒置原则。访问者模式依赖了具体类，而没有依赖抽象类。

使用场景

对象结构相对稳定，但其操作算法经常变化的程序。
对象结构中的对象需要提供多种不同且不相关的操作，而且要避免让这些操作的变化影响对象的结构。

扩展

访问者模式用到了一种双分派的技术。

分派

变量被声明时的类型叫做变量的静态类型，有些人又把静态类型叫做明显类型；而变量所引用的对象的真实类型又叫做变量的实际类型。比如 Map map = new HashMap() ，map变量的静态类型是 Map ，实际类型是HashMap 。根据对象的类型而对方法进行的选择，就是分派，分派又分为两种，即静态分派和动态分派。

**静态分派：**发生在编译时期，分派根据静态类型信息发生。静态分派对于我们来说并不陌生，方法重载就是静态分派。

**动态分派：**发生在运行时期，动态分派动态地置换掉某个方法。Java通过方法的重写支持动态分派。

案例实现须知

编译看左，运行看右。

即Map map = new HashMap()，map的真实类型在编译时期是不知道的，在运行后才会知道map的真实类型为HashMap。

对于重写的方法，通过子类对象访问到子类中的方法。

对于重载的方法，分派是根据静态类型进行的，参数类型在编译时期就已经确定了。

动态分派

java 复制代码

public class Animal{
    void print(){
        System.out.println("animal");
    }
}


public class Dog extends Animal{
    void print(){
        System.out.println("dog");
    }
}


public class Cat extends Animal{
    @Override
    void print() {
        System.out.println("cat");
    }
}


public class Client {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Animal dog = new Dog();
        Animal cat = new Cat();

        animal.print();
        dog.print();
        cat.print();
    }
}

animal

dog

cat

由于子类重写了print()方法，因此在运行时动态调用的是真实对象中的print()方法。即多态的实现。

静态分派

java 复制代码

public class Animal{
}


public class Dog extends Animal {
}


public class Cat extends Animal {
}


public class Execute {
    void print(Animal animal){
        System.out.println("animal");
    }

    void print(Dog dog){
        System.out.println("dog");
    }

    void print(Cat cat){
        System.out.println("cat");
    }
}


public class Client {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Animal dog = new Dog();
        Animal cat = new Cat();
        Execute execute = new Execute();
        execute.print(animal);
        execute.print(dog);
        execute.print(cat);
    }
}

animal

animal

animal

对应实现须知中的重载方法部分，对于execute.print()方法，参数dog与cat在编译时期就已经确定了他们的类型是静态类型Animal，因此在运行时并不会通过new Dog()与new Cat()在对dog与cat动态分派

双分派

所谓双分派技术就是因为重载在选择一个方法的时候，不仅仅要根据消息接收者（即上例中的execute运行时的真实类型）的运行时区别，还要根据参数（即参数在运行时的真实类型）的运行时区别。

java 复制代码

public class Animal{
    void accept(Execute execute){
        execute.print(this);
    }
}


public class Dog extends Animal {
    @Override
    void accept(Execute execute) {
        execute.print(this);
    }
}


public class Cat extends Animal {
    @Override
    void accept(Execute execute) {
        execute.print(this);
    }
}


public class Execute {
    void print(Animal animal){
        System.out.println("animal");
    }

    void print(Dog dog){
        System.out.println("dog");
    }

    void print(Cat cat){
        System.out.println("cat");
    }
}


public class Client {
    public static void main(String[] args) {
        Execute execute = new Execute();
        Animal animal = new Animal();
        Animal dog = new Dog();
        Animal cat = new Cat();

        animal.accept(execute);
        dog.accept(execute);
        cat.accept(execute);
    }
}

animal

dog

cat

重载与重写相结合，先进行子类中重写的方法，这里执行第一次分派是动态分派，子类实现方法中将自身作为参数去执行重载方法，完成第二次分派

双分派实现动态绑定的本质，就是在重载方法委派的前面加上了继承体系中覆盖的环节，由于覆盖是动态的，所以重载就是动态的了。