Que sont les méthodes statiques d'usine?

le modèle de méthode d'usine statique est une façon d'encapsuler la création d'objet. Sans méthode d'usine, vous appelleriez simplement le constructeur de la classe "151990920 directement: Foo x = new Foo() . Avec ce modèle, vous appelleriez plutôt la méthode d'usine: Foo x = Foo.create() . Les constructeurs sont marqués private, de sorte qu'ils ne peuvent pas être appelés sauf de l'intérieur de la classe, et la méthode d'usine est marquée comme static de sorte qu'il peut être appelée sans avoir d'abord un objet.

Il y a quelques avantages à ce modèle. La première est que l'usine peut choisir parmi de nombreuses sous-classes (ou les responsables de la mise en œuvre d'une interface) et retourner cela. De cette façon, l'appelant peut spécifier le comportement désiré via les paramètres, sans avoir à connaître ou à comprendre une hiérarchie de classe potentiellement complexe.

un autre avantage est, comme Matthew et James l'ont souligné, le contrôle de l'accès à un accès limité des ressources telles que les connexions. C'est une façon de mettre en œuvre pools d'objets réutilisables - au lieu de construire, d'utiliser et de démolir un objet, si la construction et la destruction sont des processus coûteux, il pourrait être plus logique de les construire une fois et de les recycler. La méthode d'usine peut retourner un objet existant, non utilisé instancié s'il en a un, ou en construire un si le nombre d'objets est inférieur à un seuil plus bas, ou jeter une exception ou retourner null s'il est au-dessus de la limite supérieure.

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

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

et

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

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

NOTE! "La static factory method est et non comme la Factory Method pattern " (c) Effective Java, Joshua Bloch.

méthode Factory: "définit une interface pour créer un objet, mais laisse les classes qui implémentent l'interface décider quelle classe instancier. La méthode Factory permet à une classe de différer l'instanciation vers les sous-classes" (c) GoF.

" usine statique la méthode est tout simplement une méthode statique qui renvoie une instance d'une classe."c) à compter du Java, Joshua Bloch. Habituellement, cette méthode est à l'intérieur d'une classe particulière.

la différence:

l'idée clé de la méthode de l'usine statique est de prendre le contrôle de la création d'objet et de le déléguer du constructeur à la méthode statique. La décision de l'objet à créer est comme dans L'usine abstraite faite en dehors de la méthode (dans le cas commun, mais pas toujours). Tandis que la touche (!) idée de méthode D'usine est de déléguer la décision de quelle instance de classe créer à L'intérieur de la méthode D'usine. Par exemple: l'implémentation classique de Singleton est un cas particulier de méthode d'usine statique. Exemple de méthodes statiques d'usine couramment utilisées:

• valeurde
• getInstance
• nouvelle instance

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

comparer

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();

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

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

tout se résume à la maintenabilité. La meilleure façon de le dire est que chaque fois que vous utilisez le mot-clé new pour créer un objet, vous couplez le code que vous écrivez à une implémentation.

le motif d'usine vous permet de séparer comment vous créez un objet de ce que vous faites avec l'objet. Lorsque vous créez TOUS vos objets en utilisant des constructeurs, vous êtes essentiellement le câblage dur le code qui utilise l'objet à cette implémentation. Le code qui utilise votre objet est "dépendant" de l'objet. Cela peut ne pas sembler important à première vue, mais lorsque l'objet change (pensez à changer la signature du constructeur, ou à sous-classer l'objet), vous devez revenir en arrière et rebrancher les choses partout.

Aujourd'hui les usines ont été en grande partie écartées en faveur de l'utilisation de L'Injection de dépendance parce qu'ils exigent beaucoup de code de chaudière qui s'avère être un peu difficile à maintenir lui-même. L'Injection de dépendance est essentiellement équivalent à des usines, mais vous permet de spécifier comment vos objets sont connectés ensemble de manière déclarative (par configuration ou annotations).

Si le constructeur d'une classe est privée, vous ne pouvez pas créer un objet d'une classe de l'extérieur.

class Test{
 int x, y;
 private Test(){
  .......
  .......
  }
}

nous ne pouvons pas créer un objet pour la classe ci-dessus à partir de l'extérieur de celle-ci. Vous ne pouvez donc pas accéder à x, y depuis l'extérieur de la classe. Alors qu'est-ce que l'utilisation de cette classe?

Voici la réponse: méthode de L'usine .

Ajouter la méthode ci-dessous dans la classe ci-dessus

public static Test getObject(){
  return new Test();
}

Alors maintenant, vous pouvez créer un objet de cette classe de l'extérieur. Comme le chemin...

Test t = Test.getObject();

par conséquent, une méthode statique qui renvoie l'objet de la classe en exécutant son constructeur privé est appelée usine méthode

.

j'ai pensé que je vais ajouter un peu de lumière à ce post sur ce que je sais. Nous avons largement utilisé cette technique dans notre recent android project . Au lieu de creating objects using new operator vous pouvez aussi utiliser static method pour instancier une classe. Exemple de Code:

//instantiating a class using constructor
Vinoth vin = new Vinoth(); 

//instantiating the class using static method
Class Vinoth{
  private Vinoth(){
  }
  // factory method to instantiate the class
  public static Vinoth getInstance(){
    if(someCondition)
        return new Vinoth();
  }
}

static methods support conditional object creation : chaque fois que vous invoquez un constructeur, un objet sera créé, mais vous pourriez ne pas vouloir cela. supposons que vous voulez vérifier une condition que vous souhaitez créer un nouvel objet.Vous ne créeriez pas une nouvelle instance de Vinoth à chaque fois, à moins que votre condition ne soit satisfaite.

