访问者模式：表示一个作用与某对象结构中的各元素操作，可以使在不改变各元素类的前提下定义这些元素的新操作

    优点：可以将数据操作和数据结构分离

    实现：人类在生理上分两种性别，男和女，这两种性别面对不同的行为，大多数会形成两种截然不同的反应。

    1、个体类（数据结构）

    1. /**
    2.  * 抽象个体
    3.  */
    4. public abstract class Person {
    6.     /**
    7.      * 针对行为作出的反应
    8.      */
    9.     public abstract void doAction(Action action);
    10. }
    12. /**
    13.  * 男人
    14.  */
    15. public class ManPerson extends Person{
    17.     public void doAction(Action action){
    18.         action.manAction(this);
    19.     }
    20. }
    22. /**
    23.  * 女人
    24.  */
    25. public class WoManPerson extends Person{
    27.     public void doAction(Action action){
    28.         action.woManAction(this);
    29.     }
    30. }

    2、行为类（数据操作）

    1. /**
    2.  * 抽象行为
    3.  */
    4. public abstract class Action {
    6.     /**
    7.      * 男人行为
    8.      */
    9.     public abstract void manAction(ManPerson person);
    11.     /**
    12.      * 女人行为
    13.      */
    14.     public abstract void woManAction(WoManPerson person);
    15. }
    17. /**
    18.  * 成功
    19.  */
    20. public class Success extends Action{
    22.     /**
    23.      * 男人行为
    24.      */
    25.     public void manAction(ManPerson person){
    26.         System.out.println("男人成功背后，大多拥有一个伟大的女人");
    27.     }
    29.     /**
    30.      * 女人行为
    31.      */
    32.     public void woManAction(WoManPerson person){
    33.         System.out.println("女人成功背后，大多拥有一个不成功的男人");
    34.     }
    35. }
    37. /**
    38.  * 失恋
    39.  */
    40. public class Lovelorn extends Action{
    42.     /**
    43.      * 男人行为
    44.      */
    45.     public void manAction(ManPerson person){
    46.         System.out.println("男人失恋，大多闷头喝酒，谁也不用劝");
    47.     }
    49.     /**
    50.      * 女人行为
    51.      */
    52.     public void woManAction(WoManPerson person){
    53.         System.out.println("女人失恋，大多泪眼汪汪，谁劝也不好使");
    54.     }
    55. }

    3、对象结构类（批量处理）

    1. /**
    2.  * 对象结构类
    3.  */
    4. public class ObjectStructure {
    5.     List<Person> list = new ArrayList<>();
    7.     public void add(Person person){
    8.         list.add(person);
    9.     }
    11.     public void remove(Person person){
    12.         list.remove(person);
    13.     }
    15.     public void structure(Action action){
    16.         list.forEach(person -> {
    17.             person.doAction(action);
    18.         });
    19.     }
    20. }

    4、测试类

    1. /**
    2.  * 测试访问者模式
    3.  */
    4. public class TestVisitor {
    5.     public static void main(String [] args){
    6.         ManPerson manPerson = new ManPerson();
    7.         WoManPerson woManPerson = new WoManPerson();
    9.         ObjectStructure objectStructure = new ObjectStructure();
    10.         objectStructure.add(manPerson);
    11.         objectStructure.add(woManPerson);
    13.         Action success = new Success();
    14.         Action lovelorn = new Lovelorn();
    16.         objectStructure.structure(success);
    17.         objectStructure.structure(lovelorn);
    18.     }
    19. }

    测试结果：
    image.png

    访问者模式通常的使用场景：
    1、对象结构毕竟稳定，但是通常要对对象结构定义新的操作（譬如人类性别生理上分为男女两种，这个对象结构是固定的，但是人类的行为是千千万万）
    2、需要对对象结构进行很多不同，并且不相关的操作，而需要避免这些操作污染这些类的对象，也不希望增加操作时修改这些类