Java 개정판 - SUNG-HEE

DEV Community · Bhupesh Kumar · 2026-06-25 개발(SW)

Java Interview Revision Pack

1. One-Page Cheat Sheet

Core Java Basics

Topic Must Know JDK Used to develop Java apps. Contains compiler, tools, JRE JRE Used to run Java apps. Contains JVM + libraries JVM Executes bytecode, manages memory, GC, JIT Stack Method calls, local variables, references Heap Objects, arrays, instance variables main() JVM entry point: public static void main(String[] args)

OOP + Keywords

Concept Key Rule static Belongs to class, one copy final variable Cannot reassign final method Cannot override final class Cannot extend abstract class Cannot instantiate, can have abstract + concrete methods Upcasting Safe: Parent p = new Child() Downcasting Risky: use instanceof Dynamic Dispatch Object type decides overridden method execution

String Concepts

Topic Rule String immutable Safe, secure, pool-friendly String literal Stored in String Pool new String() Creates new heap object Compile-time concat Goes to pool Runtime concat Creates new object final String concat Can be compile-time optimized

Memory Tricks

JDK = Develop
JRE = Run
JVM = Execute

Stack = Methods
Heap = Objects

Reference Type = What you can access
Object Type = What executes

Enter fullscreen mode Exit fullscreen mode

2. Interview Revision Notes

What It Is

Core Java is the foundation of Java development. It includes JVM, memory management, OOP, strings, type casting, access control, and basic runtime behavior.

Why It Exists

Java is designed to be platform-independent, object-oriented, secure, and memory-managed.

How It Works Internally

.java file
 ↓ javac
.class bytecode
 ↓ JVM
Class Loading
 ↓
Bytecode Verification
 ↓
JIT Compilation
 ↓
Execution
 ↓
Garbage Collection

Enter fullscreen mode Exit fullscreen mode

Real Production Usage

In backend systems, these concepts matter for:

Debugging memory issues
Writing thread-safe code
Avoiding string/object comparison bugs
Understanding Spring Boot startup
Handling performance issues
Explaining object lifecycle in interviews

3. Last-Minute Interview Revision

Must Remember

Java is always pass-by-value.
Stack stores method frames; Heap stores objects.
Object type decides overridden method execution.

Interview Buzzwords

JVM
Bytecode
JIT
Garbage Collection
Stack Frame
Heap Memory
String Pool
Immutability
Dynamic Dispatch
Upcasting
Downcasting
Covariant Return
Pass-by-Value

Enter fullscreen mode Exit fullscreen mode

Red Flags

Avoid saying:

Java is pass-by-reference ❌
StringBuilder is thread-safe ❌
final object cannot be modified ❌
static belongs to object ❌
Heap is per thread ❌

Enter fullscreen mode Exit fullscreen mode

4. Active Recall Questions

Beginner

What is the difference between JDK, JRE, and JVM?
What is stored in Stack memory?
What is stored in Heap memory?
Why is main() static?
Why is String immutable?
What is the String Pool?
What is the use of static?
What does final mean for a variable?
What is an enum?
What is widening type casting?

Intermediate

Difference between == and .equals() for String?
Why does new String("Java") create a new object?
What happens in runtime string concatenation?
Why is downcasting dangerous?
What is dynamic method dispatch?
Can a final ArrayList be modified?
Abstract class vs interface?
JAR vs WAR?
StringBuilder vs StringBuffer?
What is covariant return type?

Advanced

Explain Java pass-by-value with object references.
Explain initialization order in inheritance.
Why does (byte)130 become -126?
How does compile-time string optimization work?
How does JVM call main()?
What is the relation between reference type and object type?
Why are enums singleton constants?
Can static methods be overridden?
What happens when a child constructor is called?
How does immutability help thread safety?

5. Flash Cards

Q: What is JVM?
A: It executes Java bytecode and manages memory.

Q: What is Stack memory?
A: It stores method calls, local variables, and references.

Q: What is Heap memory?
A: It stores objects and arrays.

Q: Why is String immutable?
A: For security, thread safety, and String Pool optimization.

Q: What is upcasting?
A: Assigning child object to parent reference.

Q: What is downcasting?
A: Converting parent reference back to child type.

Q: Is Java pass-by-value?
A: Yes, always.

Q: Can final ArrayList be modified?
A: Yes, but the reference cannot be reassigned.

Q: What is dynamic dispatch?
A: Runtime decides overridden method based on object type.

Q: What is byte range?
A: -128 to 127.

6. Interview Story Preparation

What I Did

In my Java/backend work, I used core Java concepts while building APIs, handling object models, debugging issues, and writing maintainable backend logic.

Challenges Faced

I had to understand memory behavior, object references, string handling, and runtime behavior to avoid bugs.

How I Solved Them

I focused on JVM basics, object lifecycle, immutability, type casting, and clean OOP principles.

Business Impact

This helped me write more reliable, maintainable, and production-safe code.

STAR Answer

“In my previous development experience, I worked on backend and API-related features where Java fundamentals were important. I used OOP principles, understood object references, handled strings carefully, and debugged runtime issues. This helped me avoid common bugs like wrong object comparison, unsafe casting, and misunderstanding reference behavior. As a result, the code became cleaner, easier to maintain, and more reliable.”

7. Common Interview Traps

