设计模式(十三)-访问者模式(Visitor Pattern)——访问数据结构并处理数据

原创 2018年02月05日 09:23:39

访问者模式(Visitor Pattern)中,数据结构与处理被分离开来。

Visitor.java

package com.test.dp.Visitor.Sample;

//表示访问者的抽象来,用它来访问文件和文件夹
public abstract class Visitor {
    public abstract void visit(File file);
    public abstract void visit(Directory directory);
}
Element.java

package com.test.dp.Visitor.Sample;

//表示接口的抽象类,用它接受访问者的访问
public interface Element {
    public abstract void accept(Visitor v);
}
Entry.java

package com.test.dp.Visitor.Sample;

import java.util.Iterator;

//File类和Directory类的父类,他是也是抽象类(实现了Element接口)
public abstract class Entry implements Element {
    public abstract String getName();                                   // 获取名字
    public abstract int getSize();                                      // 获取大小
    public Entry add(Entry entry) throws FileTreatmentException {       // 增加目录条目
        throw new FileTreatmentException();
    }
    public Iterator iterator() throws FileTreatmentException {    // 生成Iterator
        throw new FileTreatmentException();
    }
    public String toString() {                                          // 显示字符串
        return getName() + " (" + getSize() + ")";
    }
}
File.java

package com.test.dp.Visitor.Sample;

//表示文件的类,代表了一种结构
public class File extends Entry {
    private String name;
    private int size;
    public File(String name, int size) {
        this.name = name;
        this.size = size;
    }
    public String getName() {
        return name;
    }
    public int getSize() {
        return size;
    }
    public void accept(Visitor v) {
        v.visit(this);
    }
}
Directory.java

package com.test.dp.Visitor.Sample;

import java.util.Iterator;
import java.util.ArrayList;

//表示文件夹的类
public class Directory extends Entry {
    private String name;                    // 文件夹名字
    private ArrayList dir = new ArrayList();      // 目录条目集合
    public Directory(String name) {         // 构造函数
        this.name = name;
    }
    public String getName() {               // 获取名字
        return name;
    }
    public int getSize() {                  // 获取大小
        int size = 0;
        Iterator it = dir.iterator();
        while (it.hasNext()) {
            Entry entry = (Entry)it.next();
            size += entry.getSize();
        }
        return size;
    }
    public Entry add(Entry entry) {         // 增加目录条目
        dir.add(entry);
        return this;
    }
    public Iterator iterator() {      // 生成Iterator
        return dir.iterator();
    }
    public void accept(Visitor v) {         // 接受访问者的访问
        v.visit(this);
    }
}
ListVisitor.java

package com.test.dp.Visitor.Sample;

import java.util.Iterator;

//Visitor访问者抽象类的子类,实现显示文件和文件一览
public class ListVisitor extends Visitor {
    private String currentdir = "";                         // 当前访问的文件夹的名字
    public void visit(File file) {                  // 在访问文件时被调用
        System.out.println(currentdir + "/" + file);
    }
    public void visit(Directory directory) {   // 在访问文件夹时被调用
        System.out.println(currentdir + "/" + directory);
        String savedir = currentdir;
        currentdir = currentdir + "/" + directory.getName();
        Iterator it = directory.iterator();
        while (it.hasNext()) {
            Entry entry = (Entry)it.next();
            entry.accept(this);
        }
        currentdir = savedir;
    }
}
FileTreatmentException.java

package com.test.dp.Visitor.Sample;

//表示向文件发送add时发生异常的类
public class FileTreatmentException extends RuntimeException {
    public FileTreatmentException() {
    }
    public FileTreatmentException(String msg) {
        super(msg);
    }
}
Main.java

package com.test.dp.Visitor.Sample;

public class Main {
    public static void main(String[] args) {
        try {
            System.out.println("Making root entries...");
            Directory rootdir = new Directory("root");
            Directory bindir = new Directory("bin");
            Directory tmpdir = new Directory("tmp");
            Directory usrdir = new Directory("usr");
            rootdir.add(bindir);
            rootdir.add(tmpdir);
            rootdir.add(usrdir);
            bindir.add(new File("vi", 10000));
            bindir.add(new File("latex", 20000));
            rootdir.accept(new ListVisitor());              

            System.out.println("");
            System.out.println("Making user entries...");
            Directory yuki = new Directory("yuki");
            Directory hanako = new Directory("hanako");
            Directory tomura = new Directory("tomura");
            usrdir.add(yuki);
            usrdir.add(hanako);
            usrdir.add(tomura);
            yuki.add(new File("diary.html", 100));
            yuki.add(new File("Composite.java", 200));
            hanako.add(new File("memo.tex", 300));
            tomura.add(new File("game.doc", 400));
            tomura.add(new File("junk.mail", 500));
            rootdir.accept(new ListVisitor());              
        } catch (FileTreatmentException e) {
            e.printStackTrace();
        }
    }
}
执行结果:

Making root entries...
/root (30000)
/root/bin (30000)
/root/bin/vi (10000)
/root/bin/latex (20000)
/root/tmp (0)
/root/usr (0)

