Java interview questions and answers

Question 1

What is Java and what does 'Write Once, Run Anywhere' mean?

Accepted Answer

Java is a high-level, object-oriented, statically-typed language created by James Gosling in 1991 (originally called Oak). 'Write Once, Run Anywhere' (WORA) means you compile your code one time into an intermediate format called bytecode, and that same bytecode file runs on any machine that has a Java Virtual Machine installed, Windows, Linux, Mac, phone, server. You do not recompile per platform. Analogy: a movie file. You export the video once as an MP4. Any device with an MP4 player can play it, the player handles the device-specific details. Bytecode is the MP4; the JVM is the player. In an interview: Java compiles to platform-neutral bytecode rather than native machine code. The JVM is the platform-specific piece, so portability is pushed down into the runtime instead of into my build. Other Java traits worth naming: object-oriented, multi-threaded, distributed, and memory-managed through garbage collection.

Question 2

Explain JDK, JRE, and JVM and how they relate.

Accepted Answer

JVM (Java Virtual Machine) is the engine that actually executes bytecode. JRE (Java Runtime Environment) is the JVM plus the standard library classes, this is everything you need to RUN a Java program. JDK (Java Development Kit) is the JRE plus the development tools like the compiler (javac), debugger, and documentation generator, this is what you need to WRITE and build Java programs. They nest: JDK contains JRE, which contains JVM. Analogy: a restaurant. The JVM is the stove that cooks. The JRE is the whole working kitchen, stove plus pans, ingredients, utensils, enough to serve a meal. The JDK is the kitchen plus the recipe development lab where the chef creates new dishes. In an interview: If I am only running an app on a server I need the JRE. If I am building it I need the JDK. The JVM is the abstraction layer that makes the bytecode portable.

Question 3

What are the three phases of running a Java program?

Accepted Answer

Edit, compile, execute. Edit: you write the source code in a .java file. Compile: javac reads the source, checks it for errors, and produces a .class file containing bytecode. Execute: the JVM loads that bytecode and translates it into machine instructions the CPU can run. Analogy: translating a book. You write it in English (edit), a translator converts it to a neutral shorthand notation (compile), and then a local interpreter reads that shorthand aloud in whatever language the audience speaks (execute). In an interview: The key detail is that the middle artifact, bytecode, is what makes Java portable. Compilation is machine-independent; only the final execution step is machine-specific.

Question 4

What is the JIT compiler and why does Java need it?

Accepted Answer

JIT stands for Just-In-Time. Purely interpreting bytecode line by line is slow. The JIT compiler watches the program while it runs, spots the methods and loops that get called over and over (called hot spots), and compiles those into native machine code once. From then on those parts run at near-native speed. It is a hybrid: interpret first for fast startup, then compile the parts that matter for speed. Analogy: a translator at a conference. At first they translate sentence by sentence. But they notice the speaker keeps repeating the same paragraph, so they write out a polished translation of it once and just read that card each time it comes up. In an interview: The JIT is why long-running Java servers often beat naive expectations on performance, the runtime has real profiling data that an ahead-of-time compiler never sees, so it can optimize based on how the code actually behaves.

Question 5

What is the difference between a compile-time error and a runtime error?

Accepted Answer

A compile-time error is caught by the compiler before the program ever runs, syntax mistakes, type mismatches, calling a method that does not exist. You cannot produce a .class file until every one is fixed. A runtime error happens while the program is executing, on code that compiled perfectly fine, dividing by zero, reading past the end of an array, calling a method on a null reference. The compiler cannot see these because they depend on the actual values at run time. Analogy: a recipe. A compile-time error is 'step 4 refers to an ingredient that is not on the list', you spot it just by reading. A runtime error is 'the oven caught fire', the recipe was fine, something went wrong in the doing. In an interview: Compile-time errors are cheap because they are found immediately. A large part of good Java design, strong typing, generics, checked exceptions, is about moving failures from runtime to compile time.

Question 6

What are the rules for a Java source file and the main method?

Accepted Answer

A source file can contain at most one public class, and if it has one, the file name must exactly match that class name. The file may contain any number of additional non-public classes. Every statement ends with a semicolon. Every runnable Java application needs a main method, and it is the entry point the JVM calls to start execution. Analogy: a book with a title on the cover. There is one headline title (the public class), and the cover must match it. Other chapters can exist inside without being on the cover. In an interview: main is public so the JVM can reach it, static so it runs without an object existing yet, void because it returns nothing to the JVM, and takes a String array for command-line arguments.

Question 7

What are the rules for naming identifiers in Java?

Accepted Answer

An identifier is any name you give, a variable, class, method, package, or interface. It must start with a letter, an underscore, or a dollar sign, never a digit. It cannot contain white space or special characters like @ or #. It cannot be a Java keyword or a reserved literal (true, false, null). Identifiers are case-sensitive, so count and Count are two different names. Analogy: usernames on a website. There are rules about what characters are legal, some names are already taken by the system, and capitalisation matters. In an interview: Beyond the rules there are conventions the whole ecosystem follows: classes in PascalCase, methods and variables in camelCase, constants in UPPER_SNAKE_CASE, packages in all lowercase reverse-domain form.

Question 8

Why do we write comments, and what types exist?

Accepted Answer

Comments are notes for humans reading the code. The compiler strips them out entirely, they are not part of execution and have no runtime cost. Java has single-line comments starting with two slashes, multi-line comments wrapped in slash-star, and documentation comments starting with slash-star-star that the javadoc tool turns into API documentation. Analogy: margin notes in a textbook. They help the next reader understand the reasoning, but they are not part of the actual text of the book. In an interview: Good comments explain why, not what. The code already says what it does; the comment should capture the intent or the constraint that is not obvious from reading it.