Trap Correct Understanding Java pass-by-reference Java is always pass-by-value final object cannot change Reference fixed, object can change == compares String content == compares reference Runtime concat goes to pool Usually creates heap object Static method override Static methods are hidden, not overridden Downcasting always safe Only safe if actual object type matches Parent reference executes parent method Overridden method uses object type

8. Memory Tricks

JDK → Develop
JRE → Run
JVM → Execute

Enter fullscreen mode Exit fullscreen mode

Stack = Story of method calls
Heap = Home of objects

Enter fullscreen mode Exit fullscreen mode

Reference type = Remote control buttons
Object type = Actual machine behavior

Enter fullscreen mode Exit fullscreen mode

final reference = fixed address
object = house can still change inside

Enter fullscreen mode Exit fullscreen mode

Upcasting = Child goes up safely
Downcasting = Coming down carefully

Enter fullscreen mode Exit fullscreen mode

9. 30-Second Interview Answer

“Core Java concepts are important because they explain how Java code actually runs. JDK is used for development, JRE runs the application, and JVM executes bytecode. Stack stores method calls and local variables, while Heap stores objects. Java is always pass-by-value, Strings are immutable and stored in the String Pool, and runtime polymorphism is handled through dynamic dispatch where the actual object type decides the overridden method execution.”

10. Ultimate Revision Table

Topic Definition Important Points Interview Focus JDK/JRE/JVM Java development/runtime/execution layers JDK contains JRE, JRE contains JVM Java execution flow Stack vs Heap Memory areas Stack per thread, Heap shared Memory debugging String Immutable text object Pool, security, thread safety == vs .equals() static Class-level member One copy per class Loading and shared data final Restriction keyword Variable/method/class rules Final reference trap abstract Incomplete class design Cannot instantiate Abstract class vs interface Upcasting Parent ref to child object Safe Polymorphism Downcasting Parent ref to child type Use instanceof Runtime exception Dynamic Dispatch Runtime method binding Object type decides method OOP internals Type Casting Convert data types Widening safe, narrowing risky Overflow traps Byte Overflow Range wraparound 128 → -128, 130 → -126 Coding output questions JAR/WAR/EAR Java packaging Boot uses executable JAR Deployment

Interview Readiness Score

8/10

You are strong on fundamentals. Main revision needed is on tricky output-based questions.

Top 5 Things To Revise Before Interview

String compile-time vs runtime concatenation
Java pass-by-value with object references
Dynamic dispatch and casting
Initialization order in inheritance
Byte overflow and narrowing casting

Java Type System & Variables – Interview Revision Pack

1. One-Page Cheat Sheet

Java Type System

Statically Typed

int age = 25;

Enter fullscreen mode Exit fullscreen mode

Type checked at compile time
Compiler knows variable types before execution
Prevents invalid assignments

Strongly Typed

int x = true; // Error

Enter fullscreen mode Exit fullscreen mode

No implicit conversion between unrelated types
Type safety enforced by compiler

var Keyword

var name = "Bhupesh";

Enter fullscreen mode Exit fullscreen mode

Compiler infers:

String name = "Bhupesh";

Enter fullscreen mode Exit fullscreen mode

Important:

var = Type Inference
NOT Dynamic Typing

Enter fullscreen mode Exit fullscreen mode

Primitive Data Types

byte
short
int
long
float
double
char
boolean

Enter fullscreen mode Exit fullscreen mode

Sizes

Type Size byte 1 byte short 2 bytes int 4 bytes long 8 bytes float 4 bytes double 8 bytes char 2 bytes boolean JVM dependent

float vs double

float f = 10.5f;
double d = 10.5;

Enter fullscreen mode Exit fullscreen mode

Interview Trap

float f = 10.5;

Enter fullscreen mode Exit fullscreen mode

❌ Compile Error

Reason:

Decimal literals are double by default

Enter fullscreen mode Exit fullscreen mode

Type Conversion

Widening

int → long
int → double

Enter fullscreen mode Exit fullscreen mode

Automatic

Narrowing

double → int
int → byte

Enter fullscreen mode Exit fullscreen mode

Requires cast

int x = (int)10.5;

Enter fullscreen mode Exit fullscreen mode

Arithmetic Promotion

byte + byte

Enter fullscreen mode Exit fullscreen mode

Result:

int

Enter fullscreen mode Exit fullscreen mode

Interview favorite.

Wrapper Classes

int → Integer
char → Character
boolean → Boolean

Enter fullscreen mode Exit fullscreen mode

Needed for Collections.

ArrayList<Integer>

Enter fullscreen mode Exit fullscreen mode

Autoboxing

Integer num = 10;

Enter fullscreen mode Exit fullscreen mode

Compiler:

Integer.valueOf(10)

Enter fullscreen mode Exit fullscreen mode

Unboxing

Integer num = 10;
int x = num;

Enter fullscreen mode Exit fullscreen mode

Compiler:

num.intValue()

Enter fullscreen mode Exit fullscreen mode

Dangerous

Integer num = null;
int x = num;

Enter fullscreen mode Exit fullscreen mode

❌ NullPointerException

Variables

Local

void test() {
    int x = 10;
}

Enter fullscreen mode Exit fullscreen mode

Stack
Must initialize

Instance

class User {
    int age;
}

Enter fullscreen mode Exit fullscreen mode

Heap
One per object

Static

static int count;

Enter fullscreen mode Exit fullscreen mode

Shared
One per class

static vs final vs static final

static

Enter fullscreen mode Exit fullscreen mode

Shared