Making user entries...
/root (31500)
/root/bin (30000)
/root/bin/vi (10000)
/root/bin/latex (20000)
/root/tmp (0)
/root/usr (1500)
/root/usr/yuki (300)
/root/usr/yuki/diary.html (100)
/root/usr/yuki/Composite.java (200)
/root/usr/hanako (300)
/root/usr/hanako/memo.tex (300)
/root/usr/tomura (900)
/root/usr/tomura/game.doc (400)
/root/usr/tomura/junk.mail (500)

总结:

应用实例:您在朋友家做客,您是访问者,朋友接受您的访问,您通过朋友的描述,然后对朋友的描述做出一个判断,这就是访问者模式。

优点:1、符合单一职责原则。2、优秀的扩展性。3、灵活性。

缺点:1、具体元素对访问者公布细节,违反了迪米特原则。2、具体元素变更比较困难。3、违反了依赖倒置原则,依赖了具体类,没有依赖抽象。

使用场景:1、对象结构中对象对应的类很少改变,但经常需要在此对象结构上定义新的操作。2、需要对一个对象结构中的对象进行很多不同的并且不相关的操作,而需要避免让这些操作"污染"这些对象的类,也不希望在增加新操作时修改这些类。

注意事项:访问者可以对功能进行统一,可以做报表、UI、拦截器与过滤器。


设计模式总结之Visitor Pattern(访问者模式)

表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。...
  • cooldragon
  • cooldragon
  • 2016年08月12日 12:10
  • 4160

设计模式(行为型)之访问者模式(Visitor Pattern)

访问者模式是一种较为复杂的行为型设计模式,它包含访问者和被访问元素两个主要组成部分,这些被访问的元素通常具有不同的类型,且不同的访问者可以对它们进行不同的访问操作。访问者模式使得用户可以在不修改现有系...
  • yanbober
  • yanbober
  • 2015年05月06日 17:11
  • 3243

JAVA设计模式之 访问者模式【Visitor Pattern】

一、概述     访问者模式是一种较为复杂的行为型设计模式,它包含访问者和被访问元素两个主要组成部分,这些被访问的元素通常具有不同的类型,且不同的访问者可以对它们进行不同的访问操作。在使用访问者...
  • l416112167
  • l416112167
  • 2014年11月15日 22:21
  • 3342

我所理解的设计模式(C++实现)——访问者模式(Visitor Pattern)

我们去银行柜台办业务,一般情况下会开几个个人业务柜台的,你去其中任何一个柜台办理都是可以的。我们的访问者模式可以很好付诸在这个场景中:对于银行柜台来说,他们是不用变化的,就是说今天和明天提供个人业务的...
  • LCL_data
  • LCL_data
  • 2013年09月12日 16:07
  • 18433

C++设计模式实现--访问者(Visitor)模式

一. 访问者模式 定义:表示一个作用于某对象结构中的各元素的操作。它你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。 结构如下: 二. 举例 假设有一项...
  • L_Andy
  • L_Andy
  • 2014年07月04日 16:12
  • 1266

JAVA设计模式十四--Visitor(访问者模式)

访问者模式(Visitor Pattern)是GoF提出的23种设计模式中的一种,属于行为模式。 据《大话设计模式》中说算是最复杂也是最难以理解的一种模式了。    定义(源于GoF《Design...
  • hfmbook
  • hfmbook
  • 2012年06月22日 10:20
  • 8949

浅谈JAVA设计模式之——访问者模式(Visitor)

一、概述 表示一个作用于某对象结构中的各元素的操作。 它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。 二、适用性 1.一个对象结构包含很多类对象,它们有不同的接口,而你想对这些对象实...
  • l1028386804
  • l1028386804
  • 2015年05月09日 14:27
  • 1077

访问者模式(Visitor Pattern)的c++实现示例

访问者模式是一种分离对象数据结构与行为的方法,通过这种分离,可以为一个已存在的类或类群(即被访问者)增加新的操作(即访问者)而无需为它们作任何修改。访问者模式属于行为型模式。 为什么要使用访问者模式?...
  • hityct1
  • hityct1
  • 2009年05月09日 23:47
  • 6269

Java设计模式(三) Visitor(访问者)模式及多分派场景应用

基本概念Visitor 封装一些作用于数据结构中的各元素的操作,不同的操作可以借助新的visitor实现,降低了操作间的耦合性 访问者可以将数据结构和对数据的操作解耦,使得增加对数据结构的操作不需要取...
  • qq_24451605
  • qq_24451605
  • 2016年04月14日 15:32
  • 5208

观察者模式(Observer),责任链模式,访问者模式(Visitor)

概念:定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。行为型模式。 main(), IObservable,被观察者接口 CHan...
  • tianyucad123
  • tianyucad123
  • 2016年08月13日 20:10
  • 1138
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:设计模式(十三)-访问者模式(Visitor Pattern)——访问数据结构并处理数据
举报原因:
原因补充:

(最多只允许输入30个字)