Dieser Artikel bietet Ihnen eine Einführung in den Kombinationsmodus und den Filtermodus in Java-Designmustern. Ich hoffe, dass er Ihnen als Referenz dienen wird.
Im vorherigen Artikel haben wir etwas über den Erscheinungsmodus und den Dekorationsmodus des Strukturmodus gelernt. In diesem Artikel erfahren Sie mehr über den Kombinationsmodus und den Filtermodus.
Einführung
Der kombinierte Modus wird verwendet, um eine Gruppe ähnlicher Objekte als ein einzelnes Objekt zu behandeln. Der Kompositionsmodus kombiniert Objekte gemäß einer Baumstruktur, die zur Darstellung von Teil- und Gesamthierarchien verwendet wird. Bei dieser Art von Entwurfsmuster handelt es sich um ein Strukturmuster, das eine Baumstruktur aus Gruppen von Objekten erstellt.
Einfach ausgedrückt geht es darum, ähnliche Objekte entsprechend der Baumstruktur zu kombinieren und dann anzugeben, wofür das Teil verwendet wird. Ein sehr anschauliches Beispiel dafür ist das Dateisystem im Computer.
Das Dateisystem besteht aus Verzeichnissen und Dateien. Jedes Verzeichnis kann Inhalte enthalten. Der Inhalt eines Verzeichnisses kann Dateien oder Verzeichnisse sein. Auf diese Weise wird das Dateisystem des Computers in einer rekursiven Struktur organisiert.
Natürlich können wir den Kombinationsmodus auch hier anhand eines einfachen Beispiels erläutern.
In der Schule gibt es viele Schüler, aber diese Schüler haben unterschiedliche Identitäten. Einige Schüler sind Präsidenten der Studentenvereinigung, einige sind Mitglieder der Studentenvereinigung, einige sind Beobachter, einige sind Mitglieder des Sportausschusses usw. Natürlich. Die meisten von ihnen sind normale Studenten, die keine anderen Positionen bekleiden. Zu diesem Zeitpunkt können wir den Kombinationsmodus zum Kombinieren verwenden.
Die größte studentische Position ist nach Angaben der Studentenvereinigung der Präsident der Studentenvereinigung, und die Mitglieder der Studentenvereinigung verwalten dann die normalen Studenten ein Teil werden kann endlich ein Ganzes werden. Man kann sagen, dass es im Kombinationsmodus sehr konsistent mit 树形结构以表示‘部分-整体’的层次结构 ist.
Kein Unsinn mehr, lassen Sie uns den folgenden Code entwickeln.
Definieren Sie zunächst eine Studentenklasse mit Studentennamen und Positionsattributen.
Fügen Sie dann die Methoden add(), remove() und get() in der Schülerklasse hinzu und führen Sie schließlich hierarchische Aufrufe durch.
Codebeispiel:
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);
});
});
}
}Ausgabeergebnis:
-Student [name=小明, position=学生会主席]
--Student [name=小刚, position=学生会委员]
---Student [name=小红, position=学生]Im obigen Beispiel haben wir drei Schüler hinzugefügt ( Mehr sind die gleichen, hauptsächlich Ideen) und spielen die Rollen des Schülerratspräsidenten, des Schülerratsmitglieds und des Schülers in der Schule. Unter ihnen verwaltet der Präsident des Studentenwerks die Mitglieder des Studentenwerks und die Mitglieder des Studentenwerkskomitees verwalten die Studenten. Zwischen ihnen besteht eine hierarchische Beziehung, Schicht für Schicht. Dabei haben wir auch herausgefunden, dass der Kombinationsmodus tatsächlich darin besteht, ein Objekt in ein anderes Objekt einzufügen und dann durch Kombination ein Layout durchzuführen.
Vorteile des Kombinationsmodus:
Modulaufrufe auf hoher Ebene sind relativ einfach und es ist bequem, einen Knoten hinzuzufügen.
Nachteile des Kombinationsmodus:
Da es sich bei den Deklarationen seiner Unterknoten um Implementierungsklassen und nicht um Schnittstellen handelt, verstößt es gegen das Abhängigkeitsinversionsprinzip.
Nutzungsszenarien:
können als hierarchische Struktur von „Teil-Ganzes“ ausgedrückt werden.
Einführung
Das Filtermuster ermöglicht es Entwicklern, eine Reihe von Objekten nach verschiedenen Kriterien zu filtern und diese durch logische Operationen zu verbinden . Bei dieser Art von Entwurfsmuster handelt es sich um ein Strukturmuster, das mehrere Kriterien kombiniert, um ein einziges Kriterium zu erreichen.
Einfach ausgedrückt besteht die Funktion dieses Modus, wie der Name schon sagt, darin, eine Filterfunktion auszuführen. Wenn wir normalerweise Hintergrundschnittstellen entwickeln, filtern wir auch einige Anfragen heraus. Tatsächlich implementiert der Filtermodus hauptsächlich diese Funktion. Beginnen wir ohne weitere Umschweife mit der entsprechenden Erklärung im Code.
Hier verwenden wir immer noch Schüler, um zu erklären, dass es unter den Schülern Jungen und Mädchen gibt und die Schule unterschiedliche Noten hat. Wenn wir die relevanten Informationen der Schüler zählen, können wir sie verwenden den Filtermodus, um sie zu gruppieren. Zählen Sie zum Beispiel, wie viele Jungen es in der Schule gibt, wie viele Mädchen in der ersten Klasse sind, wie viele Schüler oder Mädchen der dritten Klasse es gibt usw.
Codebeispiel:
Da es viel Code gibt, werde ich ihn hier separat erklären.
Definieren Sie zunächst eine Entitätsklasse mit drei Attributen: Name, Geschlecht und Note.
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 + "]";
}
}Definieren Sie dann eine öffentliche Schnittstelle und geben Sie die Implementierungsmethode an.
interface FilterinGrule {
List<Student> filter(List<Student> students);
}Dann implementieren Sie die Schnittstelle und formulieren verschiedene Filterregeln. Hier gibt es hauptsächlich drei Regeln: normales Filtern und Filtern oder Filtern.
Die spezifische Implementierungsmethode lautet wie folgt:
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;
}
}Zum Schluss rufen Sie den Test auf, fügen einige Schüler hinzu und geben das Geschlecht und die Klasse an. Filtern Sie dann nach verschiedenen Bedingungen.
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));
}
}Ausgabeergebnis:
男生:[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]]
通过上述示例，我们发现过滤器模式其实很简单，制定过滤规则，然后再根据制定的标准来进行过滤，得到符合条件的数据。过滤器模式虽然简单，但是在构建过滤规则的时候，有点繁琐，不过在jdk1.8之后，我们可以使用stream流更方便的进行规则的制定（这一点留在以后再讲）。
过滤器模式的优点：
简单，解耦，使用方便。
过滤器模式的缺点：
好像没有。。。
使用场景：
需要进行筛选的时候。
相关推荐：
Das obige ist der detaillierte Inhalt vonEinführung in Kombinationsmuster und Filtermuster in Java-Entwurfsmustern (Codebeispiel). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