final

Enter fullscreen mode Exit fullscreen mode

Fixed

static final

Enter fullscreen mode Exit fullscreen mode

Constant

2. Interview Revision Notes

What It Is

Java’s type system defines how data is stored, validated, converted, and accessed during program execution.

Why It Exists

Goals:

Type safety
Prevent runtime errors
Efficient memory usage
Platform-independent execution

How It Works Internally

Compilation

var name = "Java";

Enter fullscreen mode Exit fullscreen mode

Compiler converts:

String name = "Java";

Enter fullscreen mode Exit fullscreen mode

No runtime magic.

Arithmetic Promotion

byte a = 10;
byte b = 20;

a + b

Enter fullscreen mode Exit fullscreen mode

Internally:

(int)a + (int)b

Enter fullscreen mode Exit fullscreen mode

Result becomes:

int

Enter fullscreen mode Exit fullscreen mode

Autoboxing

Integer x = 10;

Enter fullscreen mode Exit fullscreen mode

Compiler:

Integer x = Integer.valueOf(10);

Enter fullscreen mode Exit fullscreen mode

Unboxing

int x = wrapper;

Enter fullscreen mode Exit fullscreen mode

Compiler:

wrapper.intValue();

Enter fullscreen mode Exit fullscreen mode

Real Production Usage

Wrapper Classes

Used heavily in:

Collections
Streams
Generics
Hibernate
Spring Data
REST APIs

Enter fullscreen mode Exit fullscreen mode

static final

Used for:

public static final String API_URL

Enter fullscreen mode Exit fullscreen mode

Configuration constants.

byte

Used in:

Network packets
Images
Binary protocols
Embedded systems

Enter fullscreen mode Exit fullscreen mode

Very relevant to your Jio experience.

Common Interview Questions

Is Java statically typed?

Yes. Types are checked at compile time.

Is Java strongly typed?

Yes. Type safety is enforced.

Does var make Java dynamic?

No.

Only type inference.

Why is char 2 bytes?

Java uses Unicode.

Why can’t byte + byte return byte?

Arithmetic promotion converts operands to int.

Why do Collections use Integer instead of int?

Generics only work with objects.

Can unboxing throw an exception?

Yes.

Integer num = null;
int x = num;

Enter fullscreen mode Exit fullscreen mode

Throws NPE.

Senior-Level Discussion Points

Performance

Excessive boxing/unboxing:

Integer
Long
Double

Enter fullscreen mode Exit fullscreen mode

creates extra objects and GC pressure.

Memory Optimization

Use primitives when possible in performance-sensitive systems.

Embedded Systems

Understanding:

byte
short
overflow
casting
memory layout

Enter fullscreen mode Exit fullscreen mode

is valuable in firmware/backend integration environments.

3. Last-Minute Interview Revision

Must Remember

1

Java is Statically Typed

Enter fullscreen mode Exit fullscreen mode

2

var != Dynamic Typing

Enter fullscreen mode Exit fullscreen mode

3

byte + byte = int

Enter fullscreen mode Exit fullscreen mode

Most asked trap.

Interview Buzzwords

Type Safety
Compile-Time Checking
Type Inference
Primitive
Wrapper
Autoboxing
Unboxing
Widening
Narrowing
Arithmetic Promotion
Unicode

Enter fullscreen mode Exit fullscreen mode

Red Flags

Never say:

var makes Java dynamic ❌

byte + byte = byte ❌

Collections support int ❌

char is 1 byte ❌

Unboxing is always safe ❌

Enter fullscreen mode Exit fullscreen mode

4. Active Recall Questions

Beginner

What does statically typed mean?
What does strongly typed mean?
Does Java support dynamic typing?
How many primitive types exist?
Why is char 2 bytes?
What is type inference?
What is widening?
What is narrowing?
What is autoboxing?
What is unboxing?

Intermediate

Why are decimal literals double by default?
Why does byte + byte return int?
Why do Collections need wrappers?
Difference between int and Integer?
Local vs instance variable?
Static vs instance variable?
How does compiler implement autoboxing?
How does compiler implement unboxing?
What is arithmetic promotion?
Why can unboxing throw NPE?

Advanced

How does type inference work internally?
Why did Java choose strong typing?
Explain boxing overhead.
Explain Integer caching.
Explain memory impact of wrappers.
Why isn’t boolean size defined by Java specification?
Why are generics incompatible with primitives?
How does JVM represent primitive types?
Explain primitive promotion rules.
How would you optimize a high-performance system to reduce boxing?

5. Flash Cards

Q: Is Java statically typed?
A: Yes.

Q: Is Java strongly typed?
A: Yes.

Q: Does var make Java dynamic?
A: No.

Q: How many primitive types exist?
A: 8.

Q: Why is char 2 bytes?
A: Unicode support.

Q: Default decimal type?
A: double.

Q: byte + byte returns?
A: int.

Q: Primitive → Wrapper?
A: Autoboxing.

Q: Wrapper → Primitive?
A: Unboxing.

Q: Unboxing risk?
A: NullPointerException.

6. Common Interview Traps

Trap Correct Answer var makes Java dynamic False byte + byte = byte False Collections support primitives False char = 1 byte False Integer and int are same False Unboxing never fails False Local variables get default values False

7. Memory Tricks

Primitive Types

4 Integers
2 Decimals
1 Character
1 Boolean

Enter fullscreen mode Exit fullscreen mode

Total:

