Introduction au modèle de combinaison et au modèle de filtre dans les modèles de conception Java (exemple de code)-javaDidacticiel-php.cn

Cet article vous présente une introduction au mode combinaison et au mode filtre dans les modèles de conception Java (exemples de code). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Préface

Dans l'article précédent nous avons découvert le mode d'apparence et le mode décorateur du mode structurel. Dans cet article, nous découvrirons le mode combinaison et le mode filtre.

Mode combiné

Introduction

Le mode combiné est utilisé pour traiter un groupe d'objets similaires comme un seul objet. Le mode composition combine les objets selon une structure arborescente, qui est utilisée pour représenter des hiérarchies partielles et entières. Ce type de modèle de conception est un modèle structurel, qui crée une structure arborescente de groupes d’objets.

Pour faire simple, il s'agit de combiner des objets similaires selon l'arborescence, puis d'indiquer à quoi sert la pièce. Il existe un exemple très frappant dans , qui est le système de fichiers de l'ordinateur.

Le système de fichiers se compose de répertoires et de fichiers. Chaque répertoire peut contenir du contenu. Le contenu d'un répertoire peut être des fichiers ou des répertoires. De cette manière, le système de fichiers de l'ordinateur est organisé selon une structure récursive.

Bien sûr, nous pouvons également utiliser un exemple simple pour expliquer le mode combinaison ici.

Dans l'école, il y a beaucoup d'étudiants, mais ces étudiants ont des identités différentes. Certains étudiants sont présidents de syndicats étudiants, certains sont membres de syndicats étudiants, certains sont moniteurs, certains sont membres de comités sportifs, etc. la plupart d'entre eux sont des étudiants ordinaires qui n'occupent pas d'autres postes. À ce stade, nous pouvons utiliser le mode combinaison pour combiner.

Selon la direction, le poste étudiant le plus important est celui de président du syndicat étudiant. Sous le président du syndicat étudiant se trouvent les membres du syndicat étudiant, puis les membres du syndicat étudiant gèrent les étudiants ordinaires. Ils sont indépendants les uns des autres et peuvent. devenir une partie peut enfin devenir un tout. On peut dire que c'est très cohérent avec 树形结构以表示‘部分-整体’的层次结构 en mode combinaison.

Fin de bêtises, développons le code ci-dessous.
Définissez d'abord une classe d'étudiant avec le nom de l'étudiant et les attributs de poste.
Ajoutez ensuite les méthodes add(), remove(), get() dans la classe d'élève, et enfin effectuez des appels hiérarchiques.

Exemple de code :

class Student{
    private String name;
    
    private String position;
    
    private List<Student> students;

    public Student(String name, String position) {
        this.name = name;
        this.position = position;
        students=new ArrayList<Student>();
    }
    
    
    public void add(Student student){
        students.add(student);
    }
    
    public void remove(Student student){
        students.remove(student);
    }
    
    public List<Student> get(){
        return students;
    }
    
    @Override
    public String toString() {
        return "Student [name=" + name + ", position=" + position + "]";
    }   
}


public class CompositeTest {

    public static void main(String[] args) {

        Student studentLeader=new Student("小明","学生会主席");

        Student committeeMember=new Student("小刚","学生会委员");
        
        Student student=new Student("小红","学生");
        
        committeeMember.add(student);
        studentLeader.add(committeeMember);
        
        System.out.println("-"+studentLeader);
        studentLeader.get().forEach(sl->{
            System.out.println("--"+sl);
            sl.get().forEach(cm->{
                System.out.println("---"+cm);
            });
        });
    }
}

Copier après la connexion

Résultat de sortie :

    -Student [name=小明, position=学生会主席]
    --Student [name=小刚, position=学生会委员]
    ---Student [name=小红, position=学生]

Copier après la connexion

Dans l'exemple ci-dessus, nous avons ajouté Trois les étudiants (plus les mêmes, principalement basés sur des idées), jouent respectivement les rôles de président du syndicat étudiant, de membre du syndicat étudiant et d'étudiant dans l'école. Parmi eux, le président du syndicat étudiant gère les membres du syndicat étudiant et les membres du comité du syndicat étudiant gèrent les étudiants. Il existe une relation hiérarchique entre eux, couche par couche. Dans ce cas, nous avons également découvert que le mode combinaison consiste en fait à inclure un objet dans un autre objet, puis à effectuer une mise en page par combinaison.

Avantages du mode combinaison :

Les appels de module de haut niveau sont relativement simples et il est pratique d'ajouter un nœud.

Inconvénients du mode combinaison :

Parce que les déclarations de ses sous-nœuds sont des classes d'implémentation, pas des interfaces, il viole le principe d'inversion de dépendance.

Scénarios d'utilisation :
peut être exprimé comme une structure hiérarchique de « Part-Whole ».

Modèle de filtre

Introduction

Le modèle de filtre permet aux développeurs de filtrer un ensemble d'objets en utilisant différents critères, découplés via des opérations logiques permettant de les connecter . Ce type de modèle de conception est un modèle structurel qui combine plusieurs critères pour atteindre un seul critère.

Pour faire simple, la fonction de ce mode est tout comme son nom, il agit comme un filtre. Lorsque nous développons habituellement des interfaces en arrière-plan, nous filtrerons également certaines requêtes. En fait, le mode filtre implémente principalement cette fonction. Sans plus tarder, commençons par l’explication correspondante dans le code.

Ici, nous utilisons toujours les élèves pour expliquer. Il y a des garçons et des filles parmi les élèves de l'école, et l'école a des notes différentes. À ce moment-là, si nous comptons les informations pertinentes des élèves, nous pouvons les utiliser. le mode filtre pour les regrouper. Par exemple, comptez combien de garçons il y a dans l’école, combien de filles il y a en première année, combien d’élèves ou de filles il y a en troisième année, etc.

