Besøksdesignmønster i Java
Introduksjon
Besøksdesignmønster er et atferdsmønster som lar objekter fra en hierarkisk struktur akseptere operasjoner ved hjelp av et felles grensesnitt. Med andre ord, det lar deg definere nye operasjoner for en eksisterende objektstruktur uten å endre grensesnittene til selve objektene.
Besøksdesignmønsteret er spesielt nyttig når du trenger å utføre ulike operasjoner på en samling av objekter som deler et felles superklasse, men har forskjellige typer. I stedet for å implementere operasjonene i hver enkelt klasse, kan vi bruke en besøkende klasse som utfører operasjonene på alle objektene i samlingen.
Hvordan fungerer besøksdesignmønsteret?
Besøksdesignmønsteret består av følgende komponenter:
Besøkende: Dette er et grensesnitt som definerer operasjonene som kan utføres på objekter i hierarkiet.
Konkrete besøkende: Disse er klasser som implementerer besøksgrensesnittet. Hver konkret besøkende implementerer en spesifikk operasjon eller et sett med operasjoner.
Besøkbare: Dette er et grensesnitt som definerer metoden for å akseptere en besøkende.
Konkrete besøkbare: Disse er klasser som implementerer det besøkbare grensesnittet. Hver konkret besøkbar klasse representerer et objekt som kan besøkes av konkret besøkende.
Fordeler med besøksdesignmønsteret
Bruken av besøksdesignmønsteret gir flere fordeler, blant annet:
* Fleksibilitet: Det lar deg legge til nye operasjoner til et objektstruktur uten å endre eksisterende klasser.
* Løs kobling: Det kobler ikke besøkerklassene direkte til de besøkte klassene, noe som gjør det enklere å vedlikeholde koden.
* Utvidbarhet: Det gjør det enkelt å legge til nye konkrete besøkende og besøkbare klasser i fremtiden.
Implementering av besøksdesignmønsteret i Java
For å implementere besøksdesignmønsteret i Java, kan vi følge disse trinnene:
1. Definer besøksgrensesnittet: Dette grensesnittet bør inneholde metodene for operasjonene som kan utføres på de besøkbare objektene.
2. Opprett konkrete besøkende: Disse klassene bør implementere besøksgrensesnittet og definere den konkrete logikken for hver operasjon.
3. Definer det besøkbare grensesnittet: Dette grensesnittet bør inneholde metoden accept() som aksepterer et besøksobjekt.
4. Opprett konkrete besøkbare: Disse klassene bør implementere det besøkbare grensesnittet og implementere accept()-metoden for å kalle den tilsvarende besøksmetoden.
5. Bruk besøksdesignmønsteret: I klientkoden kan vi opprette en samling av besøkbare objekter, opprette en konkret besøkende og kalle accept()-metoden på hvert besøkbare objekt for å utføre ønskede operasjoner.
Eksempel
La oss se et eksempel på hvordan vi kan implementere besøksdesignmønsteret i Java for å beregne totalt areal og volum for en samling av former:
java
// Besøksgrensesnitt
public interface Visitor {
int visit(Square square);
int visit(Triangle triangle);
int visit(Circle circle);
}
// Konkrete besøkende for å beregne totalt areal
public class AreaVisitor implements Visitor {
private int totalArea;
@Override
public int visit(Square square) {
return totalArea += square.getArea();
}
@Override
public int visit(Triangle triangle) {
return totalArea += triangle.getArea();
}
@Override
public int visit(Circle circle) {
return totalArea += circle.getArea();
}
public int getTotalArea() {
return totalArea;
}
}
// Konkrete besøkende for å beregne totalt volum
public class VolumeVisitor implements Visitor {
private int totalVolume;
@Override
public int visit(Square square) {
return totalVolume += square.getVolume();
}
@Override
public int visit(Triangle triangle) {
return totalVolume += triangle.getVolume();
}
@Override
public int visit(Circle circle) {
return totalVolume += circle.getVolume();
}
public int getTotalVolume() {
return totalVolume;
}
}
// Besøkbar grensesnitt
public interface Visitable {
int accept(Visitor visitor);
}
// Konkrete besøkbare for firkant
public class Square implements Visitable {
private int sideLength;
public Square(int sideLength) {
this.sideLength = sideLength;
}
public int getArea() {
return sideLength * sideLength;
}
public int getVolume() {
return 0; // Firkanten har ikke volum
}
@Override
public int accept(Visitor visitor) {
return visitor.visit(this);
}
}
// Konkrete besøkbare for trekant
public class Triangle implements Visitable {
private double base;
private double height;
public Triangle(double base, double height) {
this.base = base;
this.height = height;
}
public double getArea() {
return 0.5 base height;
}
public double getVolume() {
return 0; // Trekanten har ikke volum
}
@Override
public int accept(Visitor visitor) {
return visitor.visit(this);
}
}
// Konkrete besøkbare for sirkel
public class Circle implements Visitable {
private double radius;
public Circle(double radius) {
this.radius = radius;
}
public double getArea() {
return Math.PI radius radius;
}
public double getVolume() {
return 4 / 3 Math.PI * radius * radius radius;
}
@Override
public int accept(Visitor visitor) {
return visitor.visit(this);
}
}
// Klientkode
public class Client {
public static void main(String[] args) {
// Opprett en samling av former
Visitable[] shapes = {
new Square(5),
new Triangle(4, 6),
new Circle(3)
};
// Opprett besøkende for å beregne totalt areal
Visitor areaVisitor = new AreaVisitor();
for (Visitable shape : shapes) {
shape.accept(areaVisitor);
}
System.out.println("Totalt areal: " + areaVisitor.getTotalArea());
// Opprett besøkende for å beregne totalt volum
Visitor volumeVisitor = new VolumeVisitor();
for (Visitable shape : shapes) {
shape.accept(volumeVisitor);
}
System.out.println("Totalt volum: " + volumeVisitor.getTotalVolume());
}
}
Konklusjon
Besøksdesignmønsteret er et kraftfullt verktøy som gir fleksibilitet og utvidbarhet til objektorienterte programmer. Ved å skille operasjoner fra objekter, gjør det det enkelt å legge til nye funksjoner til et system uten å endre eksisterende kode.
Besøksdesignmønsteret er spesielt nyttig i situasjoner der du trenger å utføre forskjellige operasjoner på en samling av relaterte objekter, men hver operasjon må utføres annerledes avhengig av typen av hvert objekt.
Ofte stilte spørsmål (FAQs)
1. Hva er forskjellen mellom besøksdesignmønsteret og strategimønsteret?
– Strategimønsteret fokuserer på å kapsle inn algoritmer, mens besøksdesignmønsteret fokuserer på å kapsle inn operasjoner på en objektstruktur.
2. Når bør jeg bruke besøksdesignmønsteret?
– Når du trenger å utføre forskjellige operasjoner på en samling av objekter som deler en felles superklasse, men har forskjellige typer.
3. Hva er fordelene med å bruke besøksdesignmønsteret?
– Fleksibilitet, løs kobling og utvidbarhet.
4. Hva er ulempene med å bruke besøksdesignmønsteret?
– Kan introdusere kompleksitet og overhead hvis det ikke brukes riktig.
5. Kan besøksdesignmønsteret brukes med andre designmønstre?
– Ja, det