DEV Community: Milad sadeghi

Working with Private Members and Method Invocation in Java Reflection

Milad sadeghi — Mon, 19 May 2025 09:15:00 +0000

When working with reflection in Java, you are not limited to accessing only public members. Reflection gives you the power to inspect and manipulate private fields, private methods and arrays at runtime — things that are normally hidden or restricted by the language.

In this section, we'll cover:

Accessing private fields and understanding why fields are usually private and final.

Working with arrays dynamically, even when you don't know their types at compile time.

Invoking methods reflectively using Method.invoke(), including private methods.

Finally, I’ll briefly talk about a small project idea — a validation framework built with reflection — to show a practical, real-world use case of these concepts.

Field are usually private , and preferably final

The purpose of private field is for encapsulation
Makes it easier to reason about who is reading / writing them
- The purpose of final fields is safety
- cannot be changed accidently
- state is exactly what we wanted when we constructed the object
concurreny is way easier

Deep Reflection

Up to now, we have only used "shallow reflection"
Shallow reflective access is access at runtime via the core Reflection API (java.lang.reflect) without using setAccessible.
only public elements in exported packages can be accessed.
Deep reflective access is access at runtime via the Core Reflection API, using the setAccessible() method to break into non-public elements.
This allows access to any element—whether public or not, in any package, whether exported or not.

Note: Deep reflective access implies shallow reflective access.

📊 Table

Type of Reflective Access	Description
Shallow Reflective Access	Only uses public members, never violating encapsulation
Deep Reflective Access	Uses `setAccessible(true)` to access non-public members, violating encapsulation

When and Why Deep Reflection Is Used

1.broken encapsulation mainly for accessing fields
2.get hold of sun.misc.Unsafe
3.Serialization and similar mechanisms

Deep Reflection on Field

This is most common use case for deep reflection. field are usually private and preferably final.
The purpose of private fields is for encapsulation.
the purpose of final is safety

we have a Person class

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

}

create instance from Person and call it employee

public class PersonUseCase {
   public static void main(String[] args) throws ReflectiveOperationException {

      Person employee = new Person("jon" , 21);
 }
}

after that, i want to change the age so use a setAccessible(true) for age

public class PersonUseCase {
   public static void main(String[] args) throws ReflectiveOperationException {

        Person employee = new Person("john" , 21);

        Field fieldAge = Person.class.getDeclaredField("age");
        fieldAge.setAccessible(true);
        fieldAge.set(employee , 39);
 }
}

Result

person: Person{name='john', age=39}

Changing final field Isn't that dangerous?
❌ Yes, it is.
Final fields are assumed to be constant and may be inlined by the compiler or JVM. Therefore, we should never modify a final field after it has been published.

Static final fields, in particular, are considered published as soon as the class is loaded. While it is technically possible to change a static final field using sun.misc.Unsafe, doing so is highly discouraged and considered unsafe.

java.lang.invoke()

Reflection Suffers from “Amnesia”

Reflection checks permissions every time you invoke a method. This adds overhead and can reduce performance.

Reflection Wraps All Exceptions

Every reflective call wraps thrown exceptions, requiring an additional stack trace to be generated each time. This makes debugging harder and adds runtime cost.

🔍 MethodHandles.lookup()

are used to invoke methods and constructors in a more performant and flexible way compared to traditional reflection.

Before using MethodHandles, we need to identify ourselves ,this is similar to presenting an ID card.
Calling MethodHandles.lookup() effectively declares who we are in terms of access control.

This method establishes the caller’s identity, allowing finer-grained access control.
The returned MethodHandles.Lookup object is scoped with access permissions based on the calling class.

The Lookup object is used to find and access class members (methods, fields, constructors, etc.) using a variety of specialized methods:

findClass(String name) – finds a nested class.
findConstructor(Class, MethodType) – finds a constructor.
findGetter(Class, String, Class) / findStaticGetter(...) – reads fields.
findSetter(Class, String, Class) / findStaticSetter(...) – writes to fields (not applicable to final fields).
findVarHandle(Class, String, Class) / findStaticVarHandle(...) – returns a VarHandle to access fields.
findSpecial(Class, String, MethodType, Class) – used for special method invocations, like calling a super method.
findStatic(Class, String, MethodType) – finds a static method.
findVirtual(Class, String, MethodType) – finds a non-static (instance) method.

