How to run Java files with Java 11

Introduction

Java 11 is the latest long-term support (LTS) version of the Java programming language, offering improved performance, security, and new features. This tutorial will guide you through the process of running Java files using the Java 11 runtime environment, helping you get started with Java 11 development and troubleshoot any issues you may encounter.

Getting Started with Java 11

Java 11 is the latest long-term support (LTS) version of the Java programming language, released in September 2018. It provides a range of new features and improvements over previous versions, making it a powerful and versatile tool for modern software development.

Understanding Java 11

Java 11 is a major release of the Java Development Kit (JDK) that introduces several new features and enhancements. Some of the key highlights of Java 11 include:

Long-Term Support (LTS): Java 11 is an LTS release, which means it will receive regular security and bug fixes for an extended period, making it a reliable choice for enterprise-level applications.
New Language Features: Java 11 includes several new language features, such as the var keyword for type inference, improved string handling, and the HttpClient API for making HTTP requests.
Performance Improvements: Java 11 boasts various performance improvements, including faster startup times and reduced memory footprint.
Modular System: Java 11 builds upon the modular system introduced in Java 9, allowing developers to create more modular and maintainable applications.

Installing Java 11

To get started with Java 11, you'll need to download and install the JDK. You can download the JDK from the official Oracle website or use a package manager like apt on Ubuntu 22.04.

Here's an example of how to install Java 11 on Ubuntu 22.04 using apt:

sudo apt update
sudo apt install openjdk-11-jdk

After the installation is complete, you can verify the Java version by running the following command:

java -version

This should output something similar to:

openjdk version "11.0.18" 2023-01-17
OpenJDK Runtime Environment (build 11.0.18+10-post-Ubuntu-0ubuntu122.04)
OpenJDK 64-Bit Server VM (build 11.0.18+10-post-Ubuntu-0ubuntu122.04, mixed mode, sharing)

Now that you have Java 11 installed, you're ready to start running Java programs.

Running Java Programs in Java 11

Now that you have Java 11 installed, let's explore how to run Java programs using the Java 11 runtime environment.

Compiling and Running Java Files

To run a Java program, you'll need to first compile the Java source code into bytecode, and then execute the bytecode using the Java Virtual Machine (JVM).

Here's an example of how to compile and run a simple Java program on Ubuntu 22.04:

Create a new file called HelloWorld.java with the following content:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, LabEx!");
    }
}

Compile the Java file using the javac command:

javac HelloWorld.java

This will generate a new file called HelloWorld.class, which contains the compiled bytecode.

Run the compiled program using the java command:

java HelloWorld

This will execute the main() method in the HelloWorld class and output Hello, LabEx!.

Using Command-Line Arguments

You can also pass command-line arguments to your Java programs. Here's an example:

public class ArgumentExample {
    public static void main(String[] args) {
        if (args.length > 0) {
            System.out.println("Received argument(s):");
            for (String arg : args) {
                System.out.println(arg);
            }
        } else {
            System.out.println("No arguments provided.");
        }
    }
}

To run this program with command-line arguments, use the following command:

java ArgumentExample Hello World LabEx

This will output:

Received argument(s):
Hello
World
LabEx

The args parameter in the main() method is an array of strings that contains the command-line arguments passed to the program.

By understanding how to compile and run Java programs, as well as how to handle command-line arguments, you'll be well on your way to becoming a proficient Java 11 developer.

Troubleshooting Java 11 Execution

While running Java programs is generally straightforward, you may occasionally encounter issues or errors. In this section, we'll cover some common troubleshooting steps to help you resolve any problems you might encounter.

Checking the Java Version

Before troubleshooting any issues, it's important to ensure that you're using the correct version of Java. You can check the installed Java version by running the following command:

java -version

This should output the version of Java installed on your system, similar to the following:

openjdk version "11.0.18" 2023-01-17
OpenJDK Runtime Environment (build 11.0.18+10-post-Ubuntu-0ubuntu122.04)
OpenJDK 64-Bit Server VM (build 11.0.18+10-post-Ubuntu-0ubuntu122.04, mixed mode, sharing)

If the output doesn't show Java 11, you may need to install or configure the correct version of Java.

Handling Compilation Errors

If you encounter errors when compiling your Java code, you can use the compiler's output to help you identify and fix the issue. For example, if you have a syntax error in your code, the compiler will output an error message with the line number and a description of the problem.

Here's an example of a compilation error:

$ javac HelloWorld.java
HelloWorld.java:3: error: ';' expected
        System.out.println("Hello, LabEx!")
                                         ^
1 error

In this case, the error message indicates that a semicolon (;) is missing at the end of the System.out.println() statement.

Troubleshooting Runtime Errors

If your Java program compiles successfully but encounters an error at runtime, you can use the stack trace to help you identify and fix the issue. The stack trace will show you the sequence of method calls that led to the error, as well as the line numbers where the error occurred.

Here's an example of a runtime error:

$ java HelloWorld
Exception in thread "main" java.lang.NoClassDefFoundError: HelloWorld
    at java.base/java.lang.ClassLoader.defineClass1(Native Method)
    at java.base/java.lang.ClassLoader.defineClass(ClassLoader.java:1016)
    at java.base/java.security.SecureClassLoader.defineClass(SecureClassLoader.java:151)
    at java.base/jdk.internal.loader.BuiltinClassLoader.defineClass(BuiltinClassLoader.java:821)
    at java.base/jdk.internal.loader.BuiltinClassLoader.findClassOnClassPathOrNull(BuiltinClassLoader.java:719)
    at java.base/jdk.internal.loader.BuiltinClassLoader.loadClassOrNull(BuiltinClassLoader.java:642)
    at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:600)
    at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:521)
    at java.base/java.lang.Class.forName0(Native Method)
    at java.base/java.lang.Class.forName(Class.java:375)
    at java.base/sun.launcher.LauncherHelper.checkAndLoadMain(LauncherHelper.java:495)

In this case, the error message indicates that the HelloWorld class could not be found, which suggests that the class file may not have been generated correctly or may be in the wrong directory.

By understanding how to troubleshoot compilation and runtime errors, you'll be better equipped to handle any issues that may arise when running Java 11 programs.

Summary

In this comprehensive Java 11 tutorial, you'll learn the essential steps to run Java files, from setting up the Java 11 runtime environment to executing your Java programs. You'll also discover techniques to troubleshoot common problems and ensure a smooth Java 11 development experience. Whether you're a beginner or an experienced Java developer, this guide will equip you with the knowledge to effectively leverage the power of Java 11 for your projects.