Design patterns
Monostate
Zoeken…
Opmerkingen
Als een kanttekening, een paar voordelen van het Monostate
patroon ten opzichte van de Singleton
:
- Er is geen 'instance'-methode om toegang te krijgen tot een instantie van de klasse.
- Een
Singleton
voldoet niet aan de Java-bonen notatie, maar eenMonostate
doet. - De levensduur van instanties kan worden geregeld.
- Gebruikers van de
Monostate
weten niet dat ze eenMonostate
. - Polymorfisme is mogelijk.
Het monostaatpatroon
Het Monostate
patroon wordt meestal aangeduid als syntactische suiker boven het Singleton
patroon of als een conceptuele Singleton
.
Het vermijdt alle complicaties van het hebben van een enkele instantie van een klasse, maar alle instanties gebruiken dezelfde gegevens.
Dit wordt meestal bereikt door static
gegevensleden te gebruiken.
Een van de belangrijkste functies is dat het absoluut transparant is voor de gebruikers, die zich er helemaal niet van bewust zijn dat ze met een Monostate
. Gebruikers kunnen zoveel exemplaren van een Monostate
als ze willen en elk exemplaar is goed als een ander om toegang te krijgen tot de gegevens.
De klasse Monostate
wordt meestal geleverd met een begeleidende klasse die wordt gebruikt om de instellingen indien nodig bij te werken.
Het volgt een minimaal voorbeeld van een Monostate
in C ++:
struct Settings {
Settings() {
if(!initialized) {
initialized = true;
// load from file or db or whatever
// otherwise, use the SettingsEditor to initialize settings
Settings::width_ = 42;
Settings::height_ = 128;
}
}
std::size_t width() const noexcept { return width_; }
std::size_t height() const noexcept { return height_; }
private:
friend class SettingsEditor;
static bool initialized;
static std::size_t width_;
static std::size_t height_;
};
bool Settings::initialized = false;
std::size_t Settings::width_;
std::size_t Settings::height_;
struct SettingsEditor {
void width(std::size_t value) noexcept { Settings::width_ = value; }
void height(std::size_t value) noexcept { Settings::height_ = value; }
};
Hier is een voorbeeld van een eenvoudige implementatie van een Monostate
in Java:
public class Monostate {
private static int width;
private static int height;
public int getWidth() {
return Monostate.width;
}
public int getHeight() {
return Monostate.height;
}
public void setWidth(int value) {
Monostate.width = value;
}
public void setHeight(int value) {
Monostate.height = value;
}
static {
width = 42;
height = 128;
}
}
Op monostaten gebaseerde hiërarchieën
In tegenstelling tot de Singleton
is de Monostate
geschikt om te worden geërfd om zijn functionaliteiten uit te breiden, zolang de Monostate
niet static
.
Het volgt een minimaal voorbeeld in C ++:
struct Settings {
virtual std::size_t width() const noexcept { return width_; }
virtual std::size_t height() const noexcept { return height_; }
private:
static std::size_t width_;
static std::size_t height_;
};
std::size_t Settings::width_{0};
std::size_t Settings::height_{0};
struct EnlargedSettings: Settings {
std::size_t width() const noexcept override { return Settings::height() + 1; }
std::size_t height() const noexcept override { return Settings::width() + 1; }
};