Enter fullscreen mode Exit fullscreen mode

Conversion

Small → Big
=
Widening

Big → Small
=
Narrowing

Enter fullscreen mode Exit fullscreen mode

Variables

Local
 ↓
Method

Instance
 ↓
Object

Static
 ↓
Class

Enter fullscreen mode Exit fullscreen mode

Boxing

Primitive → Wrapper
          ↓
Autoboxing

Wrapper → Primitive
          ↓
Unboxing

Enter fullscreen mode Exit fullscreen mode

8. 30-Second Interview Answer

“Java is a statically and strongly typed language. The compiler knows variable types at compile time and enforces type safety. Java provides 8 primitive data types and corresponding wrapper classes for use with collections and generics. Type conversions are categorized into widening and narrowing. One common interview trap is that arithmetic on byte, short, and char is promoted to int. Java also supports autoboxing and unboxing, though unboxing a null wrapper can result in a NullPointerException.”

9. Ultimate Revision Table

Topic Definition Important Points Interview Focus Statically Typed Types known at compile time Compile-time checking Java fundamentals Strongly Typed Type safety enforced No unsafe conversions Type system var Type inference Not dynamic typing Java 10+ Primitive Types Basic data types 8 types Frequently asked char Unicode character 2 bytes Output questions float vs double Decimal types double default Traps Widening Small → Big Automatic Casting Narrowing Big → Small Explicit cast Output questions Wrapper Classes Object form of primitives Collections Generics Autoboxing Primitive → Wrapper Compiler generated Internals Unboxing Wrapper → Primitive NPE risk Interview favorite Local Variables Method scope Must initialize Common mistake Static Variables Class-level Shared OOP basics static final Constant Shared + fixed Best practices

Interview Readiness Score

8.5/10

Top 5 Things To Revise Before Interview

byte + byte = int
var vs dynamic typing
Autoboxing and unboxing internals
char and Unicode
Local variable initialization vs default values

These five are exactly the kinds of quick Java questions interviewers use to separate candidates who know syntax from candidates who understand the language.

Java OOP – Interview Revision Pack

This pack is optimized for Java Backend, Spring Boot, Full Stack, and Software Developer interviews.

1. One-Page Cheat Sheet

OOP (Object-Oriented Programming)

Definition:
A programming paradigm that organizes software around objects, which encapsulate state (data) and behavior (methods).

Object
   ↓
State (Variables)
+
Behavior (Methods)

Enter fullscreen mode Exit fullscreen mode

Class vs Object

Class Object Blueprint Real instance Logical entity Physical entity No memory until object creation Occupies memory in Heap

class Employee {}      // Class

Employee emp = new Employee();   // Object

Enter fullscreen mode Exit fullscreen mode

Four Pillars of OOP

Pillar Purpose Interview Keyword Encapsulation Protect Data Data Hiding Inheritance Reuse Code IS-A Polymorphism One Interface, Many Forms Dynamic Dispatch Abstraction Hide Implementation Contract

Encapsulation

private int salary;

public int getSalary(){}

public void setSalary(int salary){}

Enter fullscreen mode Exit fullscreen mode

✔ Hide Data

✔ Validation

✔ Controlled Access

Inheritance

class Dog extends Animal{}

Enter fullscreen mode Exit fullscreen mode

Relationship

Dog IS-A Animal

Enter fullscreen mode Exit fullscreen mode

Purpose

Code reuse
Extend functionality

Polymorphism

Compile Time

add(int a,int b)

add(int a,int b,int c)

Enter fullscreen mode Exit fullscreen mode

Method Overloading

Compiler decides.

Runtime

Animal a = new Dog();

a.sound();

Enter fullscreen mode Exit fullscreen mode

Method Overriding

JVM decides.

Abstraction

abstract class Payment{

abstract void pay();

}

Enter fullscreen mode Exit fullscreen mode

Shows WHAT to do.

Hides HOW it is done.

Types of Inheritance

Single

Animal
  ↑
 Dog

----------------

Multilevel

Animal
  ↑
Mammal
  ↑
 Dog

----------------

Hierarchical

      Animal
      / | \
   Dog Cat Lion

----------------

Multiple

Not Supported
(Classes)

Supported
(Interfaces)

Enter fullscreen mode Exit fullscreen mode

Interface vs Abstract Class

Interface Abstract Class Contract Shared Code Multiple implementation Single inheritance Constants Instance variables No constructor Constructor allowed

Constructors

Type Purpose Default Initialize default object Parameterized Initialize values Copy Copy another object (manual)

Execution Flow

new Object()

↓

Heap Allocation

↓

Default Initialization

↓

Constructor Execution

↓

Reference Returned

Enter fullscreen mode Exit fullscreen mode

Java Destructor

❌ No Destructor

✔ Garbage Collector cleans memory

✔ finalize() is deprecated

2. Interview Revision Notes

What is OOP?

OOP is a programming paradigm where software is modeled using objects that combine data and behavior.

Why OOP Exists

Without OOP:

Duplicate code
Poor maintainability
Tight coupling
Difficult scaling

OOP solves these by promoting modular, reusable, and maintainable code.

How It Works Internally

Object Creation

Employee e = new Employee();

Enter fullscreen mode Exit fullscreen mode

Internally

new

↓

Heap Memory Allocated

↓

Instance Variables Default Initialized

↓

Constructor Executes

↓

Reference Stored in Stack