Question 9

How does garbage collection work in Java?

Accepted Answer

Answer: The JVM automatically frees memory for objects that are no longer reachable from your running program. You never call free(). How it decides: starting from 'roots' (local variables on the stack, static fields, active threads), the collector walks every reference it can reach. Anything it cannot reach is garbage and its memory is reclaimed. The heap is split by age. New objects go in the 'young generation', which is collected often and quickly (most objects die young). Objects that survive several young collections are promoted to the 'old generation', which is collected less often. This is called generational garbage collection. Modern collectors (G1, ZGC, Shenandoah) do most of this work concurrently with your program to keep pauses short. Analogy: a cleaner who starts from the doors everyone actually uses and follows every path. Any room with no path leading to it gets cleared out. Rooms are sorted into 'just moved in' and 'been here for years'. In an interview: The collector walks references from the roots and frees anything unreachable. The heap is generational: young objects are collected often and cheaply, survivors are promoted to the old generation. Modern collectors run mostly concurrently to keep pauses small.

Question 10

What does the class loader do, and what are the class loader levels?

Accepted Answer

Answer: A class loader finds a class's bytecode (from a .class file, a jar, or the network) and loads it into the JVM the first time that class is used. There are three built-in levels, and they follow the 'parent delegation' rule: a loader always asks its parent to load a class first, and only loads it itself if the parent cannot. 1. Bootstrap class loader: loads the core Java classes (java.lang, java.util). Written in native code. 2. Platform (formerly extension) class loader: loads additional standard modules. 3. Application (system) class loader: loads your application's classes from the classpath. Parent delegation is a security measure: it stops your code from replacing java.lang.String with its own version. Analogy: a chain of librarians. You ask the local branch for a book, but they check with the central library first, and the central library checks with the national archive. Core books always come from the archive. In an interview: A class loader loads bytecode into the JVM on first use. Bootstrap loads core classes, platform loads standard modules, application loads your code. Parent-first delegation stops user code from replacing core classes.

Question 11

Java versus JavaScript: how does each execute a program?

Accepted Answer

Answer: Despite the name, they are unrelated languages with different execution models. Java: you compile source to platform-neutral bytecode ahead of time (javac). The JVM then runs that bytecode, interpreting it at first and using a JIT compiler to turn hot paths into native machine code. Java is statically typed (types checked at compile time) and multi-threaded with shared memory. JavaScript: there is no separate compile step you run. The engine (V8, SpiderMonkey) parses the source and runs it, also using a JIT internally. JavaScript is dynamically typed (types checked at run time) and single-threaded, using an event loop and callbacks for concurrency instead of threads. So: Java has an explicit build step and threads; JavaScript ships source and uses an event loop. Analogy: Java is a dish you pre-cook and reheat anywhere with the right oven. JavaScript is a recipe the kitchen reads and cooks on the spot every time. In an interview: Java compiles to bytecode ahead of time and the JVM runs it with a JIT; it is statically typed and threaded. JavaScript ships source that the engine parses and runs with its own JIT; it is dynamically typed and single-threaded with an event loop.

Question 12

What is a variable, and what does it mean that Java is statically typed?

Accepted Answer

A variable is a named storage location in memory whose value can change during execution. Java is statically typed, which means you must declare the type before you use the variable, and the compiler enforces that type from then on. Declaration reserves the name and type; initialisation gives it a first value. Analogy: labelled boxes in a warehouse. The label says both the name and what kind of thing goes inside. You cannot put shoes in a box labelled 'books', the warehouse manager (compiler) checks before it ever gets stored. In an interview: Static typing costs a little verbosity but buys a lot: the compiler catches whole categories of bugs before the program ever runs, and tooling can autocomplete and refactor reliably because types are known.

Question 13

Name the eight primitive data types and their sizes.

Accepted Answer

Primitives always hold an actual value, never a reference, and their size is fixed by the type. Four integer types: byte (1 byte), short (2 bytes), int (4 bytes), long (8 bytes). Two floating-point types: float (4 bytes, single precision) and double (8 bytes, double precision). One boolean holding only true or false. One char holding a single 16-bit Unicode character. Analogy: different sized containers on a shelf. A shot glass, a mug, a jug, a barrel. You pick based on how much you need to hold, using a barrel for a teaspoon of liquid wastes space. In an interview: int is the default for whole numbers and double for decimals, which is why you need the L and f suffixes to force long and float literals. For money never use float or double, use BigDecimal, because binary floating point cannot represent decimal fractions exactly.

Question 14

What is integer division and why does 5/2 give 2?

Accepted Answer

When both operands of a division are integer types, Java performs integer division and simply discards the fractional part, it does not round. So 5/2 is 2, not 2.5 and not 3. To get a decimal result at least one operand must be a floating-point type. Analogy: sharing 5 whole apples between 2 people when you are not allowed to cut them. Each gets 2, and one apple is left on the table and forgotten. In an interview: This is mixed-mode arithmetic: when types differ, the less inclusive type is automatically promoted to the more inclusive one. The classic bug is computing an average with two ints and wondering why the decimals vanished.

Question 15

Explain implicit and explicit type casting.

Accepted Answer

