I know this is an old question, but I had this problem recently and none of the answers helped me. However, Corral’s comment on Ryan Atkinson’s answer did tip me off to the problem.
I had all my compiled class files in target/classes, which are not packages in my case. I was trying to package it with jar cvfe App.jar target/classes App, from the root directory of my project, as my App class was in the default unnamed package.
This doesn’t work, as the newly created App.jar will have the class App.class in the directory target/classes. If you try to run this jar with java -jar App.jar, it will complain that it cannot find the App class. This is because the packages inside App.jar don’t match the actual packages in the project.
This could be solved by creating the jar directly from the target/classes directory, using jar cvfe App.jar . App. This is rather cumbersome in my opinion.
The simple solution is to list the folders you want to add with the -C option instead of using the default way of listing folders. So, in my case, the correct command is java cvfe App.jar App -C target/classes .. This will directly add all files in the target/classes directory to the root of App.jar, thus solving the problem.
Java Could Not Find or Load Main Class
When starting your Java application, you may encounter this error:
Error: Could not find or load main class MyClass
Caused by: java.lang.ClassNotFoundException: MyClassCaused by: java.lang.ClassNotFoundException: MyClassThis error is very common when creating new Java based projects. Whether you’re using Gradle or Maven, Spring Boot or Kafka, chances are you’ve encountered this error before.
Sometimes the error will occur unexpectedly. Sometimes the error is specific to your IDE.
Regardless, fixing the error is easy and it starts with understanding the cause:
What Causes the «Could Not Find or Load Main Class» Error?
This error is thrown whenever Java can’t find or load the main class of your application.
Let’s say you define a class like this:
public class MyClass {
public static void main(String[] args) {
System.out.println("My class is working!");
}
} public static void main(String[] args) { System.out.println("My class is working!"); }}When running this simple class, you could get the «could not find or load main class» error for several reasons…
1. IDE Configuration Issue
Most IDEs let you configure the starting point for your application. For example, in IntelliJ you can edit configuration to select a main class for running the project.
If you’re running your application through an IDE, make sure that it is configured properly to look for the main class in the right place.
2. Wrong Class Name
Remember that class names must be unique in Java. Furthermore, they are case sensitive…
Let’s say you are running your program from the CLI using the java tool..
java myclassThis will result in the «Could not find or load main class» error because class names are case sensitive.
3. Wrong Extension
When running from the command line, many developers accidentally append an extension like:
java MyClass.javaor
java MyClass.classThe correct way is to run without any extension:
java MyClass4. Wrong Location
Let’s say your class is part of a package like this:
package com.myproject;
public class MyClass {
public static void main(String[] args) {
System.out.println("My class is working!");
}
}public class MyClass { public static void main(String[] args) { System.out.println("My class is working!"); }}If you don’t run your class with the fully qualified name AND from the right directory, you will get the «Could not find or load main class» error…
5. Wrong Class Path
The class path is where the JVM looks for classes to load into your program. Sometimes developers provide a specified path like this:
java MyClass -cp /usr/local/pathWhile the optional -cp argument allows you to specify your own class path, you can easily get the «Could not find or load main class» error if this is incorrect…
How to fix the «Could Not Find or Load Main Class» Error
1. Make sure your IDE is configured properly
Make sure that your IDE has the correct configuration for finding the main class/entry point of your application.
2. Make sure your class name is correct
If you are running your program from the CLI, make sure that you are specifying the right class name without extensions…
java MyClass3. Make sure you are running your application from the right directory
Make sure you are running your application from the right folder. If your class is part of a package then you must run it from the parent directory….
java com.myproject.MyClass4. Make sure your class path is correct
Make sure your class path is correct. By default, the class path is the current working directory «.». If you override this with the -cp argument then make sure it’s accurate!
Understanding the Java Error «Could Not Find or Load Main Class»
While this error is self explanatory and easy to fix, it’s worth understanding how Class Loaders work behind the scenes. This gives you a better understanding of why the «Could Not Find or Load Main Class» error happens…
When are Classes Loaded in Java?
Classes are loaded dynamically. This means classes are loaded into memory only when they are needed.
Unlike C++, Java is a dynamically compiled language. This means the language is compiled to machine code while the program is running.
Of course, some classes must be loaded initially when your program starts. The JRE utilizes a native class loader to load the main entry point of your application. From here, class loaders are used to dynamically load (lazy load) classes as they are needed by the application.
The Class Loading Mechanism in Java
Java utilizes a delegation mechanism for loading classes at runtime. There are 3 built-in class loaders used by the JRE at runtime:
1. Bootstrap class loader: This loads the standard runtime classes found in rt.jar
2. Extensions: This loads any extension classes used by the JRE
3. System: This loads classes defined by the application and found on the class path
Each class loader first checks a cache to see if the requested class has already been loaded into memory. If nothing is found in the cache, it delegates the finding of the class to the parent class loader.
This process happens recursively…
If the system class loader can’t find the class, it delegates to the extension class loader.
If the extension class loader can’t find the class, it delegates to the bootstrap class loader.
If the bootstrap class loader can’t find the class, it tells the extension class loader to find it
If the extension class loader can’t find the class, it tells the system class loader to find it
If the system class loader can’t find it, it throws an ClassNotFound exception
This mechanism works to ensure uniqueness, visibility and delegation are applied to the class loading mechanism in Java.
Uniqueness explains the reason why no two classes can have the same name. By keeping class names unique, class loaders can easily find the single representation of a defined class.
Visibility explains the child-parent relationship between class loaders. While children can view parent classes, parents can’t view child classes. This ensures an isolation level needed to create the hierarchy between class loaders.
Delegation explains how the class loaders work together to recursively retrieve a unique class. By delegating to parent classes, class loaders ensure only one representation of a defined class exists.
Java Class Loading Order
1) Class loader searches cache for loaded classes
2) If cache has the class, it is returned. Otherwise, the class loader delegates to parent class to retrieve the class
3) Parent class loaders ultimately delegate to the bootstrap class loader. If the class isn’t found, the bootstrap loader returns responsibility to child loader.
4) Either the system loader finds and loads the class, or a ClassNotFound exception is thrown.
Custom Class Loaders
You can create your own class loaders by extending the ClassLoader class:
public class CustomClassLoader extends ClassLoader { ...Most developers don’t need to worry about creating custom class loaders. There are times where it makes sense however. Sometimes custom class loaders are used to implementing class versioning. Other custom class loaders allow you to create classes dynamically or switch implementations etc.
Conclusion
The «Could not find or load main class» error is common and easy to fix. Its cause usually has to do with specifying the wrong class name, extension, or class path.
This error can be easily fixed by checking IDE configurations, class path variables, class names, and making sure you’re running the application from the right directory.
The JRE utilizes a class loading mechanism to dynamically load classes into memory. This mechanism relies on a recursive process where class loaders delegate retrieval to parent loaders if they can’t find the class already loaded in memory.
You can create your own custom class loaders for dynamic class creation and versioning.
Your thoughts?
1. Overview
Occasionally when we run a Java program, we might see “Could not find or load main class.” It’s easy to guess the reason: The JVM failed to find the main class and gave this error. But why couldn’t it?
In this tutorial, we’ll discuss the probable reasons for failure to find the main class. We’ll also see how to fix them.
2. Sample Program
We’ll start with a HelloWorld program:
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello world..!!!");
}
}Now let’s compile it:
$ javac HelloWorld.javaHere, the compiler will generate a .class file for our program. This .class file will be generated in the same directory. The .class file will have the same name as the class name given in the Java program. This .class file is executable.
In the following sections, we’ll run this .class file and try to understand the probable reasons for error “Could not find or load main class.”
3. Wrong Class Name
To run a .class file generated by Java compiler, we can use this command:
java <.class filename>Now let’s run our program:
$ java helloworld
Error: Could not find or load main class helloworldAnd it failed with the error “Could not find or load main class helloworld.”
As discussed earlier, the compiler will generate the .class file with the exact same name given to the Java class in the program. So in our case, the main class will have the name HelloWorld, not helloworld.
Let’s give it one more try with correct casing:
$ java HelloWorld
Hello world..!!!This time it ran successfully.
3.1. File Extension
To compile a Java program, we must provide the file name with its extension (.java):
$ javac HelloWorld.javaBut to run a .class file, we need to provide the class name, not the file name. So there is no need to provide the .class extension:
$ java HelloWorld.class
Error: Could not find or load main class HelloWorld.classAgain, let’s run our program using the correct class name:
$ java HelloWorld
Hello world..!!!4. Java Package Names
In Java, we keep similar classes together in what we call a package.
Let’s move HelloWorld class into the com.baeldung package:
package com.baeldung;
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello world..!!!");
}
}Now let’s compile and run the updated HelloWorld program like before:
$ java HelloWorld
Error: Could not find or load main class HelloWorldBut again, we get the error “Could not find or load main class HelloWorld.”
Let’s try to understand what we missed here.
To run a Java class that is in a package, we must provide its fully qualified name. So in our case, HelloWorld‘s fully qualified name is com.baeldung.HelloWorld.
Now, when we created com.baeldung package, we actually created this folder structure:
com/baeldung/HelloWorld.javaFirst, let’s try to run our program from the com/baeldung directory:
$ java com.baeldung.HelloWorld
Error: Could not find or load main class com.baeldung.HelloWorldStill, we are not able to run our program.
Here, when we specified the fully qualified class name com.baeldung.HelloWorld, Java tried to find the HelloWorld.class file in com/baeldung, under the directory from where we were running the program.
As we were already inside com/baeldung, Java failed to find and run the HelloWorld program.
Now let’s move back to the parent folder and run it:
$ java com.baeldung.HelloWorld
Hello world..!!!And we are again able to say “Hello” to the world.
5. Invalid Classpath
Before going ahead, let’s first understand what the classpath is. It’s the set of classes available to our currently running JVM.
We use the classpath variable to tell the JVM where to find the .class files on the file system.
While running a program, we can provide the classpath using -classpath option:
java -classpath /my_programs/compiled_classes HelloWorldHere, Java will look for the HelloWorld.class file in /my_programs/compiled_classes folder, a folder whose name we just made up. By default, the classpath variable is set to “.”, meaning the current directory.
In the above section, we changed our directory to run our program. But what if we want to run it from some other folder? That’s when the classpath variable helps us.
To run our program from the directory com/baeldung, we can simply state that our classpath is two directories up — one for each package part:
$ java -claspath ../../ com.baeldung.HelloWorld
Hello world..!!!Here, “..” represents the parent directory. In our case “../../” represents the top of our package hierarchy.
6. Conclusion
In this article, we learned the probable reasons for the error “Could not find or load main class.”
Then, of course, we also learned how to solve this error.
- Could Not Find Error Due to Passing the Wrong Name in Java
- Could Not Find Error Due to Wrong Package Name in Java
- Could Not Find Error Due to Wrong CLASSPATH in Java
This tutorial introduces the could not find or load main class errors in Java.
Suppose we have written a code and compiled it. Till now, everything is working fine, but when we finally ran it, an error showed up.
could not find or load main class
This tutorial will discuss why this error occurs and how to resolve it. Let us first recap how we run a java program using the command prompt.
First, we compile the code using the javac command like below:
After executing the above command, A file with the .class extension gets created into the current folder.
The .class file will have the same class as the .java program. We then run the .class file using the following command to execute the Java code:
We may get the could not find or load main class error. This error is a runtime error and occurs when the Java Virtual machine cannot locate the main class (class containing the main method) we are trying to run.
This error most commonly occurs when running our Java programs using the command prompt. Before discussing the causes of this error, let us first understand CLASSPATH.
CLASSPATH in Java
This is the executable.class and other resource files.
The JVM uses it to locate the files. The default CLASSPATH is the current directory unless we explicitly set the CLASSPATH in the system variables.
To run a program, we need to pass the class name. We take the following example to illustrate the point:
public class DelftStack{
public static void main(String args[]){
System.out.println("Hello from DelftStack");
}
}
Let’s first compile it using the javac command:
C:UsersUserDocumentsDelftStackjava>javac DelftStack.java
C:UsersUSerDocumentsDelftStackjava>
After the above command execution, a DelftStack.class file gets created in our current directory. Let’s run that file by using the java command.
C:UsersUserDocumentsDelftStackjava>java DelftStack.class
Error: Could not find or load main class DelftStack.class
Caused by: java.lang.ClassNotFoundException: DelftStack.class
Here, we are getting an error because we are trying to run the .class file. Instead, we just need to pass the class name.
Look below:
C:UsersUserDocumentsDelftStackjava>java DelftStack
Hello from DelftStack
Could Not Find Error Due to Passing the Wrong Name in Java
The could not find or load the main class can also occur when we pass the wrong class name. By continuing the previous example, if we try to run the program with the wrong name as follows:
C:UsersUserDocumentsDelftStackjava>java DelftStac
Error: Could not find or load main class DelftStac
Caused by: java.lang.ClassNotFoundException: DelftStac
We get the error above because we have misspelled the class name. Here, the JVM is trying to run a class named DelftStac, which doesn’t exist.
We can resolve this issue by correctly spelling out the class name as follows:
C:UsersUserDocumentsDelftStackjava>java DelftStack
Hello from DelftStack
We should also note here that the class name is case-sensitive. If we run the class Delftstack, we will get an error.
Look below:
C:UsersUserDocumentsDelftStackjava>java Delftstack
Error: Could not find or load main class Delftstack
Caused by: java.lang.NoClassDefFoundError: Delftstack (wrong name: Delftstack)
We should use the correct spelling and the correct cases to run a file successfully.
Could Not Find Error Due to Wrong Package Name in Java
Let’s move our DelftStack class into the com.DelftStack package. A package is used to keep similar classes together.
Look at the following code:
package com.DelftStack;
public class DelftStack{
public static void main(String args[]){
System.out.println("Hello from DelftStack");
}
}
To compile a package in Java, we use the following command:
javac -d . <.java file name>
The -d flag switch is used to tell where to keep the generated class file. The . means the current directory.
We compile the above code as follows:
C:UsersUserDocumentsDelftStackjava>javac -d . DelftStack.java
After executing the above command, the following folder structure gets created in our current directory.
comDelftStackDelftStack.class
As we can see, our class file is two folders deep from our current directory. So if we try to run our class file like we were doing in previous cases, we get an error.
C:UsersUserDocumentsDelftStackjava>java DelftStack
Error: Could not find or load main class DelftStack
Caused by: java.lang.ClassNotFoundException: DelftStack
The reason for this error is that no DelftStack class exists in our current folder. To run the class present in a package, we need to pass its fully qualified name (com.DelftStack.DelftStack in this case).
C:UsersUserDocumentsDelftStackjava>java com.DelftStack.DelftStack
Hello from DelftStack
This tells Java to look for the class inside the comDelftStack folder.
Could Not Find Error Due to Wrong CLASSPATH in Java
The CLASSPATH tells the JVM where the .class files are present.
Suppose we are currently in a different folder, and we want to run a Java program whose class file exists in a different folder. In this case, we can pass the location of the class file using the -classpath option.
For example:
java -classpath XYZ/ABC <class name>
The above command tells Java to look for the .class file inside the ZYX/ABC folder.
In the previous case, we created a package.
Suppose we want to run the file inside the com/DelftStack folder. Using the following command, we can do so:
>java -classpath ../../ com.DelftStack.DelftStack
Hello from DelftStack
The ../ means the parent directory. So ../../ means to lookup two directory levels.
Let us take another example, suppose we are at the desktop (folder) location, and we want to run a class file somewhere else on the computer. We can do so by below.
>java -cp C:UsersUserDocumentsDelftStackjava com.DelftStack.DelftStack
Hello from DelftStack
The -cp flag is the shorthand for -classpath. Here, we passed the full location of the folder where the .class file is present.
In some situations, while executing a Java program from the command prompt, we may face the error “Could not find or load main class”. This occurs mainly when the JVM fails to find the main class or .class file. Whenever we compile a Java code, the compiler will automatically create a .class file with the same name as the class name. This will be present in the same directory where we have the .java file.
Let us see a simple Java code and try to compile and execute it from the command prompt.
public class HelloJava {
public static void main(String[] args) {
System.out.println("Java programming language");
}
}
First, we need to compile the code using the javac command.
D:Sample>javac HelloJava.java
This will produce the right result as below since we have compiled it correctly.
D:Sample>java HelloJava Java programming language
Now let us see the different reasons or causes to generate the error “Could not load or find the main class in Java“.
Whenever we compile the java code, the compiler creates a .class file in the same name as the class name. After compilation, if we try to run the code by providing an incorrect file name in the java command, it will result in an error “Could not load or find the main class in Java“.
D:Sample>java hellojava Error: Could not find or load main class hellojava Caused by: java.lang.NoClassDefFoundError: HelloJava (wrong name: hellojava)
Since the class names “HelloJava” and “hellojava” are different, it could not find the right file to execute. The Java file names are case-sensitive during execution.
Could not find or load main class in Java: Incorrect file extension
During compilation, we provide the file extension as.java. In this case, it compiles and successfully generates the .class file. But for executing a java code, we do not need to provide the .class extension. In case we provide the .class as file extension, it will generate the below error “Could not find or load main class in Java”.
D:Sample>java HelloJava.class Error: Could not find or load main class HelloJava.class Caused by: java.lang.ClassNotFoundException: HelloJava.class
If we try to execute without the file extension, it will execute successfully.
D:Sample>java HelloJava Java programming language
Package names
When we have multiple classes that we want to group together, we can group them under a single package. When we place a Java file inside a package, we need to specify the fully qualified name. This means we need to execute the file as packagename.filename.
Now, let us see how to execute the java code when we place the HelloJava.java file inside the package “javaDemo“. In the below example, we are already within the directory “javaDemo“. Hence the compiler tries to find the class file javaDemo.HelloJava and fails to find it. This will result in an error “Could not find or load main class in Java”.
D:SamplejavaDemo>java javaDemo.HelloJava Error: Could not find or load main class javaDemo.HelloJava Caused by: java.lang.ClassNotFoundException: javaDemo.HelloJava
Suppose we move one directory up. Now, it runs successfully. Whenever we execute a java file with a fully qualified name, we need to move one directory up.
D:Sample> java javaDemo.HelloJava Java programming language
Could not find or load main class in Java: Invalid classpath
A classpath is a path that instructs the JVM where the .class files are present. We can also execute a Java file by specifying the classpath using –cp or -classpath option in the java command.
We can specify the classpath after the -cp command as below. Here HelloJava is present inside the directory javaDemo.
C:Usersnandieclipse-workspaceFirstJavaProjectsrc>java -cp ./javaDemo;. HelloJava Java programming language
If we try to specify the classpath when we are already within the target directory, we will get the below error “Could not find or load main class in Java”. This is because it searching for the package javaDemo which is not present since we are already within the same directory.
C:Usersnandieclipse-workspaceFirstJavaProjectsrcjavaDemo>java -cp ./javaDemo;. HelloJava Error: Could not find or load main class HelloJava Caused by: java.lang.ClassNotFoundException: HelloJava
Reference
Error: Could not find or load main class HelloWorld comes when you are trying to run your Java program using java command with the main class as HelloWorld but Java is not able to find the class. In order to solve this error, you must know how Java find and loads the classes, that’s a little bit complex topic for beginners, but we will touch the same base here. For the curious reader, I would suggest reading my post How Classpath works in Java, a must read for a beginner. For now, you just remember that there is an environment variable called CLASSPATH which includes directories where Java looks for all class files and if it doesn’t find your main class there then it throws «Error: Could not find or load main class XXX», where XXX is the name of your main class.
Since many Java programmer is now started programming using Eclipse they face this issue when they first try to run their Java program from command line. In Eclipse, it’s easy to compile and run the program because Eclipse takes care of all Classpath setup, but when you run your Java program from command line, CLASSPATH environment variable comes in picture.
Personally, I don’t like this environment variable and doesn’t define in my environment variable, because its confusing and source of so many classpath related issue. Instead, I use -cp or -classpath option with java command to run my program. This way you always know which JARs are included in your classpath.
For beginners, another important thing to understand is the difference between PATH and CLASSPATH, you must know that PATH is used locate system executable, commands or .exe, .dll files (in Windows) and .so files (in Linux). It is also used to locate native libraries used by your Java program. While, CLASSPATH is used to locate the class file or JAR files. It’s Java class loader who looked into CLASSPATH for loading classes.
Coming back to the problem in hand, if you are a beginner in Java, who are able to run the program from Eclipse but getting «Error: Could not find or load main class HelloWorld» when trying to run the same program from the command line then follow the steps given here to solve it.
Solving Error: Could not find or load main class HelloWorld
Unfortunately beginner’s book like Head First Java, which many developers used to learn Java, doesn’t teach you how to deal with this kind of errors. You need to build this skill by doing active development. In order to understand the problem little better, let’s reproduce it. This is one of the most important troubleshooting skill which will help you a long way in your career. Half of the problem is solved when you are able to reproduce it.
For our purpose we will use following HelloWorld program for our testing, interestingly I have named it HelloHP and it resides in a package called «dto». I have purposefully chosen a class with a package instead of HelloWorld in the default package because many programmers get «Could not find or load main class» error when they try to run a class which is inside a package.
package dto; /** * Simple Java program to demonstrate following error * Error :Could not find or load main class * * @author Javin Paul */ public class HelloHP { public static void main(String args[]) { System.out.println("My first program in Java, HelloWorld !!"); } }
When you run this from Eclipse, by Right click on the source file and Choosing «Run as Java Program», it will run fine and print following line:
My first program in Java, HelloWorld !!
Everything as expected, Now we will try to run same Java program from command line. Since I am using Maven with Eclipse, its build process creates class files in project_directorytargetclasses directory. If you are not using Maven with Eclipse, then you can see the class file created by Eclipse’s Java compiler in project_directorybin. It doesn’t matter how those class files are created, but, what is important is the location of the class file.
If your class is inside a non-default package e.g. «dto» in our case then compiler the will put the HelloHP.class file, which contains Java bytecode in a directory named «dto». In our case the full name of class dto.HelloHP and it is present in C:UsersWINDOWS 8workspaceDemotargetclassesdto. So in the first try, I go there and execute java command to launch my program, as seen below:
C:UsersWINDOWS 8workspaceDemotargetclassesdto>java HelloHP Error: Could not find or load main class HelloHP
Do you see the error? It’s coming because the full name of the class should be dto.HelloHP and not HelloHP. So let’s correct this error and try to run the same command from the same location but this time with fully qualified name:
C:UsersWINDOWS 8workspaceDemotargetclassesdto>java dto.HelloHP Error: Could not find or load main class dto.HelloHP
Still same error, right. Why? because I don’t have any CLASSPATH environment variable, neither I am using -classpath or -cp option to suggest the path, So by default Java is only searching in the current directory. It is looking for dto/HelloHP.class but since we are already inside dto, it is not able to find the class. So, what should we do now? let’s go to the parent directory «C:UsersWINDOWS 8workspaceDemotargetclasses» and execute the same command, this time, it should work:
C:UsersWINDOWS 8workspaceDemotargetclassesdto>cd .. C:UsersWINDOWS 8workspaceDemotargetclasses>java dto.HelloHP My first program in Java, HelloWorld !!
Bingo!!, our program ran successfully because, without any hint about where to find class files, Java is by default looking into the current directory, denoted by . (dot) and able to locate ./dto/HelloHP.class.
Now, what if you want to run this program from any other directory? Well, for that purpose whether we need to define CLASSPATH or just use -classpath or -cp option. I like the second option because it’s easier to control and change. Also, remember, it overrides any CLASSPATH environment variable. If you like to set CLASSPATH environment variable in Windows, see that tutorial.
Now let’s run the program target directory first without using -classpath option:
C:UsersWINDOWS 8workspaceDemotargetclasses>cd .. C:UsersWINDOWS 8workspaceDemotarget>java dto.HelloHP Error: Could not find or load main class dto.HelloHP
You can see we are again started getting the same error, Why? because Java is still looking into the current directory and there is no .targetdtoHelloHP.class there, as it’s one level down e.g. .targetclassesdtoHelloHP.class
Now let’s run the same command using -classpath option from target directory itself:
C:UsersWINDOWS 8workspaceDemotarget>java -cp ./classes;. dto.HelloHP My first program in Java, HelloWorld !!
Bingo!!, our program ran successfully again because now Java is also looking at ./classes directory and there it is able to find dtoHelloHP.class file.
There are many ways Error: Could not find or load main class HelloWorld manifests itself, but if you know the basics of Java Classpath, you can easily sort out the problem. Most of the time you just need to either correct your CLASSPATH environment variable or run your program with java -cp or -classpath option. By the way, there are more to it e.g. Main class defined in the manifest.mf file and that’s why I suggest reading about How Classpath works in Java (see the link in the first paragraph).
Summary
If you are getting «Error: Could not find or load main class XXX», where XXX is the name of your main class while running Java program then do this to solve that error:
1) If you are running Java program right from the directory where .class file is and you have CLASSPATH environment variable defined then make sure it include current directory. (dot). You can include it as set CLASSPATH=%CLASSPATH%;. in Windows and export CLASSPATH = ${CLASSPATH}:. (see the separator, in Windows it’s;(semicolon) while in Linux it is (colon), also note we have included current directory in existing classpath. If you still face the issue of setting classpath, see this step by step guide to set the classpath. Same thing applies if you are running your program using -cp or -classpath option.
2) If you are running Java program from the directory, your .class file is and you don’t have any CLASSPATH or -cp option then check whether your class is the in the package or not. If it’s the in the package then go outside of the package directory and run java command with fully qualified name e.g. if your program is com.abc package then runs following command from the parent directory of «com»
java com.abc.HelloWorld
without any classpath hints, Java will look into the current directory and search for comabcHelloWorld.class in Windows, so if com directory exists in your current directory, your program will run otherwise you will get «Error: Could not find or load main class dto.HelloHP».
3) You can run your Java program from anywhere with the help of proper CLASSPATH or java -cp option as shown below:
java -cp C:test;. com.abc.HelloWorld
If you still facing any issue just check whether you have accidentally using CLASSPATH environment variable, you can check this in Windows by running echo %CLASSPATH% command and in Linux by running echo $CLASSPATH. If CLASSPATH is nonempty then it will print its value otherwise just echo the same command.
4) If you are running in Java version 1.6 or 1.5, then instead of receiving «Error: Could not find or load main class», you will get Exception in thread «main» java.lang.NoClassDefFoundError: HelloWorld. It’s only from JDK 1.7 onward we are started receiving this new error. The solution is exactly same, every bit of discussion applies to that case as well. So if you are not able to solve that problem by following steps here, do let me know and I will try to work with you to troubleshoot the problem.
Here is the screenshot of how I tried to reproduce and solve the error as discussed in the previous paragraph:
That’s all about how to solve «Error: Could not find or load main class HelloWorld» in Java. Classpath is little confusing topic to master, but you will understand it once you started writing and running some Java program. If you are still not able to fix your problem then post a comment there with what you have tried and we will try to troubleshoot together.
My goal is not just to give you solution but also make you able to explain why the solution is working and CLASSPATH basics are very important for a Java developer. I have seen many programmers getting frustrated, losing interest in Java due to various PATH and CLASSPATH issues e.g. NoClassDefFoundError and ClassNotFoundException and this is my humble effort to bring them back and empower with practical knowledge. Hope you understand.
Further Reading
Building debugging and troubleshooting skill is not easy and it takes lots of practice and experience to understand, reproduce and solve the error. If you are new Java developer then you first pick a book to learn Java from start to end, but if you are intermediate Java developer then you should look at the following resources to develop your debugging skill.
If you are getting Error: Could not find or load main class error, it means JVM is trying to load a class with main method. Simply, JVM cannot find this class in the classpath.
main method
main() method has a special meaning in Java, it is the entry point of Java programs.
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World");
}
}
When you run the following command, it starts JVM, loads HelloWorld class and starts running its main method.
java HelloWorld
We will go through several possible reasons for this error. We usually use IDEs for software development, so first let’s examine how to fix this problem in our IDEs.
IntelliJ IDEA – Solution 1
If you run a main class through you IDE, it will be stored in Run/debug Configurations. You can easily run the class again with the run/debug buttons at a later time.
You might want to change the name of your class (Main -> Main2). If you update a class name on your IntelliJ, all references to this class will also be updated (including Run/debug Configurations). However, if you change a class name (or change its package) outside your IDE, Run/debug Configurations will become obsolete.
I renamed Main.java to Main2.java outside Intellij IDE and tried to run the code again using Run button. Now, it gives the following error message in console.
C:Java.jdksbinjava.exe "-javaagent:C:Program FilesJetBrainsIntelliJ IDEA Community Edition 211.6556.6libidea_rt.jar=14581:C:Program FilesJetBrainsIntelliJ IDEA Community Edition 211.6556.6bin" -Dfile.encoding=UTF-8 -classpath C:abcstudyguidecodesoutproductionMain com.abc.Main
Error: Could not find or load main class com.abc.Main
Caused by: java.lang.ClassNotFoundException: com.abc.Main
Process finished with exit code 1
You can update Run/debug Configurations to fix the error.
IntelliJ IDEA – Solution 2
Sometimes just rebuilding your project is enough to resolve this error. To rebuild the project, select Build -> Rebuild Project.
IntelliJ IDEA – Solution 3
If there is some residue left in the cache, you can invalidate caches and restart you IDE.
Eclipse – Solution 1
Similar to IntelliJ, you can run Java application in eclipse.
Once you run your application, it is saved as a Run Configuration. If you update your application main class outside Eclipse IDE and try to run it again, you will get Error: Could not find or load main class error message.
If you have updated class name or package outside Eclipse IDE, you need to update Run Configurations accordingly.
Eclipse – Solution 2
If there is nothing wrong with your Run Configurations, you can try to clean and build your project. Note that Build Automatically option is selected.
Eclipse – Solution 3
If you copied the project from another computer, your build path might be pointing incorrect path. To check the build path of your project, select File -> Properties from menu and open Java Build Path.
Eclipse warns you with message: Build path entry is missing: C:/jar_libs/jdbc.jar. To fix the path of jar file, click on Edit button and update with correct path.
Command Line – Solution 1
You can also use command line to compile and run your Java programs. Consider the following HelloWorld class. It is a simple class with a main method. There is no package declaration in the source code.
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
You can compile your source code with javac command and run the compiled code with java command. There are a few things you need to pay attention to while running the code.
Java is case-sensitive, so you should type your class name exactly the same. If you type helloworld instead of HelloWorld, command will give error.
Also, file extensions (like HelloWorld.class) should not be used when running java command.
C:codes>javac HelloWorld.java C:codes>java HelloWorld Hello World! C:codes>java helloworld Error: Could not find or load main class helloworld C:codes>java HelloWorld.class Error: Could not find or load main class HelloWorld.class
Command Line – Solution 2
Following code is similar to previous one, but in this example HelloWorld class is defined under a package. In Java, packages are used to organize similar classes together.
Packages are organized as directories on your file system. For instance, HelloWorld class is created under com.abc.study.guide package, so HelloWorld.java file should be in {project-root}/com/abc/study/guide folder.
package com.abc.study.guide;
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
To run a class, we are using FQN (Fully Qualified Name) of the class – that is (package.class name). For HelloWorld class in our example FQN is com.abc.study.guide.HelloWorld. Thus, java comand to run this class is: java com.abc.study.guide.HelloWorld.
C:codes>javac comabcstudyguideHelloWorld.java
C:codes>java HelloWorld
Error: Could not find or load main class HelloWorld
C:codes>java com.abc.study.guide.HelloWorld
Hello World!
You can run HelloWorld class from any directory in file system. But if you are running java command from outside the project root directory, classpath parameter should be used. Classpath tells JVM where to look for classes – it’s path of classes. You can specify the class path is by using the -classpath (or -cp) command line switch.
C:another-directory>java com.abc.study.guide.HelloWorld Error: Could not find or load main class com.abc.study.guide.HelloWorld C:another-directory>java -classpath C:codes com.abc.study.guide.HelloWorld Hello World! C:another-directory>java -cp C:codes com.abc.study.guide.HelloWorld Hello World! C:codescomabcstudyguide>java com.abc.study.guide.HelloWorld Error: Could not find or load main class com.abc.study.guide.HelloWorld C:codescomabcstudyguide>java -cp ../../../.. com.abc.study.guide.HelloWorld Hello World!