un autre exemple tiré de Effective Java .

public static Boolean valueOf(boolean b) {
        return (b ? TRUE : FALSE);
}

cette méthode traduit une valeur primitive booléenne en référence d'objet booléen. La méthode Boolean.valueOf(boolean) nous illustre, elle ne crée jamais un objet. La capacité de static factory methods de retourner le même objet de la répétition invocations permet aux classes de maintenir un contrôle strict sur les instances qui existent à tout moment.

Static factory methods est que, contrairement à constructors , ils peuvent retourner un object de n'importe quel subtype de leur type de retour. Une application de cette flexibilité est qu'une API peut retourner des objets sans rendre leurs classes publiques. Cacher des classes d'implémentation de cette façon conduit à une API très compacte.

calendrier.gettinstance () est un grand exemple pour ce qui précède, il crée en fonction de la localisation un BuddhistCalendar , JapaneseImperialCalendar ou par défaut un Georgian .

un autre exemple que je pourrais penser est Singleton pattern , où vous faites vos constructeurs privés créer une propre méthode getInstance où vous vous assurez, qu'il ya toujours une seule instance disponible.

public class Singleton{
    //initailzed during class loading
    private static final Singleton INSTANCE = new Singleton();

    //to prevent creating another instance of Singleton
    private Singleton(){}

    public static Singleton getSingleton(){
        return INSTANCE;
    }
}

Une méthode de fabrique d'une méthode d'abstraction de l'instanciation d'un objet. Généralement les usines sont utiles quand vous savez que vous avez besoin d'une nouvelle instance d'une classe qui implémente une certaine interface mais vous ne connaissez pas la classe implementing.

ceci est utile lorsque l'on travaille avec des hiérarchies de classes connexes, un bon exemple de cela serait une boîte à outils GUI. Vous pouvez simplement appeler les constructeurs en code dur pour des implémentations concrètes de chaque widget, mais si si tu voulais échanger une boîte à outils contre une autre, tu aurais beaucoup d'endroits à changer. En utilisant une usine à réduire la quantité de code que vous devez modifier.

L'un des avantages qui découle de Static factory est que cette API peut retourner des objets sans rendre leurs classes publiques. Cela conduit à une API très compacte. En java, cela est réalisé par Collections class qui cache environ 32 classes ce qui le rend collection API très compact.

une méthode d'usine statique est bonne quand vous voulez vous assurer qu'une seule instance va retourner la classe de béton à utiliser.

par exemple, dans une classe de connexion de base de données, vous pouvez vouloir avoir une seule classe créer la connexion de base de données, de sorte que si vous décidez de passer de Mysql à Oracle, vous pouvez juste changer la logique dans une classe, et le reste de l'application utilisera la nouvelle connexion.

Si vous voulez mettre en place la mise en commun des bases de données, alors cela serait également fait sans affecter le reste de l'application.

il protège le reste de l'application des changements que vous pouvez faire à l'usine, qui est le but.

la raison pour laquelle il est statique est si vous voulez garder la trace d'une certaine ressource limitée (nombre de connexions de socket ou des poignées de dossier) alors cette classe peut garder la trace de combien de ont été passés dehors et retournés, de sorte que vous n'épuisez pas la ressource limitée.

statique

Un membre déclarée avec le mot-clé "static'.

méthodes d'usine

méthodes qui créent et renvoient de nouveaux objets.

en Java

le langage de programmation est pertinent au sens de "statique", mais non à la définition de "usine".

implémentation de Java contient les classes utilitaires de java.util.Tableaux et java.util.Collections les deux contiennent static factory methods , exemples de it et comment utiliser:

• Arrays.asList("1","2","3")

• Collections.synchronizedList(..), Collections.emptyList(), Collections.unmodifiableList(...) (seulement quelques exemples, pourrait vérifier javadocs pour les méthodes mor exemples https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html )

aussi java.lang.Chaîne classe ont cette statique méthodes de fabrique :

• String.format(...), String.valueOf(..), String.copyValueOf(...)

L'un des avantages des méthodes d'usine statique avec constructeur privé(la création d'objet doit avoir été restreinte pour les classes externes pour s'assurer que les instances ne sont pas créées à l'extérieur) est que vous pouvez créer des classes contrôlées par des instances . Et les classes à instance contrôlée garantissent qu'il n'existe pas deux instances égales distinctes( A. égal (b ) si et seulement si a==b ) pendant votre programme est en cours d'exécution cela signifie que vous pouvez vérifier l'égalité de objets avec = = opérateur au lieu de égale méthode, selon Java efficace.

la capacité des méthodes statiques d'usine de retourner le même objet de invocations répétées permet aux classes de maintenir un contrôle strict sur ce cas existe à tout moment. On dit que les Classes qui font cela sont exemple contrôlée. Il y a plusieurs raisons à écrire classes contrôlées par instance. Contrôle des instances permet à une classe de garantie qu'elle est unique (point 3) ou non substantielle (point 4). En outre, il permet à une classe immuable (Point 15) de faire la garantie qu'il n'existe pas deux instances égales: A. égale (b) si et seulement si a==B. Si une classe fait cette garantie, alors ses clients peuvent utiliser l'opérateur == au lieu de la méthode equals(objet), qui peut entraîner une amélioration performance. Les types d'Enum (rubrique 30) fournissent cette garantie.

De Java Effective, Joshua Bloch (point 1,page 6)