Que sont les méthodes d'usine statiques ?

Question

Qu'est-ce qu'une méthode de "fabrique statique" ?

Answer 1

Le site modèle de méthode d'usine statique est un moyen d'encapsuler la création d'objets. Sans une méthode de fabrique, vous appelleriez simplement la méthode de création de la classe Constructeur directement : Foo x = new Foo() . Avec ce modèle, vous feriez plutôt appel à la méthode factory : Foo x = Foo.create() . Les constructeurs sont marqués comme privés, ils ne peuvent donc être appelés que depuis l'intérieur de la classe, et la méthode d'usine est marquée comme étant static afin qu'il puisse être appelé sans avoir d'abord un objet.

Ce modèle présente quelques avantages. Le premier est que la fabrique peut choisir parmi de nombreuses sous-classes (ou implémenteurs d'une interface) et les retourner. De cette façon, l'appelant peut spécifier le comportement souhaité via des paramètres, sans avoir à connaître ou à comprendre une hiérarchie de classes potentiellement complexe.

Un autre avantage est, comme l'ont souligné Matthew et James, de contrôler l'accès à une ressource limitée telle que les connexions. C'est une façon d'implémenter des pools d'objets réutilisables - Au lieu de construire, utiliser et détruire un objet, si la construction et la destruction sont des processus coûteux, il peut être plus judicieux de les construire une fois et de les recycler. La méthode factory peut retourner un objet instancié existant et inutilisé si elle en a un, ou en construire un si le nombre d'objets est inférieur à un certain seuil, ou encore lever une exception ou renvoyer null si elle est supérieure au seuil supérieur.

Selon l'article de Wikipedia, les méthodes d'usine multiples permettent également différentes interprétations de types d'arguments similaires. Normalement, le constructeur porte le même nom que la classe, ce qui signifie que vous ne pouvez avoir qu'un seul constructeur avec une classe donnée. signature . Les usines ne sont pas aussi limitées, ce qui signifie que vous pouvez avoir deux méthodes différentes qui acceptent les mêmes types d'arguments :

Coordinate c = Coordinate.createFromCartesian(double x, double y)

et

Coordinate c = Coordinate.createFromPolar(double distance, double angle)

Cela peut également être utilisé pour améliorer la lisibilité, comme le note Rasmus.

Answer 2

NOTE ! "Le méthode d'usine statique es PAS le même que le Méthode d'usine pattern" (c) Effective Java, Joshua Bloch.

Méthode d'usine : " Définir une interface pour créer un objet, mais laisser les classes qui implémentent l'interface décider de la classe à instancier ". La méthode Factory permet à une classe de reporter l'instanciation à des sous-classes" (c) GoF.

"Une méthode de fabrique statique est simplement une méthode statique qui renvoie une instance d'une classe." (c) Effective Java, Joshua Bloch. Généralement, cette méthode se trouve à l'intérieur d'une classe particulière.

La différence :

L'idée principale de la méthode de fabrique statique est de prendre le contrôle de la création de l'objet et de le déléguer du constructeur à la méthode statique. La décision de l'objet à créer est, comme dans Abstract Factory, prise en dehors de la méthode (dans le cas courant, mais pas toujours). Alors que l'idée clé ( !) de la méthode Factory est de déléguer la décision de quelle instance de classe créer à l'intérieur de la méthode Factory. Par exemple, la mise en œuvre classique de Singleton est un cas particulier de méthode de fabrique statique. Exemple de méthodes d'usine statiques couramment utilisées :

• valeurOf
• getInstance
• newInstance

Answer 3

Nous évitons de fournir un accès direct aux connexions aux bases de données car elles sont gourmandes en ressources. Nous utilisons donc une méthode d'usine statique getDbConnection qui crée une connexion si on est en dessous de la limite. Sinon, il essaie de fournir une connexion "de réserve", et échoue avec une exception s'il n'y en a pas.

public class DbConnection{
   private static final int MAX_CONNS = 100;
   private static int totalConnections = 0;

   private static Set<DbConnection> availableConnections = new HashSet<DbConnection>();

   private DbConnection(){
     // ...
     totalConnections++;
   }

   public static DbConnection getDbConnection(){

     if(totalConnections < MAX_CONNS){
       return new DbConnection();

     }else if(availableConnections.size() > 0){
         DbConnection dbc = availableConnections.iterator().next();
         availableConnections.remove(dbc);
         return dbc;

     }else {
         throw new NoDbConnections();
     }
   }

   public static void returnDbConnection(DbConnection dbc){
     availableConnections.add(dbc);
     //...
   }
}

Answer 4

La lisibilité peut être améliorée par des méthodes d'usine statiques :

Comparez

public class Foo{
  public Foo(boolean withBar){
    //...
  }
}

//...

// What exactly does this mean?
Foo foo = new Foo(true);
// You have to lookup the documentation to be sure.
// Even if you remember that the boolean has something to do with a Bar
// you might not remember whether it specified withBar or withoutBar.

à

public class Foo{
  public static Foo createWithBar(){
    //...
  }

  public static Foo createWithoutBar(){
    //...
  }
}

// ...

// This is much easier to read!
Foo foo = Foo.createWithBar();

Answer 5

• ont des noms, contrairement aux constructeurs, ce qui peut clarifier le code.
• n'ont pas besoin de créer un nouvel objet à chaque invocation - les objets peuvent être mis en cache et réutilisés, si nécessaire.
• peuvent retourner un sous-type de leur type de retour - en particulier, peut retourner un objet dont la classe d'implémentation est inconnue de l'appelant. Il s'agit d'une fonctionnalité très précieuse et largement utilisée dans de nombreux frameworks qui utilisent des interfaces comme type de retour des méthodes de fabrique statiques.

de http://www.javapractices.com/topic/TopicAction.do?Id=21