Example usage for java.lang Class getDeclaredConstructors

Introduction

In this page you can find the example usage for java.lang Class getDeclaredConstructors.

Prototype

@CallerSensitive
public Constructor<?>[] getDeclaredConstructors() throws SecurityException 

Source Link

Document

Returns an array of Constructor objects reflecting all the constructors declared by the class represented by this Class object.

Usage

From source file:MainClass.java

public static void main(String[] args) {
    try {/*  w ww. j a  v  a  2 s .c  om*/
        Class c = Class.forName("java.util.ArrayList");

        Constructor constructors[] = c.getDeclaredConstructors();
        for (int i = 0; i < constructors.length; i++) {
            System.out.print(constructors[i].getName() + ": ");
            Class parameters[];
            parameters = constructors[i].getParameterTypes();
            for (int j = 0; j < parameters.length; j++) {
                String s = parameters[j].getName();
                s = s.substring(s.lastIndexOf(".") + 1, s.length());
                System.out.print(s + " ");
            }
            System.out.println("");
        }
    } catch (Exception ex) {
        ex.printStackTrace();
    }
}

---

From source file:Main.java

public static void main(String args[]) throws Exception {
    Class c = Class.forName("MyClass");

    Constructor constructors[] = c.getDeclaredConstructors();
    Object obj = null;/*from  ww w .j ava2s  . c o  m*/
    for (Constructor cons : constructors) {
        Class[] params = cons.getParameterTypes();
        if (params.length == 1 && params[0] == int.class) {
            obj = cons.newInstance(10);
            break;
        }
    }

    if (obj == null) {
        System.out.println("Can't Create MyClass object.");
        return;
    }
}

---

From source file:Charge.java

public static void main(String... args) {
    try {//from   ww  w  .ja v  a2  s  .c o m
        Class<?> c = Charge.class;

        Constructor[] ctors = c.getDeclaredConstructors();
        for (Constructor ctor : ctors) {
            out.format("Constructor: %s%n", ctor.toGenericString());
            ctor.setAccessible(true);
            ctor.newInstance();
        }

        // production code should handle these exceptions more gracefully
    } catch (InstantiationException x) {
        x.printStackTrace();
    } catch (IllegalAccessException x) {
        x.printStackTrace();
    } catch (InvocationTargetException x) {
        x.printStackTrace();
    }
}

---

From source file:Main.java

public static void main(String args[]) throws Exception {
    Class c = Class.forName("MyClass");
    System.out.println("Constructors:");
    Constructor constructors[] = c.getDeclaredConstructors();
    for (Constructor cons : constructors)
        System.out.println(" " + cons);
}

---

From source file:ConstructorAccess.java

public static void main(String... args) {
    try {// w  w w .j  a  v  a 2s  .  c  o m
        Class<?> c = Class.forName(args[0]);
        Constructor[] allConstructors = c.getDeclaredConstructors();
        for (Constructor ctor : allConstructors) {
            int searchMod = modifierFromString(args[1]);
            int mods = accessModifiers(ctor.getModifiers());
            if (searchMod == mods) {
                out.format("%s%n", ctor.toGenericString());
                out.format("  [ synthetic=%-5b var_args=%-5b ]%n", ctor.isSynthetic(), ctor.isVarArgs());
            }
        }

        // production code should handle this exception more gracefully
    } catch (ClassNotFoundException x) {
        x.printStackTrace();
    }
}

---

From source file:ConstructorSift.java

public static void main(String... args) {
    try {//  w w  w  .j  av  a 2s .c  o  m
        Class<?> cArg = Class.forName(args[1]);

        Class<?> c = Class.forName(args[0]);
        Constructor[] allConstructors = c.getDeclaredConstructors();
        for (Constructor ctor : allConstructors) {
            Class<?>[] pType = ctor.getParameterTypes();
            for (int i = 0; i < pType.length; i++) {
                if (pType[i].equals(cArg)) {
                    out.format("%s%n", ctor.toGenericString());

                    Type[] gpType = ctor.getGenericParameterTypes();
                    for (int j = 0; j < gpType.length; j++) {
                        char ch = (pType[j].equals(cArg) ? '*' : ' ');
                        out.format("%7c%s[%d]: %s%n", ch, "GenericParameterType", j, gpType[j]);
                    }
                    break;
                }
            }
        }

        // production code should handle this exception more gracefully
    } catch (ClassNotFoundException x) {
        x.printStackTrace();
    }
}

---

From source file:com.mirth.connect.cli.launcher.CommandLineLauncher.java

