How to Run a Java Program from the Command Line

Table of Contents

• Prerequisites for Running Java Programs
• Step 1: Compiling Java Code Using the Command Line
• Step 2: Running the Java Program Using the Command Line
• Running Java Programs with Arguments

Introduction

To begin executing Java programs from the command line, you'll need a few essential tools and environments set up on your system. This article will guide you through the prerequisites for running Java programs, including the installation of the Java Development Kit (JDK) and familiarity with your operating system's Command Line Interface (CLI).

It will also cover the steps for compiling and running Java code using the command line, as well as running Java programs with command line arguments. Whether you're a beginner or a seasoned developer, this article will provide you with the knowledge you need to get started with Java programming from the command line.

Prerequisites for Running Java Programs

To begin executing Java programs from the command line, you'll need a few essential tools and environments set up on your system. Firstly, the Java Development Kit (JDK) is indispensable, as it contains the compilers and libraries necessary for developing Java applications.

The JDK inherently includes the Java Runtime Environment (JRE), which is crucial for running Java applications, so no separate installation is required. Additionally, familiarity with your operating system's Command Line Interface (CLI) is assumed, as you will need to navigate and execute commands within it.

The significance of these requirements is underscored by real-world decisions, such as those made in the development of projects that leverage the Java 21 platform. Adopting Java's Long-Term Support (LTS) versions, for their reliability and ability to handle modern development needs, is a strategic move.

This is particularly evident in the case of incorporating virtual threads to maximize server throughput, a critical factor in cost-sensitive projects. Such choices reflect Java's maturity as a technology and its capacity to evolve, as evidenced by the updates in Java release models to date-driven (every six months) to accommodate new features and improvements. The Java application launcher has also been enhanced to support programs supplied as multiple files of Java source code, facilitating the transition from small to larger programs. This is reflective of Java's strength in writing large, complex applications that may start small but are developed and maintained over many years by extensive teams. It's important to note that while Java excels in these areas, there are some limitations when using certain tools and options, such as the UnsupportedOperationException when the operating system does not support process creation, or the IndexOutOfBoundsException for empty command arrays.

Step 1: Compiling Java Code Using the Command Line

Compiling Java code is the foundational step in Java programming, where you translate your source code into bytecode that the Java Virtual Machine (JVM) can understand and execute. To compile Java code, follow these steps: Navigate to the directory containing your Java file using the command prompt or terminal.

Compile the file using the javac command, such as javac HelloWorld.java for a file named HelloWorld.java. Successful compilation will result in a .class file, which is the bytecode representation of your program.

With advancements in Java, such as auto-compile features and the introduction of the var keyword, the process has become more streamlined, allowing both beginners and seasoned developers to work more efficiently. Moreover, the Java ecosystem is continuously evolving to support modern development workflows.

For instance, the Java application launcher has been enhanced to run programs supplied as multiple Java source code files, easing the transition from small to larger projects. This flexibility is crucial as even large-scale applications begin as small projects where fast iteration is key. Tools like the FileSystemProvider API and JavaCompiler.CompilationTask facilitate locating file system providers and managing compilation tasks, respectively. Java's robustness and adaptability, demonstrated by features like virtual threads in Java 21, make it a reliable choice for projects where performance and cost-effectiveness are paramount. As developers like Barlas have noted, Java's memory mapping capabilities and efficient direct memory access are instrumental in optimizing performance, particularly when avoiding branch mispredictions by the processor is essential.

Step 2: Running the Java Program Using the Command Line

Running a Java program from the command line is a straightforward process. Begin by navigating to the directory containing the bytecode file, denoted as *.class. Here, you won't need the .class extension; simply use the java command followed by the class name.

For instance, executing a class called HelloWorld requires typing java HelloWorld in your terminal. This command prompts the Java Virtual Machine (JVM) to kickstart your application, allowing you to witness the output directly in the console. It's essential to recognize that the main method acts as the program's execution starting point, housing the statements that kick off your Java journey with a greeting, typically a "Welcome to Java!"

message displayed on the screen. When running the bytecode, remember to exclude the .class extension to avoid errors like NoClassDefFoundError which occur if you mistakenly enter java ClassName.class. The evolution of Java, including the introduction of features like virtual threads in Java 21 and simplified coding with the var keyword, reflects its commitment to ease and efficiency.

These advancements illustrate Java's adaptability, enabling developers to focus on creating and iterating small programs that can grow into larger, more complex applications over time. As you develop your Java skills, remember that even the most intricate programs begin with simple, clear code that evolves as the project expands. The beauty of Java lies in its ability to facilitate this growth, from the first line of code to large-scale software development.

Running Java Programs with Arguments

Java's main method serves as the gateway to program execution, allowing the passage of command line arguments directly into your application. These arguments are encapsulated within the args array, which is accessible within the main method.

To utilize these command line inputs, one must first adjust the Java code to accommodate args. After this adjustment, recompilation through javac is necessary.

Subsequently, the program can be executed with the java command, the class name, and any desired arguments. For instance, invoking java MyProgram arg1 arg2 would pass arg1 and arg2 to MyProgram.

These arguments can then be harnessed within the program to enhance functionality or influence behavior. Since Java's inception nearly three decades ago, it has evolved significantly, constantly integrating new features while preserving its core capabilities.

This adaptability extends to Java's application launcher, which now supports the execution of a program supplied as multiple Java source code files, streamlining the progression from simple to complex projects. As Java continues to thrive, thanks to the vibrant community of developers, it remains a versatile language for both small and large-scale applications, with an emphasis on fast iteration and flexibility in the early stages of development. Understanding and setting environment variables is crucial for production software. In Unix-like systems, environment variables can be set via the command line or scripts, impacting the Java application's behavior. This process is mirrored across operating systems, albeit with slight variations in semantics, such as case sensitivity. Environment variables, therefore, play a pivotal role in configuring Java applications, underscoring their importance in the broader programming ecosystem.

Conclusion

To run Java programs from the command line, you need the JDK installed and familiarity with the CLI. Compiling Java code is done using the javac command to translate source code into bytecode.

Running a Java program is simple: use the java command followed by the class name. The main method acts as the starting point for execution, and command line arguments can be passed through the args array.

Java's adaptability is seen in its support for running programs with multiple source code files, facilitating small to large project transitions. Setting environment variables is crucial for configuring Java applications in production. With its maturity and continuous evolution, Java remains a versatile language for reliable performance and flexible software development.

Get started with Machinet and revolutionize your Java coding experience today!