Comment se fait-il qu'une classe abstraite "DocumentBuilderFactory" puisse instancier une nouvelle instance ?

Question

Récemment, j'ai travaillé avec des analyseurs XML. Ce n'est qu'un début pour moi et j'ai réussi à comprendre comment utiliser les classes d'analyseurs DOM en Java, à savoir DocumentBuilderFactory y DocumentBuilder pour analyser un document XML.

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();  
DocumentBuilder db = dbf.newDocumentBuilder();            

Ce que je me demande, c'est comment se fait-il qu'une classe abstraite, telle que DocumentBuilderFactory y DocumentBuilder sont autorisés à instancier de nouvelles instances ? Et puis dans un autre exemple, je vois :

Calendar calendar = Calendar.getInstance();  
System.out.println(calendar.get(Calendar.DATE)); 

1. Pour autant que je sache, vous ne pouvez pas instancier (en d'autres termes, créer un objet) les classes abstraites et les classes d'interface. Ai-je raison ?
2. Faites getInstance() y newInstancce() créent des instances des classes abstraites ci-dessus ?

Ai-je manqué quelque chose à propos de l'utilisation d'une classe abstraite et de ses nouveaux objets ?

Answer 1

Cette méthode est une méthode d'usine abstraite qui renvoie un sous-classe de DocumentBuilder qui est une mise en œuvre (concrète).

La classe exacte de l'objet n'est pas importante à connaître, vous avez seulement besoin de savoir que c'est une DocumentBuilder . La méthode peut retourner une instance décidée au moment de l'exécution, ou prédéterminée comme elle l'entend.

Si vous êtes curieux de savoir, vous pouvez imprimer le cours actuel comme ceci :

 System.out.println(dbf.getClass());

---

Notez que la méthode newInstance() ne doit pas être confondue avec la méthode du même nom de l'application Class c'est-à-dire que ces deux-là sont différents :

 // a static method of this class
 DocumentBuilderFactory.newInstance(); 

// an instance method of Class
 DocumentBuilderFactory.class.newInstance();

Un choix de nom malheureux qui a sûrement semé la confusion.

Answer 2

C'est un méthode d'usine abstraite statique qui renverra un sous-type de DocumentBuilderFactory et non l'instance réelle de DocumentBuilderFactory Ce n'est pas comme ce que je présume, vous comprenez :

DocumentBuilderFactory dbf = new DocumentBuilderFactory();

DocumentBuilderFactory#newInstance() , Obtenir une nouvelle instance d'un DocumentBuilderFactory. Cette méthode statique crée une nouvelle instance de factory. Cette méthode utilise la recherche ordonnée suivante pour déterminer la classe d'implémentation de DocumentBuilderFactory à charger.

newInstance() retournera une instance de la classe d'implémentation (sous-type) de DocumentBuilderFactory qui n'est pas abstrait et assignera une référence à cet objet à DocumentBuilderFactory variable de référence.

Answer 3

C'est une méthode statique. Vous pouvez appeler les méthodes statiques des classes abstraites (ou de toute autre classe d'ailleurs) sans référence à une instance

Answer 4

Merci à tous, après avoir essayé le code ci-dessous, mes doutes ont été levés.

Calendrier cls = Calendar.getInstance() ;
Date dt = nouvelle Date() ;
System.out.println(cls.getClass()) ; //<------ 1
DocumentBuilderFactory dbls = DocumentBuilderFactory.newInstance() ; System.out.println(dbls.getClass()) ; //<------2
DocumentBuilder db = dbls.newDocumentBuilder() ;
System.out.println(db.getClass()) ; //<--------3

Et je vois le résultat suivant :

 ********Output******
   class java.util.GregorianCalendar
   class com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderFactoryImpl
   class com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderImpl

a) La méthode statique "DocumentBuilderFactory.newInstance()" renvoie une instance de classe de sous-type appelée "DocumentBuilderFactoryImpl" .

b) "DocumentBuilderFactoryImpl" est une sous-classe de la classe abstraite "DocumentBuilderFacotory", il n'y a donc aucun problème si je donne :

DocumentBuilderFacotryImpl dbls = DocumentBuilderFactory.newInstance() ;
//-----Au lieu de donner DocumentBuilderFactory dbls = DocumentBuilderFactory.newInstance() ;

et il en va de même pour DocumentBuilderImpl db = dbls.newDocumentBuilder() ;
//---- Au lieu de DocumentBuilder db = dbls.bewDocumentBuilder() ;

Conclusion : newInstance(), newDocumentBuilder(), getInstance() renvoie un objet de sous-classe. Bien que les classes abstraites ne puissent pas créer de nouveaux objets, nous pouvons assigner un objet de sous-classe à la variable de référence de la classe abstraite (i.e.parent). ex :

Classe abstraite A{ }
classe B extends A{ }

nous pouvons dire :

 A a = new B();   

mais pas

 A a = new A();