Java Notes

Features of Java

A deep dive into all key features of Java programming language — platform independence, object-oriented nature, robustness, security, multithreading, and more with practical examples.

Java was designed with a specific set of goals in mind. The original Java team at Sun Microsystems identified key features (sometimes called "Java Buzzwords") that would make the language successful for networked, distributed computing. Let's explore each feature in depth with practical examples.

The Original Java Buzzwords

When Java was first announced in 1995, Sun Microsystems published a white paper describing Java with these characteristics:

Simple
Object-Oriented
Platform Independent (Portable)
Secure
Robust
Architecture Neutral
Multithreaded
Interpreted (and compiled)
High Performance
Distributed
Dynamic

Let's examine each one with real code examples.

1. Simple

Java was designed to be easy to learn for programmers familiar with C/C++. It achieves simplicity by removing complex features:

Removed from C/C++	Java Alternative
Pointers	References (no pointer arithmetic)
Multiple inheritance	Interfaces
Operator overloading	Method calls
Manual memory management	Garbage Collection
Preprocessor (#define, #include)	import statements
goto statement	Structured control flow
Header files	Single .java source files

Example

// Java is simpler than C++ — no pointers, no manual memory public class SimplicityDemo { public static void main(String[] args) { // No pointer arithmetic — just references String name = "Java"; // reference, not pointer // No manual memory allocation/deallocation int[] numbers = new int[5]; // GC handles cleanup // No #include — just import // No header files — everything in one file System.out.println("Language: " + name); System.out.println("Array length: " + numbers.length); } }

Output

Language: Java
Array length: 5

Why This Matters

By removing dangerous features like pointers and manual memory management, Java eliminates entire categories of bugs (buffer overflows, dangling pointers, memory leaks) that plague C/C++ programs.

2. Object-Oriented

Java is a purely object-oriented language (with the exception of primitive types). Everything is modeled as objects with state (fields) and behavior (methods).

The Four Pillars of OOP in Java

java example

// ENCAPSULATION — hiding internal details
public class BankAccount {
    private double balance; // hidden from outside
    
    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }
    
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
    
    public double getBalance() {
        return balance; // controlled access
    }
}

// INHERITANCE — reusing code through parent-child relationships
class SavingsAccount extends BankAccount {
    private double interestRate;
    
    public SavingsAccount(double balance, double rate) {
        super(balance);
        this.interestRate = rate;
    }
    
    public void addInterest() {
        deposit(getBalance() * interestRate);
    }
}

// POLYMORPHISM — one interface, multiple implementations
interface Shape {
    double area();
    double perimeter();
}

class Circle implements Shape {
    private double radius;
    
    public Circle(double radius) { this.radius = radius; }
    
    public double area() { return Math.PI * radius * radius; }
    public double perimeter() { return 2 * Math.PI * radius; }
}

class Rectangle implements Shape {
    private double width, height;
    
    public Rectangle(double w, double h) { width = w; height = h; }
    
    public double area() { return width * height; }
    public double perimeter() { return 2 * (width + height); }
}

// ABSTRACTION — showing only essential details
abstract class Vehicle {
    abstract void start();
    abstract void stop();
    
    // Common behavior
    void honk() {
        System.out.println("Beep beep!");
    }
}

java example

// Demonstrating polymorphism
public class OOPDemo {
    public static void main(String[] args) {
        Shape[] shapes = {
            new Circle(5),
            new Rectangle(4, 6)
        };
        
        for (Shape shape : shapes) {
            System.out.printf("%s: area=%.2f, perimeter=%.2f%n",
                shape.getClass().getSimpleName(),
                shape.area(),
                shape.perimeter());
        }
    }
}

Output

Circle: area=78.54, perimeter=31.42
Rectangle: area=24.00, perimeter=20.00

3. Platform Independent (Portable)

This is Java's most famous feature. Java achieves platform independence through its two-step compilation process:

Example

Source Code (.java) → javac → Bytecode (.class) → JVM → Native Execution [compile] [interpret/JIT]