Enter fullscreen mode Exit fullscreen mode

Runtime Polymorphism

Animal a = new Dog();

a.sound();

Enter fullscreen mode Exit fullscreen mode

Internally

Reference Type
↓

Animal

Object Type
↓

Dog

↓

JVM uses Dynamic Method Dispatch

↓

Dog.sound()

Enter fullscreen mode Exit fullscreen mode

Constructor Chaining

Child()

Enter fullscreen mode Exit fullscreen mode

Internally

Child()

↓

super()

↓

Parent Constructor

↓

Child Constructor

Enter fullscreen mode Exit fullscreen mode

Real Production Usage

Encapsulation

Used in:

DTOs
Entities
POJOs
Spring Beans

Inheritance

Used for:

RuntimeException

↓

CustomException

Enter fullscreen mode Exit fullscreen mode

Polymorphism

Spring uses it everywhere.

Example

UserService service;

service = new UserServiceImpl();

Enter fullscreen mode Exit fullscreen mode

Loose coupling.

Abstraction

Repositories

Services

Payment gateways

Notification systems

Authentication

Logging

Common Interview Questions

What is OOP?

Programming using objects containing state and behavior.

Why is Encapsulation important?

Protects data and enforces validation.

Difference between Encapsulation and Abstraction?

Encapsulation hides data.

Abstraction hides implementation.

Why doesn’t Java support Multiple Inheritance?

Diamond Problem.

Why can abstract classes have constructors?

To initialize inherited state when a subclass object is created.

Difference between Interface and Abstract Class?

Interface defines a contract.

Abstract class provides partial implementation and shared state.

Difference between Overloading and Overriding?

Overloading

Same class
Compile time

Overriding

Inheritance
Runtime

Does Java support Copy Constructors?

Not automatically.

Developers create them manually.

Does Java have Destructors?

No.

Garbage Collector manages memory.

Senior-Level Discussion Points

Favor Composition Over Inheritance

Instead of:

IS-A

Enter fullscreen mode Exit fullscreen mode

Prefer:

HAS-A

Enter fullscreen mode Exit fullscreen mode

More flexible.

Program to Interfaces

Instead of

UserServiceImpl service;

Enter fullscreen mode Exit fullscreen mode

Use

UserService service;

Enter fullscreen mode Exit fullscreen mode

This enables dependency injection and loose coupling.

SOLID Principles

OOP is the foundation of:

Dependency Injection
Spring Framework
Design Patterns
Microservices

3. Last-Minute Interview Revision

Must Remember

1

Encapsulation = Hide Data

Enter fullscreen mode Exit fullscreen mode

2

Abstraction = Hide Implementation

Enter fullscreen mode Exit fullscreen mode

3

Reference Type
↓

Accessible Methods

Object Type
↓

Executed Method

Enter fullscreen mode Exit fullscreen mode

Interview Buzzwords

Object

Class

Inheritance

IS-A

HAS-A

Encapsulation

Abstraction

Loose Coupling

Dynamic Dispatch

Method Overloading

Method Overriding

Constructor Chaining

Diamond Problem

Garbage Collection

Composition

Enter fullscreen mode Exit fullscreen mode

Red Flags

Never say:

Interface stores state ❌

Java supports multiple class inheritance ❌

Overloading is runtime polymorphism ❌

Overriding is compile-time polymorphism ❌

Java has destructors ❌

finalize() is destructor ❌

Enter fullscreen mode Exit fullscreen mode

4. Active Recall Questions

Beginner

What is OOP?
Difference between Class and Object?
What is Encapsulation?
What is Inheritance?
What is Polymorphism?
What is Abstraction?
What is a Constructor?
Why do we use Constructors?
What is a Default Constructor?
Does Java have Destructors?

Intermediate

Encapsulation vs Abstraction?
Interface vs Abstract Class?
Overloading vs Overriding?
Why doesn’t Java support multiple inheritance?
What is the Diamond Problem?
Constructor execution flow?
What is constructor chaining?
Why can abstract classes have constructors?
Types of inheritance?
What is runtime polymorphism?

Advanced

How does JVM perform dynamic dispatch?
Explain constructor chaining internally.
Why is composition preferred over inheritance?
How does Spring use interfaces for dependency injection?
Explain loose coupling with interfaces.
What happens in memory when an object is created?
Why can’t constructors be overridden?
Why can’t constructors be abstract or static?
Explain Liskov Substitution Principle using inheritance.
How do design patterns leverage OOP?

5. Flash Cards

Q: What is OOP?
A: Programming using objects containing state and behavior.

Q: Encapsulation?
A: Hiding data using private members and controlled access.

Q: Inheritance?
A: Acquiring properties and behavior of another class.

Q: Polymorphism?
A: One interface, many implementations.

Q: Abstraction?
A: Hiding implementation details while exposing essential functionality.

Q: Interface?
A: Defines a contract.

Q: Abstract class?
A: Provides partial implementation and shared state.

Q: Constructor?
A: Initializes an object during creation.

Q: Does Java have destructors?
A: No, memory is managed by the Garbage Collector.

Q: Why no multiple class inheritance?
A: To avoid the Diamond Problem.

6. Interview Story Preparation (Based on Your Experience)

Drawing from your resume and Jio experience :

What I Did

Designed and developed web interfaces for JioFiber Mesh and ONT devices using ReactJS and collaborated with backend APIs. Worked with cross-functional teams, participated in code reviews, testing, automation, and documentation.

