Instancier un objet de classe avec un constructeur qui accepte un paramètre de chaîne?

Je tiens à instancier un objet à partir de sa Class objet, en utilisant le constructeur qui accepte un seul String argument.

Voici un code qui s'approche de ce que je veux:

Object object = null;
Class classDefinition = Class.forName("javax.swing.JLabel");
object = classDefinition.newInstance();

Cependant, il instancie la JLabel objet sans texte. Je voudrais utiliser le JLabel constructeur qui accepte une chaîne de caractères que le texte initial. Est-il un moyen de sélectionner un constructeur à partir d'un Class objet?

InformationsquelleAutor HAMID | 2010-08-26

105

Class.newInstance invoque le non-arg constructeur (celui qui ne prend aucun paramètre). Pour invoquer un constructeur différent, vous devez utiliser la réflexion paquet (java.lang.reflect).

Obtenir un Constructor exemple comme ceci:
```
Class<?> cl = Class.forName("javax.swing.JLabel");
Constructor<?> cons = cl.getConstructor(String.class);
```
L'appel à getConstructor indique que vous souhaitez que le constructeur qui prend un seul String paramètre. Maintenant, pour créer une instance:
```
Object o = cons.newInstance("JLabel");
```
Et vous avez terminé.

P. S. utiliser la réflexion comme un dernier recours!
- "en dernier recours". Il y a effectivement des problèmes où c'est la première et la seule option, donc pas sûr de savoir pourquoi vous avez décidé de qualifier votre post comme ça.
InformationsquelleAutor mwittrock

La suite va travailler pour vous.
Essayez ceci,

Class[] type = { String.class };
Class classDefinition = Class.forName("javax.swing.JLabel"); 
Constructor cons = classDefinition .getConstructor(type);
Object[] obj = { "JLabel"};
return cons.newInstance(obj);

InformationsquelleAutor Jothi

Class.forName("className").newInstance() toujours invoque aucun argument constructeur par défaut.

D'invoquer paramétrées constructeur au lieu de zéro argument pas d'argument-constructeur,

Vous devez obtenir Constructor avec des types de paramètres par la transmission de types dans Class[]
pour getDeclaredConstructor méthode de Class
Vous devez créer constructeur instance par la transmission de valeurs dans Object[] pour

newInstance méthode de Constructor

Exemple de code:

import java.lang.reflect.*;

class NewInstanceWithReflection{
    public NewInstanceWithReflection(){
        System.out.println("Default constructor");
    }
    public NewInstanceWithReflection( String a){
        System.out.println("Constructor :String => "+a);
    }
    public static void main(String args[]) throws Exception {

        NewInstanceWithReflection object = (NewInstanceWithReflection)Class.forName("NewInstanceWithReflection").newInstance();
        Constructor constructor = NewInstanceWithReflection.class.getDeclaredConstructor( new Class[] {String.class});
        NewInstanceWithReflection object1 = (NewInstanceWithReflection)constructor.newInstance(new Object[]{"StackOverFlow"});

    }
}

de sortie:

java NewInstanceWithReflection
Default constructor
Constructor :String => StackOverFlow

InformationsquelleAutor Ravindra babu

1

À certains moments, il n'est pas nécessaire de créer un objet de la classe à l'appel des constructeurs et des méthodes. Vous pouvez appeler les méthodes de la classe sans créer d'objet direct. Il est très facile d'appeler un constructeur avec paramètre.
```
import java.lang.reflect.*;
import java.util.*;

class RunDemo
{
    public RunDemo(String s)
    {
        System.out.println("Hello, I'm a constructor. Welcome, "+s);
    }  
    static void show()
    {
        System.out.println("Hello.");
    }
}
class Democlass
{
    public static void main(String args[])throws Exception
    {
        Class.forName("RunDemo");
        Constructor c = RunDemo.class.getConstructor(String.class);  
        RunDemo d = (RunDemo)c.newInstance("User");
        d.show();
    }
}
```
la sortie sera:

Bonjour, je suis un constructeur. Bienvenue, L'Utilisateur

Bonjour.

de la Classe.forName("RunDemo"); pour charger le RunDemo Classe.

Constructeur c=RunDemo.classe.getConstructor(String.class); getConstructor() la méthode Constructeur de la classe sera de retour le constructeur qui, ayant Chaîne comme Argument et sa référence est stockée dans l'objet " c " du Constructeur de la classe.

RunDemo d=(RunDemo)c.newInstance("Utilisateur"); la méthode newInstance() du Constructeur de la classe instancier l'RundDemo classe et le retour de la version Générique de l'objet et il est converti en RunDemo type en utilisant la conversion de Type.

L'objet " d " de RunDemo détient la référence renvoyée par la méthode newInstance ().

InformationsquelleAutor reshmi reddy

Vous devez vous connecter pour publier un commentaire.