java example

public class PlatformIndependence {
    public static void main(String[] args) {
        // This bytecode runs on ANY OS with a JVM
        System.out.println("OS: " + System.getProperty("os.name"));
        System.out.println("Architecture: " + System.getProperty("os.arch"));
        System.out.println("Java Version: " + System.getProperty("java.version"));
        
        // The same .class file produces different output on different systems
        // but the LOGIC is identical
        System.out.println("File Separator: " + System.getProperty("file.separator"));
        // Windows: \ Linux/Mac: /
    }
}

Output

OS: Windows 11
Architecture: amd64
Java Version: 21.0.1
File Separator: \

How Platform Independence Works

Layer	What It Does
Source code (.java)	Human-readable, platform-independent
Bytecode (.class)	Intermediate representation, platform-independent
JVM	Translates bytecode to native machine code, platform-DEPENDENT

The JVM is platform-specific (different JVM for Windows, Mac, Linux), but your code is not. Oracle and other vendors provide JVMs for virtually every platform.

4. Secure

Java was designed for networked environments where code might come from untrusted sources. Security features include:

Example

public class SecurityFeatures { public static void main(String[] args) { // 1. No pointers — can't access arbitrary memory // int* ptr = (int*)0x12345; // IMPOSSIBLE in Java // 2. Array bounds checking — prevents buffer overflow int[] arr = {1, 2, 3}; try { System.out.println(arr[10]); // Runtime check! } catch (ArrayIndexOutOfBoundsException e) { System.out.println("Security: Array bounds are checked!"); } // 3. Bytecode verification — JVM verifies class files before execution System.out.println("Bytecode is verified before execution"); // 4. Security Manager (deprecated in Java 17, removed in Java 24) // Was used to restrict what code could do // 5. ClassLoader — isolates classes from different sources ClassLoader cl = SecurityFeatures.class.getClassLoader(); System.out.println("ClassLoader: " + cl.getClass().getName()); } }

Output

Security: Array bounds are checked!
Bytecode is verified before execution
ClassLoader: jdk.internal.loader.ClassLoaders$AppClassLoader

Java's Security Model

Compile-time checking — type safety, access control
Bytecode verification — JVM validates bytecode structure
ClassLoader — separates namespaces, prevents class spoofing
No pointer arithmetic — prevents memory access attacks
Automatic bounds checking — prevents buffer overflows

5. Robust

Java was designed to create reliable software. Robustness comes from:

java example

public class RobustnessDemo {
    public static void main(String[] args) {
        // 1. Strong type checking at compile time
        // int x = "hello"; // COMPILE ERROR — caught before running
        
        // 2. Exception handling — graceful error recovery
        try {
            int result = divide(10, 0);
        } catch (ArithmeticException e) {
            System.out.println("Caught: " + e.getMessage());
            // Program continues running!
        }
        
        // 3. Automatic garbage collection — no memory leaks
        String temp = new String("temporary");
        temp = null; // GC will reclaim this memory
        
        // 4. No undefined behavior — everything has defined semantics
        int overflow = Integer.MAX_VALUE + 1;
        System.out.println("Overflow is defined: " + overflow); // wraps around
        
        // 5. Null reference checks
        String str = null;
        try {
            str.length();
        } catch (NullPointerException e) {
            System.out.println("Null access caught at runtime");
        }
        
        System.out.println("Program still running after all errors!");
    }
    
