Building and Running Your First Java Program with Maven/Gradle

The Java "Hello, World!"

In Java, every piece of code resides within a class. Let's start with the simplest possible application.

A basic "Hello, World!" program in Java looks like this:

public class HelloWorld {
    public static void main(String[] args) {
        // This is the entry point of the application
        System.out.println("Hello, World!");
    }
}

Let's break this down:

• public class HelloWorld: This defines a class named HelloWorld. By convention, the filename must match the public class name, so this code would be saved in a file called HelloWorld.java.
• public static void main(String[] args): This is the main method. It serves as the entry point for any standalone Java application, similar to the main function in C++ or Go. The Java Virtual Machine (JVM) looks for this specific method signature to start execution.

• System.out.println("Hello, World!");: This line prints the string "Hello, World!" to the console. It is the Java equivalent of C++'s std::cout << "Hello, World!" << std::endl; or Python's print("Hello, World!").

To understand these concepts from the perspective of a C++ developer, the following video provides some excellent analogies and explanations.

From Source Code to Execution

A key difference between Java and C++ lies in the compilation process. C++ code is typically compiled directly into native machine code for a specific operating system and architecture. Java takes a different approach to achieve platform independence ("write once, run anywhere").

1. Compilation (.java -> .class): You use the Java compiler, javac, to compile your .java source file into an intermediate format called bytecode. This bytecode is saved in a .class file.
2. Execution (JVM): You then use the java command to launch the Java Virtual Machine (JVM). The JVM loads the .class file, interprets the bytecode, and executes it. The JVM is the piece of software that is platform-specific (you need a different JVM for Windows, macOS, and Linux), but it can run the same platform-agnostic bytecode everywhere.

This two-step process is a cornerstone of the Java platform. The video you just watched provides a great demonstration of this. I encourage you to watch this next clip from the same video and then try it yourself.

Practice: Your First Compilation

Now it's your turn.

1. Make sure you have a Java Development Kit (JDK) installed. Version 17 or newer is recommended for modern Spring development.
2. Create a file named HelloWorld.java with the code from above.
3. Open a terminal or command prompt in the same directory.
4. Compile the code: javac HelloWorld.java
5. Run the application: java HelloWorld (Note: you do not include the .class extension).

You should see "Hello, World!" printed to your console.

For a more detailed, step-by-step guide, you can refer to the following document.

Automating the Build with Gradle

Manually calling javac works for a single file, but modern applications consist of hundreds of files and rely on external libraries (dependencies). This is where build automation tools come in. In the Java world, the two most dominant build tools are Maven and Gradle.

These tools are analogous to make or CMake in the C++ world. They manage the entire build lifecycle: compiling code, managing dependencies, running tests, and packaging the application.

For this course, we'll primarily use Gradle, but the principles are transferable to Maven. We will now create the same "Hello, World!" project using Gradle.

The following guide provides an excellent walkthrough for setting up a project from scratch.

By following the steps in the article, you've successfully created, compiled, and run a Java application using a standard industry tool. You've seen how Gradle automates the process of finding source files, compiling them, and executing the main method you define.

The Maven Alternative

While we used Gradle, it's worth being familiar with Maven, as you will encounter it frequently. Maven uses an XML file called pom.xml (Project Object Model) to define the project and its dependencies.

The core concepts are the same as in Gradle:

• Standard Directory Layout: src/main/java for source code.
• Dependency Management: Dependencies are declared in pom.xml.
• Build Lifecycle: Maven uses goals like compile, test, and package. mvn clean install is a very common command to build a project.

The following video provides a quick but comprehensive overview of Maven. You don't need to follow along with the coding, but focus on understanding the core concepts and how they compare to what you just did with Gradle.

Conclusion

In this lesson, you've taken the first critical step into the Java ecosystem. You now understand the fundamental process of turning Java source code into a running application and how to automate that process with a modern build tool.

Here are the key takeaways:

• Java code is organized into classes, and the public static void main(String[] args) method is the application's entry point.
• Java's compilation model involves compiling source code (.java) to platform-independent bytecode (.class), which is then executed by the Java Virtual Machine (JVM).
• Build tools like Gradle and Maven are essential for managing modern Java projects. They automate compilation, dependency management, and packaging.
• Gradle uses a build.gradle script and tasks (e.g., run, build), while Maven uses a pom.xml file and goals (e.g., compile, package).

In our next lesson, we will dive deeper into two concepts you've already encountered: the Java classpath and JAR packaging. You saw that the build tools created a .jar file, and we'll explore exactly what that is and how Java uses it to manage and run applications.