Comment utiliser le modèle de visiteur Java pour gérer les structures d'objets de manière élégante

Introduction

Java Visitor Pattern est un modèle de conception comportemental qui permet de séparer les algorithmes des objets sur lesquels ils opèrent. Ce modèle définit un objet visiteur qui peut accéder à différents types d'objets et effectuer certaines opérations, mais vous permet également d'en ajouter de nouvelles. opérations sans modifier le code existant.

Dans le modèle visiteur, il y a deux rôles importants : les visiteurs et les éléments sont des composants d'une structure d'objet. Un visiteur est un objet qui représente une opération à effectuer. via sa méthode d'acceptation.

Le modèle de visiteur Java implique généralement les 5 rôles suivants :

• Visiteur abstrait (Visitor) : Définition Une méthode d'accès qui peut accéder à chaque élément

• Visiteur concret : Implémente la méthode d'accès définie. par le visiteur abstrait, y compris des opérations spécifiques pour différents éléments.

• Abstract Element (Element) : définit une méthode pour accepter l'objet visiteur afin que le visiteur puisse accéder à lui-même.

• Concrete Element (Concrete Element) : implémente. la méthode accepteur définie par l'élément abstrait afin que le visiteur puisse accéder à lui-même

• Structure de l'objet : une collection contenant des éléments, qui peut fournir un itérateur pour parcourir les éléments et peut accepter l'accès des visiteurs

Implémentation.

Il existe différents types d'animaux dans le zoo, notamment les chiens, les chats et les oiseaux. Visite Le mode visiteur peut être utilisé pour compter le nombre de différents types d'animaux, ainsi que les informations sur les attributs des différents types d'animaux. Éléments abstraits

public interface Animal {
    void accept(Visitor visitor);
}

Éléments concrets

@Data
public class Bird implements Animal{
    private String name;
    private String habitat;
    public Bird(String name, String habitat) {
        this.name = name;
        this.habitat = habitat;
    }
    @Override
    public void accept(Visitor visitor) {
        visitor.visitor(this);
    }
}
@Data
public class Cat implements Animal{
    private String sound;
    private int age;
    public Cat(String sound, int age) {
        this.sound = sound;
        this.age = age;
    }
    @Override
    public void accept(Visitor visitor) {
        visitor.visitor(this);
    }
}
@Data
public class Dog implements Animal{
    private String color;
    private int size;
    public Dog(String color, int size) {
        this.color = color;
        this.size = size;
    }
    @Override
    public void accept(Visitor visitor) {
        visitor.visitor(this);
    }
}

Visiteurs abstraits

public interface Visitor {
    void visitor(Dog dog);
    void visitor(Cat cat);
    void visitor(Bird bird);
}

Visiteurs concrets

public class AnimalCountVisitor implements Visitor{
    private int dogCount;
    private int birdCount;
    private int catCount;
    @Override
    public void visitor(Dog dog) {
        dogCount++;
    }
    @Override
    public void visitor(Cat cat) {
        catCount++;
    }
    @Override
    public void visitor(Bird bird) {
        birdCount++;
    }
    public void printCount(){
        System.out.println("狗的个数:"+dogCount);
        System.out.println("猫的个数:"+catCount);
        System.out.println("鸟的个数:"+birdCount);
    }
}
public class AnimalFeatureVisitor implements Visitor {
    private List<String> features;
    public AnimalFeatureVisitor() {
        features = new ArrayList<>();
    }
    @Override
    public void visitor(Dog dog) {
        features.add("Dog:color=" + dog.getColor() + ",size=" + dog.getSize());
    }
    @Override
    public void visitor(Cat cat) {
        features.add("Car:sound=" + cat.getSound() + ",age=" + cat.getAge());
    }
    @Override
    public void visitor(Bird bird) {
        features.add("Bird:name=" + bird.getName() + ",habitat=" + bird.getHabitat());
    }
    public void printFeatures(){
        features.forEach(System.out::println);
    }
}

Test

public class Demo {
    public static void main(String[] args) {
        List<Animal> animals = new ArrayList<>();
        animals.add(new Dog("褐色", 50));
        animals.add(new Dog("白色", 45));
        animals.add(new Cat("喵喵叫", 2));
        animals.add(new Cat("呜呜声", 3));
        animals.add(new Bird("鹦鹉", "森林"));
        animals.add(new Bird("麻雀", "田野"));
        AnimalCountVisitor animalCountVisitor = new AnimalCountVisitor();
        AnimalFeatureVisitor animalFeatureVisitor = new AnimalFeatureVisitor();
        animals.forEach(animal -> {
            animal.accept(animalCountVisitor);
            animal.accept(animalFeatureVisitor);
        });
        animalCountVisitor.printCount();
        animalFeatureVisitor.printFeatures();
    }
}

Dans cet exemple, nous avons défini trois classes d'animaux, dont Chien, Chat et Oiseau. Ils implémentent tous l'Animal. et avoir une méthode d'acceptation, qui passe dans le paramètre Type de visiteur.

Ensuite, l'interface Visiteur est définie, qui contient la méthode visiteur, qui accède en fonction des différents types d'animaux transmis.

Dans l'implémentation spécifique de Visiteur, deux visiteurs, AnimalCountVisitor et AnimalFeatureVisitor, sont définis. Le premier est utilisé pour compter le nombre de types d'animaux différents, et le second est utilisé pour imprimer les attributs des différents types d'animaux

Résumé

Avantages

.

Séparation des algorithmes et des objets : Le modèle visiteur permet de séparer les algorithmes et les objets, car l'algorithme est défini dans le visiteur, et l'objet expose ses propres données au visiteur lors de son accès
Bonne évolutivité : Ce modèle. peut facilement ajouter de nouvelles opérations sans affecter la structure de l'objet existante, car l'accès Le modèle Visiteur sépare la structure de l'objet des opérations
Conforme au principe ouvert-fermé : Le modèle visiteur est conforme au principe ouvert-fermé car vous pouvez en ajouter de nouvelles. visiteurs et nouveaux types d'éléments sans modifier le code existant. ajouter de nouveaux types d'éléments, L'interface visiteur existante doit être modifiée, ce qui peut entraîner des modifications du code existant
Rupture de l'encapsulation : Le modèle visiteur nécessite d'exposer les données internes de l'objet au visiteur, ce qui peut détruire l'encapsulation de l'objet.
Scénarios d'application

Lorsque vous devez exploiter une structure d'objet complexe sans exposer son implémentation interne, vous pouvez utiliser le modèle de visiteur.
Lorsque vous devez ajouter de nouveaux objets à chaque objet dans le. structure de l'objet Le modèle Visiteur peut être utilisé lorsque les opérations sont effectuées sans affecter sa hiérarchie de classes.
Le modèle Visiteur peut être utilisé lorsque la hiérarchie de classes d'un objet change mais que ses opérations restent relativement stables. déterminer dynamiquement les actions à effectuer au moment de l'exécution.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!