    static int divide(int a, int b) {
        return a / b; // throws ArithmeticException if b is 0
    }
}

Output

Caught: / by zero
Overflow is defined: -2147483648
Null access caught at runtime
Program still running after all errors!

6. Architecture Neutral

Java's bytecode is designed to be architecture-neutral — it doesn't depend on any specific CPU instruction set:

Same bytecode runs on Intel x86, ARM, RISC-V, SPARC
Data types have fixed sizes (int is ALWAYS 32 bits, long is ALWAYS 64 bits)
No implementation-dependent aspects

java example

public class ArchitectureNeutral {
    public static void main(String[] args) {
        // In C, sizeof(int) varies by platform (2 or 4 bytes)
        // In Java, int is ALWAYS 32 bits (4 bytes)
        System.out.println("int: always " + Integer.SIZE + " bits");
        System.out.println("long: always " + Long.SIZE + " bits");
        System.out.println("double: always " + Double.SIZE + " bits");
        System.out.println("char: always " + Character.SIZE + " bits (Unicode)");
        
        // No platform-specific behavior for arithmetic
        int maxInt = Integer.MAX_VALUE;
        System.out.println("Max int on ALL platforms: " + maxInt);
    }
}

Output

int: always 32 bits
long: always 64 bits
double: always 64 bits
char: always 16 bits (Unicode)
Max int on ALL platforms: 2147483647

7. Multithreaded

Java has built-in support for multithreading — concurrent execution of multiple parts of a program:

Example

public class MultithreadingDemo { public static void main(String[] args) throws InterruptedException { // Creating threads is straightforward Thread thread1 = new Thread(() -> { for (int i = 1; i <= 5; i++) { System.out.println("Thread-1: Count " + i); try { Thread.sleep(100); } catch (InterruptedException e) {} } }); Thread thread2 = new Thread(() -> { for (int i = 1; i <= 5; i++) { System.out.println("Thread-2: Count " + i); try { Thread.sleep(100); } catch (InterruptedException e) {} } }); thread1.start(); // Runs concurrently thread2.start(); // Runs concurrently thread1.join(); // Wait for completion thread2.join(); System.out.println("Both threads finished!"); } }

Output

Thread-1: Count 1
Thread-2: Count 1
Thread-1: Count 2
Thread-2: Count 2
Thread-1: Count 3
Thread-2: Count 3
Thread-1: Count 4
Thread-2: Count 4
Thread-1: Count 5
Thread-2: Count 5
Both threads finished!

Why Built-in Threading Matters

In C, you need OS-specific libraries (pthreads on Unix, WinAPI on Windows). Java's threading is platform-independent and part of the core language.

8. High Performance

While Java was initially slower than C/C++ due to interpretation, modern JVMs are extremely fast:

Example

public class PerformanceDemo { public static void main(String[] args) { // JIT (Just-In-Time) compilation makes Java fast // Hot code paths are compiled to native machine code long start = System.nanoTime(); long sum = 0; for (int i = 0; i < 100_000_000; i++) { sum += i; } long elapsed = System.nanoTime() - start; System.out.println("Sum: " + sum); System.out.println("Time: " + (elapsed / 1_000_000) + " ms"); System.out.println("JIT makes this nearly as fast as C!"); } }

Output

Sum: 4999999950000000
Time: 45 ms
JIT makes this nearly as fast as C!

How Java Achieves High Performance

JIT Compilation — frequently executed code is compiled to native machine code
Adaptive optimization — JVM profiles running code and optimizes hot paths
Inline caching — frequently called methods are inlined
Escape analysis — objects that don't escape a method are stack-allocated
Garbage collector improvements — ZGC, Shenandoah provide sub-millisecond pauses

9. Distributed

Java was designed for the distributed environment of the internet:

java example

import java.net.*;

public class DistributedDemo {
    public static void main(String[] args) throws Exception {
        // Java has built-in networking support
        
        // URL handling
        URL url = new URL("https://www.example.com");
        System.out.println("Protocol: " + url.getProtocol());
        System.out.println("Host: " + url.getHost());
        
        // Getting local network info
        InetAddress localhost = InetAddress.getLocalHost();
        System.out.println("Hostname: " + localhost.getHostName());
        System.out.println("IP: " + localhost.getHostAddress());
        
        // Java supports: TCP, UDP, HTTP, RMI, CORBA, Web Services
        System.out.println("\nJava networking capabilities:");
        System.out.println("- Socket programming (TCP/UDP)");
        System.out.println("- HTTP Client (Java 11+)");
        System.out.println("- RMI for remote objects");
        System.out.println("- Web services (REST, SOAP)");
    }
}

Output

Protocol: https
Host: www.example.com
Hostname: DESKTOP-ABC123
IP: 192.168.1.100

Java networking capabilities:
- Socket programming (TCP/UDP)
- HTTP Client (Java 11+)
- RMI for remote objects
- Web services (REST, SOAP)

10. Dynamic

Java is dynamic in that it can adapt to evolving environments:

java example

import java.lang.reflect.*;

public class DynamicDemo {
    public static void main(String[] args) throws Exception {
        // Reflection — inspect and modify classes at runtime
        Class<?> clazz = String.class;
        
        System.out.println("Class: " + clazz.getName());
        System.out.println("Methods count: " + clazz.getMethods().length);
        
        // Create objects dynamically
        Object str = clazz.getConstructor(String.class).newInstance("Dynamic!");
        System.out.println("Dynamically created: " + str);
        
        // Call methods dynamically
        Method method = clazz.getMethod("toUpperCase");
        Object result = method.invoke(str);
        System.out.println("Dynamic method call: " + result);
        
        // Classes can be loaded at runtime
        System.out.println("\nJava dynamic features:");
        System.out.println("- Runtime class loading");
        System.out.println("- Reflection API");
        System.out.println("- Dynamic proxies");
        System.out.println("- Annotations processing");
    }
}

Output

Class: java.lang.String
Methods count: 76
Dynamically created: Dynamic!
Dynamic method call: DYNAMIC!

Java dynamic features:
- Runtime class loading
- Reflection API
- Dynamic proxies
- Annotations processing

Features Comparison Table

Feature	Java	C	C++	Python
Platform Independent	✅	❌	❌	✅ (interpreted)
Object Oriented	✅	❌	✅	✅
Garbage Collection	✅	❌	❌	✅
Pointers	❌	✅	✅	❌
Multiple Inheritance	❌ (interfaces)	N/A	✅	✅
Operator Overloading	❌	❌	✅	✅
Multithreading (built-in)	✅	❌	❌	Limited (GIL)
Exception Handling	✅	❌	✅	✅
Memory Safety	✅	❌	❌	✅

Common Mistakes

Saying "Java has no pointers" — Java has references, which ARE pointers internally. The correct statement is "Java has no pointer ARITHMETIC" — you can't add/subtract from references.
Claiming Java is slow — This was true in 1996. Modern JVMs with JIT compilation, escape analysis, and adaptive optimization make Java competitive with C++ for most workloads.
Confusing platform independence with "runs everywhere" — Java bytecode is portable, but you still need a JVM installed on the target platform. The JVM itself is platform-specific.
Thinking simple means lacking power — Java removed dangerous features, not useful ones. It's simpler than C++ but just as capable for most applications.
Ignoring that Java is NOT purely OOP — Primitive types (int, float, char) are not objects. This is a deliberate performance optimization.

Best Practices

Leverage type safety — don't use raw types or suppress warnings without understanding them
Use exception handling properly — catch specific exceptions, not generic Exception
Embrace OOP — design with encapsulation, use interfaces for abstraction
Utilize multithreading — but use java.util.concurrent instead of raw threads
Trust the GC — don't call System.gc() in production; tune the GC if needed

Interview Questions

Q1: What are the main features of Java?

Answer: Java's key features are: (1) Platform Independence via bytecode and JVM, (2) Object-Oriented with encapsulation, inheritance, polymorphism, and abstraction, (3) Robust through strong typing, exception handling, and GC, (4) Secure with no pointers, bytecode verification, and classloaders, (5) Multithreaded with built-in concurrency support, (6) High Performance through JIT compilation.

Q2: How does Java achieve platform independence?

Answer: Java source code is compiled into platform-independent bytecode by javac. This bytecode is then executed by the JVM, which is platform-specific. Since each OS has its own JVM implementation that translates bytecode to native instructions, the same bytecode runs on any platform with a JVM.

Q3: Why doesn't Java support multiple inheritance?

Answer: Java avoids multiple inheritance of classes to prevent the Diamond Problem — ambiguity when a class inherits from two classes that have the same method. Instead, Java uses interfaces (which can have multiple inheritance) to achieve similar flexibility without the ambiguity.

Q4: Is Java 100% object-oriented? Why or why not?

Answer: No. Java is not purely object-oriented because it has primitive data types (int, float, boolean, etc.) that are NOT objects. They exist for performance reasons — primitive operations are faster than object operations. Java provides wrapper classes (Integer, Float, Boolean) when object behavior is needed.

Q5: What makes Java robust?

Answer: Java is robust due to: (1) Compile-time type checking that catches errors early, (2) Automatic garbage collection preventing memory leaks, (3) Exception handling for runtime error recovery, (4) No pointer arithmetic eliminating memory corruption, (5) Array bounds checking preventing buffer overflows, and (6) Strong type system preventing type confusion bugs.

Summary

Java's features were carefully chosen to create a language that is safe, portable, and productive. Each feature addresses a real problem: platform independence solves the "works on my machine" problem, garbage collection eliminates memory bugs, strong typing catches errors early, and built-in multithreading makes concurrent programming accessible. Together, these features explain why Java remains dominant in enterprise computing after nearly three decades.

Exam Focus

Revise definitions, diagrams, examples, and short-answer points for Features of Java.

Interview Use

Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.

Search Terms

java-master-course, java master course, java, master, course, fundamentals, introduction, features

Continue learning this concept

FundamentalsHistory of JavaThe complete history of Java programming language — from the Green Project at Sun Microsystems in 1991 to modern Java 21+ LTS releases, covering every major version and milestone.FundamentalsArray IntroductionComplete introduction to arrays in Java covering definition, memory layout, types of arrays, declaration, initialization, accessing elements, and real-world use cases with detailed examples.FundamentalsJava Compilation ProcessStep-by-step explanation of how Java source code becomes executable — from writing .java files through javac compilation, bytecode generation, class loading, verification, and JVM execution.FundamentalsYour First Java ProgramWrite, compile, and run your first Java program — a detailed walkthrough of Hello World, explaining every line, common errors beginners face, and how to progress beyond the basics.FundamentalsJava EditionsComplete guide to Java editions — Java SE, Java EE (Jakarta EE), Java ME, and JavaFX. Understand which edition to use for desktop, web, enterprise, mobile, and embedded development.FundamentalsJava Program StructureComplete guide to Java program structure — package declarations, import statements, class definitions, methods, main method anatomy, and the rules for organizing Java source files.

PreviousJava Compilation Process NextYour First Java Program

Java Notes

Features of Java

A deep dive into all key features of Java programming language — platform independence, object-oriented nature, robustness, security, multithreading, and more with practical examples.

The Original Java Buzzwords

When Java was first announced in 1995, Sun Microsystems published a white paper describing Java with these characteristics:

Simple
Object-Oriented
Platform Independent (Portable)
Secure
Robust
Architecture Neutral
Multithreaded
Interpreted (and compiled)
High Performance
Distributed
Dynamic

Let's examine each one with real code examples.

1. Simple

Java was designed to be easy to learn for programmers familiar with C/C++. It achieves simplicity by removing complex features:

Removed from C/C++	Java Alternative
Pointers	References (no pointer arithmetic)
Multiple inheritance	Interfaces
Operator overloading	Method calls
Manual memory management	Garbage Collection
Preprocessor (#define, #include)	import statements
goto statement	Structured control flow
Header files	Single .java source files

Example

Output

Language: Java
Array length: 5

Why This Matters

By removing dangerous features like pointers and manual memory management, Java eliminates entire categories of bugs (buffer overflows, dangling pointers, memory leaks) that plague C/C++ programs.

2. Object-Oriented

Java is a purely object-oriented language (with the exception of primitive types). Everything is modeled as objects with state (fields) and behavior (methods).

The Four Pillars of OOP in Java

java example

// ENCAPSULATION — hiding internal details
public class BankAccount {
    private double balance; // hidden from outside
    
    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }
    
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
    
    public double getBalance() {
        return balance; // controlled access
    }
}

// INHERITANCE — reusing code through parent-child relationships
class SavingsAccount extends BankAccount {
    private double interestRate;
    