Challenges Faced

Needed a maintainable architecture while supporting multiple device models and features without duplicating code.

How I Solved Them

Applied OOP principles:

Encapsulation for protecting object state.
Inheritance where common functionality could be shared.
Polymorphism through interfaces and overriding to support different implementations.
Abstraction to expose only required functionality across modules.

Business Impact

This improved code reuse, reduced duplication, simplified maintenance, and made feature enhancements easier across multiple device types.

STAR Answer

Situation: We were developing and maintaining web interfaces for multiple JioFiber devices.

Task: Ensure the application remained scalable and maintainable as new device models and features were added.

Action: I applied OOP principles by designing reusable classes, using encapsulation to protect object state, abstraction to separate implementation details, and polymorphism to support different device behaviors without changing client code.

Result: The codebase became easier to maintain, new features were integrated faster, and collaboration across the team improved because of the modular design.

7. Common Interview Traps

Interview Trap Correct Answer Encapsulation = Data hiding only It also provides controlled access and validation Abstraction = Same as encapsulation Encapsulation hides data; abstraction hides implementation Overloading is runtime No, compile-time Overriding is compile-time No, runtime Java supports multiple inheritance with classes No, only through interfaces Interfaces can have constructors No Abstract classes cannot have constructors They can Constructors are inherited No Constructors can be static No finalize() is a destructor No, it’s deprecated and not equivalent to a destructor

8. Memory Tricks

Four Pillars

Protect
Reuse
Many Forms
Hide

↓

Encapsulation
Inheritance
Polymorphism
Abstraction

Enter fullscreen mode Exit fullscreen mode

Overloading vs Overriding

Overloading
↓

Compiler

Overriding
↓

JVM

Enter fullscreen mode Exit fullscreen mode

Interface vs Abstract Class

Need Contract?

↓

Interface

Need Shared Code?

↓

Abstract Class

Enter fullscreen mode Exit fullscreen mode

Constructor Flow

Heap

↓

Defaults

↓

Constructor

↓

Reference

Enter fullscreen mode Exit fullscreen mode

9. 30-Second Interview Answer

“Object-Oriented Programming organizes software around objects that combine state and behavior. The four pillars are encapsulation, inheritance, polymorphism, and abstraction. Encapsulation protects data, inheritance enables code reuse, polymorphism allows one interface with multiple implementations, and abstraction hides implementation details. In Java, multiple class inheritance is not supported to avoid the Diamond Problem, so interfaces are used to achieve multiple inheritance of type. These principles form the foundation of enterprise frameworks like Spring Boot.”

10. Ultimate Revision Table

Topic Definition Important Points Interview Focus OOP Programming with objects State + Behavior Java fundamentals Class vs Object Blueprint vs Instance Heap allocation Memory model Encapsulation Hide data Getters, setters, validation Data protection Inheritance IS-A relationship Code reuse OOP design Polymorphism One interface, many forms Overloading vs overriding Runtime behavior Abstraction Hide implementation Abstract classes, interfaces API design Interface Contract Loose coupling, multiple implementation Spring DI Abstract Class Shared implementation Constructors, state Code reuse Constructors Object initialization Default, parameterized, copy Object lifecycle Garbage Collection Automatic memory management No destructors JVM internals

Interview Readiness Score

9.5/10

You have covered the Java OOP fundamentals expected in most Software Developer interviews. To reach an expert level, spend extra time on:

Runtime polymorphism and dynamic dispatch internals.
Interface vs abstract class scenarios.
Constructor chaining and object creation flow.
Composition vs inheritance (a favorite senior-level design topic).
Explaining how Spring Boot uses OOP principles (interfaces, dependency injection, loose coupling) in real-world applications.

Java Control Flow & Exception Handling – Interview Revision Pack

Optimized for Software Developer, Java Backend, Spring Boot, Full Stack, and Production Support interviews.

1. One-Page Cheat Sheet

Loops

Loop When to Use Production Example for Known iterations Arrays, Lists, counting while Unknown iterations Reading files, sockets, user input do-while Must execute at least once Menu-driven applications Enhanced for Arrays & Collections Iterating over Lists, Sets

Memory Trick

Known Count
     ↓
for

Unknown Count
     ↓
while

Must Run Once
     ↓
do-while

Collections
     ↓
Enhanced for

Enter fullscreen mode Exit fullscreen mode

Loop Control

break

break;

Enter fullscreen mode Exit fullscreen mode

Terminates nearest loop
Can be labeled

continue

continue;

Enter fullscreen mode Exit fullscreen mode

Skips current iteration
Continues next iteration

Switch vs If-Else

switch

✔ One variable

✔ Fixed values

✔ Better readability

if-else

✔ Multiple variables

✔ Range checks

✔ Complex Boolean expressions

Exception Handling Flow

Normal

try
 ↓
finally

----------------

Exception

try
 ↓
catch
 ↓
finally

Enter fullscreen mode Exit fullscreen mode

try-with-resources

try(FileInputStream fis = ...)

Enter fullscreen mode Exit fullscreen mode

Automatically closes:

Files
Database connections
Streams
Scanners

Must implement:

AutoCloseable

Enter fullscreen mode Exit fullscreen mode

Checked vs Unchecked

Checked Unchecked Compile-time Runtime Must handle Optional IOException NullPointerException SQLException ArithmeticException FileNotFoundException IllegalArgumentException

throw vs throws