Implicit casting, also called widening or numeric promotion, happens automatically when you move from a smaller type to a larger one, int to long, float to double. It is safe because the bigger type can hold everything the smaller one could. Explicit casting, also called narrowing or numeric demotion, goes the other way and you must write the cast in parentheses yourself. The compiler forces you to be explicit because information can be lost. Analogy: pouring liquid between containers. Pouring a cup into a bucket always works, nobody needs to ask (implicit). Pouring a bucket into a cup will spill, so you have to sign a waiver saying you accept the loss (explicit). In an interview: The widening order is byte to short to int to long to float to double. Anything against that direction needs an explicit cast, and it is the developer's job to confirm the value actually fits.

Question 16

What is the difference between primitive types and reference types?

Accepted Answer

A primitive variable holds the actual value directly in its own memory slot. A reference variable does not hold the object, it holds the memory address where the object lives. That is why assigning one reference to another makes both point at the same object, whereas assigning one primitive to another copies the value. Analogy: a primitive is a note with the number written on it. A reference is a note with a street address written on it. Photocopy the first note and you have two independent numbers. Photocopy the second and you have two notes pointing to the same house. In an interview: Arrays, Strings, and every class instance are reference types. All reference variables default to null when they are instance or static variables, meaning they point at nothing yet.

Question 17

What are wrapper classes, and what are autoboxing and unboxing?

Accepted Answer

A wrapper class wraps a primitive value inside an object, Integer wraps int, Double wraps double, Character wraps char, and so on. You need them because collections and generics can only hold objects, not primitives. Autoboxing is the compiler automatically converting a primitive into its wrapper. Unboxing is the reverse, pulling the primitive back out. Both happen silently. Analogy: posting a coin. You cannot drop a loose coin into a mailbox, it needs an envelope. The wrapper is the envelope. Autoboxing is a machine that puts it in the envelope for you; unboxing is one that opens it. In an interview: Two gotchas worth naming. First, unboxing a null wrapper throws NullPointerException. Second, comparing wrappers with == compares references, not values, Integer caches only -128 to 127, so two Integers of 1000 are not == even though equals() says they are equal.

Question 18

How do you declare a constant in Java?

Accepted Answer

You use the final modifier so the value cannot be reassigned after it is set, and usually static as well so there is only one shared copy belonging to the class rather than one per object. The naming convention is all uppercase with underscores between words. Analogy: the speed limit sign on a road. It belongs to the road itself, not to any one car (static), and no driver is allowed to change it (final). In an interview: One subtlety: final on a reference variable means the reference cannot be repointed, not that the object is immutable. A final List can still have items added to it, you just cannot swap in a different List.

Question 19

What are the default values of variables in Java?

Accepted Answer

Instance variables and static variables are given default values automatically: numeric types default to 0, char to the null character, boolean to false, and all reference types to null. Local variables inside a method get no default at all. If you try to read a local variable before assigning it, the compiler refuses to compile. Analogy: a form. The company-issued form (instance/static) comes pre-filled with sensible blanks. A scrap of paper you grab from the desk (local) has nothing on it, and your manager will not accept it until you fill it in. In an interview: This is a deliberate safety design. Fields must have a defined state because objects can be used before every field is touched, whereas locals are short-lived and forgetting to initialise one is almost always a bug, so the compiler catches it.

Question 20

What is the difference between the stack and the heap?

Accepted Answer

The stack stores method calls and local variables. Each thread gets its own stack, and each method call pushes a frame that is popped off automatically when the method returns, so stack memory cleans itself up. The heap is one shared area where all objects live, no matter which method created them. Objects on the heap stay alive as long as something references them, and the garbage collector reclaims the rest. Analogy: the stack is a pile of trays in a cafeteria, you add and remove strictly from the top and it manages itself. The heap is the storage room out back where the actual food sits; trays just carry tickets telling you which shelf to look on. In an interview: This explains why each thread having its own stack means locals are automatically thread-safe, while heap objects shared between threads are exactly what needs synchronization.

Question 21

What is the difference between a class and an object?

Accepted Answer

A class is a blueprint or template, it describes what attributes (data) and behaviours (methods) something will have, but it is not a thing itself and takes no memory for instance data. An object is an actual instance created from that blueprint using the new keyword, with its own memory and its own copy of the instance variables. Analogy: an architectural drawing versus the houses built from it. One drawing, many houses. Every house has the same rooms in the same places, but house number 4 has blue walls and number 7 has green ones. You cannot live in the drawing. In an interview: The class is compile-time; the object is runtime. new does three things: allocates heap memory, runs the constructor to initialise state, and returns the reference.

Question 22

What is a method signature, and what is not part of it?

Accepted Answer

A method signature is the method name plus the number, types, and order of its parameters. That is all. The return type is NOT part of the signature, and neither is the access modifier or the parameter names. This matters because overloading resolution and overriding rules are both based on the signature. Analogy: a phone number. The number itself identifies who you reach. What they say when they pick up (the return type) is not part of how you dial them. In an interview: That last rule is exactly why you cannot overload by return type alone, at the call site the compiler would have no way to tell which one you meant.

Question 23

What are the four parts of a method declaration, and how does invoking work?

Accepted Answer

A method declaration needs a return type, a name, a pair of parentheses holding the parameter list, and a body in braces. When you invoke a method, program control transfers into it. It returns control to the caller in one of three ways: a return statement executes, execution reaches the closing brace, or it throws an exception. Return type void means the method gives back no value. Analogy: delegating a task at work. You hand it over (invoke), the other person works on it while you wait, and they come back either with the result, with 'done, nothing to report', or with a problem they could not solve. In an interview: Methods are how you represent an object's behaviour, and keeping each one focused on a single job is the practical foundation of the single responsibility principle.

Question 24

Compare instance variables, static variables, and local variables.

Accepted Answer