    public SavingsAccount(double balance, double rate) {
        super(balance);
        this.interestRate = rate;
    }
    
    public void addInterest() {
        deposit(getBalance() * interestRate);
    }
}

// POLYMORPHISM — one interface, multiple implementations
interface Shape {
    double area();
    double perimeter();
}

class Circle implements Shape {
    private double radius;
    
    public Circle(double radius) { this.radius = radius; }
    
    public double area() { return Math.PI * radius * radius; }
    public double perimeter() { return 2 * Math.PI * radius; }
}

class Rectangle implements Shape {
    private double width, height;
    
    public Rectangle(double w, double h) { width = w; height = h; }
    
    public double area() { return width * height; }
    public double perimeter() { return 2 * (width + height); }
}

// ABSTRACTION — showing only essential details
abstract class Vehicle {
    abstract void start();
    abstract void stop();
    
    // Common behavior
    void honk() {
        System.out.println("Beep beep!");
    }
}

java example

// Demonstrating polymorphism
public class OOPDemo {
    public static void main(String[] args) {
        Shape[] shapes = {
            new Circle(5),
            new Rectangle(4, 6)
        };
        
        for (Shape shape : shapes) {
            System.out.printf("%s: area=%.2f, perimeter=%.2f%n",
                shape.getClass().getSimpleName(),
                shape.area(),
                shape.perimeter());
        }
    }
}

Output

Circle: area=78.54, perimeter=31.42
Rectangle: area=24.00, perimeter=20.00

3. Platform Independent (Portable)

This is Java's most famous feature. Java achieves platform independence through its two-step compilation process:

Example

Source Code (.java) → javac → Bytecode (.class) → JVM → Native Execution [compile] [interpret/JIT]

java example

public class PlatformIndependence {
    public static void main(String[] args) {
        // This bytecode runs on ANY OS with a JVM
        System.out.println("OS: " + System.getProperty("os.name"));
        System.out.println("Architecture: " + System.getProperty("os.arch"));
        System.out.println("Java Version: " + System.getProperty("java.version"));
        
        // The same .class file produces different output on different systems
        // but the LOGIC is identical
        System.out.println("File Separator: " + System.getProperty("file.separator"));
        // Windows: \ Linux/Mac: /
    }
}

Output

OS: Windows 11
Architecture: amd64
Java Version: 21.0.1
File Separator: \

How Platform Independence Works

Layer	What It Does
Source code (.java)	Human-readable, platform-independent
Bytecode (.class)	Intermediate representation, platform-independent
JVM	Translates bytecode to native machine code, platform-DEPENDENT

The JVM is platform-specific (different JVM for Windows, Mac, Linux), but your code is not. Oracle and other vendors provide JVMs for virtually every platform.

4. Secure

Java was designed for networked environments where code might come from untrusted sources. Security features include:

Example

Output

Security: Array bounds are checked!
Bytecode is verified before execution
ClassLoader: jdk.internal.loader.ClassLoaders$AppClassLoader

Java's Security Model

Compile-time checking — type safety, access control
Bytecode verification — JVM validates bytecode structure
ClassLoader — separates namespaces, prevents class spoofing
No pointer arithmetic — prevents memory access attacks
Automatic bounds checking — prevents buffer overflows

5. Robust

Java was designed to create reliable software. Robustness comes from:

java example

public class RobustnessDemo {
    public static void main(String[] args) {
        // 1. Strong type checking at compile time
        // int x = "hello"; // COMPILE ERROR — caught before running
        
        // 2. Exception handling — graceful error recovery
        try {
            int result = divide(10, 0);
        } catch (ArithmeticException e) {
            System.out.println("Caught: " + e.getMessage());
            // Program continues running!
        }
        
        // 3. Automatic garbage collection — no memory leaks
        String temp = new String("temporary");
        temp = null; // GC will reclaim this memory
        
        // 4. No undefined behavior — everything has defined semantics
        int overflow = Integer.MAX_VALUE + 1;
        System.out.println("Overflow is defined: " + overflow); // wraps around
        
        // 5. Null reference checks
        String str = null;
        try {
            str.length();
        } catch (NullPointerException e) {
            System.out.println("Null access caught at runtime");
        }
        
        System.out.println("Program still running after all errors!");
    }
    
