Introduction

Classes and objects form the foundation of Java’s object-oriented programming model. A class acts as a blueprint defining variables and methods, while objects are runtime instances created from that blueprint. Interviewers evaluate how well candidates understand class structure, object creation, memory allocation, lifecycle, access modifiers, and JVM-level behavior. Understanding how objects store state, how methods operate on that state, and how class loading works is essential. Candidates must also demonstrate clarity about static vs instance members, reference variables, object equality, immutability, garbage collection, and object interactions. Strong understanding of classes and objects helps in modeling real-world problems and writing clean, modular, maintainable Java code.

What Interviewers Expect

• Clear differentiation between classes, objects, instances, and reference variables.
• Understanding of JVM memory areas involved in object creation and method execution.
• Ability to explain object lifecycle and garbage collection behavior.
• Knowledge of static vs instance behavior and how Java resolves method calls.
• Ability to design meaningful classes with well-defined responsibilities.

Table of Contents

• Interview Questions
• Scenario-Based Interview Questions
• Common Mistakes
• FAQs

Interview Questions

Q1. What is a class in Java?

• A class in Java is a blueprint or template that defines properties (fields) and behaviors (methods) of objects.
• It does not occupy heap memory until an object is instantiated from it.
• Classes are stored in method area after being loaded by the class loader subsystem of JVM.
• Classes define the structure and behavior shared by all their objects.
• Class can contain instance variables, static variables, methods, constructors, blocks, and nested classes.
• The layout of an object is determined by the class definition and its members.

Follow-up Questions:

• Where is class metadata stored in JVM?
• What happens when a class is loaded?

Q2. What is an object in Java?

• An object is a runtime instance of a class containing its own copy of instance variables and accessible methods.
• Objects are created using the new keyword, which allocates memory in the heap.
• Each object has identity, state, and behavior managed by JVM.
• Object references are stored in stack or registers, while actual data resides in heap.
• Multiple objects can be created from the same class, each maintaining separate state.
• Garbage collector removes objects that are no longer referenced, freeing heap memory.

Follow-up Questions:

• How does JVM allocate object memory?
• How does an object differ from a reference?

Q3. What is the difference between a class and an object?

• A class is a logical structure or template, while an object is a physical instance of that structure.
• Class defines common attributes and methods; objects hold actual values for those attributes.
• Classes reside in method area; objects reside in the heap memory.
• One class can create multiple objects, each with independent state.
• Objects interact at runtime, while classes define behavior at compile time.
• Changes to an object do not affect the class definition.

Follow-up Questions:

• Can we create an object without a class?
• How does class loading work internally?

Q4. How does Java create objects internally?

• Object creation starts when the new keyword triggers memory allocation in heap using JVM memory manager.
• JVM allocates space for all instance variables defined in the class.
• Constructor is invoked to initialize the object’s state.
• Reference to the newly created object is returned and stored in stack as a variable.
• Class’s method table (vtable) is linked to the object for method resolution.
• Finally, the object becomes eligible for usage within the program scope.

Follow-up Questions:

• What is vtable in Java?
• Can we create an object without the new keyword?

Q5. What is an instance variable?

• Instance variables are non-static fields defined inside a class but outside any method.
• They hold the state of an object and each object gets its own separate copy.
• Instance variables are stored in heap memory inside the object structure.
• Default values are assigned by JVM if not initialized explicitly.
• Access to instance variables requires an object reference.
• Instance variables support encapsulation by restricting direct access through modifiers.

Follow-up Questions:

• Where are instance variables stored in JVM?
• How do instance variables differ from static variables?

Q6. What is an instance method?

• An instance method belongs to an object and requires an object reference for invocation.
• It can access both instance variables and static variables of the class.
• During execution, a stack frame is created and the method operates on the object’s state through this reference.
• Instance methods enable behavior customization per object.
• They support encapsulation by controlling how object state is manipulated.
• Method resolution occurs at runtime using dynamic dispatch when overriding is involved.

Follow-up Questions:

• Can instance methods be invoked from static methods?
• How does JVM resolve instance method calls?

Q7. What is a reference variable in Java?

