Error could not find or load main class java maven

TLDR : check if packaging element inside the pom.xml file is set to jar.

Like this — <packaging>jar</packaging>. If it set to pom your target folder will not be created even after you Clean and Build your project and Maven executable won’t be able to find .class files (because they don’t exist), after which you get Error: Could not find or load main class your.package.name.MainClass

After creating a Maven POM project in Netbeans 8.2, the content of the default pom.xml file are as follows —

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.mycompany</groupId>
   <artifactId>myproject</artifactId>
   <version>1.0-SNAPSHOT</version>
   <packaging>pom</packaging>
   <properties>
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
   </properties>
</project>

Here packaging element is set to pom. Hence the target directory is not created as we are not enabling maven to package our application as a jar file. Change it to jar then Clean and Build your project, you should see target directory created at root location. Now you should be able to run that java file with main method.

When no packaging is declared, Maven assumes the packaging as jar. Other core packaging values are pom, war, maven-plugin, ejb, ear, rar. These define the goals that execute on each corresponsding build life-cycle phase of that package. See more here

I have a bit of a different but similar scenario so I thought I would share. I have a primary maven application packaged into a war through the build (pom.xml packaging configuration). I wanted to add a jar file that is created from one package within our source code, and added into the assembled output along with the webapp war. This allows us to deliver the web application along with a cli tool separately. I didn’t want to reconfigure the pom.xml to be multi-module, but just to add a jar as a separate executable within our existing structure. I was banging my head against this for a while.

First, I ended up deleting my entire .m2 directory with maven repositories locally. It appears there may have been an issue for me here, because my ultimate code that worked seems to be the same as what wasn’t working originally. I suspect the reasoning for this was I was trying different versions of libraries and was creating conflicts, but who knows. First suggestion I have if you are having issues is delete your .m2 folder and try from scratch.

Also reference @Adam Howell’s answer because that is the fundamentals. I created a simplified example project to figure out why nothing was happening and in there I realized i forgot to prefix the folder structure as src/main/java… doh! Of course in my existing project, this was not the case.

And here is my plugin code i inserted in my pom.xml that worked:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>3.2.0</version>
    <configuration>
        <archive>
            <manifest>
                <addClasspath>true</addClasspath>
                <mainClass>com.myCompany.app.cli.CLITool</mainClass>
            </manifest>
        </archive>
        <outputDirectory>${project.build.directory}</outputDirectory>
        <finalName>our-cli</finalName>
    </configuration>
    <executions>
        <execution>
            <phase>compile</phase>
            <goals>
                <goal>jar</goal>
            </goals>
        </execution>
    </executions>
</plugin>

I am pretty sure you can change the phase you want this done in, I figured earlier on in compile made since to ensure it was available for packaging later. I’m not very experienced with Maven though, so note that this may not be semantically in-line with Maven conventions.

And it worked! Not sure why this took me hours to work out although it did. This I just updated my bin.xml to include the jar file in my assembled deliverable, and Voilah! I have a jar executable separate from my webapp that I can use as a command-line interface tool.

1. Could Not Find Error Due to Passing the Wrong Name in Java
2. Could Not Find Error Due to Wrong Package Name in Java
3. 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.

Introduction

Java developers often face the ‘could not find or load main class’ error out of the blue during compilation. If you keep getting this error without any specific reason, you are not alone. Whether you’re just starting out as a programmer or have some experience under the belt, we’ve all seen this error at least once. And we know it has nothing to do with our code.

Why does the “JVM could not find or load the main class” error occur?

As the name suggests, the ‘could not find or load main class’ error means that the JVM (Java Virtual Machine) could not locate the main class in your code and throws this runtime error. The question is can we not find it?

It is one of the most unpredicted and spontaneous errors in Java, which occurs due to the tendency of JVM to stick with a default classpath, the “main class not found issue” is something that haunts amateurs and professionals alike. As serious as it seems, it is not that difficult to fix. We will be exploring in this article how you can easily fix this annoying Java compilation error.

What Is Classpath?

Before we dive into the how and why of it, we need to understand what Classpath is and its role in Java.

The classpath is the file path where the JRE (Java runtime environment) searches for the classes and other resource files to run the code. As the name suggests, it is simply a file path where the .class format files can be found in a JDK package or directory.

Classpath can be set using two ways:

