Modo de visitante: Encapsula algunas operaciones que actúan en cada elemento en una determinada estructura de datos. Puede definir nuevas operaciones que actúen sobre estos elementos sin cambiar esta estructura de datos. El diagrama de estructura del modo de visitante es el siguiente:
De la imagen de arriba, puedes ver que tiene los siguientes personajes:
Rol de visitante abstracto: define una interfaz y declara una o más operaciones de acceso.
Rol de visitante concreto: implementa la interfaz declarada por los visitantes abstractos, es decir, las diversas operaciones de acceso declaradas por los visitantes abstractos.
Rol de elemento abstracto (visitable): declara una operación de aceptación, aceptando un objeto de visitante como parámetro.
Role de retrete: implementa la operación de aceptación especificada por nodos abstractos.
Rol de objeto de estructura de datos (ObjectStructure): puede atravesar todos los elementos de la estructura y proporcionar una interfaz para que el objeto del visitante acceda a cada elemento.
El código de simulación es el siguiente:
Visitante de interfaz {Visita void (Gladiolus G); Visita nula (Chrysanthemum C); } // Nombre del visitante concreto La clase de acceso StringVisitor implementa el visitante {String S; public String toString () {return s; } visita pública nula (gladiolus g) {s = "gladiolus"; } visita publicitaria publicitaria (Chrysanteumum c) {s = "Chrysanteumum"; }} // La clase de visitante concreto Beevisitor implementa el visitante {Visita pública void (Gladiolus g) {System.out.println ("Bee para acceder a Gladiolus"); } visita publicitaria pública (Chrysanteum c) {System.out.println ("Bee para acceder a Chrysanteum"); }} flor de interfaz {void actge (visitante v); } / * * Elemento de concreto Chrysanthemum implementa flor {public void Acept (Visitor V) {V.Visit (this); }} // La clase de elemento concreto Gladiolus implementa flor {public void Acept (Visitor V) {V.Visit (this); }} // Esta es una clase de generador de objetos de flores FlowerGenerator {private static aleator Rand = new Random (); public static Flower Newflower () {switch (rand.nextint (2)) {predeterminado: caso 0: return new Gladiolus (); Caso 1: devolver nuevo Chrysanthemum (); }}} Prueba de clase pública { / * * Primero, obtenga un rol de visitante específico en el cliente. La estructura del objeto está atravesada. Llame al método de aceptación para cada elemento y pase el rol de visitante específico en. Esto completa todo el proceso*/ public static void main (string args []) {list <flower> flores = new ArrayList <Flower> (); para (int i = 0; i <10; i ++) flores.add (florgenerator.newflower ()); Visitante visitante = new StringVisitor (); Iterador <flower> iterator = flowers.iterator (); while (iterator.hasNext ()) {iterator.next (). Acept (visitante); System.out.println (visitante); } System.out.println ("-----------------------"); /** Un nuevo comportamiento de acceso: Beevisitor Bee Access*/ Visitor Visitor2 = new Beevisitor (); para (flor de flor: flores) {flor.accept (visitante2); }}}resultado:
Glyiolus Chrysanthemum Chrysanthemum Glysanthemum Chrysanthemum Chrysanthemum Chrysanthemum Gladiolus Gladiolus ---------------------------------------------------------------------------------------------------------------------------------------------------------------
El modo de visitante se puede considerar si:
1. Una estructura de objeto contiene muchos objetos de clase, y tienen diferentes interfaces, y desea implementar algunas operaciones que dependan de sus clases específicas de estos objetos.
2. Debe realizar muchas operaciones diferentes e irrelevantes en objetos en una estructura de objetos, y desea evitar que estas operaciones "contaminen" las clases de estos objetos. El visitante le permite concentrar operaciones relacionadas y definirlas en una clase.
3. Cuando muchas aplicaciones compartan la estructura del objeto, use el modo de visitante para permitir que cada aplicación contenga solo las operaciones que deben usarse.
4. Las clases que definen la estructura del objeto rara vez cambian, pero a menudo se necesitan nuevas operaciones para definir esta estructura. Cambiar la clase de estructura de objetos requiere redefinir la interfaz a todos los visitantes, lo que puede ser un gran costo. Si la clase de estructura del objeto cambia con frecuencia, puede ser mejor definir estas operaciones en estas clases.
Estos individuos parecen ser sugerencias, y los problemas específicos deben analizarse en el proyecto.