¿Crear una instancia de un objeto de clase con constructor que acepte un parámetro de cadena?

Lo siguiente funcionará para usted. Prueba esto,

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

Class.forName("className").newInstance() siempre invoca ningún argumento constructor predeterminado.

Para invocar constructor parametrizado en lugar del argumento cero constructor no-arg,

1. Tienes que obtener Constructor con tipos de parámetros pasando tipos en Class[] para getDeclaredConstructor método de Class
2. Debe crear una instancia de constructor pasando valores en Object[] para
   newInstance método de Constructor

Código de ejemplo:

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"});

    }
}

Salida:

java NewInstanceWithReflection
Default constructor
Constructor :String => StackOverFlow

Algunas veces no es necesario crear un objeto para que la clase llame a constructores y métodos is. Puede llamar a métodos de clase sin crear objeto directo. Es muy fácil llamar a un constructor con parámetro.

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 salida será:

Hola, soy un constructor. Bienvenido, Usuario

Hola.

Clase.forName ("RunDemo"); cargará la clase RunDemo.

Constructor c = RunDemo.clase.getConstructor (String.clase); El método getConstructor () de la clase Constructor devolverá el constructor que tiene String como Argumento y su referencia se almacena en el objeto 'c' de la clase Constructor.

RunDemo d = (RunDemo) c. newInstance("User"); el método newInstance () de la clase Constructor instanciará la clase RundDemo y devolverá la versión Genérica de object y se convertirá en tipo RunDemo usando Type casting.

El objeto ' d ' de RunDemo contiene la referencia devuelta por el Método newInstance ().