En termes simples, qu'est-ce qu'une usine?

Connaissez-vous JDBC? C'est une seule et même usine (abstraite). C'est un bon exemple dans la réalité.

// Factory method. Loads the driver by given classname. It actually returns a 
// concrete Class<Driver>. However, we don't need it here, so we just ignore it.
// It can be any driver class name. The MySQL one here is just an example.
// Under the covers, it will do DriverManager.registerDriver(new Driver()).
Class.forName("com.mysql.jdbc.Driver");

// Abstract factory. This lets the driver return a concrete connection for the
// given URL. You can just declare it against java.sql.Connection interface.
// Under the covers, the DriverManager will find the MySQL driver by URL and call
// driver.connect() which in turn will return new ConnectionImpl().
Connection connection = DriverManager.getConnection(url);

// Abstract factory. This lets the driver return a concrete statement from the
// connection. You can just declare it against java.sql.Statement interface.
// Under the covers, the MySQL ConnectionImpl will return new StatementImpl().
Statement statement = connection.createStatement();

// Abstract factory. This lets the driver return a concrete result set from the
// statement. You can just declare it against java.sql.ResultSet interface.
// Under the covers, the MySQL StatementImpl will return new ResultSetImpl().
ResultSet resultSet = statement.executeQuery(sql);

Vous n'avez pas besoin d'avoir une seule ligne de import spécifique au pilote JDBC dans votre code. Vous n'avez pas besoin de faire import com.mysql.jdbc.ConnectionImpl ou quelque chose. Il suffit de tout déclarer contre java.sql.*. Vous n'avez pas besoin de faire connection = new ConnectionImpl(); vous-même. Il vous suffit de l'obtenir à partir d'une usine abstraite dans le cadre d'une API standard.

Si vous faites du nom de classe du pilote JDBC une variable qui peut être configuré en externe (par exemple, fichier de propriétés) et écrire des requêtes SQL compatibles ANSI, alors vous n'avez jamais besoin de réécrire, recompiler, reconstruire et redistribuer votre application Java pour chaque fournisseur de base de données et/ou pilote JDBC dont le monde est au courant. Il vous suffit de déposer le fichier JAR du pilote JDBC souhaité dans le chemin de classe d'exécution et de fournir la configuration par un fichier (propriétés) sans avoir besoin de changer de ligne de code Java chaque fois que vous souhaitez changer de base de données ou réutiliser l'application sur un DB différent.

C'est la puissance des interfaces et des usines abstraites.

Un autre exemple connu du monde réel est Java EE. Remplacez "JDBC" par "Java EE" et "JDBC driver" par "Java EE application server" (WildFly, TomEE, GlassFish, Liberty, etc.).

Voir aussi:

• Comment voulez - Class#forName() et DriverManager#getConnection() travail?
• Qu'est-ce que Java EE exactement?
• Wikipedia: Modèle de méthode d'usine
• Wikipédia: Modèle abstrait d'usine

En termes simples, Factoryest un modèle de conception OO qui traite de la création d'objets sans spécifier la classe exacte de l'objet à créer.

Une bonne raison pour les utiliser, il est bien définie dans wikipedia:

La création d'un objet nécessite souvent des processus complexes non approprié pour inclure dans un objet composant. Objet la création peut conduire à une duplication importante du code, peut nécessiter information non accessible à l'objet composant, peut ne pas fournir un niveau d'abstraction suffisant, ou peut autrement ne pas faire partie de la composer les préoccupations de l'objet. Les poignées de modèle de conception de méthode d'usine ces problèmes en définissant une méthode distincte pour créer les objets, quelles sous-classes peuvent alors remplacer pour spécifier le type dérivé de produit qui va être créé.

Le modèle de conception d'usine est idéal lorsque vous devez créer plusieurs instances d'un objet au moment de l'exécution. Plutôt que de créer explicitement chaque instance, vous pouvez initialiser de nombreux cas. De plus, vous pouvez encapsuler du code de création complexe qui peut être réutilisé plusieurs fois.

Exemple:

public class Person {
    int ID;
    String gender;
    public Person(int ID,String gender){
        this.ID=ID;
        this.gender=gender;
    }
    public int getID() {
        return ID;
    }
    public String getGender() {
        return gender;
    }
}
public class PersonFactory{
    public static Person createMale(int id){
        return new Person(id,"M");
    }
    public static Person createFemale(int id){
        return new Person(id,"F");
    }
}
public class factorytest{
    public static void main(String[]args){
        Person[] pList= new Person[100];
        for(int x=0;x<100;x++){
            pList[x]=PersonFactory.createMale(x);
        }
    }
}

Dans cet exemple, nous encapsulons les détails du paramètre d'initialisation du genre et pouvons simplement demander à PersonFactory de createMale ou createFemale Person objet.

Qu'est-ce qu'une usine ?

Wikipédia, explique en détail

Voir également la réponse du légendaireBalusC sur ici à propos de nombreux exemples de modèles GoF
En termes simples Factory crée\initialiser\allouer les objets que vous pouvez utiliser dans le code.
par exemple si vous avez une classe abstraite ou une interface person ou même une classe concrète et que vous la déclarez dans une autre classe, par exemple private person;, c'est juste que l'objet a été déclaré mais pas créé. Vous utiliserez soit une nouvelle injection de dépendance, soit une usine pour créer cet objet (il existe également d'autres options, par exemple Localisateur, etc.).

Pourquoi voudrais-je en utiliser un?

Maintenant, vous pourriez avoir besoin d'un type spécifique de personne, par exemple, un enseignant ou même une personne pourrait avoir une implantation différente basée sur différentes configurations, etc.Le modèle d'usine prend soin de this.It vous permet ou devrais je dire vous libère de vous soucier de ce que la mise en œuvre ou l'initialisation d'une classe particulière doit être utilisée.

La fabrique est un objet, qui crée des objets. L'usage courant comprend deux cas:

• Lorsque vous souhaitez déléguer le choix de l'objet concret à l'usine - par exemple, il peut renvoyer un objet déjà existant (voir Integer.valueOf(), qui est une méthode dite d'usine) ou choisir une implémentation concrète en fonction de certaines conditions-par exemple argument fourni ou options prédéfinies (voir XPathFactory classe dans API Java pour le traitement XML )
• Quand vous voulez plus de flexibilité pour certains universelle de l'emploi. Vous ne pouvez pas passer une méthode ou un constructeur comme argument (eh bien, vous pouvez, mais la réflexion est nulle), vous utilisez donc une usine concrète comme source d'objet (par exemple SomeFactory<T> dans une méthode générique).

Usine est un objet pour la création d'autres objets.

Il crée des objets sans exposer la logique d'instanciation au client.

Utilisez ce modèle lorsque vous ne souhaitez pas exposer la logique d'instanciation d'objet au client / appelant

Articles connexes:

Modèles de conception: Usine vs Méthode d'usine vs Usine abstraite

Quelle est la différence de base entre les modèles d'usine et les modèles d'usine abstraits?