An instance variable is declared in the class body outside any method and without static. Every object gets its own copy, and it cannot exist without an object. A static variable, also called a class variable, uses the static modifier and belongs to the class itself, there is exactly one copy shared by all objects, initialised once at the start and living for the whole program. A local variable is declared inside a method and only exists from the moment the method is entered until it exits. Analogy: a school. Each student has their own student ID (instance variable). The school has one address that all students share (static variable). A note a student scribbles during one class and throws away at the bell is a local variable. In an interview: Method parameters are essentially pre-initialised local variables, they follow local scoping rules but always arrive with a value.

Question 25

Why can't a static method access instance variables directly?

Accepted Answer

A static method belongs to the class and can be called without any object existing. Instance variables only exist inside an object. So if a static method tried to read an instance variable, the JVM would have no way to know which object's copy you meant, there might be a thousand objects or none at all. Static methods can access other static members directly, and can access instance members only if you hand them an object reference. Analogy: asking 'what is the phone number?' at a company reception desk. The company has one main number (static), so that question makes sense. But 'what is the desk number?' is meaningless unless you name which employee you mean. In an interview: This is also why main is static, the JVM has to call it before any object of your class has been created.

Question 26

What is a reference variable?

Accepted Answer

A reference variable holds the memory address of an object rather than the object itself. When you write Dog d = new Dog(), the variable d does not contain the Dog; it contains a pointer to where that Dog lives on the heap. Multiple reference variables can point to the same object, and a reference pointing at nothing has the value null. Analogy: a house key with the address on the tag. The key is small and easy to pass around, but it is not the house. Two people can have copies of the same key, repaint the living room and both see the change. In an interview: Understanding this is the key to explaining == versus equals, why passing an object to a method lets that method mutate it, and why NullPointerException happens.

Question 27

What is scope, and how do braces define it?

Accepted Answer

Scope determines two things about a variable: where it is visible and how long it lives. In Java, scope is defined by curly braces. A variable declared inside a block is visible from its declaration to the closing brace of that block, and then it is gone. Inner blocks can see outer variables, but outer blocks cannot see inner ones. Analogy: rooms in a building. Something on a desk inside a room can be seen from that room and any smaller closet inside it, but not from the corridor outside. In an interview: The practical rule is to declare variables in the narrowest scope that works. It reduces the chance of accidental reuse and makes it obvious when a variable's job is finished.

Question 28

What is a package and why do we use them?

Accepted Answer

A package groups related classes under a single namespace, like a folder for code. It prevents name collisions, two different libraries can both have a class called Utils as long as they are in different packages. You declare a package with the package keyword as the first non-comment line of the file, only one per file, and you bring in classes from other packages with import. Analogy: surnames. There are many people called John, but John Silva and John Perera are unambiguous. The package is the surname of the class. In an interview: Convention is reverse domain name in lowercase. Packages also interact with access control: default (package-private) members are visible to other classes in the same package and nowhere else.

Question 29

What are varargs and how do they behave?

Accepted Answer

Varargs, short for variable arguments, let a method accept any number of arguments of a given type, written with three dots after the type. Inside the method, that parameter is simply an array. A method can have only one varargs parameter and it must be the last one in the list. If two overloads both match a call, Java prefers the non-varargs version. Analogy: a taxi that says 'up to 4 passengers'. You can send 0, 1, or 4 people. The driver just treats whoever got in as a list. In an interview: The classic use is something like String.format or a logging method, where the caller should not have to build an array just to pass two values.

Question 30

What does the static keyword mean for fields, methods, and nested classes?

Accepted Answer

