Java Developer interview questions

The JDK provides development tools, while the JVM executes Java bytecode and the JRE supplies what that execution needs.

• The JDK includes tools such as the javac compiler as well as the runtime components.
• javac compiles Java source files into platform-neutral .class bytecode.
• The JVM loads and executes that bytecode on a specific operating system.
• The JRE traditionally means the JVM plus runtime libraries, although modern Java distributions are usually delivered as JDKs or custom runtime images.

Java is platform-independent because source code is compiled to bytecode that different JVM implementations can execute.

• The compiler targets the JVM instruction set rather than one operating system's machine code.
• Each supported platform has its own JVM that translates or interprets the same bytecode.
• Platform independence still depends on avoiding operating-system-specific APIs and native libraries.

The main method is the conventional entry point the Java launcher calls to start an application.

• Its usual declaration is public static void main(String[] args).
• public lets the launcher access it, and static allows invocation without creating an object.
• String[] args contains command-line arguments, while void means the method returns no value to the caller.

Declaration introduces a variable and its type, while initialization gives it its first value.

• int count; declares a local variable named count.
• count = 0; assigns a value, and int count = 0; combines declaration with initialization.
• A local variable must be definitely initialized before use, which the compiler verifies.

Java has eight primitive value types: byte, short, int, long, float, double, char, and boolean.

• byte, short, int, and long represent signed integer values with different ranges.
• float and double represent floating-point values, with double offering greater precision.
• char stores a UTF-16 code unit, while boolean stores true or false.

A primitive variable contains a simple value, while a reference variable identifies an object or can contain null.

• Primitives have fixed language-defined types and do not expose instance methods.
• Objects are created from classes and carry fields and behavior accessed through a reference.
• Assigning a primitive copies its value, while assigning a reference copies the reference to the same object.

Instance and static fields receive default values, but local variables must be initialized explicitly before use.

• Numeric fields default to zero, boolean fields to false, and reference fields to null.
• Array elements also receive the default value of their component type.
• The compiler rejects a path that reads an uninitialized local variable.

Widening is a primitive conversion Java permits implicitly, while narrowing targets a type that requires an explicit cast.

• Converting int to long is widening and preserves every possible int value.
• Converting long to int is narrowing because an int cannot represent the full long range.
• Narrowing can overflow or lose precision, and even a widening conversion such as int to float can lose numeric precision.

Autoboxing converts a primitive to its wrapper type automatically, while unboxing extracts the primitive value from a wrapper.

• Assigning an int to an Integer can trigger autoboxing through Integer.valueOf.
• Assigning an Integer to an int can trigger unboxing through intValue.
• Unboxing a null wrapper throws NullPointerException, so wrappers require null awareness.

For primitives, == compares values, while for object references it tests whether both references point to the same object.

• Two separate objects can contain equal data and still produce false with ==.
• Logical equality between objects is normally checked with equals.
• Comparing a boxed value and a primitive may trigger unboxing, which can hide the difference between identity and value comparison.

String is immutable because its character content cannot change after the object is created.

• Operations such as concat, replace, and toUpperCase return a new String rather than modifying the original.
• Immutability makes strings safe to share, cache, and use as map keys when their equality is stable.
• Repeated concatenation in a loop creates many temporary objects, so a mutable builder is usually better there.

The string pool is a JVM-managed store that lets identical interned strings share one object.

• String literals with the same content normally refer to the same pooled instance.
• new String("java") explicitly creates a separate object even if the literal is pooled.
• Pooling saves memory, but string content should still be compared with equals rather than relying on reference identity.

Use StringBuilder when constructing text through multiple changes within one thread.

• append and related methods modify the same builder instead of creating a new String at every step.
• This reduces temporary allocations in loops or when assembling many fragments.
• Convert the completed value to an immutable String with toString when construction is finished.

A class defines a type's state and behavior, while an object is a runtime instance of that class.

• Fields describe the data each instance can hold.
• Methods describe operations available on instances or on the class itself.
• Multiple objects of one class have the same structure but can hold different field values.

A constructor initializes a newly created object and has the same name as its class with no return type.

• The new expression allocates an object and invokes a matching constructor.
• Constructors can be overloaded with different parameter lists.
• If a class declares no constructor, the compiler may provide a no-argument default constructor.

this refers to the current object whose instance method or constructor is executing.

• It disambiguates a field from a parameter with the same name, as in this.name = name.
• this(...) calls another constructor in the same class and must be the constructor's first statement.
• It cannot be used in a static context because no current instance exists there.

A static member belongs to the class rather than to any one instance.

• All instances observe the same static field, so it is suitable for shared class-level state or constants.
• A static method can be called through the class name without constructing an object.
• Static code cannot directly access instance fields or methods because it has no this reference.

final prevents reassignment, overriding, or inheritance depending on where it is applied.

• A final variable can be assigned once, but a final object reference does not make the referenced object immutable.
• A final method cannot be overridden by a subclass.
• A final class cannot be extended, which can preserve its behavior and invariants.

Encapsulation keeps an object's internal state behind a controlled public interface.

• Fields are commonly private so callers cannot freely put the object into an invalid state.
• Methods can validate changes and preserve class invariants.
• Callers depend on stable behavior rather than the current storage details, making internals easier to change.

Inheritance lets a subclass reuse and specialize accessible behavior from one superclass.

• A class declares the relationship with extends and inherits eligible fields and methods.
• Constructors are not inherited, and a subclass constructor invokes a superclass constructor directly or implicitly.
• Every class except Object has one direct superclass because Java does not support multiple class inheritance.