What is the Difference Between NoClassDefFoundError and ClassNotFoundException in Java

Errors and exceptions are unavoidable issues that developers encounter when working with Java programming. Two common errors among the many exceptions are NoClassDefFoundError and ClassNotFoundException. Despite their first similarity, they have distinct functions inside the Java environment. 

We will explore the details that set these errors differently in this article, as well as their causes, impacts, and fixes.

The key differences between NoClassDefFoundError and ClassNotFoundException are outlined in the following table:

Attribute	NoClassDefFoundError	ClassNotFoundException
Timing	Runtime	Runtime
Cause	Missing Class at Runtime	Class Not Found
Methods	Thrown by the JVM	Thrown by Class.forName() or ClassLoader.loadClass()

Understand NoClassDefFoundError

The class definition is connected to the NoClassDefFoundError. It happens when a class is included in the code during compilation but is absent during execution. 

To put it simply, the class was accessible throughout the compilation stage, but the JVM was unable to locate it during runtime.

Example of NoClassDefFoundError:

An example of a NoClassDefFoundError that is produced when a class that is available at compile time but not at runtime is attempted to be loaded is as follows:

class Apple   
{   
    void display()   
    {   
        System.out.println( "apple fruit color is red" );   
    }   
}   
class NoClassDefFoundErrorExample
{   
    public static void main(String args[])    
    {   
        Apple obj = new Apple();   
        obj.display();          
    }   
} 

Output:

apple fruit color is red

Explanation:

Apple is the parent class and NoClassDefFoundErrorExample is the main class in the code above. The display() method is part of the Apple class.

We make an Apple class object and invoke its method (display) in the main method.

The program mentioned above will generate two .class files upon compilation. Apple.class will be in one, and NoClassDefFoundErrorExample.class in the other.

The described program will work successfully and give the intended results if you run it.

Now,

The Java Runtime System will throw a NoClassDefFoundError similar to this one if you delete the Apple.class file and execute the NoClassDefFoundErrorExample.class file without compiling:

See the screenshot below we deleted Apple.class file.

Output:

After deleting Apple.class file we ran the program without compiling after that a NoClassDefFoundError was caused.

H:\Hamid>java NoClassDefFoundErrorExample
Exception in thread "main" java.lang.NoClassDefFoundError: Apple
        at NoClassDefFoundErrorExample.main(NoClassDefFoundErrorExample.java:12)
Caused by: java.lang.ClassNotFoundException: Apple
        at java.net.URLClassLoader.findClass(URLClassLoader.java:381)
        at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
        at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:338)
        at java.lang.ClassLoader.loadClass(ClassLoader.java:357)

Causes of NoClassDefFoundError:

Incorrect Compilation: A NoClassDefFoundError is raised if your code is compiled with a class and the class is missing at runtime. When there are differences between the runtime and compile-time environments, this frequently occurs.

Classpath Mismatch: This error is similar to ClassNotFoundException in that it might be caused by a mismatch in the classpath between compilation and runtime.

Issues with JAR Files: If the necessary classes are included in JAR files, make sure the files are available and unbroken while the program is running.

Corrupted Class File: JVM will throw this error if it cannot read the class definition because the class file has been corrupted or was not generated correctly.

Resolving NoClassDefFoundError:

Recompile the Code: Verify that the code is being compiled with all required classes. To make sure that all dependencies are integrated into the compilation process, rebuild your project.

Check Classpath Consistency: Make sure that the classpath used at compile time and runtime are the same. Differences of any kind may result in NoClassDefFoundError.

Inspect JAR Files: Check JAR files if your project uses them to make sure they are not corrupted. Redownload or replace the corrupted JAR files if necessary.

---

Understand ClassNotFoundException Error:

Java developers are probably familiar with the term ClassNotFoundException. 

This exception happens when a class is not found in the classpath when the Java Virtual Machine (JVM) tries to load it at runtime using the Class.forName() or ClassLoader.loadClass() methods. To put it another way, during execution, the JVM is unable to locate the class file.

Example of ClassNotFoundException:

We attempt to connect to the Oracle database in this Java program using the Java Database Connectivity (JDBC) driver. The driver is loaded using the Class class's forName method. A ClassNotFoundException will be thrown by this program since the driver's JAR file is not present in the classpath.

import java.sql.Connection;
import java.sql.DriverManager;

public class ClassNotFoundExceptionExample 
{
    public static void main(String args[]) 
	{
        try 
		{
            Class.forName("oracle.jdbc.driver.OracleDriver");
            Connection con = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:xe","system","tiger");
            System.out.println("database Connect successfully");
        } 
		catch (Exception e) 
		{
            System.out.println("Unable to connect to the database");
            e.printStackTrace();
        }
    }
}

Output:

H:\Hamid>java ClassNotFoundExceptionExample
Unable to connect to the database
java.lang.ClassNotFoundException: oracle.jdbc.driver.OracleDriver
        at java.net.URLClassLoader.findClass(URLClassLoader.java:381)
        at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
        at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:338)
        at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
        at java.lang.Class.forName0(Native Method)
        at java.lang.Class.forName(Class.java:264)
        at ClassNotFoundExceptionExample.main(ClassNotFoundExceptionExample.java:10)

Causes of ClassNotFoundException:

Incorrect Classpath Configuration:  An incorrectly configured classpath is one of the most common reasons for this issue. The JVM would not find the necessary class files if the classpath is incorrectly specified.

Missing External Libraries: A ClassNotFoundException will occur when the JVM cannot locate the required classes because your code depends on external JAR libraries and these libraries miss during runtime.

Class Loading Conflict: An instance of a ClassNotFoundException can occur if the JVM is unable to decide which of the several versions of the same class on the classpath to load.

Incorrect Class Name:  An improper class name is another common way a ClassNotFoundException occurs. Verify that the class name, including the package name, is spelled correctly and is fully qualified.

Resolving ClassNotFoundException:

Check Classpath: Make sure your classpath is set up properly. Make sure that the classpath includes all of the directories and JAR files that contain the necessary classes.

Validate External Libraries: Verify again the external libraries that are necessary for your project. Verify that they are available at runtime and that they are imported correctly.

Dynamic Class Loading: Make sure the paths and class names are correct if you are loading classes dynamically. If an exception arises during the dynamic class loading procedure, handle it.

Conclusion:

In conclusion, class loading problems in Java programs are the cause of errors such as ClassNotFoundException and NoClassDefFoundError. NoClassDefFoundError occurs when the class definition is accessible during compilation but missing at runtime, whereas ClassNotFoundException occurs when a class is not discovered during runtime because of classpath misconfigurations or missing external libraries. 

Java developers must be aware of these distinctions to properly identify and troubleshoot when such issues occur.