public static void main(String[] args) {
    System.setProperty("log4j.configuration", "log4j-cli.properties");
    logger = Logger.getLogger(CommandLineLauncher.class);

    try {//from w w  w .  j  a  va 2  s .  c  o m
        ManifestFile mirthCliJar = new ManifestFile("cli-lib/mirth-cli.jar");
        ManifestFile mirthClientCoreJar = new ManifestFile("cli-lib/mirth-client-core.jar");
        ManifestDirectory cliLibDir = new ManifestDirectory("cli-lib");
        cliLibDir.setExcludes(new String[] { "mirth-client-core.jar" });

        ManifestEntry[] manifest = new ManifestEntry[] { mirthCliJar, mirthClientCoreJar, cliLibDir };

        List<URL> classpathUrls = new ArrayList<URL>();
        addManifestToClasspath(manifest, classpathUrls);
        addSharedLibsToClasspath(classpathUrls);
        URLClassLoader classLoader = new URLClassLoader(classpathUrls.toArray(new URL[classpathUrls.size()]));
        Class<?> cliClass = classLoader.loadClass("com.mirth.connect.cli.CommandLineInterface");
        Constructor<?>[] constructors = cliClass.getDeclaredConstructors();

        for (int i = 0; i < constructors.length; i++) {
            Class<?> parameters[] = constructors[i].getParameterTypes();

            if (parameters.length == 1) {
                constructors[i].newInstance(new Object[] { args });
                i = constructors.length;
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

---

From source file:EnumSpy.java

public static void main(String... args) {
    try {/*from  w  ww. ja v  a2  s.c o m*/
        Class<?> c = Class.forName(args[0]);
        if (!c.isEnum()) {
            out.format("%s is not an enum type%n", c);
            return;
        }
        out.format("Class:  %s%n", c);

        Field[] flds = c.getDeclaredFields();
        List<Field> cst = new ArrayList<Field>(); // enum constants
        List<Field> mbr = new ArrayList<Field>(); // member fields
        for (Field f : flds) {
            if (f.isEnumConstant())
                cst.add(f);
            else
                mbr.add(f);
        }
        if (!cst.isEmpty())
            print(cst, "Constant");
        if (!mbr.isEmpty())
            print(mbr, "Field");

        Constructor[] ctors = c.getDeclaredConstructors();
        for (Constructor ctor : ctors) {
            out.format(fmt, "Constructor", ctor.toGenericString(), synthetic(ctor));
        }

        Method[] mths = c.getDeclaredMethods();
        for (Method m : mths) {
            out.format(fmt, "Method", m.toGenericString(), synthetic(m));
        }

        // production code should handle this exception more gracefully
    } catch (ClassNotFoundException x) {
        x.printStackTrace();
    }
}

---

From source file:ShowClass.java

public static void main(String[] args) throws ClassNotFoundException {
    Class aClass = Class.forName("javax.swing.JComponent");
    if (aClass.isInterface()) {
        System.out.print(Modifier.toString(aClass.getModifiers()) + " " + typeName(aClass));
    } else if (aClass.getSuperclass() != null) {
        System.out.print(Modifier.toString(aClass.getModifiers()) + " class " + typeName(aClass) + " extends "
                + typeName(aClass.getSuperclass()));
    } else {/*from  w w w .  ja  va  2  s .  co  m*/
        System.out.print(Modifier.toString(aClass.getModifiers()) + " class " + typeName(aClass));
    }

    Class[] interfaces = aClass.getInterfaces();
    if ((interfaces != null) && (interfaces.length > 0)) {
        if (aClass.isInterface())
            System.out.print(" extends ");
        else
            System.out.print(" implements ");
        for (int i = 0; i < interfaces.length; i++) {
            if (i > 0)
                System.out.print(", ");
            System.out.print(typeName(interfaces[i]));
        }
    }

    System.out.println(" {");

    Constructor[] constructors = aClass.getDeclaredConstructors();
    for (int i = 0; i < constructors.length; i++)
        printMethodOrConstructor(constructors[i]);

    Field[] fields = aClass.getDeclaredFields();
    for (int i = 0; i < fields.length; i++)
        printField(fields[i]);

    Method[] methods = aClass.getDeclaredMethods();
    for (int i = 0; i < methods.length; i++)
        printMethodOrConstructor(methods[i]);

    System.out.println("}");
}

---

From source file:ReflectClass.java

public static void main(String args[]) {
    Constructor cn[];// w w  w  .  j a v  a  2  s.com
    Class cc[];
    Method mm[];
    Field ff[];
    Class c = null;
    Class supClass;
    String x, y, s1, s2, s3;
    Hashtable classRef = new Hashtable();

    if (args.length == 0) {
        System.out.println("Please specify a class name on the command line.");
        System.exit(1);
    }

    try {
        c = Class.forName(args[0]);
    } catch (ClassNotFoundException ee) {
        System.out.println("Couldn't find class '" + args[0] + "'");
        System.exit(1);
    }

    /*
     * Step 0: If our name contains dots we're in a package so put
     * that out first.
     */
    x = c.getName();
    if (x.lastIndexOf(".") != -1) {
        y = x.substring(0, x.lastIndexOf("."));
        System.out.println("package " + y + ";\n\r");
    }

    /*
     * Let's use the Reflection API to sift through what is
     * inside this class.
     *
     * Step 1: Collect referenced classes
     * This step is used so that I can regenerate the import statements.
     * It isn't strictly required of course, Java works just fine with
     * fully qualified object class names, but it looks better when you
     * use 'String' rather than 'java.lang.String' as the return type.
     */

    ff = c.getDeclaredFields();
    for (int i = 0; i < ff.length; i++) {
        x = tName(ff[i].getType().getName(), classRef);
    }

    cn = c.getDeclaredConstructors();
    for (int i = 0; i < cn.length; i++) {
        Class cx[] = cn[i].getParameterTypes();
        if (cx.length > 0) {
            for (int j = 0; j < cx.length; j++) {
                x = tName(cx[j].getName(), classRef);
            }
        }
    }

    mm = c.getDeclaredMethods();
    for (int i = 0; i < mm.length; i++) {
        x = tName(mm[i].getReturnType().getName(), classRef);
        Class cx[] = mm[i].getParameterTypes();
        if (cx.length > 0) {
            for (int j = 0; j < cx.length; j++) {
                x = tName(cx[j].getName(), classRef);
            }
        }
    }

    // Don't import ourselves ...
    classRef.remove(c.getName());

    /*
     * Step 2: Start class description generation, start by printing
     *  out the import statements.
     *
     * This is the line that goes 'public SomeClass extends Foo {'
     */
    for (Enumeration e = classRef.keys(); e.hasMoreElements();) {
        System.out.println("import " + e.nextElement() + ";");
    }
    System.out.println();

    /*
     * Step 3: Print the class or interface introducer. We use
     * a convienience method in Modifer to print the whole string.
     */
    int mod = c.getModifiers();
    System.out.print(Modifier.toString(mod));

    if (Modifier.isInterface(mod)) {
        System.out.print(" interface ");
    } else {
        System.out.print(" class ");
    }
    System.out.print(tName(c.getName(), null));

    supClass = c.getSuperclass();
    if (supClass != null) {
        System.out.print(" extends " + tName(supClass.getName(), classRef));
    }
    System.out.println(" {");

    /*
     * Step 4: Print out the fields (internal class members) that are declared
     * by this class.
     *
     * Fields are of the form [Modifiers] [Type] [Name] ;
     */

    System.out.println("\n\r/*\n\r * Field Definitions.\r\n */");
    for (int i = 0; i < ff.length; i++) {
        Class ctmp = ff[i].getType();
        int md = ff[i].getModifiers();

        System.out.println("    " + Modifier.toString(md) + " " + tName(ff[i].getType().getName(), null) + " "
                + ff[i].getName() + ";");
    }

    /*
     * Step 5: Print out the constructor declarations.
     *
     * We note the name of the class which is the 'name' for all
     * constructors. Also there is no type, so the definition is
     * simplye [Modifiers] ClassName ( [ Parameters ] ) { }
     *
     */
    System.out.println("\n\r/*\n\r * Declared Constructors. \n\r */");
    x = tName(c.getName(), null);
    for (int i = 0; i < cn.length; i++) {
        int md = cn[i].getModifiers();
        System.out.print("    " + Modifier.toString(md) + " " + x);

        Class cx[] = cn[i].getParameterTypes();
        System.out.print("( ");
        if (cx.length > 0) {
            for (int j = 0; j < cx.length; j++) {
                System.out.print(tName(cx[j].getName(), null));
                if (j < (cx.length - 1))
                    System.out.print(", ");
            }
        }
        System.out.print(") ");
        System.out.println("{ ... }");
    }

    /*
     * Step 6: Print out the method declarations.
     *
     * Now methods have a name, a return type, and an optional
     * set of parameters so they are :
     *  [modifiers] [type] [name] ( [optional parameters] ) { }
     */
    System.out.println("\n\r/*\n\r * Declared Methods.\n\r */");
    for (int i = 0; i < mm.length; i++) {
        int md = mm[i].getModifiers();
        System.out.print("    " + Modifier.toString(md) + " " + tName(mm[i].getReturnType().getName(), null)
                + " " + mm[i].getName());

        Class cx[] = mm[i].getParameterTypes();
        System.out.print("( ");
        if (cx.length > 0) {
            for (int j = 0; j < cx.length; j++) {
                System.out.print(tName(cx[j].getName(), classRef));
                if (j < (cx.length - 1))
                    System.out.print(", ");
            }
        }
        System.out.print(") ");
        System.out.println("{ ... }");
    }

    /*
     * Step 7: Print out the closing brace and we're done!
     */
    System.out.println("}");
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• »