throw throws Actually throws Declares possible exception Inside method Method signature One exception object Multiple exceptions allowed

Error vs Exception

Exception Error Recoverable JVM problem Application issue Serious system issue Can handle Usually cannot recover

StackOverflowError vs OutOfMemoryError

StackOverflowError OutOfMemoryError Stack full Heap full Infinite recursion Too many objects Method calls Object allocation

2. Interview Revision Notes

What It Is

Control Flow determines how a program executes, while Exception Handling allows Java applications to recover gracefully from runtime failures.

Why It Exists

Without exception handling:

Exception

↓

Program Crash

Enter fullscreen mode Exit fullscreen mode

With exception handling:

Exception

↓

Catch

↓

Recover

↓

Continue Execution

Enter fullscreen mode Exit fullscreen mode

How It Works Internally

Loop Execution

for(int i=0;i<5;i++)

Enter fullscreen mode Exit fullscreen mode

Internally

Initialization

↓

Condition Check

↓

Body

↓

Increment

↓

Repeat

Enter fullscreen mode Exit fullscreen mode

Exception Handling Flow

try{

}
catch(){

}
finally{

}

Enter fullscreen mode Exit fullscreen mode

Internally

Execute try

↓

Exception?

↓

No
↓

finally

-----------------

Yes

↓

Find Matching Catch

↓

Execute Catch

↓

finally

Enter fullscreen mode Exit fullscreen mode

try-with-resources

Compiler converts:

try(FileInputStream fis = ...)

Enter fullscreen mode Exit fullscreen mode

Into something similar to:

FileInputStream fis = ...

try{

}
finally{

fis.close();

}

Enter fullscreen mode Exit fullscreen mode

Automatic cleanup.

Stack Trace Generation

When an exception occurs:

Method A

↓

Method B

↓

Method C

↓

Exception

↓

Stack Trace Generated

↓

Stack Unwinding

↓

Matching Catch Found

↓

Execute Catch

Enter fullscreen mode Exit fullscreen mode

Real Production Usage

for Loop

Processing:

Arrays
Batch jobs
Reports

while Loop

Used for:

Reading log files
Kafka consumers
TCP socket communication
Streaming APIs

Exception Handling

Spring Boot uses exceptions extensively:

@ControllerAdvice

@ExceptionHandler

ResponseEntity

Enter fullscreen mode Exit fullscreen mode

try-with-resources

Used for:

JDBC
File IO
REST client streams
BufferedReader

Custom Exceptions

Business validation

InvalidUserException

InsufficientBalanceException

OrderNotFoundException

Enter fullscreen mode Exit fullscreen mode

Common Interview Questions

Difference between break and continue?

break exits the loop.
continue skips only the current iteration.

Why use while instead of for?

When the number of iterations is unknown.

Why use try-with-resources?

Automatic resource cleanup.

No resource leaks.

Difference between Checked and Unchecked Exceptions?

Checked

Compiler forces handling.

Unchecked

Runtime exceptions.

Difference between throw and throws?

throw

Actually throws.

throws

Declares responsibility.

Why does finally exist?

To guarantee cleanup regardless of whether an exception occurs.

Can finally fail to execute?

Yes.

Examples:

System.exit()
JVM crash
Power failure
OS kill

Difference between Error and Exception?

Exception

Recoverable application problem.

Error

Serious JVM problem.

Difference between StackOverflowError and OutOfMemoryError?

StackOverflowError

Infinite recursion.

OutOfMemoryError

Heap exhausted.

Senior-Level Discussion Points

Never Swallow Exceptions

Bad

catch(Exception e){

}

Enter fullscreen mode Exit fullscreen mode

Good

catch(IOException e){

logger.error(...);

throw e;
}

Enter fullscreen mode Exit fullscreen mode

Catch Specific Exceptions

Avoid

catch(Exception e)

Enter fullscreen mode Exit fullscreen mode

Prefer

catch(IOException e)

Enter fullscreen mode Exit fullscreen mode

Use Custom Exceptions

Instead of

Exception

Enter fullscreen mode Exit fullscreen mode

Prefer

UserNotFoundException

OrderException

PaymentException

Enter fullscreen mode Exit fullscreen mode

Prefer try-with-resources

Never manually forget to close:

Files
Connections
Streams

3. Last-Minute Interview Revision

Must Remember

1

break

↓

Exit Loop

Enter fullscreen mode Exit fullscreen mode

2

continue

↓

Skip Iteration

Enter fullscreen mode Exit fullscreen mode

3

Checked

↓

Compiler

Unchecked

↓

Runtime

Enter fullscreen mode Exit fullscreen mode

Interview Buzzwords

Control Flow

Loop

Iteration

Stack Unwinding

Exception Propagation

Checked Exception

Unchecked Exception

RuntimeException

AutoCloseable

try-with-resources

finally

Custom Exception

Stack Trace

Resource Leak

Enter fullscreen mode Exit fullscreen mode

Red Flags

Never say:

finally always executes ❌

Error can always be recovered ❌

throw and throws are same ❌

try needs catch ❌

break exits current iteration ❌

continue exits loop ❌

OutOfMemoryError = Stack Overflow ❌

Enter fullscreen mode Exit fullscreen mode

4. Active Recall Questions

Beginner

Difference between for and while?
When should you use do-while?
What does break do?
What does continue do?
What is a checked exception?
What is an unchecked exception?
What is finally?
What is try-with-resources?
What is throw?
What is throws?