🛠️ Practical Example: MethodHandles.lookup() in Action

public class LookupDemo {


    public static void main(String[] args) throws Throwable {
        MethodHandles.Lookup lookup = MethodHandles.lookup();
        //Usually we cannot, know our class in a static
        //Context, since getClass() is not available
        Class<?> whoAmI = lookup.lookupClass();

        System.out.println("whoAmI: " + whoAmI);

        MethodHandle constructorWithParameter = lookup.findConstructor(Person.class, MethodType.methodType(void.class, String.class, String.class, int.class));
        Person person = (Person) constructorWithParameter.invoke("ted","doe",24);



        MethodHandle setLastNameMethod = lookup.findVirtual(Person.class, "setLastName", MethodType.methodType(void.class, String.class));



        MethodHandle constructor = lookup.findConstructor(Person.class, MethodType.methodType(void.class));


   /**
    * WrongMethodTypeException: expected ()person but found ()Object
    * Object Person1 = constructor.invokeExact();
    * setLastNameMethod.invokeExact( Person1,"ted");
    */

        //work because i force constructor is Person
        Person person1 = (Person) constructor.invokeExact();
        setLastNameMethod.invokeExact( person1,"ted");
        System.out.println(person1);


    /**
     * other solution is using invoke
     * so return type doesn't matter
     */
        Person person2 = (Person) constructor.invoke();
        setLastNameMethod.invoke( person2,"mozby");
        System.out.println(person2);


        System.out.println(setLastNameMethod.toString());


    }
}

🚀MethodHandles

are used to invoke methods and constructors in a more performant and flexible way compared to traditional reflection.

MethodHandle is similar to java.lang.reflect.Method, but with key differences that improve performance and flexibility.

✅ No Boxing of Parameters (with @PolymorphicSignature)

MethodHandle avoids parameter boxing thanks to @PolymorphicSignature, enabling more efficient method calls, especially for primitives.

✅ Direct Exception Throwing

All invoke() methods throw Throwable directly — exceptions are not wrapped like in reflection.
This means we must catch Throwable explicitly when using invoke.

✅ No Access Checks at Invocation Time

Security/access checks are not repeated during method calls.
Access control is enforced once when the MethodHandles.Lookup object is created.

✅ Return Type Matching

MethodHandle ensures that the return type matches the expected type.
This adds an additional layer of type safety, helping avoid accidental calls to the wrong method.

To see these concepts in action, I've developed the mono validator project with reflection and annotation processing for validate property like Hibernate Validator

Check out the mono-validator project on GitHub

How to Use Java Reflection with Methods, Constructors, and Class Types

Milad sadeghi — Wed, 16 Apr 2025 13:55:42 +0000

Methods

A Method object let you get more information on the corresponding method: its type and its modifiers, the types and names of its parameters, and enables you to invoke it on a given object, passing the arguments you need. This section also covers how you can discover methods in a class.
Source: dev.java - methods

There are two ways to access the methods of a class in Java:

get() method
getDeclared() method

The get() To access only the public method of a class. The get() method would only return type from superclasses

Include all public would members of similar type from superclasses
public does not meant that method is accessible. we saw before that a class itself can be inaccessible

The getDeclared() methods return all members of that class only

includes private, protected, package access and public memvers
But only from the current class, not from superclasses

Example

import java.lang.reflect.Method;

class Example {
    public void publicMethod() {
        System.out.println("Public method called");
    }

    private void privateMethod() {
        System.out.println("Private method called");
    }
}