Exemple de code :
Comme il y a beaucoup de code, je vais l'expliquer séparément ici.
Définissez d’abord une classe d’entité avec trois attributs : nom, sexe et grade.

class Student{
    private String name; 
    private String gender; 
    private Integer grade;
    public Student(String name, String gender, Integer grade) {
        super();
        this.name = name;
        this.gender = gender;
        this.grade = grade;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String getGender() {
        return gender;
    }
    
    public void setGender(String gender) {
        this.gender = gender;
    }
    
    public Integer getGrade() {
        return grade;
    }
    
    public void setGrade(Integer grade) {
        this.grade = grade;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", gender=" + gender + ", grade=" + grade + "]";
    }
}

Copier après la connexion

Définissez ensuite une interface publique et spécifiez la méthode d'implémentation.

interface FilterinGrule {
    List<Student>  filter(List<Student> students);
}

Copier après la connexion

Implémentez ensuite l'interface et formulez différentes règles de filtrage. Il y a principalement trois règles ici, le filtrage ordinaire et le filtrage, ou filtrage.
La méthode de mise en œuvre spécifique est la suivante :

class MaleStudents implements FilterinGrule{
    @Override
    public List<Student> filter(List<Student> students) {
        List<Student> maleStudents = new ArrayList<Student>(); 
        students.forEach(student->{
             if(student.getGender().equalsIgnoreCase("male")){
                 maleStudents.add(student);
             }
        });
        return maleStudents;
    }
}

class FemaleStudents implements FilterinGrule{
    @Override
    public List<Student> filter(List<Student> students) {
        List<Student> femaleStudents = new ArrayList<Student>(); 
        students.forEach(student->{
             if(student.getGender().equalsIgnoreCase("female")){
                 femaleStudents.add(student);
             }
        });
        return femaleStudents;
    }
}

class SecondGrade implements FilterinGrule{
    @Override
    public List<Student> filter(List<Student> students) {
        List<Student> secondGradeStudents = new ArrayList<Student>(); 
        students.forEach(student->{
             if(student.getGrade() == 2){
                 secondGradeStudents.add(student);
             }
        });
        
        return secondGradeStudents;
    }
}


class And implements FilterinGrule{
     private FilterinGrule filter;
     private FilterinGrule filter2;
    
     public And(FilterinGrule filter,FilterinGrule filter2) {
         this.filter=filter;
         this.filter2=filter2;
     }
    
    @Override
    public List<Student> filter(List<Student> students) {
        List<Student> students2=filter.filter(students);
        return filter2.filter(students2);
    }
}

class Or implements FilterinGrule{
     private FilterinGrule filter;
     private FilterinGrule filter2;
    
     public Or(FilterinGrule filter,FilterinGrule filter2) {
         this.filter=filter;
         this.filter2=filter2;
     }
    
    @Override
    public List<Student> filter(List<Student> students) {
        List<Student> students1=filter.filter(students);
        List<Student> students2=filter2.filter(students);
        students2.forEach(student->{
             if(!students1.contains(student)){
                 students1.add(student);
             }
        });
        return students1;
    }
}

Copier après la connexion

Enfin, appelez le test, ajoutez quelques étudiants et précisez le sexe et la classe. Filtrez ensuite en fonction de différentes conditions.

public class FilterTest {

    public static void main(String[] args) {
        List<Student> list=new ArrayList<Student>();
        list.add(new Student("小明", "male", 1));
        list.add(new Student("小红", "female", 2));
        list.add(new Student("小刚", "male", 2));
        list.add(new Student("小霞", "female", 3));
        list.add(new Student("小智", "male", 3));
        list.add(new Student("虚无境", "male", 1));
        
        
        FilterinGrule male = new MaleStudents();
        FilterinGrule female = new FemaleStudents();
        FilterinGrule secondGrade = new SecondGrade();
        FilterinGrule secondGradeMale = new And(secondGrade, male);
        FilterinGrule secondGradeOrFemale = new Or(secondGrade, female);
        
        System.out.println("男生:"+male.filter(list));
        System.out.println("女生:"+female.filter(list));
        System.out.println("二年级学生:"+secondGrade.filter(list));
        System.out.println("二年级男生:"+secondGradeMale.filter(list));
        System.out.println("二年级的学生或女生:"+secondGradeOrFemale.filter(list));      
    }
}

Copier après la connexion

Résultat de sortie :

男生:[Student [name=小明, gender=male, grade=1], Student [name=小刚, gender=male, grade=2], Student [name=小智, gender=male, grade=3], Student [name=虚无境, gender=male, grade=1]]
女生:[Student [name=小红, gender=female, grade=2], Student [name=小霞, gender=female, grade=3]]
二年级学生:[Student [name=小红, gender=female, grade=2], Student [name=小刚, gender=male, grade=2]]
二年级男生:[Student [name=小刚, gender=male, grade=2]]
二年级的学生或女生:[Student [name=小红, gender=female, grade=2], Student [name=小刚, gender=male, grade=2], Student [name=小霞, gender=female, grade=3]]

Copier après la connexion

通过上述示例，我们发现过滤器模式其实很简单，制定过滤规则，然后再根据制定的标准来进行过滤，得到符合条件的数据。过滤器模式虽然简单，但是在构建过滤规则的时候，有点繁琐，不过在jdk1.8之后，我们可以使用stream流更方便的进行规则的制定（这一点留在以后再讲）。

过滤器模式的优点：

简单，解耦，使用方便。

过滤器模式的缺点：

好像没有。。。

使用场景：

需要进行筛选的时候。