1. Using the -classpath option at the time of executing the code,
2. By setting the file path to the system CLASSPATH environment variable.

When the JVM is unable to locate the main class, it is usually because you would have entered the wrong .class name to run the classpath or the corresponding .class files have been altered.

See this example of generating a class file of a simple code:

1. public class example01 {
2. public static void main(String[] args) {
3. out.println("This is a simple code");
4. }
5. }

To run a .class file, you can use the following command:

java <.class filename>

Now if we run this line of code to run the class we made.

$ java eg01

Output:

Error: Could not find or load main class

It will fail with the error “Could not find or load main class eg01.”

As mentioned earlier, the .class file will have the same name given to the Java class of the program. So, in this case, the main class will have the name example01, not eg01.

Let’s try this one more with the correct name:

$ java example01

Output:

This is a simple code

Now it ran successfully.

While it’s not as simple in a project, the easiest way to rectify it is by either manually specifying the classpath or using packages.

Using Packages

Packages are used in Java to group similar classes or to provide a unique namespace to a group of classes. We will be now creating a class called example02 and place it in a package called example02Package.

1. package example02Package;
2. public class example02 {
3. public static void main(String args[]) {
4. out.println("File is found successfully!");
5. }
6. }

We will then use this package to visualize how the classpath works in Java. In your files directory, a package is represented as an independent folder by its name that you can easily observe in a file manager application.

After ensuring that the working directory is the same as the one that contains the package folder, you can also change the working directory on the terminal (command prompt) by using the cd command on almost every popular operating system.

Example02.java can be compiled by running the following command:

1. package example02Package;
2. javac example02Package/example02.java

This will now save the compiled .class file in the example02Package directory.

To run the compiled class, you need to type in the fully qualified class name in the command line. The fully qualified name of a Java class is written by prefixing it with the package name.

For this example, this is the fully qualified name:

java example02Package.example02

Using packages also allows Java developers to call executables from different packages from the same working directory. It can be easily done just by modifying the fully qualified class name without getting the ‘could not find or load main class error.

Manually Specifying Classpath

The other way to prevent could not find or load main class error is by manually specifying the classpath. It is recommended to manage your java files by creating separate directories for all source files and classes.

Just like the .class files are labeled as classes. the directory with source files is labeled as src. It also helps in significantly reducing the chances of JVM not being able to find the main class.

If you use this method for organization, this is how the directory structure of your projects will look like before compilation:

|___Project01
|     |___src
|           |___example02Package
|                       |___example02.java
|
|     |___classes

The indentations in the above example show the one level of the file hierarchy that your project should be following.

When compiling this code, you must make sure that your working directory is Project01. The following command is used to execute it:

javac -d classes src/testPackage/Test.java

The .class executable file must be saved in Project01/classes/example02Package. Now, the file directory structure will look like this:

|___Project01
|     |___src
|           |___example02Package
|                       |___example02.java
|
|         classes
|           |___example02Package
|                       |___example02.class

To run the .class file, you have to run the Java command with the fully qualified class name and the specification of the local classpath. Every path is declared relative to the working directory, which in this example is Project01.

java -classpath classes example02Package

Running this command will now provide you with the desired output without any chances of getting the error. The question is, why do you need to reorganize the files to solve such a small runtime error?

Why Organizing Files is important in Java?

The primary reason behind why the ‘could not find or load main class ’ is encountered is because JVM is unable to locate where your .class files were being saved.

The easiest way to resolve this error and prevent it from ever happening is to organize where the .class files are saved. Developers have to explicitly indicate the JVM to look for the .class file in the assigned location. This can only be done by organizing the source files and executables separately and using the working directory to manage either manually or using packages.

Your project code will likely keep expanding over time as the project work keeps going. By adding more constructs such as inheritance, inner classes, and more to your project, the file system keeps getting more complex. In such projects, this simple practice of organizing files can save you several hours of precious time that it would take in debugging if something goes wrong and you end up getting the could not find or load main class error.

See Also: What Are Annotations in Java – How do They Work

Conclusion

“Could not find or load main class” error is very common in Java however, we have discussed some effective ways to prevent this error in the article above. The file organization methods we discussed not only prevent this error but also make your code and directories manageable. These fixes go a long way for Java developers as they save a lot of time and trouble when debugging, especially for complex codes!