History and key features of Java

The viva question Riya couldn't explain

Java's history and features in one place

Words you'll meet in this lesson

Java's history at a glance

The 12 features of Java, grouped by the problem they solve

Learning twelve words in a row is hard. Learning four problems is easy, and each problem brings its features with it.

Every feature: what it means and how Java achieves it

How Java grew: from Oak to Java 25

Each step shows what changed for programmers, and what changed behind the screen inside the JDK and JVM.

1. 1991: The Green Project creates Oak

   James Gosling, Mike Sheridan and Patrick Naughton start a secret project at Sun to build software for smart consumer devices. Gosling designs a new language for it, called Oak.

   Consumer devices used many different chips. Rewriting C++ code for each chip was slow and error-prone, so Oak was compiled to an intermediate code that a small interpreter on each device could run. This is the seed of today's bytecode and JVM.

2. 1992: The first demo device

   The team shows a handheld controller prototype called *7 (“Star Seven”), running Oak. The device never became a product.

   The demo proved the idea worked: one program, an interpreter on the device, and no rebuilding for its chip.

3. 1995: Renamed Java, aimed at the internet

   The consumer-device market didn't take off, but the World Wide Web did. The language is renamed Java and announced on 23 May 1995, along with a web browser that could run small Java programs called applets.

   Applets meant running code downloaded from unknown websites. That's why the bytecode verifier and the sandbox were built in from the start. Browser applets were dropped years later, but the safety design stayed.

4. 1996–2000: JDK 1.0, then “Java 2”

   JDK 1.0 ships in January 1996. J2SE 1.2 (1998) is branded “Java 2” and adds the Collections framework and Swing for desktop windows. J2SE 1.3 (2000) makes HotSpot the default JVM.

   Early JVMs mostly interpreted bytecode, so Java was called slow. JIT compilers became standard around Java 2, and HotSpot finds the “hot” (busy) methods and compiles them to machine code. That's how “interpreted” and “high performance” can both be true.

5. 2004: Java 5, the big language upgrade

   Generics, the enhanced for-each loop, autoboxing, enums and annotations. The version name jumps from 1.4 to 5.0.

   Generics are checked by javac and then erased from the bytecode (called type erasure). So new code still ran on the same kind of JVM, and old programs kept working.

6. 2006–2010: Open source, then Oracle

   Sun releases Java's source code as OpenJDK (2006–2007). Oracle buys Sun and takes over Java in January 2010.

   OpenJDK is now the shared source code that almost every JDK is built from, including Oracle JDK, Eclipse Temurin and Amazon Corretto. That's why they all behave the same.

7. 2014: Java 8, lambdas and streams

   Java 8 adds lambda expressions, the Stream API and a new date-and-time library. It became one of the most widely used Java versions ever.

   Lambdas are compiled using a bytecode instruction called invokedynamic, which lets the JVM decide at run time how to build the lambda object. This is the “dynamic” feature at work.

8. 2017–2018: Modules and a faster release train

   Java 9 adds the module system and JShell, an interactive Java prompt. From Java 10 (March 2018), a new version comes every six months. Java 11 (September 2018) is an LTS release.

   The JDK itself was split into modules, such as java.base, so smaller runtimes can be built that contain only the modules an application needs.

9. 2021–2025: Modern Java LTS versions

   Java 17 (2021), Java 21 (2023, with virtual threads) and Java 25 (2025, with a simpler main method for beginners). LTS versions now come every two years.

   Virtual threads are lightweight threads managed by the JVM rather than the operating system. One server can run millions of them, which makes “multithreaded” much cheaper than before.

“Robust and secure” in action: one bug, two languages

Riya stores 3 marks in an array, then makes a classic mistake: she writes to position 3, which doesn't exist (positions are 0, 1 and 2). Press Play to see what C does with this bug and what Java does.

Java vs C vs C++: which features each one has

Java's features at work in real systems

Features matter because real systems depend on them. Here's where each group of features shows up.

Watch it with an example: Tatkal booking at 10 AM