• A reference variable stores the address of an object located in the heap, not the actual object itself.
• References are created in stack memory and point to objects stored in heap memory.
• Multiple references can point to the same object, enabling shared access to object state.
• Reference variables decide which object a method call or field access applies to.
• Changing the reference does not change the underlying object unless modified through the reference.
• Garbage collection occurs when no reference points to an object anymore.

Follow-up Questions:

• What happens if multiple references point to the same object?
• Can a reference be null? What happens if you access it?

Q8. What is the purpose of the new keyword in Java?

• The new keyword requests heap memory allocation for an object through the JVM memory manager.
• It triggers class constructor execution to initialize object state.
• The new keyword binds the newly created object to a reference variable returned by JVM.
• JVM sets up method dispatch tables (vtable) for the object during creation.
• Without new, objects are not created unless using reflection, cloning, or deserialization.
• It ensures predictable initialization through constructors rather than arbitrary memory writes.

Follow-up Questions:

• Is object creation possible without new?
• How does deserialization create objects internally?

Q9. What is an object’s state in Java?

• An object’s state consists of values stored in its instance variables.
• State can change at runtime based on method calls or assignments.
• All state data is stored in heap memory as part of the object structure.
• Each object maintains independent state, even when created from the same class.
• State influences object behavior, output, and interactions with other objects.
• Proper state management ensures consistency, predictability, and thread safety.

Follow-up Questions:

• How do constructors influence state initialization?
• What is the difference between stateful and stateless objects?

Q10. What is object behavior?

• Object behavior refers to actions an object can perform, represented through instance methods.
• Behavior operates on an object’s state and may change it based on logic.
• Behavior is shared across all objects of the class but executed with different states.
• JVM creates stack frames for each behavior invocation during runtime execution.
• Behavior can use parameters, return values, and interact with other objects.
• Well-defined behavior improves modularity and responsibility distribution in OOP.

Follow-up Questions:

• How is behavior different from functionality?
• Can behavior exist without state?

Q11. What happens in memory when an object is created?

• JVM allocates memory in the heap for instance variables defined by the class.
• Memory layout includes object header (mark word + class pointer) and instance fields.
• Constructor initializes the object after allocation but before reference assignment.
• Reference variable stores the address of the allocated object in stack memory.
• Garbage collector monitors object reachability to reclaim memory later.
• JVM links method dispatch tables for runtime method resolution.

Follow-up Questions:

• What is object header?
• How does JVM optimize object allocation?

Q12. What are static members in a class?

• Static members belong to the class itself, not to any specific object instance.
• Static variables are stored in the method area (or metaspace) and shared across all objects.
• Static methods cannot access instance variables directly because no object context exists.
• Static members are loaded during class loading, before any object creation happens.
• Used for utilities, constants, shared resources, and factory methods.
• Misuse of static members may increase coupling and reduce testability.

Follow-up Questions:

• Can static methods be overridden?
• How does static initialization work?

Q13. What is the difference between static and instance members?

• Static members belong to the class, while instance members belong to objects created from the class.
• Static members load once, whereas instance members load each time an object is created.
• Static members are shared; instance members are unique per object.
• Static methods cannot use this keyword; instance methods can.
• Static memory lies in method area; instance data resides in heap memory.
• Instance methods can call static members, but static methods cannot directly call instance members.

Follow-up Questions:

• Why can’t static methods use this?
• When should static be avoided?

Q14. What is the role of the constructor in object creation?

• Constructor initializes an object’s state immediately after memory allocation.
• It assigns values to instance variables, ensuring predictable initial state.
• Constructors do not create objects; they only initialize them after allocation.
• JVM calls the constructor after allocating memory and linking class metadata.
• Every object must pass through a constructor (default or custom) before it is usable.
• Constructor chaining allows reuse of initialization logic across constructors.

Follow-up Questions:

• What is the difference between initialization and allocation?
• How does JVM handle default constructors?

Q15. What is object reference comparison vs object content comparison?

