Running Java from the command line remains the most direct way to interact with the Java Virtual Machine. This method strips away the abstractions of IDEs and build tools, revealing the core mechanics of how your code executes. Understanding this process is essential for debugging complex production issues and for working in environments where graphical interfaces are unavailable.
Setting Up Your Environment
Before you can execute any Java application, your operating system needs to know where the Java Development Kit (JDK) is located. This involves setting the JAVA_HOME environment variable and ensuring the bin directory is included in your system's PATH . Without this configuration, the terminal will not recognize basic commands like java or javac .
Verification and Configuration
You can verify a successful setup by opening a new terminal window and typing java -version . This command returns the installed Java Runtime Environment (JRE) version, confirming that the system can locate the Java executable. If the command is not found, you must revisit your environment variables to ensure the path points to the correct JDK installation directory.
Compiling Java Source Code
The journey from writing code to running it begins with compilation. The javac compiler reads your human-readable .java file and translates it into bytecode, which is stored in a .class file. This bytecode is a platform-agnostic intermediate representation that the JVM can understand on any operating system.
Handling Package Structures
When your Java code declares a package, the directory structure must mirror this declaration. For example, a file declaring package com.example.app; must reside in a directory path com/example/app/ . When compiling, you should run the javac command from the root of this structure to ensure the compiler generates the correct output paths for the class files.
Executing Your Application
Once the .class file exists, execution is straightforward. You use the java command followed by the class name, but you must exclude the .class extension. At this stage, the JVM loads the class, verifies the bytecode, and initiates the execution thread by calling the main method.
Managing the Classpath
The classpath is a crucial parameter that tells the JVM where to search for user-defined classes and libraries. By default, the JVM looks in the current directory. However, if your application depends on external JAR files, you must specify them using the -cp or -classpath flag. Incorrect classpath settings are a common source of ClassNotFoundException errors.
Advanced Runtime Options
For production environments or performance troubleshooting, you will need to go beyond basic execution. The JVM accepts a wide array of flags that control memory allocation, garbage collection behavior, and performance monitoring. These options are passed to the java command before the class name to optimize runtime performance.
Troubleshooting and Monitoring
Flags such as -Xms and -Xmx allow you to set the initial and maximum heap size, preventing out-of-memory errors in resource-intensive applications. Additionally, tools like jstack and jvisualvm can be launched from the command line to analyze thread dumps and monitor application health in real time, providing insights that are not visible in an IDE.
