Learning Java - Pre-Requisites Skill & Setup Environment

#Introduction

Welcome to the Learn Java series! This series will take you to mastery of Java — the programming language that is the backbone of enterprise systems, backend, and cloud-native applications — from the foundations of the concepts all the way to production readiness. There are 24 episodes in total, arranged into six learning phases.

But before you touch the javac compiler, there are some core skills and software you must have. Why do prerequisites matter? Because Java is a fully object-oriented language with layered concepts. If your foundation in logic and core concepts is not solid yet, syntax that looks simple will feel confusing.

Episode 0 is your roadmap: we will make sure your core skills are in place, set up JDK 21 LTS, choose an IDE, install a build tool, install Git, and perform the first verification. Once this episode is done, the entire series can be followed comfortably.

#Core Skills You Need to Master

#Programming Logic and Algorithms

A basic understanding of algorithms and programming logic is a non-negotiable foundation. You must be comfortable breaking problems into small steps, recognizing repeating patterns, and arranging instructions in sequence. This ability determines how quickly you absorb the concepts in episodes 3 through 5.

#Variables, Data Types, Operators, and Control Structures

Master the concepts of variables, data types, operators, and control structures such as if, loops, and switch. Java is a statically typed language, which means every variable must be declared with an explicit type. Understanding this first will make Java syntax feel familiar.

#Object-Oriented Programming Fundamentals

Java is a language that fully embraces OOP. You need to understand the concepts of class, object, inheritance, and encapsulation. Do not worry if they still feel abstract — episode 6 will break them down completely. For now, it is enough to understand that Java models the real world as objects that have attributes and behavior.

#Basic CLI and Terminal Understanding

Most interactions with Java — compiling, running programs, dependency management — happen through the command line. Get comfortable with directory navigation, running commands, and reading output. A quick exercise:

pwd
ls -la
cd workspace

The pwd command shows your working directory, and ls -la shows the contents of a directory. These small skills will help you throughout the series.

#Software You Need to Prepare

#The Latest Stable JDK: Java 21 LTS

Install JDK 21 LTS or the latest recommended stable version. The JDK (Java Development Kit) includes the javac compiler, the JVM runtime, and various tools. Make sure the JAVA_HOME environment variable points to your JDK installation directory.

#A Modern IDE with Java Support

Pick one: IntelliJ IDEA Community Edition, Eclipse, or VS Code with the Java extension. An IDE helps with autocompletion, visual debugging, and build tool integration. This series prioritizes working from the terminal so you understand what happens behind the scenes.

#A Build Tool: Maven or Gradle

A build tool manages dependencies, compilation, and application packaging. Maven is popular in enterprise, while Gradle excels in speed and flexibility. We will focus on Maven in most episodes and cover Gradle in episode 19.

#JRE, Git, and Hardware Requirements

The JDK already bundles the JVM runtime, so installing the JDK covers your JRE needs. Install Git for version control and CI/CD integration. For hardware, the minimum recommendation is a 64-bit operating system, a 64-bit CPU, and 8GB of RAM so that your IDE and build tool run comfortably.

#Verify the Environment

#Checking the JDK

After installation finishes, verify from the terminal:

java -version
javac -version

The output should show version 21 or newer. The java -version command checks the runtime, while javac -version checks the compiler. If the commands are not found, re-check JAVA_HOME and PATH.

#Checking Maven and Git

Make sure the build tool and Git are ready to use:

mvn -version
git --version

mvn -version shows the Maven version along with the JAVA_HOME location it recognizes. If both appear, your environment is ready for the entire series.

#Your First Program

Test your installation with a simple program. Create a file named Halo.java:

public class Halo {
    public static void main(String[] args) {
        System.out.println("Halo, dunia Java!");
    }
}

Compile and run it from the terminal:

javac Halo.java
java Halo

The javac Halo.java command produces a Halo.class file, then java Halo runs it on the JVM. If the output shows Halo, dunia Java!, your environment is perfect.

#Closing

Episode 0 lays the foundation for the entire series: making sure your programming logic and core concepts are solid, setting up JDK 21 LTS, an IDE, Maven or Gradle, and Git, and verifying the installation with your first program.

Key takeaways:

• Master logic, variables, data types, control structures, and OOP fundamentals before writing code.
• JDK 21 LTS is the standard used throughout this entire series.
• An IDE boosts productivity, but also understand the terminal workflow.
• Maven or Gradle is required for dependency management and builds.
• Always verify with java -version, mvn -version, then the Halo.java program.

In the next episode, episode 1, we will discuss the history, background, and why you need Java — from its birth at Sun Microsystems, the Write Once Run Anywhere philosophy, the evolution from JDK 1.0 to JDK 21 LTS, to the reasons Java is still relevant for modern backend. Make sure your environment is ready, because your Learn Java journey has only just begun!