Java nouvelleInstance()

La méthode Java newinstance() de la classe entre en jeu chaque fois que la classe doit créer une nouvelle instance de manière dynamique. Cette méthode sera appelée en plus de la méthode déjà existante, qui est le nom .class utilisé pour charger dynamiquement n'importe quelle classe. Cette méthode newInstance() sera appelée en plus de cette classe pour créer des objets dynamiquement. Cette méthode newInstance() de la classe ne prend en compte aucun paramètre ou argument de la classe, ce qui signifie qu'elle ne possède aucun constructeur ; ainsi, il peut être appelé le constructeur sans argument pour une classe.

PUBLICITÉ Cours populaire dans cette catégorie MAÎTRISÉE JAVA - Spécialisation | 78 séries de cours | 15 tests simulés

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Syntaxe

public Tsk newInstance() throws InitiationException, IllegalAccessException

Le flux syntaxique se compose des paramètres suivants, qui représentent :

• Public : Modificateur d'accès à la classe en cours de définition et de déclaration.
• Tsk : Nom de la classe déclarée et est générique, ce qui signifie qu'elle peut penser comme une classe Object et des génériques.
• newInstance() : Nom de la méthode appelée pour créer et charger un objet dynamiquement avec ajout au nom .class de la classe.
• lancements : mot-clé pour attraper et lancer des exceptions.
• InitiationException : suivi du mot-clé throws, il est utilisé pour intercepter les exceptions qui sont initiées initialement.
• IllegalAccessException : utilisé pour intercepter et accéder à toutes les exceptions illégales ou inutilisées.

Comment fonctionne la méthode newInstance() en Java ?

Tout newInstance() de la classe ou du constructeur est appelé et est utilisé pour créer une nouvelle instance de la classe. Il est toujours préférable d'utiliser la méthode newInstance() du constructeur plutôt que d'utiliser la méthode newInstance() de la classe car la méthode newInstance() du constructeur peut utiliser n'importe quel nombre d'arguments, ce qui n'est pas le cas avec newInstance( ) de la classe car la méthode newInstance() de la classe ne possède aucun argument, ce qui signifie un constructeur sans argument dans la classe. De plus, il est parfois comparé et mélangé avec le nouvel opérateur de n'importe quelle classe.

Le flux de travail de la méthode newInstance() est ainsi celui où le nouvel opérateur est utilisé pour créer les objets, puis une décision est prise s'il est nécessaire de créer l'objet au moment de l'exécution ou de la compilation ou s'il est très nécessaire pour créer l'objet de manière dynamique. S'il est décidé que l'objet doit être créé au moment de l'exécution, la création d'un nouvel opérateur sera vague. Par conséquent, pour créer l'objet au moment de l'exécution et charger l'objet de manière dynamique, il est nécessaire de créer et d'utiliser la méthode newInstance().

Comme indiqué, la méthode newInstance() de la classe créera d'abord un objet du type classe, puis sera appelée en utilisant un nom .class pour créer la nouvelle instance. La méthode Class.forName() renverra un objet pour la classe, qui renverra l'objet de cette classe qui est passé en argument et si la classe qui passe le paramètre n'existe pas, elle lèvera une exception de ClassNotFoundException.

L'exception d'instanciation suivie de lancers sera appelée et utilisée lorsque la méthode appelle en interne le constructeur par défaut de cette classe. IllegalAccessException se produira s’il n’y a pas d’accessibilité à la classe définie et spécifiée. Ainsi, la méthode newInstance() de la classe est recommandée en raison de la flexibilité et de la polyvalence qu'elle offre pour la création de newInstance() de l'objet à l'aide du chargement dynamique. Le comportement typique et l'invocation des constructeurs et des objets sont différents et améliorés car ils n'incluent aucun paramètre à transmettre aux méthodes et aux objets.

Exemples de Java newInstance()

Voici les exemples suivants mentionnés ci-dessous :

Exemple n°1

Ce programme est utilisé pour illustrer la méthode Class.forName avec la méthode newInstance pour créer l'objet, puis imprimer l'objet de cette classe pour imprimer la valeur de l'animal et le créer pour les exceptions.

Code :

class Animal {  int p; }
class Birds {  int q; }
public class NewInstanceTst
{
public static void sounds(String s)  throws InstantiationException,
IllegalAccessException, ClassNotFoundException
{
Object obj_1 = Class.forName(s).newInstance();
System.out.println("Creation of newly instantiated class:"
+ obj_1.getClass().getName());
}
public static void main(String[] args) throws InstantiationException,
IllegalAccessException, ClassNotFoundException
{
sounds("Animal");
}
}

Sortie :

Exemple n°2

Ce programme démontre la classe newInstance de Java avec la transmission de paramètres ou de constructeurs. Ensuite, il est utilisé pour l'allocation dynamique de l'objet mais n'est pas utilisé car il générera des exceptions illégales. Une classe de test est écrite et exécutée pour vérifier si la classe instanciée peut gérer le chargement dynamique de l'objet.

Code :

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class NwInstncWithconstructors {
public static void main(String[] args)
throws InstantiationException,
IllegalAccessException,
IllegalArgumentException,
InvocationTargetException
{
Constructor[] constructor_a  = Instnace_Constructor_Test.class.getConstructors();
Instnace_Constructor_Test animal = (Instnace_Constructor_Test)constructor_a[0].newInstance();
System.out.println(animal.content);
}
}
class Instnace_Constructor_Test {
String content;
public Instnace_Constructor_Test()
{
System.out.println("Create a new Instance:");
content = "new_instance_of_the_value";
}
}

Output:

Example #3

This program also demonstrates the newInstance class of Java. Still, without passing parameters or constructors, it is used for the dynamic allocation of objects seamlessly and makes the overall class flexible for allocation. Still, if not used, it will throw illegal exceptions. A test class is written and executed to verify whether the instantiated class can handle the object’s dynamic loading. This program calls for a no-arg method which means newInstance class directly.

Code:

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class NewInstanceWithout_Constructors {
public static void main(String[] args)
throws InstantiationException,
IllegalAccessException,
IllegalArgumentException,
InvocationTargetException
{
Constructor[] constructor_without_arr = Without_constructor_Test.class.getConstructors();
Without_constructor_Test sm_ob
= (Without_constructor_Test)constructor_without_arr[0]
.newInstance("one_field_value");
System.out.println(sm_ob.getthat_value());
}
}
class Without_constructor_Test {
private String that_value;
public Without_constructor_Test(String that_value)
{
this.that_value = that_value;
}
public String getthat_value()
{
return that_value;
}
public void setthat_value(String that_value)
{
this.that_value = that_value;
}
}

Output:

Note: It is always recommended to use a newInstance class instead of using a newInstance constructor because it can easily perform dynamic loading of the class and is flexible, unlike the newInstance constructor, which is not at all preferable if used with multiple parameters that too at the run time.

Conclusion

newInstance() method of java class is an added advantage as it is used to dynamically load the object without passing multiple parameters, and then it can be used with versatility within the class, and no external method is called at the run time with the help of .classForName method of the class the work gets solved relentlessly.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!