Java Basics: Getting Started with Java

The Magic Kitchen Analogy

Imagine you’re learning to cook in a magical kitchen. This kitchen is special—it works the same way no matter where you put it: in your house, on a spaceship, or underwater! Java is like a recipe book for this magical kitchen. Once you write a recipe (your code), it works everywhere!

What is Java and Its Features

The Story

Once upon a time, programmers had a big problem. They wrote programs for one computer, but those programs wouldn’t work on other computers. It was like writing a letter in French that only French people could read!

Then came Java in 1995. Java said: “Write once, run anywhere!”

What Makes Java Special?

Think of Java as a universal translator for computers:

Quick Example

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

This tiny program says “Hello” to the world. Simple, right?

JVM, JDK, JRE Architecture

The Three Superheroes

Meet three friends who work together to run Java:

graph TD
    A[JDK - The Complete Toolbox] --> B[JRE - The Running Shoes]
    B --> C[JVM - The Translator]
    A --> D[Compiler javac]
    A --> E[Debugger]
    A --> F[Other Tools]
    B --> G[Libraries]
    C --> H[Runs Your Code]

Understanding Each One

JVM (Java Virtual Machine) - The Translator

• Like a translator who speaks every computer language
• Takes your Java code and tells the computer what to do
• Every computer has its own JVM, but they all understand the same Java!

JRE (Java Runtime Environment) - The Running Shoes

• Everything you need to RUN Java programs
• Contains the JVM + helpful libraries
• If you just want to run Java apps, you need this

JDK (Java Development Kit) - The Complete Toolbox

• Everything you need to CREATE Java programs
• Contains JRE + compiler + tools
• If you want to write code, you need this!

Simple Memory Trick

JDK = I want to BUILD things (Developer) JRE = I want to USE things (User) JVM = The brain that makes it all work

Platform Independence

The Magic Trick

Here’s Java’s secret superpower:

graph TD
    A[Your Code .java] --> B[Compiler]
    B --> C[Bytecode .class]
    C --> D[JVM on Windows]
    C --> E[JVM on Mac]
    C --> F[JVM on Linux]
    D --> G[Windows understands!]
    E --> H[Mac understands!]
    F --> I[Linux understands!]

The Bytecode Secret

1. You write code in Java (human-readable)
2. The compiler turns it into bytecode (a universal language)
3. The JVM on ANY computer can read this bytecode
4. Your program runs everywhere!

It’s like writing a recipe in pictures instead of words—everyone in the world understands pictures!

Why This Matters

• Write code on your Windows laptop
• Your friend runs it on their Mac
• It works on a Linux server
• Same code, works everywhere!

Setting Up Environment

Your Cooking Station Setup

Before cooking (coding), you need to set up your kitchen (environment):

Step 1: Download JDK

Go to Oracle’s website and download the JDK for your computer.

Step 2: Install It

Run the installer like any other program.

Step 3: Set PATH Variable

This tells your computer where to find Java:

On Windows:

JAVA_HOME = C:\Program Files\Java\jdk-21
PATH = %JAVA_HOME%\bin

On Mac/Linux:

export JAVA_HOME=/usr/lib/jvm/jdk-21
export PATH=$JAVA_HOME/bin:$PATH

Step 4: Verify Installation

Open terminal/command prompt and type:

java -version

If you see version info, you’re ready to cook!

First Program and main Method

Your First Recipe

Every Java program starts with a class and a main method:

public class MyFirstProgram {
    public static void main(String[] args) {
        System.out.println("I did it!");
    }
}

Breaking It Down Like LEGO

Why “main” is Special

• Java looks for main to know where to start
• It’s like the “Chapter 1” of your story
• Without main, Java doesn’t know where to begin!

The Magic Words

• public = Everyone can see this
• static = Ready to use immediately
• void = Doesn’t give anything back
• main = The starting point

Compiling and Running Programs

From Recipe to Meal

graph TD
    A[Write Code<br>MyProgram.java] --> B[Compile<br>javac MyProgram.java]
    B --> C[Bytecode Created<br>MyProgram.class]
    C --> D[Run<br>java MyProgram]
    D --> E[Output on Screen!]

Two Simple Commands

Step 1: Compile (Turn recipe into cooking instructions)

javac MyProgram.java

This creates MyProgram.class (the bytecode)

Step 2: Run (Actually cook the meal)

java MyProgram

This runs your program!

Common Mistakes to Avoid

• Don’t type .class when running: java MyProgram NOT java MyProgram.class
• File name must match class name exactly
• Save as .java not .txt

Scanner Class for Input

Listening to the User

What if you want your program to ask questions? Use Scanner!

import java.util.Scanner;

public class AskName {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.print("What is your name? ");
        String name = input.nextLine();

        System.out.println("Hello, " + name + "!");

        input.close();
    }
}

Scanner’s Special Powers

Example: Age Calculator

import java.util.Scanner;

public class AgeCalculator {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        System.out.print("Enter birth year: ");
        int birthYear = scan.nextInt();

        int age = 2024 - birthYear;
        System.out.println("You are " + age);

        scan.close();
    }
}

Remember!

• Always import java.util.Scanner at the top
• Create Scanner: Scanner sc = new Scanner(System.in)
• Close when done: sc.close()

Stack vs Heap Memory

Two Types of Storage

Think of your computer’s memory as two rooms:

graph TD
    subgraph STACK[Stack - Small Boxes]
        A[Fast]
        B[Organized]
        C[Limited Space]
        D[Stores: numbers, true/false]
    end

    subgraph HEAP[Heap - Big Warehouse]
        E[Larger Space]
        F[Less Organized]
        G[Stores: Objects, Arrays]
    end

Stack Memory (The Small Desk)

• Fast to access
• Stores simple things: numbers, yes/no values
• Automatically cleans up when done
• Like sticky notes on your desk

Heap Memory (The Big Warehouse)

• Bigger storage space
• Stores complex things: objects, arrays
• Needs garbage collection to clean up
• Like boxes in a warehouse

Visual Example

int age = 10;           // Goes to STACK
String name = "Java";   // Reference in STACK
                        // Actual "Java" in HEAP

STACK                HEAP
┌───────────┐       ┌──────────────┐
│ age = 10  │       │   "Java"     │
│ name ───────────► │              │
└───────────┘       └──────────────┘

Simple Rules

Your Journey Begins!

You’ve learned:

1. Java - The universal programming language
2. JVM/JDK/JRE - Your coding tools
3. Platform Independence - Write once, run anywhere
4. Environment Setup - Getting ready to code
5. First Program - Your “Hello World” moment
6. Compiling & Running - Making code work
7. Scanner - Talking to users
8. Memory - Where data lives

What’s Next?

Now that you’ve set up your magical kitchen and cooked your first dish, you’re ready to create amazing programs! Every expert was once a beginner. Keep coding, keep exploring, and most importantly—have fun!

“The only way to learn programming is by programming.” - Start now!