Come implementare le classi che dovrebbero essere caricate una volta?

Molte di queste risposte suggeriscono l'uso del pattern Singleton o l'uso di statiche, ma non sono d'accordo. Sì, questo porterà a termine il lavoro, ma IMHO, è una cattiva pratica. È più difficile testare e isolare il codice che utilizza il codice Singleton / statico, quindi non è l'ideale. Userei il pattern Inversion of Control / In Dependency Injection. Fondamentalmente funziona così ( Nota che provengo da uno sfondo Java ):

class INeedOneInstanceOfAClass {
    OneInstanceOfAClass oneInstanceOfAClass;

    public void setOneInstanceOfAClass(OneInstanceOfAClass oneInstanceOfAClass) {
        this.oneInstanceOfAClass = oneInstanceOfAClass;
    }
    // ...
}

Qualche altro codice è responsabile per chiamare quel setter. Il codice che chiama il setter si assicura che crei solo un'istanza di OneInstanceOfAClass e passi la stessa istanza in tutte le altre classi che hai con un metodo setOneInstanceOfAClass. Di conseguenza, esiste una sola istanza di OneInstanceOfAClass ma, OneInstanceOfAClass non è un Singleton e non è necessario utilizzare statico in alcun luogo. È solo una lezione normale che ti istanzia solo una volta.

Ora è davvero facile isolare INeedOneInstanceOfAClass in un test unitario. Il tuo test unitario crea INeedOneInstanceOfAClass e passa in un falso OneInstanceOfAClass che fa tutto ciò che deve fare per uscire dal test dell'unità.

quello che stai cercando "Un'istanza SINGOLA di una classe" la strada da percorrere è con un modello Singleton.

implementazione di base di un modello singleton.

Class Test
{
    $private $testInstance;

    private function __construct() { };

    public static function getInstance();
    {
        if ($this->testInstance === null) {
            $this->testInstance = new self();
        }

        return $this->testInstance;
    }
}

e da un altro posto si ottiene quella classe instanciata con

$test = Test::getInstance();

ogni volta che avrai bisogno dell'oggetto chiamerai il metodo statico getInstance e restituirà l'oggetto, oppure lo creerà e lo restituirà.

spero che aiuti.

Suggerisco di renderli statici se puoi, cioè se la tua classe non deve salvare il suo stato. Se lo fa, penso che tu possa fare meglio una sorta di classe framework che ha un membro di tipo INPUT. Quando si desidera utilizzare il framework, viene creato un oggetto framework che crea un'istanza di un oggetto INPUT. Trascini l'oggetto framework ovunque ti servano i metodi da INPUT. È meglio debuggable e manutenibile di un singleton. inoltre, questo: link

Quando si utilizza il pattern Singleton, è necessario creare __clone () private

class Single
{
    ... some code here ...
    private function __clone(){}
}

in modo che tu non possa fare qualcosa del genere:

$instance = Single::getInstance();
$second = clone $instance;

quando NON è fatto in questo modo, stai ricevendo due istanze separate, e se __clone () è privato questo produrrà un errore