Reason #2 - the application's classpath is incorrectly specified Read the three documents linked above. (Yes ... READ them! It is important that a Java programmer understands at least the basics of how the Java classpath mechanisms works.) I want to add this documentation to this very good post from above JDK Tools and Utilities General General Information (file structure, classpath, how classes are found, changes) Enhancements(enhancements in JDK 7) Standard JDK Tools and Utilities https://docs.oracle.com/javase/7/docs/technotes/tools/index.html https://docs.oracle.com/javase/7/docs/technotes/tools/findingclasses.html https://docs.oracle.com/javase/7/docs/technotes/tools/windows/classpath.html How the Java Launcher Finds Classes Understanding the class path and package names https://docs.oracle.com/javase/7/docs/technotes/tools/solaris/javac.html
ClassLoader in Java The Java ClassLoader is a part of the Java Runtime Environment that dynamically loads Java classes into the Java Virtual Machine. The Java run time system does not need to know about files and file systems because of classloaders.
Java classes aren’t loaded into memory all at once, but when required by an application. At this point, the Java ClassLoader is called by the JRE and these ClassLoaders load classes into memory dynamically. https://en.wikipedia.org/wiki/Java_Classloader https://www.geeksforgeeks.org/classloader-in-java/ https://en.wikipedia.org/wiki/Java_virtual_machine
If your source code name is HelloWorld.java, your compiled code will be HelloWorld.class
.
You will get that error if you call it using:
java HelloWorld.class
Instead, use this:
java HelloWorld
In the context of IDE development (Eclipse, NetBeans or whatever) you have to configure your project properties to have a main class, so that your IDE knows where the main class is located to be executed when you hit "Play".
This might help you if your case is specifically like mine: as a beginner I also ran into this problem when I tried to run a Java program.
I compiled it like this:
javac HelloWorld.java
And I tried to run also with the same extension:
java Helloworld.java
When I removed the .java
and rewrote the command like java HelloWorld
, the program ran perfectly. :)
Right click the project.
src
folder as "sources"This worked for me.
If it's a Maven project:
The issue should go away.
What fixed the problem in my case was:
Right click on the project/class you want to run, then Run As
->Run Configurations
. Then you should either fix your existing configuration or add new in the following way:
open the Classpath
tab, click on the Advanced...
button then add bin
folder of your project.
After searching for 2 days I found this solution and this works. It is pretty weird but it works for me.
package javaapplication3;
public class JavaApplication3 {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
System.out.println("Hello");
}
}
this is my program i want to run that locates at C:\Java Projects\JavaApplication3\src\javaapplication3
Now open cmd on this location and compile program using this command
javac JavaApplication3.java
After compiling navigate one directory down i.e. C:\Java Projects\JavaApplication3\src
now run following command to execute program
java javaapplication3.JavaApplication3
Sometimes what might be causing the issue has nothing to do with the main class, and I had to find this out the hard way. It was a referenced library that I moved, and it gave me the:
Could not find or load main class xxx Linux
I just deleted that reference, added it again, and it worked fine again.
I had same problem and finally found my mistake :) I used this command for compiling and it worked correctly:
javac -cp "/home/omidmohebbi/AAAATest/jars/core-1.7.jar:/home/omidmohebbi/AAAATest/jars/javase-1.7.jar:/home/omidmohebbi/AAAATest/jars/qrgen-1.2.jar" qrcode.java
But this command did not work for me (I could not find or load the main class, qrcode
):
java -cp "/home/omidmohebbi/AAAATest/jars/core-1.7.jar:/home/omidmohebbi/AAAATest/jars/javase-1.7.jar:/home/omidmohebbi/AAAATest/jars/qrgen-1.2.jar" qrcode
Finally I just added the ':' character at end of the classpath and the problem was solved:
java -cp "/home/omidmohebbi/AAAATest/jars/core-1.7.jar:/home/omidmohebbi/AAAATest/jars/javase-1.7.jar:/home/omidmohebbi/AAAATest/jars/qrgen-1.2.jar:" qrcode
I had a weird one:
Error: Could not find or load main class mypackage.App
It turned out I had a reference to POM (parent) coded up in my project's pom.xml
file (my project's pom.xml
was pointing to a parent pom.xml
) and the relativePath
was off/wrong.
Below is a partial of my project's pom.xml
file:
<parent>
<groupId>myGroupId</groupId>
<artifactId>pom-parent</artifactId>
<version>0.0.1-SNAPSHOT</version>
<relativePath>../badPathHere/pom.xml</relativePath>
</parent>
Once I resolved the POM relativePath, the error went away.
Go figure.
In my case, error appeared because I had supplied the source file name instead of the class name.
We need to supply the class name containing the main method to the interpreter.
All answers here are directed towards Windows users it seems. For Mac, the classpath separator is :
, not ;
. As an error setting the classpath using ;
is not thrown then this can be a difficult to discover if coming from Windows to Mac.
Here is corresponding Mac command:
java -classpath ".:./lib/*" com.test.MyClass
Where in this example the package is com.test
and a lib
folder is also to be included on classpath.
After reading all the answers, I noticed most didn't work for me. So I did some research and here is what I got. Only try this if step 1 doesn't work.
Open go to C:\Program Files (x86)\Java or C:\Program Files\Java
jdk
folder and then the bin
folder.ii. Copy the path and add it to environment variables. Make sure you separate variables with a semi-colon, ;
. For example, "C:\Yargato\bin;C:\java\bin;". If you don't, it will cause more errors.
iii. Go to the jre
folder and open its bin
folder.
iv. Here search for rt.jar file. Mine is:
C:\Program Files (x86)\Java\jre1.8.0_73\lib\rt.jar Copy and under environment variable and search for the classpath variable and paste it there.
What helped me was specifying the classpath on the command line, for example:
Create a new folder, C:\temp
Create file Temp.java in C:\temp
, with the following class in it:
public class Temp {
public static void main(String args[]) {
System.out.println(args[0]);
}
}
Open a command line in folder C:\temp
, and write the following command to compile the Temp class:
javac Temp.java
Run the compiled Java class, adding the -classpath
option to let JRE know where to find the class:
java -classpath C:\temp Temp Hello!
I spent a decent amount of time trying to solve this problem. I thought that I was somehow setting my classpath incorrectly but the problem was that I typed:
java -cp C:/java/MyClasses C:/java/MyClasses/utilities/myapp/Cool
instead of:
java -cp C:/java/MyClasses utilities/myapp/Cool
I thought the meaning of fully qualified meant to include the full path name instead of the full package name.
When the same code works on one PC, but it shows the error in another, the best solution I have ever found is compiling like the following:
javac HelloWorld.java
java -cp . HelloWorld
I had such an error in this case:
java -cp lib.jar com.mypackage.Main
It works with ;
for Windows and :
for Unix:
java -cp lib.jar; com.mypackage.Main
You really need to do this from the src
folder. There you type the following command line:
[name of the package].[Class Name] [arguments]
Let's say your class is called CommandLine.class
, and the code looks like this:
package com.tutorialspoint.java;
/**
* Created by mda21185 on 15-6-2016.
*/
public class CommandLine {
public static void main(String args[]){
for(int i=0; i<args.length; i++){
System.out.println("args[" + i + "]: " + args[i]);
}
}
}
Then you should cd
to the src folder and the command you need to run would look like this:
java com.tutorialspoint.java.CommandLine this is a command line 200 -100
And the output on the command line would be:
args[0]: this
args[1]: is
args[2]: a
args[3]: command
args[4]: line
args[5]: 200
args[6]: -100
I got this issue for my demo program created in IntelliJ.
There are two key points to solve it:
my demo program:
package io.rlx.tij.c2;
public class Ex10 {
public static void main(String[] args) {
// do something
}
}
the path of source code:
../projectRoot/src/main/java/io/rlx/tij/c2/Ex10.java
java
dir: cd ../projectRoot/src/main/java
javac ./io/rlx/tij/c2/Ex10.java
java io.rlx.tij.c2.Ex10
if I run program in ../projectRoot/src/main/java/io/rlx/tij/c2
or I run it without package name, I will get this error: Error: Could not find or load main class
.
This happened to me too. In my case, it only happened when a HttpServlet
class was present in source code (IntelliJ IDEA didn't give a compile time error; the servlet package got imported just fine, however at run time there was this main class
error).
I managed to solve it. I went to menu File → Project Structure...:
Then to Modules:
There was a Provided scope near the servlet module. I changed it to Compile:
And it worked!
When running the java
with the -cp
option as advertised in Windows PowerShell you may get an error that looks something like:
The term `ClassName` is not recognized as the name of a cmdlet, function, script ...
In order to for PowerShell to accept the command, the arguments of the -cp
option must be contained in quotes as in:
java -cp 'someDependency.jar;.' ClassName
Forming the command this way should allow Java process the classpath arguments correctly.
I ran into this error while trying to execute this code written in intellij idea on onlinegdb compiler.
For me commenting out this line helped me prevent this error.
//package com.company;
By default, Java uses .
, the current working directory, as the default CLASSPATH
. What this means is that when you type a command at the prompt e.g. java MyClass
, the command is interpreted as if you had type java -cp . MyClass
. Did you see that dot between -cp
and MyClass
? (cp is short for the longer classpath option)
This is sufficient for most cases and things seems to work just fine until at some time you try to add a directory to your CLASSPATH
. In most cases when programmers need to do this, they just run a command like set CLASSPATH=path\to\some\dir
. This command creates a new environment variable called CLASSPATH
having the value path\to\some\dir
or replaces its value with path\to\some\dir
if CLASSPATH
was already set before.
When this is done, you now have a CLASSPATH
environment variable and Java no longer uses its default classpath (.
) but the one you've set. So the next day you open your editor, write some java program, cd
to the directory where you saved it, compile it, and try to run it with the command java MyClass
, and you are greeted with a nice output: Could not find or load main class ... (If your commands were working well before and you are now getting this output, then this might be the case for you).
What happens is that when you run the command java MyClass
, Java searches for the class file named MyClass
in the directory or directories that you have set in your CLASSPATH
and not your current working directory so it doesn't find your class file there and hence complains.
What you need to do is add .
to your class path again which can be done with the command set CLASSPATH=%CLASSPATH%;.
(notice the dot after the semicolon). In plain english this command says "Pick what was initially the value of CLASSPATH
(%CLASSPATH%
), add .
to it (;.
) and assign the result back to CLASSPATH
".
And voila, you are once again able to use your command java MyClass
as usual.
Seems like when I had this problem, it was unique.
Once I removed the package declaration at the top of the file, it worked perfectly.
Aside from doing that, there didn't seem to be any way to run a simple HelloWorld.java on my machine, regardless of the folder the compilation happened in, the CLASSPATH or PATH, parameters or folder called from.
Answering with respect to an external library -
Compile:
javac -cp ./<external lib jar>: <program-name>.java
Execute:
java -cp ./<external lib jar>: <program-name>
The above scheme works well in OS X and Linux systems. Notice the :
in the classpath.
In Java, when you sometimes run the JVM from the command line using the java executable and are trying to start a program from a class file with public static void main (PSVM), you might run into the below error even though the classpath parameter to the JVM is accurate and the class file is present on the classpath:
Error: main class not found or loaded
This happens if the class file with PSVM could not be loaded. One possible reason for that is that the class may be implementing an interface or extending another class that is not on the classpath. Normally if a class is not on the classpath, the error thrown indicates as such. But, if the class in use is extended or implemented, java is unable to load the class itself.
Reference: https://www.computingnotes.net/java/error-main-class-not-found-or-loaded/
If you use Maven to build the JAR file, please make sure to specify the main class in the pom.xml file:
<build>
<plugins>
<plugin>
<artifactId>maven-jar-plugin</artifactId>
<configuration>
<archive>
<manifest>
<mainClass>class name us.com.test.abc.MyMainClass</mainClass>
</manifest>
</archive>
</configuration>
</plugin>
</plugins>
</build>
One more scenario that got me scratch my head, and I found no reference to it herein, is:
package com.me
Public class Awesome extends AwesomeLibObject {
....
public static void main(String[] argv) {
System.out.println("YESS0");
}
}
Where AwesomeLibObject is a class defined in an external lib. I got the same confusing error message for it:
Error: Could not find or load main class com.Awesome
The resolution is simple: the external lib must be in classpath as well!
This is how I solved my issue.
I noticed if you are including jar files with your compilation, adding the current directory (./) to the classpath helps.
javac -cp "abc.jar;efg.jar" MyClass.java
java -cp "abc.jar;efg.jar" MyClass
VS
javac -cp "./;abc.jar;efg.jar" MyClass.java
java -cp "./;abc.jar;efg.jar" MyClass
In this instance you have:
Could not find or load main class ?classpath
It's because you are using "-classpath", but the dash is not the same dash used by java
on the command prompt. I had this issue copying and pasting from Notepad to cmd.
Scenario: using command prompt(CMD in Windows) for compile and run a simple 'java' program which have only 'Main.java' file, with specified 'package main'.
Source file path :
some-project-name-folder\src\main\Main.java
Destination folder :
some-project-name-folder\dest
Destination file path (folder '\main' and file '\Main.class' will be produced by 'javac') :
some-project-name-folder\dest\main\Main.class
Main.java is as follow :
package main;
public class Main {
public static void main(String[] args) {
System.out.println("Hello world");
}
}
Compilation :
// 'javac' compiler will produce 'Main.class' in the 'dest\main' folder.
// 'main' folder is created because in the source file(in our case: 'Main.java') is
// specified 'package main'.
javac -d ./dest ./src/main/Main.java
Run compiled file (in our case: 'Main.class') :
// '-cp'(is the same as '-classpath')
// './dest'(means destination folder, where resides compiled 'Main.class').
// 'main.Main'(means 'package' 'main', which contains class 'Main'('Main.class'))
// WARNING: when run 'java' class, MUST NOT type extension '.class'
// after 'class name
// (in our case: 'main.Main'(<package>.<class-name>) WITHOUT extension
// '.class').
java -cp ./dest main.Main
// Hello world
Here's another issue that took me a bit of time: The command line class path param doesn't behave as you'd expect. I'm on MacOS calling the CLI directly, and I'm including two jars in the call.
For example, both of these were confusing the tool about the name of the main class:
This one because the asterisk was causing it to parse the args incorrectly:
java -cp path/to/jars/* com.mypackage.Main
And this one because -- I'm not sure why:
java -cp "*.jar" com.mypackage.Main
This worked:
java -cp "path/to/jars/*" com.mypackage.Main
Listing the two jars explicitly also worked:
java -cp path/to/jars/jar1.jar:path/to/jars/jar2.jar com.mypackage.Main
All right, there are many answers already, but no one mentioned the case where file permissions can be the culprit.
When running, a user may not have access to the JAR file or one of the directories of the path. For example, consider:
Jar file in /dir1/dir2/dir3/myjar.jar
User1 who owns the JAR file may do:
# Running as User1
cd /dir1/dir2/dir3/
chmod +r myjar.jar
But it still doesn't work:
# Running as User2
java -cp "/dir1/dir2/dir3:/dir1/dir2/javalibs" MyProgram
Error: Could not find or load main class MyProgram
This is because the running user (User2) does not have access to dir1, dir2, or javalibs or dir3. It may drive someone nuts when User1 can see the files, and can access to them, but the error still happens for User2.
For a database connection I was getting this one. I just added the following in the class path:
export CLASSPATH=<path>/db2jcc4.jar:**./**
Here I appended ./ in last so that my class also get identified while loading.
Now just run:
java ConnectionExample <args>
It worked perfectly fine.
This is a specific case, but since I came to this page looking for a solution and didn't find it, I'll add it here.
Windows (tested with 7) doesn't accept special characters (like á
) in class and package names. Linux does, though.
I found this out when I built a .jar
in NetBeans and tried to run it in command line. It ran in NetBeans but not in command line.
According to the error message ("Could not find or load main class"), there are two categories of problems:
Main class could not be found when there is typo or wrong syntax in the fully qualified class name or it does not exist in the provided classpath.
Main class could not be loaded when the class cannot be initiated, typically the main class extends another class and that class does not exist in the provided classpath.
For example:
public class YourMain extends org.apache.camel.spring.Main
If camel-spring is not included, this error will be reported.
In my case, I got the error because I had mixed UPPER- and lower-case package names on a Windows 7 system. Changing the package names to all lower case resolved the issue. Note also that in this scenario, I got no error compiling the .java file into a .class file; it just wouldn't run from the same (sub-sub-sub-) directory.
I was unable to solve this problem with the solutions stated here (although the answer stated has, no doubt, cleared my concepts). I faced this problem two times and each time I have tried different solutions (in the Eclipse IDE).
main
methods in different classes of my project. So, I had deleted the main
method from subsequent classes.I got this error after doing mvn eclipse:eclipse
This messed up my .classpath
file a little bit.
Had to change the lines in .classpath
from
<classpathentry kind="src" path="src/main/java" including="**/*.java"/>
<classpathentry kind="src" path="src/main/resources" excluding="**/*.java"/>
to
<classpathentry kind="src" path="src/main/java" output="target/classes" />
<classpathentry kind="src" path="src/main/resources" excluding="**" output="target/classes" />
Excluding the following files solved the problem.
META-INF/*.SF
META-INF/*.DSA
META-INF/*.RSA
Added the following code in build.gradle
jar {
from {
configurations.compile.collect { it.isDirectory() ? it : zipTree(it) }
}
{
exclude "META-INF/*.SF"
exclude "META-INF/*.DSA"
exclude "META-INF/*.RSA"
}
manifest {
attributes(
'Main-Class': 'mainclass'
)
}
}
If your classes are in packages then you have to cd
to the root directory of your project and run using the fully qualified name of the class (packageName.MainClassName).
Example:
My classes are in here:
D:\project\com\cse\
The fully qualified name of my main class is:
com.cse.Main
So I cd
back to the root project directory:
D:\project
Then issue the java
command:
java com.cse.Main
This answer is for rescuing newbie java programmers from the frustration caused by a common mistake, I recommend you read the accepted answer for more in depth knowledge about the java classpath.
Use this command:
java -cp . [PACKAGE.]CLASSNAME
Example: If your classname is Hello.class created from Hello.java then use the below command:
java -cp . Hello
If your file Hello.java is inside package com.demo then use the below command
java -cp . com.demo.Hello
With JDK 8 many times it happens that the class file is present in the same folder, but the java
command expects classpath and for this reason we add -cp .
to take the current folder as reference for classpath.
I also faced similar errors while testing a Java MongoDB JDBC connection. I think it's good to summarize my final solution in short so that in the future anybody can directly look into the two commands and are good to proceed further.
Assume you are in the directory where your Java file and external dependencies (JAR files) exist.
Compile:
javac -cp mongo-java-driver-3.4.1.jar JavaMongoDBConnection.java
Run:
java -cp mongo-java-driver-3.4.1.jar: JavaMongoDBConnection
First set the path using this command;
set path="paste the set path address"
Then you need to load the program. Type "cd (folder name)" in the stored drive and compile it. For Example, if my program stored on the D drive, type "D:" press enter and type " cd (folder name)".
Try -Xdiag.
Steve C's answer covers the possible cases nicely, but sometimes to determine whether the class could not be found or loaded might not be that easy. Use java -Xdiag
(since JDK 7). This prints out a nice stacktrace which provides a hint to what the message Could not find or load main class
message means.
For instance, it can point you to other classes used by the main class that could not be found and prevented the main class to be loaded.
On Windows put .;
at the CLASSPATH value in the beginning.
The . (dot) means "look in the current directory". This is a permanent solution.
Also you can set it "one time" with set CLASSPATH=%CLASSPATH%;.
. This will last as long as your cmd window is open.
If your classes are in packages
(The main class is defined in a package), you should run it over the hierarchical directory, using the full name of the class (packageName.MainClassName
).
Assume there is a source code file (Main.java):
package com.test;
public class Main {
public static void main(String[] args) {
System.out.println("salam 2nya\n");
}
}
For running this code, you should place Main.Class
in the package like directory ./com/test/Main.Java
. And in the root directory use java com.test.Main
.
Sometimes, in some online compilers that you might have tried you will get this error if you don't write public class [Classname]
but just class [Classname]
.
Source: Stackoverflow.com