Quand utiliser statique vs instancié classes

C'est assez intéressante question, et les réponses peuvent être intéressant aussi ^^

La façon la plus simple de penser à des choses peut-être :

• utiliser une classe instanciée où chaque objet dispose de données sur son propre (comme un utilisateur a un nom)
• utiliser une classe statique alors que c'est juste un outil qui fonctionne sur d'autres trucs (comme, par exemple, une syntaxe convertisseur pour BB code HTML ; il n'a pas une vie propre)

(Ouais, j'avoue, vraiment, vraiment trop simplifié...)

Une chose à propos des méthodes statiques/classes, c'est qu'ils ne facilitent pas les tests unitaires (au moins en PHP, mais probablement dans d'autres langues).

Une autre chose à propos de la statique des données est d'une seule instance, il en existe un dans votre programme : si vous définissez Maclasse::$myData une valeur à quelque part, il va avoir cette valeur, et seulement, à chaque où, Parlant de l'utilisateur, vous serez en mesure d'avoir un seul utilisateur -- qui n'est pas très grande, est-il ?

Pour un système de blog, que pouvais-je dire ? Il n'y a pas beaucoup que je voudrais écrire comme statique, en fait, je pense que, peut-être que le DB-classe d'accès, mais probablement pas, en fin de compte ^^

Donc en PHP statique peut être appliqué à des fonctions ou des variables. Non les variables statiques sont liés à une instance spécifique d'une classe. Non statique méthodes de loi sur l'instance d'une classe. Donc, nous allons faire une classe appelée BlogPost.

title serait un non-membre statique. Il contient le titre de ce billet de blog. On pourrait également avoir une méthode appelée find_related(). Il n'est pas statique, car il a besoin d'informations à partir d'une instance spécifique de l'article du blog de la classe.

Cette classe devrait ressembler à quelque chose comme ceci:

class blog_post {
    public $title;
    public $my_dao;

    public function find_related() {
        $this->my_dao->find_all_with_title_words($this->title);
    }
}

Sur l'autre main, à l'aide des fonctions statiques, vous pouvez écrire une classe comme ceci:

class blog_post_helper {
    public static function find_related($blog_post) {
         //Do stuff.
    }
}

Dans ce cas, puisque la fonction est statique et n'agit pas sur tout billet de blog particulier, vous devez passer le blog en tant qu'argument.

Fondamentalement c'est une question à propos de la conception orientée objet. Vos cours sont les noms dans votre système et les fonctions qui agissent sur eux sont les verbes. Les fonctions statiques sont d'ordre procédural. Vous passez à l'objet de l'fonctions comme arguments.

Mise à jour: je voudrais aussi ajouter que la décision est rarement entre les méthodes d'instance et des méthodes statiques, et de plus en plus entre l'utilisation des classes et à l'aide de tableaux associatifs. Par exemple, dans une application de blogs, soit vous lisez les messages de blog à partir de la base de données et de les convertir en objets, ou de vous laisser dans le jeu de résultats et de les traiter comme des tableaux associatifs. Ensuite, vous écrivez des fonctions qui prennent des tableaux ou des listes de tableaux associatifs comme arguments.

Dans le OO scénario, vous méthodes d'écriture sur votre BlogPost classe qui agissent sur les postes individuels, et vous écrivez les méthodes statiques de la loi sur les collections de postes.

J'ai une approche différente de la plupart des réponses ici, en particulier lors de l'utilisation de PHP. Je pense que toutes les classes doivent être statique, sauf si vous avez une bonne raison, pourquoi pas. Une partie de la "pourquoi pas" les raisons sont les suivantes:

• Vous avez besoin de plusieurs instances de la classe
• Votre classe doit être étendue
• Les parties de votre code ne peut pas partager les variables de classe avec d'autres parties

Permettez-moi de prendre un exemple. Étant donné que chaque script PHP génère du code HTML, mon cadre est un html écrivain de classe. Cela garantit qu'aucune autre classe va tenter d'écrire le code HTML car il est spécialisé tâche qui devrait être concentrée dans une seule classe.

En général, vous utilisez le code html de la classe comme ceci:

html::set_attribute('class','myclass');
html::tag('div');
$str=html::get_buffer();

Chaque fois get_buffer() est appelée, elle réinitialise tout, de sorte que la prochaine classe à utiliser le html écrivain commence dans un état connu.

Toutes mes classes statiques ont une fonction init() qui doit être appelée avant que la classe est utilisée pour la première fois. C'est plus par convention que d'une nécessité.

L'alternative à une classe statique dans ce cas est en désordre. Vous ne voudriez pas que chaque classe qui a besoin d'écrire un petit peu de html d'avoir à gérer une instance de l'html écrivain.

Maintenant, je vais vous donner un exemple de quand ne pas utiliser les classes statiques. Ma classe de formulaire gère une liste de la forme des éléments, comme des saisies de texte, listes déroulantes et plus. Il est généralement utilisé comme ceci:

$form = new form(stuff here);
$form->add(new text(stuff here));
$form->add(new submit(stuff here));
$form->render(); //Creates the entire form using the html class

Il n'y a aucun moyen que vous pouvez le faire avec les classes statiques, d'autant plus que certains des constructeurs de chaque classe de faire beaucoup de travail. Aussi, la chaîne de la succession pour tous les éléments est assez complexe. Donc, c'est un exemple clair où les classes statiques ne doivent pas être utilisés.

La plupart des classes utilitaires tels que ceux de la conversion/chaînes de mise en forme sont de bons candidats pour être une classe statique. Ma règle est simple: tout se passe statique en PHP sauf si il y a une raison pourquoi il ne devrait pas.

D'abord vous demander, qu'est-ce que cet objet va représenter? Une instance de l'objet qui est bon pour les opérations sur les ensembles distincts de données dynamiques.

Un bon exemple serait l'ORM ou couche d'abstraction de base. Vous pouvez avoir plusieurs connexions de base de données.

$db1 = new Db(array('host' => $host1, 'username' => $username1, 'password' => $password1));
$db2 = new Db(array('host' => $host2, 'username' => $username2, 'password' => $password2));

Les deux connexions peuvent désormais fonctionner de manière indépendante:

$someRecordsFromDb1 = $db1->getRows($selectStatement);
$someRecordsFromDb2 = $db2->getRows($selectStatement);

Maintenant à l'intérieur de ce paquet/bibliothèque, il y a peut être d'autres classes telles que Db_Row, etc. pour représenter une ligne spécifique retourné par une instruction SELECT. Si cette Db_Row classe était une classe statique, alors ce serait être en supposant que vous n'avez qu'une ligne de données dans une base de données et il serait impossible de faire ce que l'instance d'un objet pourrait. Avec une instance, vous pouvez maintenant avoir un nombre illimité de lignes dans un nombre illimité de tables dans un nombre illimité de bases de données. La seule limite est le matériel du serveur ;).

Par exemple, si la méthode getRows sur la Db objet renvoie un tableau de Db_Row objets, vous pouvez maintenant utiliser sur chaque ligne indépendamment l'un de l'autre:

foreach ($someRecordsFromDb1 as $row) {
    //change some values
    $row->someFieldValue = 'I am the value for someFieldValue';
    $row->anotherDbField = 1;

    //now save that record/row
    $row->save();
}

foreach ($someRecordsFromDb2 as $row) {
    //delete a row
    $row->delete();
}

Un bon exemple d'une classe statique serait quelque chose qui gère les variables de registre, ou des variables de session car il n'y aura qu'un registre ou une session par utilisateur.

Dans une partie de votre application:

Session::set('someVar', 'toThisValue');

Et dans une autre partie:

Session::get('someVar'); //returns 'toThisValue'

Depuis il n'est jamais va être un utilisateur à la fois par session, il n'y a pas de point dans la création d'une instance de la Session.

J'espère que cette aide, ainsi que les autres réponses pour aider à clarifier les choses. Comme une note de côté, découvrez "la cohésion" et "couplage". Ils présentent de très, très bonnes pratiques à utiliser lors de l'écriture de votre code qui s'appliquent à tous les langages de programmation.

En général, vous devez utiliser des variables et des fonctions de membre, sauf si elle doit absolument être partagée entre toutes les instances ou à moins de créer un singleton. À l'aide des données sur les membres et les fonctions de membre vous permet de réutiliser vos fonctions de plusieurs pièces différentes de données, alors que vous ne pouvez avoir qu'une seule copie de données sur lequel vous travaillez, si vous utilisez des données statiques et des fonctions. En outre, bien que pas aussi applicable à PHP, les fonctions statiques de données et de conduire à un code non réentrant, tandis que la classe de données facilite la réentrée.