Intermediate

When should switch be preferred over if-else?
When can finally not execute?
Difference between Error and Exception?
Why is try-with-resources better?
What must a resource implement?
Can try exist without catch?
Can try exist without finally?
What is stack unwinding?
Why create custom exceptions?
Difference between StackOverflowError and OutOfMemoryError?

Advanced

How does JVM search for a matching catch block?
Explain exception propagation.
How does compiler transform try-with-resources?
Why shouldn’t you catch Exception everywhere?
Explain suppressed exceptions.
How does Spring Boot handle exceptions globally?
Explain exception translation in Spring Data.
What happens if finally throws another exception?
Why are Errors usually not caught?
Design a custom exception hierarchy for an e-commerce system.

5. Flash Cards

Q: Which loop is best for known iterations?
A: for.

Q: Which loop runs at least once?
A: do-while.

Q: break?
A: Exits the loop.

Q: continue?
A: Skips current iteration.

Q: Checked exception?
A: Compiler-enforced exception.

Q: Unchecked exception?
A: Runtime exception.

Q: throw?
A: Throws an exception object.

Q: throws?
A: Declares exceptions in a method signature.

Q: try-with-resources requires?
A: AutoCloseable.

Q: StackOverflowError?
A: Infinite recursion.

6. Interview Story Preparation (Based on Your Experience)

Based on your Jio Software Developer experience :

What I Did

While developing and supporting JioFiber applications, I handled exceptions during backend development, automation, and testing. I also worked with file operations, logging, and production issue analysis.

Challenges Faced

Production issues could occur due to invalid inputs, file access problems, or unexpected runtime conditions. Proper error handling was essential to avoid application failures.

How I Solved Them

I used structured exception handling, logged errors for troubleshooting, cleaned up resources properly, and created validation logic to prevent invalid operations from reaching production.

Business Impact

This improved application stability, simplified debugging, reduced downtime, and made production support more efficient.

STAR Answer

Situation: During backend development and production support, applications had to handle unexpected runtime failures without crashing.

Task: Ensure the application remained stable and failures could be diagnosed quickly.

Action: I implemented proper exception handling using specific catch blocks, ensured resources were closed correctly, logged meaningful error messages, and validated inputs before processing.

Result: The application became more reliable, production incidents were easier to troubleshoot, and the development team could resolve issues faster.

7. Common Interview Traps

Trap Correct Answer finally always executes Not if System.exit(), JVM crash, OS kill, or power failure occurs break skips one iteration No, it exits the loop continue exits the loop No, it skips only the current iteration throw and throws are identical throw performs the action; throws declares it Checked exceptions occur at runtime only They are enforced at compile time try must always have a catch It can also have only a finally block Errors should always be caught Most Errors indicate serious JVM issues and are generally not meant to be handled

8. Memory Tricks

Loop Selection

Known Count
↓

for

Unknown Count
↓

while

Must Execute Once
↓

do-while

Collections
↓

Enhanced for

Enter fullscreen mode Exit fullscreen mode

Exception Hierarchy

Throwable

↓

Exception
↓

RuntimeException

↓

Unchecked

Enter fullscreen mode Exit fullscreen mode

Everything else under Exception is generally Checked.

throw vs throws

throw

↓

Action

throws

↓

Declaration

Enter fullscreen mode Exit fullscreen mode

Memory Errors

Stack

↓

Methods

↓

StackOverflowError

----------------

Heap

↓

Objects

↓

OutOfMemoryError

Enter fullscreen mode Exit fullscreen mode

9. 30-Second Interview Answer

“Java control flow uses loops such as for, while, do-while, and enhanced for depending on the iteration requirement. Exception handling allows applications to recover gracefully from runtime failures using try, catch, and finally. Checked exceptions are enforced by the compiler, while unchecked exceptions occur at runtime. Modern Java uses try-with-resources to automatically close resources that implement AutoCloseable, helping prevent resource leaks and making production code safer.”

10. Ultimate Revision Table

Topic Definition Important Points Interview Focus Loops Repeated execution Choose based on iteration pattern Control flow break Exit loop Can be labeled Nested loops continue Skip current iteration Loop continues Iteration control switch vs if-else Choice vs condition Fixed values vs complex logic Code readability try-catch-finally Exception handling Cleanup with finally Runtime reliability try-with-resources Automatic cleanup Requires AutoCloseable File I/O, JDBC Checked Exception Compile-time enforced Must handle or declare API design Unchecked Exception Runtime exception Optional to handle Input validation throw vs throws Action vs declaration One object vs method contract Exception flow Error vs Exception JVM vs application problem Recoverability JVM internals StackOverflowError Stack exhausted Infinite recursion Recursion bugs OutOfMemoryError Heap exhausted Excessive object allocation Memory management Custom Exception Domain-specific error Extends Exception or RuntimeException Clean architecture

Interview Readiness Score

9.5/10

You have a solid grasp of Java control flow and exception handling. To perform well in senior-level interviews, focus on these five areas:

Exception propagation and stack unwinding.
try-with-resources internals and AutoCloseable.
Choosing checked vs unchecked exceptions in API design.
Global exception handling in Spring Boot (@ControllerAdvice, @ExceptionHandler).
Resource management and logging best practices in production systems.

원문에서 계속 ↗

추출 본문 · 출처: dev.to · https://dev.to/_bhupeshk_/java-revision-36nf