Java - NoSuchFieldException

Quiz

The Java NoSuchFieldException is thrown when a class does not contain the field (or variable) specified. The NoSuchFieldException is a checked exception that is thrown when a class does not contain the field (or variable) specified.

It extends ReflectiveOperationException, which is the super-class for exceptions thrown by reflection-related operations.

Hierarchy of NoSuchFieldException

Given below is the class hierarchy of NoSuchFieldException:

java.lang.Object
  â³ java.lang.Throwable
      â³ java.lang.Exception
          â³ java.lang.ReflectiveOperationException
              â³ java.lang.NoSuchFieldException

So, it means ReflectiveOperationException is the superclass for exceptions thrown by reflection-related operations and it is unchecked.

Cause of NoSuchFieldException

Following are the reasons when JVM throws a NoSuchFieldException in Java:

A field that does not exist is accessed via reflection.
A field exists but is private and is accessed using getField() instead of getDeclaredField().
A misspelled field name is used.
The class being inspected is dynamically loaded but does not contain the expected field.

Constructors of NoSuchFieldException

There are two constructors of NoSuchFieldException class:

NoSuchFieldException(): This constructor is used to create a NoSuchFieldException object without any message.
NoSuchFieldException(String message): This constructor is used to create a NoSuchFieldException object with a message.

Methods of NoSuchFieldException

There are some methods of NoSuchFieldException class:

Method	Description
getMessage()	It is used to return the message of the exception.
toString()	It is used to return the detail message string of the exception.
printStackTrace()	It is used to print the stack trace of the exception.

Example 1 : Accessing a Non-Existent Field

In this example, we are accessing a field that does not exist in the class, so JVM will throw a NoSuchFieldException.

import java.lang.reflect.Field;

public class NoSuchFieldExample {
   public static void main(String[] args) {
      Class<?> clazz = Class.forName("java.lang.String");
      Field field = clazz.getField("nonExistentField"); // This field does not exist
   }
}

Output

Following is the output of the above code:

NoSuchFieldExample.java:6: error: unreported exception NoSuchFieldException; must be caught or declared to be thrown
      Field field = clazz.getField("nonExistentField"); // This field does not exist
                                  ^
2 errors

As you can see in the output, JVM throws a NoSuchFieldException because we are accessing a field that does not exist in the class.

Difference Between getField() and getDeclaredField()

Following table shows the difference between getField() and getDeclaredField() methods:

Method	Visibility	Accesses Inherited Fields?
getField(String name)	Only public	Yes
getDeclaredField(String name)	Any (private, protected, public)	No

Example 2 : Accessing a Private Field Correctly

In this example, we are accessing a private field using getDeclaredField() method, so JVM will not throw a NoSuchFieldException.

import java.lang.reflect.Field;

class TestClass {
   private String secret = "Hidden Data";
}

public class AccessPrivateField {
   public static void main(String[] args) {
      try {
          Class<?> clazz = TestClass.class;
          Field field = clazz.getDeclaredField("secret");
          field.setAccessible(true); // Allows access to private fields
          TestClass obj = new TestClass();
          System.out.println("Private Field Value: " + field.get(obj));
    } catch (NoSuchFieldException | IllegalAccessException e) {
         e.printStackTrace();
      }
   }
}

Output

Following is the output of the above code:

Private Field Value: Hidden Data

As you can see in the output, we are accessing a private field using getDeclaredField() method, so JVM does not throw a NoSuchFieldException.

Handling NoSuchFieldException

Following are the to avoid and handle NoSuchFieldException in Java:

Always use getDeclaredField() method to access private fields.
Use try-catch block to handle NoSuchFieldException.
Check if the field exists before accessing it.
Use the correct field name.

Example: Check Field Existence Before Accessing

In this example, we are checking if the field exists before accessing it, so JVM will not throw a NoSuchFieldException.

import java.lang.reflect.Field;

class SomeClass {  
    private String targetField;  // Example field  
}

public class CheckFieldExistence {
   public static void main(String[] args) {
      boolean fieldExists = false;

      for (Field field : SomeClass.class.getDeclaredFields()) {
         if (field.getName().equals("targetField")) {
            fieldExists = true;
            break;
         }
      }

      System.out.println("Field 'targetField' exists: " + fieldExists);
   }
}

Output

Following is the output of the above code:

Field 'targetField' exists: true

As you can see in the output, we are checking if the field exists before accessing it, so JVM does not throw a NoSuchFieldException.

Handling NoSuchFieldException

In this example, we are accessing a field that does not exist in the class. We are handling this exception using a try-catch block.

import java.lang.reflect.Field;

public class NoSuchFieldExample {
   public static void main(String[] args) {
      try {
         Class<?> clazz = Class.forName("java.lang.String");
         Field field = clazz.getField("nonExistentField"); // This field does not exist
      } catch (NoSuchFieldException e) {
         System.out.println("Field does not exist");
      }
   }
}

Output

Following is the output of the above code:

Field does not exist

As you can see in the output, we are handling the NoSuchFieldException using a try-catch block.

Use of getDeclaredField() Method

Following is the use of getDeclaredField() method to avoid NoSuchFieldException:

Use the getDeclaredField() method to access any field (private, protected, public).
Use the getDeclaredField() method to access fields that are not inherited.
Use the getDeclaredField() method to access fields that are inherited but are private.

Example: Accessing a Private Field Using getDeclaredField()

In this example, we are accessing a private field using getDeclaredField() method, so JVM will not throw a NoSuchFieldException.

import java.lang.reflect.Field;

class TestClass {
   private String secret = "Hidden Data";
}

public class AccessPrivateField {
   public static void main(String[] args) {
      try {
          Class<?> clazz = TestClass.class;
          Field field = clazz.getDeclaredField("secret");
          field.setAccessible(true); // Allows access to private fields
          TestClass obj = new TestClass();
          System.out.println("Private Field Value: " + field.get(obj));
    } catch (NoSuchFieldException | IllegalAccessException e) {
         e.printStackTrace();
      }
   }
}

Output

Following is the output of the above code:

Private Field Value: Hidden Data

As you can see in the output, we are accessing a private field using getDeclaredField() method, so JVM does not throw a NoSuchFieldException.

Summary

The NoSuchFieldException is thrown when a class does not contain the field (or variable) specified.
The NoSuchFieldException is a checked exception that is thrown when a class does not contain the field (or variable) specified.
It extends ReflectiveOperationException, which is the superclass for exceptions thrown by reflection-related operations.
Always use getDeclaredField() method to access private fields.
Use try-catch block to handle NoSuchFieldException.
Check if the field exists before accessing it.
Use the correct field name.

java_lang_exceptions.htm

Print Page