• Reference comparison (==) checks whether two reference variables point to the same memory location.
• Content comparison uses equals() to compare values stored inside objects.
• By default, equals() behaves like == unless overridden to compare content.
• Reference comparison is faster but not useful for logical equality checks.
• Content comparison is essential for collections like HashMap and Set.
• JVM uses reference comparison extensively for object identity and GC reachability.

Follow-up Questions:

• Why must equals() be overridden based on class fields?
• How does hashCode relate to equals()?

Q16. How does garbage collection relate to objects?

• Garbage collection automatically removes unreachable objects from heap memory.
• An object becomes eligible for GC when no reference points to it.
• GC prevents memory leaks and optimizes heap usage.
• JVM uses algorithms like mark-and-sweep, generational GC, and compacting GC.
• Objects in survivor spaces may get promoted to old generation based on lifecycle.
• GC does not destroy objects immediately; it runs based on JVM heuristics.

Follow-up Questions:

• What is a memory leak in Java?
• Can GC be forced manually?

Q17. What is an anonymous object in Java?

• An anonymous object is created without storing its reference in a variable.
• Used when an object is needed only once and does not need to be reused later.
• Anonymous objects become eligible for garbage collection immediately after execution.
• They are commonly used for method arguments and initialization blocks.
• JVM still allocates heap space, but no reference is preserved afterwards.
• Anonymous objects reduce unnecessary reference variables and clutter.

Follow-up Questions:

• Can anonymous objects call multiple methods?
• How are anonymous inner classes related?

Q18. What is the difference between object initialization and object instantiation?

• Instantiation refers to allocation of memory for an object using new keyword.
• Initialization happens inside the constructor where values are assigned to fields.
• Instantiation creates the physical object; initialization prepares it for use.
• JVM performs instantiation first and then invokes the constructor for initialization.
• Uninitialized objects cannot exist; JVM guarantees constructor execution.
• Initialization logic can be overloaded using multiple constructors.

Follow-up Questions:

• Do static blocks participate in initialization?
• What happens first: instance block or constructor?

Q19. What is the default value of instance variables?

• JVM assigns default values to instance variables if not explicitly initialized.
• Numeric types default to 0, floating types to 0.0, boolean to false, char to ‘\u0000’.
• Object references default to null, indicating no object is assigned yet.
• Default initialization happens before constructor execution.
• Local variables are not assigned defaults; they must be initialized manually.
• Default values depend on JVM type system and memory model.

Follow-up Questions:

• Why are local variables not given default values?
• How does JVM handle null references?

Q20. What is an immutable object?

• An immutable object’s state cannot be changed after creation, ensuring thread-safety and predictability.
• Instance variables are private, final, and set only through the constructor.
• No setter methods exist, preventing modification of internal state.
• Immutable objects reduce the risk of inconsistent state in multi-threaded environments.
• They are stored safely in caches and collections because their state never mutates.
• JVM optimizes immutable objects by reusing instances (e.g., String pool).

Follow-up Questions:

• How does immutability differ from final keyword usage?
• Why are immutable objects preferred in concurrency?

Q21. What is the object lifecycle in Java?

• The lifecycle starts with class loading, where class bytecode is loaded into the method area by the JVM class loader.
• The new keyword triggers memory allocation for the object in the heap, followed by default initialization of fields.
• Constructor executes to initialize state, preparing the object for use.
• The object is referenced and used in program execution through method calls.
• Once no references point to it, the object becomes eligible for garbage collection.
• Finally, GC reclaims memory, and the object is removed from heap space permanently.

Follow-up Questions:

• What is the finalize() method?
• Can the GC resurrect an object?

Q22. Why are classes important in Java application design?

• Classes define the structure and behavior blueprint for objects that participate in system operations.
• They help logically group related data and functionality into a single entity.
• Classes enforce modularity, making it easier to maintain, scale, and modify parts of the system.
• They allow consistent object creation with predictable state and methods.
• Classes support abstraction and encapsulation by controlling how data is accessed.
• They form the basis for object interactions that implement business logic.

Follow-up Questions:

• What happens if class structure is poorly designed?
• How do classes enable code reuse?

Q23. How does JVM handle class loading?

