How to run Java programs from terminal

JavaJavaBeginner
Practice Now

Introduction

This comprehensive tutorial provides developers with essential knowledge for running Java programs directly from the terminal. By understanding the fundamental steps of compiling and executing Java applications through command-line interfaces, programmers can enhance their technical skills and improve their development workflow.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("`Java`")) -.-> java/ObjectOrientedandAdvancedConceptsGroup(["`Object-Oriented and Advanced Concepts`"]) java(("`Java`")) -.-> java/FileandIOManagementGroup(["`File and I/O Management`"]) java(("`Java`")) -.-> java/BasicSyntaxGroup(["`Basic Syntax`"]) java/ObjectOrientedandAdvancedConceptsGroup -.-> java/packages_api("`Packages / API`") java/FileandIOManagementGroup -.-> java/files("`Files`") java/FileandIOManagementGroup -.-> java/io("`IO`") java/FileandIOManagementGroup -.-> java/create_write_files("`Create/Write Files`") java/BasicSyntaxGroup -.-> java/identifier("`Identifier`") java/BasicSyntaxGroup -.-> java/output("`Output`") subgraph Lab Skills java/packages_api -.-> lab-418038{{"`How to run Java programs from terminal`"}} java/files -.-> lab-418038{{"`How to run Java programs from terminal`"}} java/io -.-> lab-418038{{"`How to run Java programs from terminal`"}} java/create_write_files -.-> lab-418038{{"`How to run Java programs from terminal`"}} java/identifier -.-> lab-418038{{"`How to run Java programs from terminal`"}} java/output -.-> lab-418038{{"`How to run Java programs from terminal`"}} end

Java Runtime Basics

What is Java Runtime Environment (JRE)?

Java Runtime Environment (JRE) is a crucial software package that enables running Java applications on a computer. It provides the necessary runtime libraries, Java Virtual Machine (JVM), and other components required to execute Java programs.

Key Components of Java Runtime

Java Virtual Machine (JVM)

The JVM is the core component of the Java runtime that interprets and executes Java bytecode. It provides:

  • Platform independence
  • Memory management
  • Security features
graph TD A[Java Source Code] --> B[Java Compiler] B --> C[Bytecode] C --> D[JVM] D --> E[Machine Code Execution]

Runtime Libraries

Java provides a comprehensive set of standard libraries that support various programming tasks:

Library Category Purpose
java.lang Core language functionality
java.util Utility classes and data structures
java.io Input/Output operations
java.net Network programming

Installing JRE on Ubuntu

To install Java Runtime Environment on Ubuntu 22.04, use the following command:

sudo apt update
sudo apt install default-jre

Verifying Java Installation

After installation, verify the Java version:

java --version

Runtime Environment Configuration

JAVA_HOME Environment Variable

Setting the JAVA_HOME environment variable helps applications locate the Java installation:

export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
export PATH=$PATH:$JAVA_HOME/bin

Performance and Resource Management

The JRE manages system resources dynamically, including:

  • Memory allocation
  • Garbage collection
  • Thread management

LabEx Learning Tip

At LabEx, we recommend practicing Java runtime concepts through hands-on exercises to build a solid understanding of how Java applications execute.

Compiling Java Programs

Understanding Java Compilation Process

Java compilation transforms human-readable source code into machine-executable bytecode. This process involves converting .java files into .class files that can be run on the Java Virtual Machine.

Java Compiler (javac)

The Java compiler javac is a crucial tool for converting source code:

graph LR A[Java Source Code .java] --> B[Java Compiler javac] B --> C[Bytecode .class]

Basic Compilation Steps

1. Writing Java Source Code

Create a simple Java program HelloWorld.java:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Welcome to LabEx Java Tutorial!");
    }
}

2. Compiling the Program

Compile the Java source file using javac:

javac HelloWorld.java

Compilation Options

Option Description
-d Specifies destination directory for class files
-classpath Sets the class path
-source Specifies Java source version
-target Specifies Java target version

Advanced Compilation Techniques

Compiling Multiple Files

javac *.java

Specifying Classpath

javac -classpath ./libs HelloWorld.java

Common Compilation Errors

Syntax Errors

  • Missing semicolons
  • Incorrect method declarations
  • Type mismatches

Compilation Workflow

graph TD A[Write Source Code] --> B{Syntax Correct?} B -->|Yes| C[Compile with javac] B -->|No| D[Fix Errors] C --> E[Generate .class Files]

Best Practices

  • Use meaningful variable and class names
  • Handle compilation warnings
  • Keep source code organized
  • Use consistent indentation

LabEx Recommendation

Practice compilation techniques in LabEx's interactive Java programming environments to build strong foundational skills.

Executing Java Applications

Java Execution Basics

Java applications are executed using the java command, which launches the Java Virtual Machine (JVM) and runs compiled bytecode.

Running Simple Java Programs

Basic Execution Command

java ClassName

Example Execution

## Compile the program first
javac HelloWorld.java

## Run the compiled program
java HelloWorld

Execution Workflow

graph TD A[Compiled .class File] --> B[Java Command] B --> C[JVM Loads Bytecode] C --> D[Bytecode Interpretation] D --> E[Program Execution]

Advanced Execution Techniques

Classpath Management

Scenario Command Example
Local Directory java -cp . MainClass
Multiple Directories java -cp ./src:./libs MainClass
JAR Files java -cp application.jar MainClass

Passing Arguments

java ClassName arg1 arg2 arg3

Handling Exceptions and Debugging

Common Execution Flags

Flag Purpose
-verbose Detailed runtime information
-Xms Initial heap memory
-Xmx Maximum heap memory
-ea Enable assertions

Performance Optimization

graph LR A[Java Execution] --> B{Performance Tuning} B --> C[Memory Configuration] B --> D[Garbage Collection] B --> E[JIT Compilation]

Handling Large Applications

Running JAR Files

java -jar application.jar

Best Practices

  • Verify Java installation
  • Use appropriate classpath
  • Handle runtime exceptions
  • Monitor memory usage

LabEx Learning Tip

Explore various execution scenarios in LabEx's interactive Java programming environments to master application execution techniques.

Summary

Mastering Java program execution from the terminal is a crucial skill for developers. By learning how to compile Java source files, manage class paths, and run applications using command-line tools, programmers can efficiently develop, test, and deploy Java applications across different environments.

Other Java Tutorials you may like