JAVA 设计模式 访问者模式

简介: 用途 访问者模式 (Visitor) 表示一个作用于某对象结构中的各元素的操作。 它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。 访问者模式是一种行为型模式。

用途


访问者模式 (Visitor)
表示一个作用于某对象结构中的各元素的操作。
它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
访问者模式是一种 行为型模式


 

用途

图-访问者模式结构图

Visitor : 为该对象结构中 ConcreteElement 的每一个类声明一个 Visit 操作。
abstract  class Visitor {
     public  abstract  void VisitConcreteElementA(ConcreteElementA elementA);
     public  abstract  void VisitConcreteElementB(ConcreteElementB elementB);
}

ConcreteVisitor : 实现每个由 Visitor 声明的操作。每个操作实现算法的一部分,而该算法片段乃是对应于结构中对象的类。

class ConcreteVisitor1  extends Visitor {
    @Override
     public  void VisitConcreteElementA(ConcreteElementA elementA) {
        System.out.println( this.getClass().getName() + " 访问 " + elementA.getClass().getName());
    }

    @Override
     public  void VisitConcreteElementB(ConcreteElementB elementB) {
        System.out.println( this.getClass().getName() + " 访问 " + elementB.getClass().getName());
    }
}

class ConcreteVisitor2  extends Visitor {
    @Override
     public  void VisitConcreteElementA(ConcreteElementA elementA) {
        System.out.println( this.getClass().getName() + " 访问 " + elementA.getClass().getName());
    }

    @Override
     public  void VisitConcreteElementB(ConcreteElementB elementB) {
        System.out.println( this.getClass().getName() + " 访问 " + elementB.getClass().getName());
    }
}

Element : 定义一个Accpet操作,它以一个访问者为参数。

abstract  class Element {
     public  abstract  void Accept(Visitor visitor);
}

ConcreteElement : 实现 Element 声明的 Accept 操作。

class ConcreteElementA  extends Element {
    @Override
     public  void Accept(Visitor visitor) {
        visitor.VisitConcreteElementA( this);
    }
}

class ConcreteElementB  extends Element {
    @Override
     public  void Accept(Visitor visitor) {
        visitor.VisitConcreteElementB( this);
    }
}

ObjectStructure : 可以枚举它的元素,可以提供一个高层的接口以允许访问者访问它的元素。

class ObjectStructure {
     private List<Element> elements =  new ArrayList<Element>();
    
     public  void Attach(Element element) {
        elements.add(element);
    }
    
     public  void Detach(Element element) {
        elements.remove(element);
    }
    
     public  void Accept(Visitor visitor) {
         for (Element elem : elements) {
            elem.Accept(visitor);
        }
    }
}

测试代码

img_405b18b4b6584ae338e0f6ecaf736533.gif
public  class VisitorPattern {
     public  static  void main(String[] args) {
        ObjectStructure o =  new ObjectStructure();
        o.Attach( new ConcreteElementA());
        o.Attach( new ConcreteElementB());
        
        ConcreteVisitor1 v1 =  new ConcreteVisitor1();
        ConcreteVisitor2 v2 =  new ConcreteVisitor2();
        
        o.Accept(v1);
        o.Accept(v2);
    }
}
View Code

运行结果

img_405b18b4b6584ae338e0f6ecaf736533.gif
ConcreteVisitor1 访问 ConcreteElementA
ConcreteVisitor1 访问 ConcreteElementB
ConcreteVisitor2 访问 ConcreteElementA
ConcreteVisitor2 访问 ConcreteElementB
View Code



推荐

本文属于 JAVA设计模式系列



参考资料

《大话设计模式》

《HeadFirst设计模式》
目录
相关文章
|
设计模式 算法
Java--设计模式-24-访问者模式
访问者模式(Visitor Pattern)就是封装一些作用于某种数据结构中的各元素的操作,它可以在不改变这个数据结构的前提下定义作用于其内部各个元素的新操作。通过访问者类改变元素类的执行算法,属于行为型模式。
64 0
Java--设计模式-24-访问者模式
|
设计模式 前端开发
Java-设计模式-20-中介者模式
中介者模式(Mediator Pattern)就是用一个中介类将多个对象和类之间的交互全部放到该类中来处理,这样使得对象之间不需要显式的相互通信,降低代码的耦合性。也属于行为型模式。
43 0
Java-设计模式-20-中介者模式
|
设计模式 Java
Java中常用的设计模式【模板模式】
在模板模式(Template Pattern)中,一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现,但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。
64 0
Java中常用的设计模式【模板模式】
|
设计模式 Java
Java中常用的设计模式【装饰器模式】
装饰器模式(Decorator Pattern)允许向一个现有的对象添加新的功能,同时又不改变其结构。这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装。
99 0
Java中常用的设计模式【装饰器模式】
|
设计模式 算法 Java
java 设计模式之模板方法模式
java 设计模式之模板方法模式
95 0
java 设计模式之模板方法模式
|
设计模式 Java uml
java 设计模式之装饰器模式学习
java 设计模式之装饰器模式学习
100 0
java 设计模式之装饰器模式学习
|
设计模式 自动驾驶 Java
Java中的设计模式(三):装饰器模式
从多型号小鹏中学习装饰器模式
Java中的设计模式(三):装饰器模式
|
Java
JAVA中的设计模式四(装饰模式)
-------装饰模式   装饰模式(Decorator Pattern)允许向一个现有的对象添加新的功能,同时又不改变其结构。这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装。 这种模式创建了一个装饰类,用来包装原有的类,并在保持类方法签名完整性的前提下,提供了额外的功能。
1030 0
|
算法 Java Go
JAVA中的设计模式三(策略模式)
问题: 如何让算法和对象分开来,使得算法可以独立于使用它的客户而变化?   方案: 把一个类中经常改变或者将来可能改变的部分提取出来,作为一个接口,然后在类中包含这个对象的实例,这样类的实例在运行时就可以随意调用实现了这个接口的类的行为。
774 0

热门文章

最新文章