public class ReflectionDemo {
    public static void main(String[] args) {
        try {
            Class<?> clazz = Example.class;

            // Using getMethod() - Accesses only public methods (including inherited)
            Method publicMethod = clazz.getMethod("publicMethod");
            System.out.println("Found with getMethod: " + publicMethod.getName());

            // Using getDeclaredMethod() - Accesses any method declared in the class (including private)
            Method privateMethod = clazz.getDeclaredMethod("privateMethod");
            System.out.println("Found with getDeclaredMethod: " + privateMethod.getName());

            // To invoke private method, setAccessible(true) is needed
            privateMethod.setAccessible(true);
            privateMethod.invoke(clazz.getDeclaredConstructor().newInstance());

        } catch (NoSuchMethodException e) {
            System.out.println("Method not found: " + e.getMessage());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Found with getMethod: publicMethod
Found with getDeclaredMethod: privateMethod
Private method called

📊 Table

Feature	getXXX()	getDeclaredXXX()
Access level	Only public	All access levels (private, etc.)
Includes inherited?	✅ Yes	❌ No
Typical use case	External API access	Internal inspection / deep reflection
Needs setAccessible(true)?	Not usually	Often yes (for private members)

Modifire & AccessFlag

The Modifier class in Java helps interpret the modifier flags (like public, private, static, etc.) of classes, fields, methods, and constructors at runtime.

Besides that, with getModifiers() you can retrieve the modifiers of a class. It returns an int representing bitwise flags, which you can decode using the java.lang.reflect.Modifier class.

import java.lang.reflect.*;

public class ModifierDemo {
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Sample.class;

        System.out.println("Class modifiers:");
        int classModifiers = clazz.getModifiers();
        System.out.println("  Is public? " + Modifier.isPublic(classModifiers));
        System.out.println("  Is abstract? " + Modifier.isAbstract(classModifiers));

        Field field = clazz.getDeclaredField("count");
        int fieldModifiers = field.getModifiers();
        System.out.println("\nField modifiers:");
        System.out.println("  Is static? " + Modifier.isStatic(fieldModifiers));
        System.out.println("  Is final? " + Modifier.isFinal(fieldModifiers));
    }

    public static abstract class Sample {
        public static final int count = 42;
    }
}

AccessFlag is an enumeration that introduced in java 20, which are bitwise flags that represent the modifiers.
Examples of access flags in bytecode:

ACC_PUBLIC (0x0001)
ACC_PRIVATE (0x0002)
ACC_STATIC (0x0008)
ACC_FINAL (0x0010)

These are defined in the ClassFile structure of the Java Virtual Machine Specification. They’re not typically used directly in reflection, but Modifier uses these under the hood.

Constructor

Constructor is a special case of a method. we dont specify a name, but do specify the parameter types. even the exception are the same "NoSuchMethodException"

In Constructor instead of calling invoke(), we call newInstance();

public class ConstructorReflect {
    private static final List<Integer> pi = List.of(0,1,3,7,9) ;

    public static void main(String[] args) throws ReflectiveOperationException {
        createCollection(ArrayList.class.getTypeName());
    }

    public static void createCollection(String name) throws ReflectiveOperationException{

        Class<? extends Collection> subclass = Class.forName(name).asSubclass(Collection.class);
        System.out.println(subclass.getSimpleName());

        Constructor<? extends Collection> constructorNoArgs = subclass.getConstructor();
        System.out.println(constructorNoArgs.newInstance());

        Constructor<? extends Collection> constructor = subclass.getConstructor(Collection.class);
        System.out.println(constructor.newInstance(pi));
    }

}

🛠️ getConstructors()

Point	Description
Similar to getMethod()	Similar to `getMethod()`, but focuses on constructors.
Constructors Differentiation	Constructors are differentiated only by parameter types. If the type is known, use `getConstructor()`.
Unlike getMethods()	Unlike `getMethods()`, does not include constructors from superclasses.
Return Value	Returns all the public constructors.

Nested Class

Nested classes are classes that are declared within another class. In Java, we can discover public nested classes using the Class.getClasses() method. However, this method does not return local or anonymous classes, as they are scoped within methods and are not part of the class's members.

As mentioned previously, the getClasses() method returns only the public nested classes of a class. If we need to access private, protected, or package-private nested classes, the getDeclaredClasses() method should be used instead, as it returns all declared nested classes regardless of their access modifiers.

Sealed Classes

Sealed classes were introduced in Java 15 to provide more control over class inheritance.

They limit which classes can extend or implement them.
All permitted subclasses must be explicitly declared and must themselves be final, sealed, or non-sealed.
Sealed classes also support reflection, allowing us to discover their permitted subclasses at runtime.

We can use Class.getPermittedSubclasses() to retrieve the list of allowed subclasses, and Class.isSealed() to check whether a class is sealed.

public class PermittedSubClassExplorer {
    public static Set<Class<?>> find(Class<?> clazz){
        if ( !clazz.isSealed()) throw new IllegalArgumentException( clazz + " root must be sealed");

        var permittedClassSet = Arrays.stream(clazz.getPermittedSubclasses()).collect(Collectors.toSet());
        for (Class<?> subClass : permittedClassSet) {

            if (subClass.isSealed())  permittedClassSet.addAll(find(subClass));
        }
        return Set.copyOf(permittedClassSet);
    }
}


import com.sadeghi.reflection.exercise_1D.PermittedSubClassExplorer;
import org.junit.jupiter.api.Test;

import java.util.Set;

import static org.junit.jupiter.api.Assertions.*;

class PermittedSubClassExplorerTest {
    public sealed class Shape permits Circle, Rectangle, Square {}

    public final class Circle extends Shape {}
    public final class Rectangle extends Shape {}
    public final class Square extends Shape {}

    @Test
    void testPermittedSubClassOfShape(){

        assertAll( () -> PermittedSubClassExplorer.find(Shape.class) , ()-> Set.of(Circle.class, Rectangle.class , Square.class));
    }
}

Records

Record was added in Java 16 to provide a simplified way to define data-carrying objects.

They automatically generate hashCode() , equals() and toString() methods.
Records are immutable by default (final fields, no setters).
They do not follow the traditional JavaBean getter naming convention (getX()), instead, they expose component names directly as methods.

In reflection, you can use the method getRecordComponents() to retrieve the record components from a class.
There is another method to check if a class is a record:Class.isRecord()

Class<?> clazz = PersonRecord.class;
boolean isRecord = clazz.isRecord();
RecordComponent[] recordComponents = clazz.getRecordComponents();

JavaBean Convention

The JavaBean convention uses getters and setters like:

getFirstName()
getLastName()
getAge()

For boolean values, the getter typically starts with "is", e.g., isMarried().

What if we have a property called “iPhone”?
The convention would generate: getIPhone().

For records, Java moved away from the JavaBean convention, using component names directly instead of traditional getter methods.

The old, legacy approach for reading JavaBean properties is using the Introspector class.

BeanInfo info = Introspector.getBeanInfo(MyBean.class);
PropertyDescriptor[] props = info.getPropertyDescriptors();

Check out the project on GitHub

In the final part of reflection, we will explore private properties and also take a look at method invocation using invoke().

Getting Started with Java Reflection

Milad sadeghi — Sun, 13 Apr 2025 09:46:49 +0000

I've always been curious about Java Reflection but never took the time to dive into it — until now. Recently, I decided to finally explore this powerful feature in depth and picked a couple of solid resources to guide me along the way:

1. The Reflection API – dev.java
2. Learn Reflection with Java by Dr. Heinz M. Kabutz (O’Reilly)

In this blog series ,I’ll share what I’ve learned, highlight key takeaways, and include practical examples to help you understand how Reflection works and when (or when not) to use it.

What is Reflection?

Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language. With that caveat in mind, reflection is a powerful technique and can enable applications to perform operations which would otherwise be impossible.
Source: https://dev.java/learn/reflection/intro

Why learn reflection?

Using reflection in Java is like using a painkiller
- It's a bit too strong for everyday use.
- But it can relieve severe pain.
We Can discover what class an object is
Once we know, we can
- Call method
- Read and write fields
- Construct new instance

Usefulness of Reflection

Frameworks
- DI(Dependency Injection), Data Serialization, Dynamic Configuration
Serialization
- ObjectOutputStream.writeObject() uses reflection extensively

Dangers Of Reflection

reflection can make code harder to understand
static code tools do not work anymore

Using Reflection on Class

Each Object in java knows its class

We can find out what it is with Object.getClass()
getClass() returns the actual Object type, not the declaration

Who has a class?

Every Type in java has a representative class
- Even primitive type,interface, enums, annutations
- insted of getClass() , we can use .class

What is a Type of Class?

class is a generic class, defined as class
- objects generic type parameters are erased at compile time
- int.class and Integer.class are both type of class But they are not the same object

Name Of Class

getName()
- Oldest Method, write Strange output for arrays
- Integer.class.getName() return java.lang.Integer
getSimpleName()
- Strips away the package name
- Integer.class.getSimpleName() return Integer
getCanonicalName()
- Full Class name, better array output, null for unknown type
- Integer.class.getCanonicalName() return java.lang.Integer
getTypeName()
- Full Class name, better array output, never null "introduced in java 8"
- Integer.class.getTypeName() return java.lang.Integer
getPackageName()
- Package in which class resides,java.lang for primitives "introduced in java 9"
- Integer.class.getPackageName() return java.lang

Using Class.forName()

it is possible to get the corresponding Class using the static method Class.forName()

Class.forName() has three forms:

forName(String className)
- most simple, all that is needed is the full class name
forName(String className, boolean initialize, ClassLoader loader)
- most useful - we can avoid initializing until we need it and specify another class loader
forName(Module module , String name)
- java 9 support for modules

All forName() method return a Class<?>
forName() method cannot be used for primitive types, but can be used for any array, including arrays of primitive types.

 // Get Class object for String[]
 Class<?> stringArrayClass = Class.forName("[Ljava.lang.String;");

call class with forName() method:

Class<?> c = Class.forName("java.lang.String");

This code return the class object of string. If this class does not exist, this method throws a ClassNotFoundException.

Using Class.forPrimitiveName()

A method Class.forPrimitiveName() was added to the class Class in Java SE 22. This method returns the corresponding class for any primitive type, including void.

Class<?> c = Class.forPrimitiveName("int");
System.out.println("class: " + c); //class: int

What is a ReflectiveOperationException

When you work with reflection, several exceptions may occur. To handle this,We use ReflectiveOperationException class.

ReflectiveOperationException has 6 subclasses:

ClassNotFoundException - class.forName() did not resolve
IllegalAccessException - trying to access a private memeber
InstantiationException - trying to instantiate an abstract type
NoSuchFieldException - field by that name not found
NoSuchMethodException - method/constructor not found
InvocationTargetException - wrapper for another exception

public static void main(String[] args) 
throws ReflectiveOperationException {

     Class<ArrayList> arrayListClass = 
     (Class<ArrayList>) Class.forName(ArrayList.class.getTypeName());

     System.out.println(arrayListClass.getName());
}

Know the super type of Class.forName()

The asSubclass() method is used to cast a Class<?> to a more specific Class, with type safety checked at runtime.

It ensures that the class represented by the Class object is actually a subclass (or same class) of the given clazz, otherwise it throws a ClassCastException

import java.util.*;

public class ListReflectionExample {
    public static void main(String[] args) throws Exception {

      // Load the class dynamically
      Class<?> rawClass = Class.forName(ArrayList.class.getTypeName());

        // Ensure it's a subclass of List
        Class<? extends List> listClass = rawClass.asSubclass(List.class);

        // Create an instance using the no-arg constructor
        List<String> list = listClass.getDeclaredConstructor().newInstance();

        // Use the list like normal
        list.add("Reflection");
        list.add("is");
        list.add("cool!");

        System.out.println(String.join(" ", list));
    }
}

Better way of loading unknown class

Class.forName(String) calls all the static initializers

This happens before asSubclass can check the type
Better is to load the class uninitialized
- it will be initialized before we use it for the first time

By default loaded into the current class loader

Better to use Thread.currentThread().getContextClassLoader()
- Allows frameworks to inject different class loaders

public class ClassForNameWithContextLoader {
    public static void main(String[] args) throws Exception {
        // Get the context class loader of the current thread
        ClassLoader loader = Thread.currentThread().getContextClassLoader();

        System.out.println("Loading class with initialize = false...");
        Class<?> clazz1 = Class.forName("MyStaticClass", false, loader);
        System.out.println("Class loaded: " + clazz1.getName());

        System.out.println("\nNow loading with initialize = true...");
        Class<?> clazz2 = Class.forName("MyStaticClass", true, loader);
        System.out.println("Class loaded and initialized: " + clazz2.getName());
    }
}

Tip: Use Thread.currentThread().getContextClassLoader() when loading classes in environments where multiple class loaders are involved — like in application servers, Spring Boot, or plugin systems. It helps avoid ClassNotFoundException when the default loader can’t see certain classes

In next part we check method, modifiers, Constructor, nested class, sealed class and record