• Class loading is performed by the ClassLoader subsystem, which loads .class files into the JVM method area.
• The loading phase locates and reads class bytecode into memory.
• The linking phase verifies bytecode, prepares static fields, and resolves references.
• Initialization phase executes static blocks and static variable assignments.
• Class loading is done lazily, meaning classes load only when first referenced.
• Custom class loaders can extend loading behavior, especially in web and enterprise applications.

Follow-up Questions:

• What is parent delegation model?
• When are static blocks executed?

Q24. What is the difference between class loading and object creation?

• Class loading is performed once per class, whereas object creation occurs multiple times.
• Class loading happens in the method area; object creation happens in the heap.
• Class loading loads metadata; object creation allocates memory for fields.
• Class loader executes static initializers; constructors handle object initialization.
• Without class loading, object creation is not possible.
• Objects depend on class definitions, but classes do not depend on objects.

Follow-up Questions:

• When do class loaders unload classes?
• Can object creation occur without loading the class?

Q25. What is shadowing in classes and objects?

• Shadowing occurs when a variable in a method or inner scope has the same name as an instance or static variable.
• The local variable hides the instance variable inside the method scope.
• The this keyword is required to access the shadowed instance variable.
• Shadowing may cause confusion if too many variables share the same name.
• JVM resolves variable access based on scope hierarchy from local to class level.
• Shadowing does not affect actual object state unless explicitly referenced.

Follow-up Questions:

• How is shadowing different from overriding?
• Can static variables also be shadowed?

Q26. What is an object’s identity, and why is it important?

• Identity is the unique reference assigned to an object stored in heap memory.
• Identity distinguishes objects even if their state is identical.
• Reference comparison uses identity to determine if variables point to the same object.
• Identity remains constant throughout the object’s lifecycle.
• JVM manages identity using memory addresses or compressed references internally.
• Identity is critical for avoiding duplicate data and managing caching or pooling.

Follow-up Questions:

• How is identity different from equality?
• How does Java handle identity hashing?

Q27. What is a nested class?

• A nested class is a class defined inside another class to logically group dependent components.
• It improves encapsulation by limiting visibility of internal helper classes.
• Nested classes can access private members of the enclosing class.
• They can be static (static nested classes) or non-static (inner classes).
• JVM stores nested class metadata separately but associates it with the enclosing class.
• They reduce clutter and help organize complex class structures.

Follow-up Questions:

• What is the difference between static and non-static nested classes?
• Why are nested classes used in data structures?

Q28. What are inner classes?

• Inner classes are non-static nested classes that maintain a reference to the outer class instance.
• They can access outer class instance variables and methods directly.
• Inner classes are used when behavior logically belongs with the outer instance.
• JVM maintains synthetic references to link inner and outer objects.
• Inner classes help encapsulate small helper behaviors without exposing them.
• They are commonly used in event handling and callback design.

Follow-up Questions:

• How does JVM compile inner classes?
• What are anonymous inner classes?

Q29. What is an object composition?

• Object composition means creating complex objects by assembling smaller independent objects.
• It promotes reuse through delegation instead of inheritance.
• Objects collaborate instead of forming rigid parent-child relationships.
• JVM manages memory independently for composed objects.
• Composition improves modularity and allows dynamic behavior changes at runtime.
• This design avoids tight coupling associated with inheritance-based models.

Follow-up Questions:

• How is composition different from aggregation?
• Why is composition favored in design patterns?

Q30. What are object creation alternatives besides new?

• Deserialization creates objects from byte streams without invoking constructors.
• Cloning creates a copy of an existing object using the clone() mechanism.
• Reflection creates objects using Class.newInstance() or constructors accessed reflectively.
• Factory methods return new or cached instances depending on logic.
• JVM handles memory allocation similarly except constructor behavior differs.
• Each method has its own use cases, advantages, and risks.

Follow-up Questions:

• Why is reflection slower?
• Does cloning call constructors?

Q31. What is a POJO?

• POJO stands for Plain Old Java Object, representing simple Java objects with minimal restrictions.
• POJOs typically contain private fields with public getters and setters.
• They avoid inheritance requirements or container-specific annotations.
• POJOs are widely used for data transfer, modeling, and domain entities.
• They improve flexibility by decoupling business logic from frameworks.
• JVM handles POJOs like any other object with heap allocation and GC handling.