Three people book at the same second. See why multithreading (one of Java's key features) matters, and how Java stops two people getting the same seat.

Examples are simplified to show where each feature fits. Each company's exact technology choices vary.

See three features with your own eyes

This program shows platform independence and robustness in a few lines. Read the notes, then try the challenges in the live editor.

public class Main {
    public static void main(String[] args) {
        // Platform independent: the same code asks "where am I?"
        System.out.println("Running on: " + System.getProperty("os.name"));
        System.out.println("Java version: " + Runtime.version().feature());

        // Robust: Java checks every array index
        int[] marks = {78, 85, 92};
        try {
            System.out.println(marks[3]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Caught: " + e.getMessage());
        }
        System.out.println("Program still running!");
    }
}

The first two lines depend on the machine. On a Windows laptop you might see Running on: Windows 11, and the version number is whatever JDK is installed. The same Main.class works on both.

• System.getProperty("os.name")Asks the JVM which operating system it's running on. The code doesn't change, only the answer does.
• Runtime.version().feature()Returns the main Java version number, such as 17, 21 or 25.
• int[] marks = {78, 85, 92};An array of 3 whole numbers at positions 0, 1 and 2. Arrays get their own lesson in Module 4.
• try { … }“Try this code, and watch for errors.” Exceptions are covered fully in Module 7.
• catch (ArrayIndexOutOfBoundsException e)“If this kind of error happens, run this block instead of crashing.” e holds the details.
• e.getMessage()The error's message: Index 3 out of bounds for length 3.

Watch the JVM catch the bug

Step through the program and watch the stack (methods and their variables) and the heap (objects). You'll see the array, the exception object and the garbage collector's moment.

Worked examples: real problems, solved and traced in memory

Three programs that show Java's famous features at work: robust (errors are caught, not crashes), strongly typed (sizes of numbers are fixed on every machine) and automatic memory management (unused objects are cleaned up for you).

prices {150, 220, 350}; customer asks for class index 5

Sorry, seat class 5 does not exist.
Kiosk still running. Classes available: 3

daily revenue 95000000, 365 days

int result:  315261632
long result: 34675000000
int limit:   2147483647

three notices in a row

Canteen opens at 8
Canteen opens at 9 today
No notice. Is it null? true

Check yourself

Quick revision

Interview and viva questions

Practice problems

Small programs that touch Java's features: safe error handling, fixed-size types and strings. Every output is fixed. The last three are business tasks.

1995, 2026

Java is 31 years old

public class Main {
    public static void main(String[] args) {
        int born = 1995;
        int now = 2026;
        System.out.println("Java is " + (now - born) + " years old");
    }
}

(none)

int max:  2147483647
long max: 9223372036854775807

public class Main {
    public static void main(String[] args) {
        System.out.println("int max:  " + Integer.MAX_VALUE);
        System.out.println("long max: " + Long.MAX_VALUE);
    }
}

100 / 0

Cannot divide by zero

public class Main {
    public static void main(String[] args) {
        try {
            System.out.println(100 / 0);
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero");
        }
    }
}

2147483647 + 1

-2147483648

public class Main {
    public static void main(String[] args) {
        int big = Integer.MAX_VALUE;
        big = big + 1;
        System.out.println(big);
    }
}

the slogan

24

public class Main {
    public static void main(String[] args) {
        String slogan = "Write once, run anywhere";
        System.out.println(slogan.length());
    }
}

{99, 149, 249, 399}; indexes 2 and 9

Product 2: Rs 249
Product not found

public class Main {
    public static void main(String[] args) {
        int[] prices = {99, 149, 249, 399};
        try {
            System.out.println("Product 2: Rs " + prices[2]);
            System.out.println("Product 9: Rs " + prices[9]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Product not found");
        }
    }
}

1450000000, 28

Average per state: 51785714

public class Main {
    public static void main(String[] args) {
        long population = 1450000000L;
        System.out.println("Average per state: " + population / 28);
    }
}

1200, 45000

Monthly: Rs 54000000
Yearly:  Rs 648000000

public class Main {
    public static void main(String[] args) {
        long monthly = 1200L * 45000;
        long yearly = monthly * 12;
        System.out.println("Monthly: Rs " + monthly);
        System.out.println("Yearly:  Rs " + yearly);
    }
}

Real-world scenario questions (asked in company interviews)

In company interviews, Java's features come up as real situations, not definitions. Each scenario below tests one feature from this lesson. Decide your answer first, then open the model answer.