Ricerca…


Osservazioni

Come nota a margine, alcuni vantaggi del modello Monostate rispetto a Singleton :

  • Non esiste un metodo 'instance` per poter accedere a un'istanza della classe.
  • Un Singleton non è conforme alla notazione Java bean, ma un Monostate fa.
  • La durata delle istanze può essere controllata.
  • Gli utenti della Monostate non sanno che stanno usando una Monostate .
  • Il polimorfismo è possibile.

Il modello Monostate

Il pattern Monostate viene solitamente definito zucchero sintattico sul pattern Singleton o come Singleton concettuale .

Evita tutte le complicazioni di avere una singola istanza di una classe, ma tutte le istanze usano gli stessi dati.
Ciò si ottiene principalmente utilizzando membri di dati static .
Una delle caratteristiche più importanti è che è assolutamente trasparente per gli utenti, che sono completamente all'oscuro del fatto che stanno lavorando con una Monostate . Gli utenti possono creare tutte le istanze di Monostate come vogliono e ogni istanza è buona come un'altra per accedere ai dati.

La classe Monostate viene solitamente fornita con una classe companion che viene utilizzata per aggiornare le impostazioni, se necessario.

Segue un esempio minimale di 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; }
};

Ecco un esempio di una semplice implementazione di un 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;
    }
}

Gerarchie basate su monostazione

In contrasto con Singleton , il Monostate è adatto per essere ereditato per estendere le sue funzionalità, purché i metodi dei membri non siano static .
Segue un esempio minimale 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; }
};


Modified text is an extract of the original Stack Overflow Documentation
Autorizzato sotto CC BY-SA 3.0
Non affiliato con Stack Overflow