Follow-up Questions:

• How is a POJO different from a JavaBean?
• Why are POJOs preferred in modern frameworks?

Q32. What is a DTO (Data Transfer Object)?

• A DTO is a simple object used to transfer data across layers in an application.
• DTOs contain no business logic and focus solely on holding structured data.
• They help reduce network overhead by aggregating required fields.
• DTOs improve security by exposing only necessary fields to external layers.
• They improve API clarity and decouple domain models from transport formats.
• JVM processes DTOs as lightweight memory structures optimized for serialization.

Follow-up Questions:

• Why separate DTO from entity classes?
• Can DTOs be immutable?

Q33. What is object collaboration?

• Object collaboration refers to objects interacting through method calls to achieve functionality.
• Each object performs specific responsibilities and delegates tasks when necessary.
• Collaboration prevents god objects by distributing workload across multiple classes.
• JVM uses stack frames for each interaction, managing state and method execution.
• Collaborations support modularity and maintain logical separation of concerns.
• Collaboration diagrams help visualize runtime interactions during design.

Follow-up Questions:

• How does delegation support collaboration?
• What problems occur with excessive collaboration?

Q34. What is object cohesion?

• Object cohesion measures how closely related the methods and attributes inside a class are.
• High cohesion indicates a well-structured class with focused responsibilities.
• Low cohesion means the class handles unrelated tasks, becoming difficult to maintain.
• Cohesion enhances readability, testing, and reusability.
• JVM handles cohesive classes efficiently since methods align with internal state.
• High cohesion complements low coupling for clean architecture.

Follow-up Questions:

• What causes low cohesion?
• How can cohesion be improved?

Q35. What are class-level and object-level members?

• Class-level members include static variables and methods, accessible using the class name.
• Object-level members include instance variables and methods associated with an object instance.
• Class-level members share a single memory location across all objects.
• Object-level members are independent and stored in heap per object.
• Improper mixing of both types leads to design confusion.
• JVM loads class members at startup and allocates object members during instantiation.

Follow-up Questions:

• Why avoid storing state in static variables?
• Can static methods access instance context?

Q36. How does Java handle method invocation on objects?

• Method invocation is resolved using reference type at compile time and object type at runtime.
• JVM creates a stack frame for each method call containing local variables and return address.
• For instance methods, the JVM passes an implicit this reference to access object state.
• Method dispatch uses vtable pointers to resolve overridden methods.
• Exceptions during method invocation propagate through stack frames.
• Invocation patterns affect performance and memory usage.

Follow-up Questions:

• How does JVM handle overloaded methods?
• What is dynamic dispatch?

Q37. What happens when an object reference is passed to a method?

• Java passes object references by value, meaning the reference copy is passed.
• Both the original and the copied reference point to the same object in the heap.
• Modifying the object via the reference inside the method affects the original object.
• Reassigning the reference inside the method does not affect the caller’s reference.
• JVM handles this behavior through copy semantics for reference variables.
• This mechanism often causes confusion in beginners regarding object mutability.

Follow-up Questions:

• Why do some people mistakenly think Java is pass-by-reference?
• How does this relate to mutable vs immutable objects?

Q38. How does class design impact performance?

• Poorly designed classes can lead to excessive object creation, fragmenting heap memory.
• Large objects consume more memory, causing more frequent GC cycles.
• Tight coupling increases dependency resolution overhead during runtime execution.
• Reducing unnecessary state improves caching efficiency.
• High cohesion and low coupling yield efficient execution and easier optimization.
• JVM optimizations like JIT can better optimize small, well-designed classes.

Follow-up Questions:

• How do memory leaks occur in poorly designed classes?
• How does lazy initialization improve performance?

Q39. What are best practices for designing Java classes?

• Assign a single responsibility to each class for clarity and maintainability.
• Keep instance variables private and expose behavior through well-defined methods.
• Avoid god classes and heavy static usage to prevent rigid architecture.
• Prefer composition over inheritance for better flexibility.
• Ensure meaningful naming conventions for classes and members.
• Write cohesive methods that perform one logical task.