    static int divide(int a, int b) {
        return a / b; // throws ArithmeticException if b is 0
    }
}

Output

Caught: / by zero
Overflow is defined: -2147483648
Null access caught at runtime
Program still running after all errors!

6. Architecture Neutral

Java's bytecode is designed to be architecture-neutral — it doesn't depend on any specific CPU instruction set:

Same bytecode runs on Intel x86, ARM, RISC-V, SPARC
Data types have fixed sizes (int is ALWAYS 32 bits, long is ALWAYS 64 bits)
No implementation-dependent aspects

java example

public class ArchitectureNeutral {
    public static void main(String[] args) {
        // In C, sizeof(int) varies by platform (2 or 4 bytes)
        // In Java, int is ALWAYS 32 bits (4 bytes)
        System.out.println("int: always " + Integer.SIZE + " bits");
        System.out.println("long: always " + Long.SIZE + " bits");
        System.out.println("double: always " + Double.SIZE + " bits");
        System.out.println("char: always " + Character.SIZE + " bits (Unicode)");
        
        // No platform-specific behavior for arithmetic
        int maxInt = Integer.MAX_VALUE;
        System.out.println("Max int on ALL platforms: " + maxInt);
    }
}

Output

int: always 32 bits
long: always 64 bits
double: always 64 bits
char: always 16 bits (Unicode)
Max int on ALL platforms: 2147483647

7. Multithreaded

Java has built-in support for multithreading — concurrent execution of multiple parts of a program:

Example

Output

Thread-1: Count 1
Thread-2: Count 1
Thread-1: Count 2
Thread-2: Count 2
Thread-1: Count 3
Thread-2: Count 3
Thread-1: Count 4
Thread-2: Count 4
Thread-1: Count 5
Thread-2: Count 5
Both threads finished!

Why Built-in Threading Matters

In C, you need OS-specific libraries (pthreads on Unix, WinAPI on Windows). Java's threading is platform-independent and part of the core language.

8. High Performance

While Java was initially slower than C/C++ due to interpretation, modern JVMs are extremely fast:

Example

Output

Sum: 4999999950000000
Time: 45 ms
JIT makes this nearly as fast as C!

How Java Achieves High Performance

JIT Compilation — frequently executed code is compiled to native machine code
Adaptive optimization — JVM profiles running code and optimizes hot paths
Inline caching — frequently called methods are inlined
Escape analysis — objects that don't escape a method are stack-allocated
Garbage collector improvements — ZGC, Shenandoah provide sub-millisecond pauses

9. Distributed

Java was designed for the distributed environment of the internet:

java example

import java.net.*;

public class DistributedDemo {
    public static void main(String[] args) throws Exception {
        // Java has built-in networking support
        
        // URL handling
        URL url = new URL("https://www.example.com");
        System.out.println("Protocol: " + url.getProtocol());
        System.out.println("Host: " + url.getHost());
        
        // Getting local network info
        InetAddress localhost = InetAddress.getLocalHost();
        System.out.println("Hostname: " + localhost.getHostName());
        System.out.println("IP: " + localhost.getHostAddress());
        
        // Java supports: TCP, UDP, HTTP, RMI, CORBA, Web Services
        System.out.println("\nJava networking capabilities:");
        System.out.println("- Socket programming (TCP/UDP)");
        System.out.println("- HTTP Client (Java 11+)");
        System.out.println("- RMI for remote objects");
        System.out.println("- Web services (REST, SOAP)");
    }
}

Output

Protocol: https
Host: www.example.com
Hostname: DESKTOP-ABC123
IP: 192.168.1.100

Java networking capabilities:
- Socket programming (TCP/UDP)
- HTTP Client (Java 11+)
- RMI for remote objects
- Web services (REST, SOAP)

10. Dynamic

Java is dynamic in that it can adapt to evolving environments:

java example

import java.lang.reflect.*;

public class DynamicDemo {
    public static void main(String[] args) throws Exception {
        // Reflection — inspect and modify classes at runtime
        Class<?> clazz = String.class;
        
        System.out.println("Class: " + clazz.getName());
        System.out.println("Methods count: " + clazz.getMethods().length);
        
        // Create objects dynamically
        Object str = clazz.getConstructor(String.class).newInstance("Dynamic!");
        System.out.println("Dynamically created: " + str);
        
        // Call methods dynamically
        Method method = clazz.getMethod("toUpperCase");
        Object result = method.invoke(str);
        System.out.println("Dynamic method call: " + result);
        
        // Classes can be loaded at runtime
        System.out.println("\nJava dynamic features:");
        System.out.println("- Runtime class loading");
        System.out.println("- Reflection API");
        System.out.println("- Dynamic proxies");
        System.out.println("- Annotations processing");
    }
}

Output

Class: java.lang.String
Methods count: 76
Dynamically created: Dynamic!
Dynamic method call: DYNAMIC!

Java dynamic features:
- Runtime class loading
- Reflection API
- Dynamic proxies
- Annotations processing

Features Comparison Table

Feature	Java	C	C++	Python
Platform Independent	✅	❌	❌	✅ (interpreted)
Object Oriented	✅	❌	✅	✅
Garbage Collection	✅	❌	❌	✅
Pointers	❌	✅	✅	❌
Multiple Inheritance	❌ (interfaces)	N/A	✅	✅
Operator Overloading	❌	❌	✅	✅
Multithreading (built-in)	✅	❌	❌	Limited (GIL)
Exception Handling	✅	❌	✅	✅
Memory Safety	✅	❌	❌	✅

Common Mistakes

Saying "Java has no pointers" — Java has references, which ARE pointers internally. The correct statement is "Java has no pointer ARITHMETIC" — you can't add/subtract from references.
Claiming Java is slow — This was true in 1996. Modern JVMs with JIT compilation, escape analysis, and adaptive optimization make Java competitive with C++ for most workloads.
Confusing platform independence with "runs everywhere" — Java bytecode is portable, but you still need a JVM installed on the target platform. The JVM itself is platform-specific.
Thinking simple means lacking power — Java removed dangerous features, not useful ones. It's simpler than C++ but just as capable for most applications.
Ignoring that Java is NOT purely OOP — Primitive types (int, float, char) are not objects. This is a deliberate performance optimization.

Best Practices

Leverage type safety — don't use raw types or suppress warnings without understanding them
Use exception handling properly — catch specific exceptions, not generic Exception
Embrace OOP — design with encapsulation, use interfaces for abstraction
Utilize multithreading — but use java.util.concurrent instead of raw threads
Trust the GC — don't call System.gc() in production; tune the GC if needed

Interview Questions

Q1: What are the main features of Java?

Q2: How does Java achieve platform independence?

Q3: Why doesn't Java support multiple inheritance?

Q4: Is Java 100% object-oriented? Why or why not?

Q5: What makes Java robust?

Summary

Exam Focus

Revise definitions, diagrams, examples, and short-answer points for Features of Java.

Interview Use

Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.

Search Terms

java-master-course, java master course, java, master, course, fundamentals, introduction, features

Continue learning this concept

PreviousJava Compilation Process NextYour First Java Program