Answer: static means 'belongs to the class itself, not to any instance'. Static field: one copy shared by every object of the class (and it exists even with zero objects). Used for constants and shared counters. Static method: callable as ClassName.method() without an object. It cannot use this or touch instance fields directly, because there is no instance. main is static so the JVM can call it before any object exists. Static nested class: a class defined inside another but not tied to an outer instance. It is really just a top-level class with a namespace. A non-static (inner) class holds a hidden reference to its outer object. There is no 'static class' at the top level in Java (that is a C# thing); the closest is a final class with only static members. Analogy: static members are on the company noticeboard: one for the whole company, readable without booking a meeting with any particular employee. In an interview: static binds a member to the class, not an instance. A static field is one shared copy; a static method needs no object and cannot use this; a static nested class has no link to an outer instance. Java has no top-level static class.

Question 31

What is encapsulation and how do you achieve it in Java?

Accepted Answer

Encapsulation is bundling variables and the methods that operate on them together inside a single class, and controlling what the outside world can touch. In practice you mark your instance variables private so nobody outside can read or change them directly, then provide public getter and setter methods as the only doorway in. Because every change now goes through your setter, you can put validation rules there and guarantee the object never enters an invalid state. Analogy: an ATM. The cash and the ledger are locked inside the machine. You interact only through the buttons on the front, and the machine enforces the rules, you cannot withdraw more than your balance, and you certainly cannot reach in and rewrite the ledger. In an interview: Encapsulation gives me two things. Data hiding: sensitive state cannot be corrupted from outside. And freedom to change: as long as the public methods keep the same shape, I can rewrite the internals completely without breaking any caller.

Question 32

Are encapsulation and abstraction the same thing?

Accepted Answer

No, though they are related. Encapsulation is about hiding data, restricting direct access to internal state so it cannot be corrupted. Abstraction is about hiding complexity, exposing only what an object does while concealing how it does it. Encapsulation is the implementation technique (private fields, public methods); abstraction is the design idea (a simple interface over a complicated reality). Analogy: a car again. Abstraction is that you steer with a wheel and go with a pedal, so you never have to think about combustion or gear ratios. Encapsulation is that the bonnet is bolted shut so you cannot yank on the fuel line while driving. In an interview: One line answer: abstraction hides complexity so the caller has less to think about; encapsulation hides data so the object stays valid. Abstraction is achieved with abstract classes and interfaces, encapsulation with access modifiers.

Question 33

Explain the four access levels in Java.

Accepted Answer

Java has three access modifier keywords producing four access levels. private is visible only inside the same class. Default, which is what you get when you write no modifier at all, is visible inside the same package. protected is visible inside the same package and additionally to subclasses in other packages. public is visible everywhere. Analogy: concentric rings of trust: your own diary (private), things you share with your household (default/package), things you also share with your extended family (protected), and things posted publicly (public). In an interview: The design rule is to start with the most restrictive level that works and widen only when there is a real reason. Every public member is a promise you have to keep for as long as the class exists.

Question 34

What is the difference between default and protected access?

Accepted Answer

Default gives access to everything in the same package and nothing else, not even to a subclass, if that subclass lives in a different package. protected gives you everything default gives you, plus access to subclasses regardless of package. The catch is that a subclass in a different package can only access the protected member through inheritance, on itself, not on some other instance of the parent. Analogy: default is a key that works on your office floor. protected is that same key, plus a special pass your children can use in other buildings, but only to open their own inherited door, not someone else's. In an interview: protected is really a signal to subclass authors: this is part of the extension contract. Because of that it is almost as costly to change as a public member, so it should be used sparingly.

Question 35

Why not just make everything public and skip getters and setters?

Accepted Answer

Three reasons. First, validation: with a public field anyone can assign an invalid value and the object silently becomes broken. Second, flexibility: once a field is public, its name and type are part of your API, so you can never change how the data is stored without breaking every caller. Third, control: a getter can return a defensive copy, log access, or compute the value on the fly, and a setter can fire an event or reject a change. Analogy: a shop with no counter. If customers can walk into the stockroom and take things off the shelves, you cannot check payment, cannot track stock, and cannot rearrange the shelves without confusing everyone. In an interview: The key insight is that a public field and a public method are not equally expensive. A method is an indirection layer, and that layer is exactly what lets the implementation evolve.

Question 36

How do you make a class truly immutable?

Accepted Answer

Mark the class final so nobody can subclass it and weaken your guarantees. Make every field private and final. Set all fields once in the constructor. Provide no setters. And if any field is itself a mutable object, make a defensive copy both when you take it in and when you hand it out, so the caller cannot reach through your reference and change your state. Analogy: a printed certificate. Once issued, the text cannot change. If you hand someone a photocopy rather than the original, nothing they scribble on it affects your copy. In an interview: Immutable objects are automatically thread-safe because there is no state to race on, they are safe to use as map keys because their hash never changes, and they are easy to reason about. String is the standard library's headline example.

Question 37

What should a setter actually do beyond assigning a value?

Accepted Answer

A setter is your last line of defence, so it should validate. Check ranges, reject nulls where they make no sense, enforce business rules, and throw a clear exception when the input is invalid. It can also normalise the input, keep a derived field in sync, or notify listeners that something changed. A setter that just assigns is a missed opportunity, that is a public field with extra steps. Analogy: a bouncer at a door. Their job is not just to open it, it is to check the guest list first and turn away anyone who does not belong. In an interview: The principle is fail fast. Rejecting bad data at the boundary is far cheaper than discovering it three layers deep when something else breaks.

Question 38

What is inheritance and what problem does it solve?

Accepted Answer

Inheritance lets one class take on the fields and methods of another. You lift the features that several classes have in common up into a higher-level class, and the more specific classes inherit them. The class being inherited from is the superclass, parent, or base class; the ones inheriting are subclasses, child, or derived classes. The benefit is that shared code is written once, and when it needs to change, you change it in one place and every subclass picks the change up. Analogy: a family recipe. The base recipe for bread lives with the grandmother. Every grandchild who bakes starts from it and adds their own twist. If she improves the base recipe, everyone's bread improves automatically. In an interview: Inheritance models an IS-A relationship. The two advantages I would name are removing duplicate code, and making modification a single-point change that propagates down the hierarchy.

Question 39

Explain IS-A versus HAS-A with examples.

Accepted Answer

IS-A is inheritance: a Triangle IS-A Shape, so Triangle extends Shape. HAS-A is composition: a Car HAS-A Engine, so Car holds an Engine as a field. The mistake to avoid is using inheritance for a part-of relationship. An Engine is not a kind of Vehicle, it is a component inside one. They are related, but not by inheritance. Analogy: IS-A is 'a sedan is a kind of car'. HAS-A is 'a car has a steering wheel'. If you would say 'is a kind of', reach for inheritance. If you would say 'has a' or 'is made of', reach for a field. In an interview: A useful test: if the subclass cannot honestly be substituted anywhere the superclass is expected, the relationship is not IS-A. That is the Liskov substitution principle showing up in practice.

Question 40

What are the types of inheritance in Java?

Accepted Answer

Single inheritance is one class extending one other. Multilevel is a chain, A is extended by B, which is extended by C. Hierarchical is one parent with several direct children. Multiple inheritance, where one class has two direct parents, is NOT supported in Java through classes. It is supported through interfaces, because a class can implement any number of them. Analogy: a family tree. Single is one parent, one child. Multilevel is grandparent to parent to child. Hierarchical is one parent with several siblings. Multiple would be a child with two biological fathers, Java says no when it comes to classes. In an interview: So the accurate statement is: Java allows multiple inheritance of type, through interfaces, but not multiple inheritance of state, through classes.

Question 41

What is the diamond problem and how does Java avoid it?

Accepted Answer

Imagine class A, then B and C both extend A, then D extends both B and C. If B and C each override the same method differently, and you call that method on a D, there is no way to know which version should run. That ambiguity is the diamond problem, named for the shape of the inheritance graph. Java sidesteps it by simply not allowing a class to extend more than one class. With interfaces there is nothing to inherit but a declaration, so no conflict arises, and since Java 8 added default methods, the compiler forces you to override explicitly if two interfaces supply conflicting defaults. Analogy: two managers giving you contradictory instructions with no tie-breaker. Java's answer is that you only ever report to one manager. In an interview: The design trade-off is clear: Java gave up multiple class inheritance to keep method resolution unambiguous, and gave back the flexibility through interfaces where the ambiguity cannot occur.

Question 42

Every class in Java extends Object, what does that give you?

Accepted Answer

If a class does not explicitly extend anything, it implicitly extends java.lang.Object. That means every object in Java, without exception, inherits a handful of methods: toString for a text representation, equals and hashCode for comparison and hashing, getClass for runtime type information, and the thread coordination methods wait, notify, and notifyAll. The default toString prints the class name and a hash code, which is why unhelpful output like ClassName@1b6d3586 shows up when you forget to override it. Analogy: a basic ID card everyone is issued at birth. It is not very informative by default, but the fields exist so any system can process you. You can fill it in properly by overriding. In an interview: The practical takeaway is that Object gives Java a single rooted type hierarchy, which is what makes it possible to write a collection or a utility method that accepts literally anything.

Question 43

What does the super keyword do?

Accepted Answer

super refers to the immediate superclass. It has two uses. Written as super.something, it accesses a superclass field or method, most often inside an overridden method, when you want to run the parent's version and then add to it. Written as super(...) as the first statement of a constructor, it calls a specific superclass constructor. Analogy: asking your parent for advice before making your own decision. You do what they suggested first, then add your own step. In an interview: Two constraints worth stating: super(...) must be the very first statement in a constructor, and you cannot use super and this constructor calls in the same constructor because both claim that first slot.

Question 44

Are constructors inherited?

Accepted Answer

No. Constructors are not inherited by subclasses. If a parent has a constructor taking a String, that does not give the child a String constructor. The child must declare its own constructors and can pass values up to the parent using super(). This is because a constructor's job is to build an instance of one specific class, it is tied to the class name itself. Analogy: a birth certificate. You do not inherit your parent's certificate; a new one is issued for you, though it does record who your parents are. In an interview: A related trap: if the parent has only a parameterised constructor and no no-argument one, the child is forced to call super(...) explicitly, because the implicit no-arg super() the compiler would insert does not exist.

Question 45

When should you NOT use inheritance?

Accepted Answer

Avoid inheritance when the relationship is not genuinely IS-A, when you only want to reuse a couple of methods, or when the parent could change in ways that would silently break the child. Inheritance creates the tightest coupling in object-oriented programming, the subclass depends on the parent's internal behaviour, not just its public shape. Composition, where you hold an object as a field and delegate to it, is usually more flexible and can be swapped at runtime. Analogy: inheritance is a tattoo, composition is a jacket. The tattoo is permanent and part of you. The jacket does the same job of keeping you warm, and you can swap it for a different one whenever you like. In an interview: The guideline I follow is favour composition over inheritance. Use inheritance when you genuinely want polymorphic substitution and the IS-A relationship is real; otherwise delegate.

Question 46

What does the final keyword do on a class, method, and variable?

Accepted Answer

On a variable, final means the value cannot be reassigned after it is first set, for a reference, that means it cannot be repointed, though the object it points to may still change internally. On a method, final means no subclass may override it, which locks in that behaviour for the whole hierarchy. On a class, final means the class cannot be extended at all. Analogy: final variable is ink instead of pencil. final method is a house rule the children are not allowed to renegotiate. final class is a family line that ends here. In an interview: final on classes and methods is a safety and security tool, it is why String is final, so nobody can subclass it and break the immutability guarantees the whole platform depends on.

Question 47

What is polymorphism?

Accepted Answer

Polymorphism means 'many forms', one object can be treated as more than one type, and one method name can behave differently depending on context. It comes in two flavours. Static or compile-time polymorphism is method overloading: the compiler picks which version to call based on the argument types. Dynamic or runtime polymorphism is method overriding: the JVM picks which version to call based on the actual object type at run time. Analogy: the word 'run'. A person runs, a program runs, a river runs, a nose runs. Same word, meaning determined by context. Polymorphism is that idea applied to method calls. In an interview: The value is that I can write code against a general type and have it automatically do the right thing for each specific type, without a chain of if-else checks. That is what makes systems extensible.

Question 48

What is method overloading and what are the rules?

Accepted Answer

Overloading is having several methods in the same class with the same name but different parameter lists, different number of parameters, different types, or a different order. The return type MAY differ, but you cannot overload by changing only the return type. Access levels may differ freely, including becoming more restrictive. Constructors can be overloaded the same way. Analogy: a shop assistant who understands several ways of asking for the same thing. 'A coffee', 'a coffee, large', 'a coffee, large, oat milk'. Same request, different amounts of detail. In an interview: Overloading is resolved entirely at compile time from the static types of the arguments, which is worth stating clearly because it is the crucial difference from overriding.

Question 49

What is method overriding and what are the rules?

Accepted Answer

Overriding is a subclass redefining a method it inherited from its superclass. The method name and parameter list must be identical. The return type must be the same or a subclass of the original, that is called a covariant return. The access level must be the same or less restrictive, never more restrictive. The overriding method cannot throw broader checked exceptions than the original declared. Analogy: a contract. The child agrees to provide the same service under at least the same terms. It can be more generous, more accessible, more specific return, but never more restrictive, or callers who relied on the parent's promise would be let down. In an interview: I always add the @Override annotation. It is not required, but it makes the compiler verify that I really am overriding something, which catches typos in the method name that would otherwise silently create a brand new method.

Question 50

Give a clear comparison of overloading versus overriding.

Accepted Answer

Overloading happens within a single class and is about convenience, offering several ways to call the same conceptual operation. It is resolved by the compiler using the declared types of the arguments. Overriding happens across a class hierarchy and is about substitutability, letting a subclass supply its own behaviour. It is resolved by the JVM at run time using the actual object. Analogy: overloading is one person who speaks several languages, choosing which to use based on who is asking. Overriding is several people who all answer to the same job title, each doing it their own way. In an interview: The single sharpest distinction is when the decision is made. Overloading is the compiler's decision from static types; overriding is the JVM's decision from the runtime object.

Question 51

Why can't static and final methods be overridden?

Accepted Answer

A static method belongs to the class, not to any object. Overriding depends on the JVM looking at the actual object to decide which version to call, and there is no object involved in a static call, so there is nothing to dispatch on. If you declare a static method with the same signature in a subclass, that is method hiding, not overriding, and which one runs depends on the reference type. A final method is explicitly declared unchangeable, so the compiler rejects any attempt to override it. Analogy: static is a company-wide policy posted at head office, you cannot 'override' it from your branch, you can only post a different sign, and which one people read depends on which building they walk into. final is a policy stamped 'not negotiable'. In an interview: That last output is the whole point. Overridden instance methods use the object; hidden static methods use the reference. It is a favourite trick question.

Question 52

What are upcasting and downcasting?

Accepted Answer

Upcasting is treating a child object as its parent type. It is always safe and Java does it implicitly, because every Dog genuinely is an Animal. Downcasting is treating a parent reference as a child type. It is not implicit, you must write the cast, because not every Animal is a Dog. If the object is not actually of that type at run time, you get a ClassCastException. Analogy: upcasting is calling a specific person 'an employee', always true and needs no proof. Downcasting is claiming a random employee is 'the CFO', you had better check first, or you will be embarrassed. In an interview: Upcasting is what makes polymorphism work, it is how you store many types in one collection. Downcasting is how you get specific behaviour back, and it should always be guarded with instanceof.

Question 53

How do interfaces enable polymorphism?

Accepted Answer

An interface defines a type that any number of unrelated classes can implement. Because they all share that type, you can hold any of them in a variable declared as the interface, put them all in one collection, and call the interface methods without knowing or caring which concrete class you actually have. This is polymorphism without needing a shared parent class, which matters because a class can implement many interfaces but extend only one class. Analogy: a power socket. Any appliance with the right plug works, a lamp, a kettle, a laptop. The socket does not know what is on the other end, only that the shape of the connection matches. In an interview: This is the practical basis for programming to an interface rather than an implementation, which is what makes code testable, I can slot in a fake implementation for a test without changing any of the calling code.

Question 54

What is dynamic method dispatch and how does the JVM decide which method runs?

Accepted Answer

Dynamic method dispatch is the mechanism behind runtime polymorphism. When you call an overridden method through a superclass reference, the JVM does not look at the reference type, it looks at the actual object sitting on the heap and runs that class's version. The reference type only controls which methods you are ALLOWED to call; the object type controls which implementation actually executes. Analogy: calling a company's main number. The number you dial (reference type) determines what services you can request. Which specific person picks up (object type) determines how the request is actually handled. In an interview: The one exception is fields. Fields are not polymorphic, they are resolved by the reference type, not the object. So an inherited field accessed through a parent reference gives you the parent's field, which is another reason to keep fields private.

Question 55

What is the instanceof operator and when should you use it?

Accepted Answer

instanceof tests whether an object is an instance of a given class or interface, returning true or false. Its main job is to make downcasting safe, check first, then cast. It returns false for null, which conveniently means you never get a NullPointerException from it. Modern Java offers pattern matching, which combines the check and the cast into one step. Analogy: checking someone's ID before letting them into the members-only room. Cheaper than letting them in and dealing with the fallout. In an interview: I would add a design caveat. A long chain of instanceof checks usually means polymorphism was missed, the behaviour that differs per type should live as an overridden method on those types instead.

Question 56

Can constructors be overloaded or overridden?

Accepted Answer

Constructors can be overloaded, you can have several with different parameter lists, and that is extremely common. Constructors cannot be overridden. Overriding requires inheritance of the method, and constructors are not inherited at all; a constructor's name is the class name, so a subclass constructor is a different name entirely. Analogy: a factory can have several assembly lines producing the same product from different starting parts (overloading). But a new factory cannot 'override' the old factory's assembly line, it builds its own. In an interview: The related concept is constructor chaining, this() to call another constructor in the same class, super() to call the parent's, which keeps initialisation logic in one place instead of duplicated across every overload.

Question 57

How do you stop a method from being overridden, and can you stop it being overloaded?

Accepted Answer

Answer: To stop overriding: mark the method final. A subclass then cannot provide its own version, and the compiler enforces it. Marking a whole class final stops any subclassing at all (String is final). private and static methods also cannot be overridden (a subclass can declare one with the same name, but that is hiding, not overriding). You cannot stop overloading. Overloading just means another method in the same class with the same name and a different parameter list. Anyone editing that class can add one. There is no keyword to forbid it, and there is rarely a reason to want to. Analogy: final on a method is like laminating a page so nobody can rewrite it. Overloading is just adding a new page with the same title, and you cannot stop someone adding pages to their own book. In an interview: final on the method blocks overriding (final on the class blocks subclassing entirely). Overloading cannot be prevented, since it is just another same-name method with different parameters, and there is no keyword for it.

Question 58

What is abstraction?

Accepted Answer

Abstraction means showing only what an object does and hiding how it does it. You expose a simple, meaningful interface and keep the complicated machinery out of sight. In Java you achieve it with abstract classes and interfaces, both let you declare that something must be possible without saying how it happens. Analogy: a TV remote. You press 'volume up'. You do not think about infrared frequencies, signal encoding, or the amplifier circuit. The remote abstracts all of that into one button. In an interview: Abstraction reduces what a caller has to understand, and it decouples them from the implementation, so I can change the internals without breaking anyone.

Question 59

What is an abstract class and what are the rules?

Accepted Answer

An abstract class is declared with the abstract keyword and cannot be instantiated, you cannot call new on it. It exists to be extended. An abstract method is declared with abstract and has no body, just a signature ending in a semicolon. A non-abstract class cannot contain abstract methods. An abstract class may contain ordinary concrete methods, fields, and constructors. The first concrete class down the inheritance tree must implement every abstract method it has inherited. Analogy: a job description. It says the role requires 'produce the monthly report' without saying how. You cannot hire the job description, you hire a person who fills it in. In an interview: The point worth stressing is that although you cannot instantiate an abstract class, you can absolutely use it as a reference type, that is the whole mechanism for polymorphism over a family of subclasses.

Question 60

What is an interface and what are its rules?

Accepted Answer

An interface is a contract: it declares what methods a class must provide without providing implementations. Before Java 8, every method in an interface was implicitly public and abstract, whether you wrote those keywords or not. Every variable in an interface is implicitly public, static and final, so they are constants, not state. Interfaces cannot have final methods, because a final method could never be implemented. An interface can extend more than one other interface, and a class can implement any number of interfaces. Analogy: an electrical standard. It says a plug must have these three pins at these positions. It does not say what the appliance does. Any manufacturer that meets the standard fits the socket. In an interview: The first concrete class implementing an interface must supply every abstract method, and those implementations must be public, because the interface methods are public, and overriding cannot reduce access.

Question 61

Abstract class versus interface, when do you use each?

Accepted Answer

Use an abstract class when the subclasses are genuinely a family that shares state and partial implementation, you want fields, constructors, and some ready-made methods. Use an interface when unrelated classes need to share a capability, or when you need a class to take on several roles, since a class can implement many interfaces but extend only one class. The rough rule: an abstract class expresses what something IS; an interface expresses what something CAN DO. Analogy: an abstract class is a species, mammals share warm blood and live birth. An interface is a skill certificate, swimming. A fish and a human can both hold a swimming certificate without being related. In an interview: In modern design I reach for interfaces first because they keep coupling loose and leave the single inheritance slot free. I bring in an abstract class when there is real shared state or duplicated implementation to lift up.

Question 62

Why can't you instantiate an abstract class or an interface?

Accepted Answer

Because they are incomplete. An abstract class may have methods with no body, so if you could create an instance and someone called one of those methods, there would be no code to run. An interface, prior to default methods, has no implementations at all. Java refuses at compile time rather than letting you build a half-finished object. However, both can be used as reference types pointing at a complete concrete object. Analogy: a blueprint with rooms marked 'to be designed'. You cannot move in. Once an architect fills in the blanks, the house exists and you can live in it, and you can still refer to it using the original blueprint's name. In an interview: The anonymous class syntax often confuses people. It looks like you are instantiating the abstract type, but the compiler is actually generating an unnamed concrete subclass on the spot and instantiating that.

Question 63

Can an abstract class have a constructor? Can an interface?

Accepted Answer

An abstract class can absolutely have constructors, including parameterised ones. They are never called by direct instantiation, but they run through constructor chaining when a concrete subclass is created, the subclass constructor calls super(), which runs the abstract class's constructor to initialise the inherited fields. An interface cannot have a constructor, because it has no instance state to initialise and is never itself instantiated. Analogy: the abstract class constructor is the foundation of a building. You never live in a foundation, but every house built on top requires it to be poured first. In an interview: This is a favourite trick question. The answer is yes for abstract classes, no for interfaces, and the reason in both cases comes down to whether there is instance state to set up.

Question 64

Can an abstract class have final methods, or a method that is both abstract and final?

Accepted Answer

An abstract class can have final methods, and that is a useful pattern, you lock down the parts of the algorithm that must not change while leaving the variable steps abstract. But a method cannot be both abstract and final at the same time. That combination is a contradiction: abstract means it must be overridden, final means it cannot be. The compiler rejects it. Analogy: a recipe that says 'always preheat to 180 degrees, this step is fixed' (final) and 'choose your own filling' (abstract). Sensible. Saying 'you must choose your own filling, and you may not choose' is nonsense. In an interview: What I have written there is essentially the template method pattern: a final method defines the skeleton of an algorithm and defers specific steps to subclasses.

Java interview preparation

Java & the JVM

Variables, types & memory

Classes, objects & methods

Encapsulation & access control

Inheritance

Polymorphism

Abstraction, abstract classes & interfaces

Constructors & object creation

Strings & immutability

Control flow & arrays

Enums

Generics

Collections & data structures

Exception handling

Multithreading & concurrency

File I/O & streams

Event-driven programming & networking