Thread: Java Reflection API

Do you have an specific questions about how to use the classes and methods in the reflect package?
What have you tried?

Have you read this: https://www.oracle.com/technical-res...eflection.html

So I created two classes and wrote a code to read them.

package javareflectionapi;
 
 
import java.lang.reflect.*;
 
 
 
 
/**
 *
 * @author
 */
public class ReflectionAPI {
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws NoSuchMethodException {
        // TODO code application logic here
 
        //getting the class
        Class c1 = ClassName.class;
 
        //getting the name of the class
        String class1 = c1.getSimpleName();
        String newClass1 = null;
 
        //Printing the Header
         System.out.println("------------- Classes --------------");
 
        System.out.println("The name of all the Classes are: ");
 
        //Printing the class name
        System.out.println(class1);
 
 
       //getting the class
        Class c2 = AnotherClassName.class;
        String class2 = c2.getSimpleName();
 
        //Printing the class name
          System.out.println(class2);
 
          // Accessing the Modifiers
        int class1Modifiers = c1.getModifiers();
 
        // 
        boolean isPublic = Modifier.isPublic(class1Modifiers);
        boolean isFinal = Modifier.isFinal(class1Modifiers);
        boolean isInterface = Modifier.isInterface(class1Modifiers);
        boolean isAbstract = Modifier.isAbstract(class1Modifiers);
 
        //Printing the Header
        System.out.println("------- Class1  Modifiers --------------");
        // Checking if the modifier is Public
        System.out.println("Is Public? " + isPublic);
        // hecking if the modifier is Final
        System.out.println("Is Final? " + isFinal);
        // hecking if the modifier is Interface
        System.out.println("Is Interface? " + isInterface);
        // hecking if the modifier is Abstract
        System.out.println("Is Abstract? " + isAbstract);
 
 
       //Printing the Header 
       System.out.println("------------ Method 1 --------------");
 
       // Initializing the Method
        Method[] methods1;
 
     methods1 = ClassName.class.getMethods();
    System.out.println("All methods of the " + class1 + " Class are: ");
    for(Method method : methods1){
    System.out.println(method.getName());
      }
 
    System.out.println("------------ Method 2 --------------");
     // Initializing the Method
    Method[] methods2;
    methods2 = AnotherClassName.class.getMethods();
    System.out.println("All methods of the " + class2 + " Class are: ");
    for(Method method : methods2){
    System.out.println(method.getName());
      }
 
 
    System.out.println("----------- Getter & Setter Methods --------------");  
 
           // Initializing the Method
          Method[] methods = c1.getMethods();
 
          // iteratiing through the methods 
          for(Method method : methods){
          boolean isGetter = isGetter(method);
          boolean isSetter = isSetter(method);
 
 
          // printing the getter and setter methods
          System.out.println("Method names are: " + method.getName());
          System.out.println("is Getter?: " + isGetter);
          System.out.println("is Setter?: " + isSetter);
          }
 
 
   System.out.println("----------- Constructor --------------"); 
 
      // Getting the 
        c1 = String.class;
        Constructor specific = null;
 
        try{
            specific = c1.getConstructor(String.class);
 
        }catch(NoSuchMethodException | SecurityException e)
        {
            e.printStackTrace();
        }
 
        Class[] parameter = specific.getParameterTypes();
 
        if(parameter.length == 1 && parameter[0].equals(class1.getClass()))
        {
            try {
                newClass1 = (String) specific.newInstance(class1);
            } catch (InstantiationException | IllegalAccessException
                    | IllegalArgumentException | InvocationTargetException e)
            {
                        e.printStackTrace();
 
 
 
            }
 
    }
            //Get the constructor name
            System.out.println("Constructor is: "+ newClass1);
 
            //Return the parameter type
                     for(Class para : parameter){
            System.out.println("Parameter Type is: " + para.getName());
        }   
 
              System.out.println("----------- Fields --------------");            
 
 
 
          //getting private fields
          Class newTourist = Tourist.class;
          Field[] privateFields = newTourist.getDeclaredFields();
 
          for(Field privField : privateFields){
 
          System.out.println("Fields are: " + privField.getName());
          }
 
 
 
 
 
    } 
 
    // Method is getter if names start with get, and no parameters.
    public static boolean isGetter(Method method) {
        if (!method.getName().startsWith("get")) {
            return false;
        }
        if (method.getParameterTypes().length != 0) {
            return false;
        }
        if (void.class.equals(method.getReturnType())) {
            return false;
        }
        return true;
    }
 
 
    // Method is setter if names start with set, and only one parameter.
    public static boolean isSetter(Method method) {
        if (!method.getName().startsWith("set")) {
            return false;
        }
        if (method.getParameterTypes().length != 1) {
            return false;
        }
        return true;
    }
 
 
}

What I want to achieve is, using the reflection to inspect any random class objects, (that is not ClassName or AnotherClassName) through a GUI.

random class objects

Where are those located? How does the code access them?
For example if you have a .class file, will the code read the bytes of the code and parse out its contents?

Please edit your post and wrap your code with code tags:

[code]
**YOUR CODE GOES HERE**
[/code]

to get highlighting and preserve formatting.

Where are the classes to be inspected located? How will your program access them?

For simplicity, assume the .class file's location is known. How will the code look at that file?
Later the FileChooser class can be added to allow the user to find and select the .class file.

Takee a look at https://docs.oracle.com/javase/7/doc...ows/javap.html

They are all in one .class file.

What does that mean? I thought there can only be one class in a .class file.

How does the program access the .class files you want it to inspect?

Thanks. From your answer, I assume the program accesses the class files via the default classpath set when the program executes.

How does that arrangement satisfy your requirements: using the reflection to inspect any random class?
The code has hardcoded the class names instead of having the class names come from a variable.

The Class class has a method that returns the Class object associated with the class or interface with the given string name.
Take a look at the API doc for the Class class.

Continue here if on the same program and problem.