Follow-up Questions:

• How do design patterns help in class design?
• Why avoid excessive inheritance?

Q40. How do classes and objects support scalability?

• Classes create reusable templates that reduce duplication when scaling features.
• Objects maintain isolated state, enabling independent workflows in distributed systems.
• Well-designed classes support modular expansion of functionality.
• Objects collaborate through interfaces, supporting scalable architecture layers.
• Encapsulation reduces side effects when the system grows.
• JVM handles large numbers of objects efficiently with optimized memory management.

Follow-up Questions:

• How does modular design improve scalability?
• What role do interfaces play in scalability?

Scenario-Based Interview Questions

Scenario 1: A class is growing too large with many methods. What should you do?

• Analyze responsibilities within the class and identify logical groupings of behavior.
• Split the class into smaller cohesive classes, each focused on one responsibility.
• Delegate tasks through well-defined interfaces to maintain collaboration.
• Reduce unnecessary instance variables that represent unrelated data.
• This increases maintainability and reduces cognitive complexity.
• JVM benefits from simpler class structures for efficient execution.

Scenario 2: You need multiple objects to share common behavior but maintain their own state.

• Define a class with shared behavior implemented through instance methods.
• Create separate object instances, each holding its own state in heap memory.
• Behavior is reused across objects while state remains independent.
• This ensures scalable designs where multiple users or sessions operate concurrently.
• JVM manages the shared method structure while creating unique instances.
• This pattern is ideal for multi-threaded and multi-session applications.

Scenario 3: You must return an object from a method but avoid exposing internal state to modifications.

• Return defensive copies of objects instead of internal references.
• Use immutable objects to prevent state changes by consumers.
• Encapsulate internal logic by not exposing mutable fields directly.
• JVM will allocate new objects for defensive copies ensuring safety.
• This approach protects object integrity and prevents unintended data corruption.
• Commonly used in getter methods for collections or complex objects.

Scenario 4: You need to manage multiple related objects as a cohesive unit.

• Use an aggregator class that holds references to several component objects.
• Define explicit methods to coordinate interactions between these objects.
• Ensure each component object maintains its own state and behavior.
• JVM handles separate object allocations while enabling coordinated access.
• This design supports clear object boundaries and predictable collaboration.
• Ideal for composite structures like orders, invoices, or UI components.

Scenario 5: Memory usage grows unexpectedly due to unreferenced objects. How do you address it?

• Identify long-lived references that prevent GC from reclaiming objects.
• Remove references from collections when objects are no longer needed.
• Use weak references where appropriate to allow automatic cleanup.
• Profile heap memory to locate leaks caused by poor class design.
• Ensure objects do not store unnecessary data or cache large datasets.
• JVM tools like VisualVM or JDK Flight Recorder can aid in diagnosis.

Common Mistakes

• Confusing object reference with the actual object in memory.
• Overusing static members, reducing modularity and increasing coupling.
• Designing classes with too many responsibilities (god classes).
• Neglecting encapsulation and exposing internal state directly.
• Misusing constructors or failing to initialize instance variables properly.

Quick Revision Snapshot

• A class defines structure; an object represents a runtime instance.
• Objects store state in heap; references are stored in stack.
• Static members belong to class; instance members belong to objects.
• Constructors initialize objects; new allocates heap memory.
• Garbage collection removes unreachable objects automatically.
• Good class design improves modularity, scalability, and testability.

FAQs

Can we create an object without a class?

No. In Java, every object must be created from a class, except for special cases like anonymous arrays.

Is new the only way to create an object?

No. Objects can also be created using cloning, reflection, or deserialization.

Are classes loaded only once?

Yes. A class is loaded once per ClassLoader and reused throughout the JVM lifecycle.

Conclusion

Classes and objects form the core of Java’s object-oriented system by defining structure and creating runtime instances. Understanding class loading, object lifecycle, memory allocation, reference handling, and behavior execution is essential for writing efficient and maintainable Java applications.
The next recommended topic is: Constructors in Java.