JAVA & OOP INTERVIEW GUIDE

Complete Guide for Freshers

Most Asked Interview Questions with Detailed Answers

IT Industry Professional Interview Preparation

TABLE OF CONTENTS
• 1. Object-Oriented Programming (OOP) Fundamentals
• 2. Java Basics
• 3. Core Java Concepts
• 4. Advanced Java Concepts
• 5. Collections Framework
• 6. Exception Handling
• 7. Multithreading
• 8. Design Patterns
• 9. JDBC & Database
• 10. Behavioral & Technical Interview Questions

1. OBJECT-ORIENTED PROGRAMMING (OOP)

FUNDAMENTALS
Q: What is Object-Oriented Programming (OOP)?
A: OOP is a programming paradigm based on the concept of 'objects' which are instances of
classes. It emphasizes data and functions working together within objects, promoting
modularity, reusability, and maintainability.
Key Benefits: Code reusability, better organization, easier maintenance, and real-world
modeling.

Q: What are the four pillars of OOP?

A: 1. ENCAPSULATION - Bundling data (variables) and methods (functions) within a class,
hiding internal details using access modifiers (private, protected, public).
2. INHERITANCE - Mechanism to acquire properties and methods from a parent class,
promoting code reuse.
3. POLYMORPHISM - Ability of objects to take multiple forms. Types: Method Overloading
(compile-time) and Method Overriding (runtime).
4. ABSTRACTION - Hiding complex implementation details and showing only essential
features. Achieved through abstract classes and interfaces.

Q: Explain Encapsulation with an example

A: Encapsulation is the bundling of data and methods that operate on that data, keeping them
within a single unit (class) while hiding internal details.
Example:
public class Student {
private String name; // Private variable
private int age;
public String getName() { // Public getter
return name;
}
public void setName(String name) { // Public setter
if (name != null && ![Link]()) {
[Link] = name;
}
}
}
Benefit: Controlled access, validation of data, and change of internal implementation without
affecting external code.

Q: What is Inheritance? What are its types?

A: Inheritance is a mechanism where a class (child) inherits properties and methods from
another class (parent).
Types:
1. SINGLE INHERITANCE - One class inherits from one parent (A <- B)
2. MULTILEVEL INHERITANCE - Hierarchical inheritance (A <- B <- C)
3. HIERARCHICAL INHERITANCE - One parent, multiple children (B, C <- A)
4. MULTIPLE INHERITANCE - Not directly supported in Java (conflicts), but achievable through
interfaces
Java doesn't support multiple inheritance to avoid the Diamond Problem.

Q: What is Polymorphism? Explain Method Overloading vs Method Overriding

A: Polymorphism means 'many forms' - ability to perform the same action in different ways.
METHOD OVERLOADING (Compile-time/Static Polymorphism):
- Same method name with different parameters
- Can differ in number, type, or order of parameters
- Resolved at compile time
Example: void add(int a, int b) and void add(double a, double b)
METHOD OVERRIDING (Runtime/Dynamic Polymorphism):
- Child class provides its own implementation of a parent class method
- Must have same method signature
- Resolved at runtime using object type
Example: Parent class move(), Child class move() with different implementation

Q: Explain Abstraction. What is the difference between abstract classes and interfaces?
A: Abstraction means hiding complex implementation details and showing only the necessary
features.
ABSTRACT CLASS:
- Can have both abstract and concrete methods
- Can have instance variables (any access modifier)
- Can have constructors
- Single inheritance
- Uses 'abstract' keyword
- Used for IS-A relationship
INTERFACE:
- All methods are abstract (before Java 8)
- Only static final variables
- No constructors
- Multiple inheritance supported
- Uses 'interface' keyword
- Used for 'CAN-DO' capability

Q: What is the SOLID principle?

A: S - SINGLE RESPONSIBILITY PRINCIPLE - A class should have only one reason to change
O - OPEN/CLOSED PRINCIPLE - Classes should be open for extension but closed for
modification
L - LISKOV SUBSTITUTION PRINCIPLE - Objects of child classes must be substitutable with
parent class objects
I - INTERFACE SEGREGATION PRINCIPLE - Clients should not depend on interfaces they
don't use
D - DEPENDENCY INVERSION PRINCIPLE - Depend on abstractions, not concrete
implementations

2. JAVA BASICS
Q: What is Java? Why is it popular?
A: Java is a high-level, object-oriented, platform-independent programming language following
the 'Write Once, Run Anywhere' (WORA) principle.
Popularity due to:
- Platform independence (JVM)
- Strong OOP support
- Robust exception handling
- Rich standard library
- Community support
- Used in enterprise applications

Q: What is the difference between JDK, JRE, and JVM?

A: JDK (Java Development Kit) - Complete package for development including JRE +
development tools (compiler, debugger, etc.)
JRE (Java Runtime Environment) - Runtime environment to execute Java programs. Includes
JVM + libraries
JVM (Java Virtual Machine) - Abstract computing machine that executes Java bytecode, making
Java platform-independent
Relationship: JDK includes JRE, JRE includes JVM

Q: What is bytecode? How does Java achieve platform independence?

A: Bytecode is the intermediate code generated by the Java compiler (.class file) that's
independent of any specific machine.
How Java is platform-independent:
1. Java source code (.java) is compiled to bytecode (.class file)
2. The JVM present on each platform (Windows, Linux, Mac) interprets this bytecode
3. Same .class file runs on any machine with JVM, without recompilation
This makes Java truly platform-independent.

Q: Explain the main method in Java. Why is it static?

A: public static void main(String[] args)
- Entry point for any Java application
- JVM looks for this specific method signature to start program execution
It is STATIC because:
- JVM doesn't need to create an object to call it
- It can be called directly using class name: [Link]()
- Ensures single entry point regardless of object creation
- Memory efficient - method loaded once in memory

Q: What are access modifiers in Java?

A: Access modifiers control visibility and accessibility of classes, methods, and variables.
1. PUBLIC - Accessible from anywhere
2. PRIVATE - Accessible only within the same class
3. PROTECTED - Accessible within same package and subclasses
4. DEFAULT (Package-private) - No keyword, accessible only within same package

Q: What is the difference between Stack and Heap memory?

A: STACK MEMORY:
- Stores primitive values and object references
- Memory allocated in LIFO order
- Thread-safe (each thread has its own stack)
- Memory automatically freed when variable scope ends
- Limited size, throws StackOverflowError if exceeded
HEAP MEMORY:
- Stores actual objects
- Dynamic memory allocation
- Shared among all threads
- Memory freed by garbage collector
- Larger size, throws OutOfMemoryError if exceeded

Q: What is type casting in Java? What is the difference between explicit and implicit
casting?
A: Type casting is converting one data type to another.
IMPLICIT CASTING (Widening/Upcasting):
- Automatic conversion from smaller to larger type
- No loss of data
- Example: int x = 5; double y = x; (int to double)
EXPLICIT CASTING (Narrowing/Downcasting):
- Manual conversion from larger to smaller type
- Potential loss of data
- Requires explicit syntax
- Example: double x = 5.5; int y = (int)x; (double to int)

3. CORE JAVA CONCEPTS

Q: What are classes and objects? What is the relationship between them?
A: CLASS - Logical entity that is a blueprint or template for creating objects. Defines structure
(properties) and behavior (methods).
OBJECT - Physical entity created from a class. Instance of a class with actual values for
properties.
Relationship:
- A class is a logical concept; an object is a concrete realization
- Multiple objects can be created from a single class
- Example: Class 'Car' is the blueprint; actual cars (Honda, Toyota) are objects

Q: What is the 'this' keyword?

A: The 'this' keyword refers to the current instance of the class.
Uses:
1. To refer to current object's instance variables: [Link] = name;
2. To call another constructor from the same class: this();
3. To return current object: return this;
4. To pass current object as a parameter: someMethod(this);

Q: What is the 'super' keyword?

A: The 'super' keyword refers to the parent class object.
Uses:
1. To access parent class methods: [Link]();
2. To access parent class variables: [Link];
3. To call parent class constructor: super(); or super(args);
4. Useful in method overriding when need parent class functionality

Q: Explain constructor in Java. What is constructor chaining?

A: Constructor - Special method used to initialize objects. Same name as class, no return type.
Types:
1. Default Constructor - No parameters, provided by Java if not defined
2. Parameterized Constructor - Takes parameters to initialize object
CONSTRUCTOR CHAINING - Calling one constructor from another constructor within the same
class.
Achieved using 'this()' for same class constructor
Achieved using 'super()' for parent class constructor
Must be the first statement in constructor

Q: What is the difference between == and .equals()?

A: == operator - Compares reference/memory address, checks if both variables point to same
object
.equals() method - Compares actual content/values of objects
Example:
String s1 = new String('Hello');
String s2 = new String('Hello');
s1 == s2 returns false (different objects in memory)
[Link](s2) returns true (same content)
Q: What are final, finally, and finalize()?
A: FINAL - Keyword used to restrict modification
- final class - Cannot be inherited
- final method - Cannot be overridden
- final variable - Cannot be reassigned (must be initialized)
FINALLY - Block that always executes after try-catch, regardless of exception
- Used for cleanup operations like closing resources
FINALIZE() - Method called by garbage collector before destroying object
- Rarely used in modern Java

Q: What is a static variable and static method?

A: STATIC VARIABLE - Belongs to the class, not to individual objects. Shared by all instances.
- Memory allocated only once
- Accessed using [Link]
STATIC METHOD - Belongs to class, called without creating object.
- Cannot access non-static members directly
- Called using [Link]()
Use Case: Utility methods, counter variables shared across instances

Q: What is the difference between instance variable and static variable?

A: INSTANCE VARIABLE:
- Belongs to object, not class
- Created when object is created, destroyed when object is destroyed
- Each object has its own copy
- Accessed using [Link]
STATIC VARIABLE:
- Belongs to class, not object
- Created when class is loaded, destroyed when class is unloaded
- All objects share the same copy
- Accessed using [Link]

4. ADVANCED JAVA CONCEPTS

Q: What are packages? Why do we use them?
A: Packages are containers for classes and interfaces that help organize code.
Naming convention: reverse domain name ([Link])
Benefits:
- Code organization and structure
- Avoid naming conflicts
- Control access with access modifiers
- Easier maintenance and reuse

Q: What is serialization and deserialization?

A: SERIALIZATION - Converting object to byte stream (for storage or transmission)
DESERIALIZATION - Converting byte stream back to object
How to implement: Class must implement Serializable interface
Uses: Saving object state, transmitting over network, caching
Important: serial version UID ensures version compatibility

Q: What is the difference between ArrayList and Array?

A: ARRAY:
- Fixed size
- Faster access (constant time)
- Type-specific (int[], String[])
- Primitive types supported
ARRAYLIST:
- Dynamic size (grows/shrinks)
- Slower access (might require shifting)
- Generic type (ArrayList<Type>)
- Only objects, not primitives
- Easier to use for variable data

Q: What is immutability? Give an example

A: Immutability means once created, object cannot be modified. Changes result in new object.
Example: String class is immutable
Creating immutable class:
1. Make class final
2. Make all fields private final
3. No setter methods
4. Initialize fields in constructor
5. For object fields, return copy in getter
Benefits: Thread-safe, can use as HashMap keys, easier to cache

Q: What is the difference between String, StringBuffer, and StringBuilder?

A: STRING - Immutable, thread-safe, slower when concatenating many times
STRINGBUFFER - Mutable, thread-safe (synchronized), slightly slower
STRINGBUILDER - Mutable, not thread-safe (faster), preferred for non-threaded environment
Performance: StringBuilder > StringBuffer > String
Use StringBuffer for multi-threaded, StringBuilder for single-threaded

Q: What are wrapper classes? Give examples

A: Wrapper classes convert primitives to objects. Autoboxing and unboxing handle conversion.
Primitive - Wrapper Class
byte - Byte
short - Short
int - Integer
long - Long
float - Float
double - Double
boolean - Boolean
char - Character
Used in: Collections (ArrayList<Integer>), null values, type conversion

Q: What is the difference between method overloading and method overriding?

A: METHOD OVERLOADING (Compile-time/Static Polymorphism):
- Same class
- Same method name, different parameters
- Can vary return type if parameters differ
- Resolved at compile time
METHOD OVERRIDING (Runtime/Dynamic Polymorphism):
- Different classes (parent-child)
- Same method name, same parameters, same return type
- @Override annotation recommended
- Resolved at runtime

5. COLLECTIONS FRAMEWORK
Q: What is the Collections Framework?
A: Collection of interfaces and classes for storing and manipulating groups of objects.
Three main types:
1. LIST - Ordered, allows duplicates (ArrayList, LinkedList, Vector)
2. SET - Unordered, no duplicates (HashSet, TreeSet, LinkedHashSet)
3. MAP - Key-value pairs, unique keys (HashMap, TreeMap, LinkedHashMap)

Q: Explain ArrayList vs LinkedList

A: ARRAYLIST:
- Backed by array
- Faster random access O(1)
- Slower insertion/deletion O(n)
- Better for read-heavy operations
LINKEDLIST:
- Doubly linked list
- Slower random access O(n)
- Faster insertion/deletion O(1)
- Better for write-heavy operations
Implements Queue and Deque interfaces

Q: What are HashSet and TreeSet?

A: HASHSET:
- Hash table based
- No guaranteed order
- O(1) average time complexity
- Allows null values
TREESET:
- Red-Black tree based
- Sorted order
- O(log n) time complexity
- No null values
- implements NavigableSet

Q: Explain HashMap vs Hashtable vs ConcurrentHashMap

A: HASHMAP:
- Not synchronized (not thread-safe)
- Allows null key and values
- Better for single-threaded
HASHTABLE:
- Synchronized (thread-safe)
- Doesn't allow null key or value
- Legacy class, slower
CONCURRENTHASHMAP:
- Thread-safe without synchronizing entire map
- Multiple threads can read simultaneously
- No null key or value
- Best for multi-threaded environment
Q: What is Iterator? How to use it?
A: Iterator interface provides methods to iterate through collections.
Methods: hasNext(), next(), remove()
Example:
Iterator<String> it = [Link]();
while([Link]()) {
String element = [Link]();
}
Why use: Safe removal during iteration, universal way to traverse any collection

Q: What is the difference between Comparable and Comparator?

A: COMPARABLE ([Link]):
- Implemented by class being compared
- compareTo() method
- Natural ordering
- Sorting: [Link](list);
COMPARATOR ([Link]):
- Implemented separately
- compare() method
- Multiple ways to sort
- Sorting: [Link](list, comparator);

6. EXCEPTION HANDLING
Q: What are checked and unchecked exceptions?
A: CHECKED EXCEPTIONS - Must be handled or declared in method signature
- Checked at compile time
- Extends Exception class
- Examples: IOException, SQLException, ClassNotFoundException
UNCHECKED EXCEPTIONS - Not required to handle
- Checked at runtime
- Extends RuntimeException
- Examples: NullPointerException, ArrayIndexOutOfBoundsException, ClassCastException

Q: What is try-catch-finally? Explain with example

A: TRY - Block containing code that might throw exception
CATCH - Block to handle exception if thrown
FINALLY - Block that always executes, used for cleanup
Example:
try {
int result = 10/0;
} catch(ArithmeticException e) {
[Link]();
} finally {
[Link]('Always executed');
}

Q: What is throw vs throws?

A: THROW - Keyword to explicitly throw an exception
- Used inside method body
- Syntax: throw new Exception('message');
THROWS - Keyword to declare exceptions thrown by method
- Used in method signature
- Syntax: public void method() throws IOException
- Responsibility passed to caller to handle

Q: What is custom exception? How to create one?

A: Custom exception is user-defined exception for specific error conditions.
How to create:
1. Extend Exception (checked) or RuntimeException (unchecked)
2. Call super() in constructor
Example:
public class InvalidAgeException extends Exception {
public InvalidAgeException(String message) {
super(message);
}
}
Used for business logic exceptions

Q: What is try-with-resources?
A: Feature to automatically close resources implementing AutoCloseable interface.
Available from Java 7+
Syntax: try(ResourceType resource = new Resource()) {
Example: try(Scanner sc = new Scanner(new File('[Link]'))) {
// code
}
Benefit: No need explicit close(), automatic resource management
7. MULTITHREADING
Q: What is a thread? How to create a thread in Java?
A: Thread is a lightweight unit of execution within a process. Multiple threads can run
concurrently.
Two ways to create thread:
1. EXTEND Thread CLASS:
class MyThread extends Thread {
public void run() { }
}
MyThread t = new MyThread();
[Link]();
2. IMPLEMENT Runnable INTERFACE:
class MyRunnable implements Runnable {
public void run() { }
}
Thread t = new Thread(new MyRunnable());
[Link]();

Q: What is the difference between run() and start() method?

A: START() METHOD:
- Creates new thread and calls run() in that thread
- Actual thread creation
- Multiple calls allowed
RUN() METHOD:
- Contains code to execute in thread
- If called directly, runs in same thread (no new thread created)
- Should not be called directly

Q: Explain Thread lifecycle (states)

A: 1. NEW - Thread created but not started
2. RUNNABLE - After start() called, ready to run
3. RUNNING - Currently executing
4. BLOCKED - Waiting for lock or resource
5. WAITING - Waiting indefinitely for another thread
6. TIMED_WAITING - Waiting for specified time
7. TERMINATED - Execution completed

Q: What is synchronization? Why needed?

A: Synchronization mechanism to control access to shared resource by multiple threads.
Prevents race condition - situation where multiple threads access shared resource and cause
inconsistent state.
Two types:
1. METHOD SYNCHRONIZATION - Entire method synchronized
2. BLOCK SYNCHRONIZATION - Only critical section synchronized
Synchronized keyword ensures only one thread executes at a time

Q: What is a deadlock? How to avoid it?

A: Deadlock - Situation where two or more threads are blocked permanently waiting for each
other.
How to avoid:
1. Use proper locking order - Ensure threads acquire locks in same order
2. Avoid nested synchronization
3. Use Lock with timeouts
4. Use [Link] classes
5. Keep synchronized blocks short

Q: What is the difference between wait() and sleep()?

A: WAIT():
- Called on object, not thread
- Releases lock and waits
- Used with synchronized blocks
- Awakened by notify() or notifyAll()
SLEEP():
- Called on thread
- Does not release lock
- Pauses execution for specified time
- After time, automatically resumes

Q: What is the volatile keyword?

A: Volatile keyword ensures that variable is read from and written to main memory.
Prevents compiler optimization that might cache variable value.
Ensures visibility of changes across threads.
Not a substitute for synchronization - doesn't provide atomicity.
Used for flags and status variables
8. DESIGN PATTERNS
Q: What is Singleton Pattern?
A: Ensures class has only one instance and provides global point of access.
Implementation:
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if(instance == null) {
instance = new Singleton();
}
return instance;
}
}
Thread-safe version uses synchronized or eager initialization

Q: What is Factory Pattern?

A: Creates objects without specifying exact classes.
Provides abstraction from object creation process.
Benefits: Flexibility, maintainability, loose coupling
Example:
public class AnimalFactory {
public static Animal getAnimal(String type) {
if('dog'.equals(type)) return new Dog();
else if('cat'.equals(type)) return new Cat();
return null;
}
}

Q: What is Builder Pattern?

A: Constructs complex objects step by step.
Separates object construction from its representation.
Benefits: Cleaner code, flexible object construction
Example: StringBuilder, SQL query builders
When to use: Many constructor parameters, optional fields

Q: What is Observer Pattern?

A: Defines one-to-many dependency between objects.
When subject changes, all observers are notified automatically.
Example: Event handling, MVC architecture
Benefits: Loose coupling, event-driven architecture

Q: What is Decorator Pattern?

A: Adds new functionality to objects dynamically without modifying their structure.
Provides flexible alternative to subclassing.
Example: Java I/O classes (BufferedInputStream), GUI components
Benefits: Single Responsibility Principle, Open-Closed Principle

9. JDBC & DATABASE

Q: What is JDBC? What are its main components?
A: JDBC (Java Database Connectivity) is API for database connectivity and SQL execution.
Main Components:
1. DriverManager - Manages database drivers
2. Connection - Connection to database
3. Statement - Execute SQL queries
4. PreparedStatement - Pre-compiled SQL statement
5. ResultSet - Contains results of query execution
6. SQLException - Exception handling

Q: Explain JDBC connection process

A: 1. LOAD DRIVER:
[Link]('[Link]');
2. CREATE CONNECTION:
Connection conn = [Link](url, user, password);
3. CREATE STATEMENT:
Statement stmt = [Link]();
4. EXECUTE QUERY:
ResultSet rs = [Link]('SELECT * FROM table');
5. PROCESS RESULT:
while([Link]()) { }
6. CLOSE RESOURCES:
[Link](); [Link](); [Link]();

Q: What is PreparedStatement? Why is it preferred over Statement?

A: PreparedStatement - Pre-compiled SQL statement with placeholders (?)
Benefits:
1. Better performance - Compiled once, executed multiple times
2. SQL Injection protection - Parameters handled safely
3. Readability - Cleaner code with parameters
Example:
PreparedStatement pstmt = [Link]('SELECT * FROM user WHERE id=?');
[Link](1, 5);
ResultSet rs = [Link]();

Q: What are ACID properties in database?

A: A - ATOMICITY - Transaction succeeds completely or fails completely
C - CONSISTENCY - Database remains in consistent state
I - ISOLATION - Concurrent transactions don't interfere
D - DURABILITY - Committed data persists despite failures
Important for data integrity and reliability

10. BEHAVIORAL & TECHNICAL INTERVIEW QUESTIONS

Q: Tell me about yourself
A: Structure your answer:
1. Introduction - Name, background
2. Education - Degree, field of study
3. Technical Skills - Languages, frameworks, tools
4. Experience - Projects, internships, relevant work
5. Why IT - Interest in software development
6. Future Goals - Career aspirations
Keep it to 2-3 minutes, be concise and relevant

Q: Why do you want to join our company?

A: Before interview: Research company, their projects, culture
Answer should include:
1. Company's achievements and values align with yours
2. Career growth opportunities
3. Technical challenges that excite you
4. Company culture and team environment
Avoid generic answers, be specific and genuine

Q: What are your strengths and weaknesses?

A: STRENGTHS - Highlight relevant skills:
- Quick learner, problem-solving, teamwork, attention to detail
- Mention specific example/project
WEAKNESSES - Choose real but solvable weakness:
- Perfectionism (working on it with time management)
- Delegation (improving through leadership training)
NOT: 'I have no weaknesses' or irrelevant weaknesses
Always follow with how you're improving

Q: Describe a challenging project you worked on

A: Use STAR method (Situation, Task, Action, Result):
SITUATION - Project context and challenge
TASK - Your specific responsibility
ACTION - Steps you took to solve problem
RESULT - Outcomes and what you learned
Example: Mention technical solution, teamwork, problem-solving
Highlight learning and growth

Q: How do you handle disagreement with team members?

A: Show maturity and communication skills:
1. Listen to understand their perspective
2. Present your viewpoint respectfully
3. Focus on solution, not ego
4. Escalate to manager if needed
5. Work together for best outcome
Avoid: Aggression, dismissiveness, stubbornness

Q: What are your career goals?

A: Short-term (1-2 years):
- Master core technologies, contribute effectively to projects
- Learn company's codebase and best practices
Medium-term (3-5 years):
- Senior developer, lead projects, mentor juniors
- Specialize in specific technology
Long-term (5+ years):
- Technical lead, architect, or team lead role
Show ambition but realistic expectations

Q: What is your approach to learning new technology?

A: Demonstrate learning ability:
1. Learn fundamentals from online courses, documentation
2. Build small projects to practice
3. Read others' code on GitHub
4. Participate in communities, forums
5. Apply knowledge to real problems
Mention specific technologies you learned this way

Q: How do you handle tight deadlines?

A: Show time management and prioritization:
1. Break work into smaller tasks
2. Prioritize by importance and deadline
3. Communicate realistic timelines to team
4. Focus on core functionality first
5. Ask for help when needed
Give example of meeting deadline under pressure

Q: What is your approach to code quality and testing?

A: Show understanding of software quality:
1. Write clean, readable, well-documented code
2. Follow coding standards and conventions
3. Unit testing for critical functionality
4. Code review participation
5. Refactoring to improve maintainability
Testing ensures reliability and reduces bugs

Q: Tell me about a time you failed. What did you learn?

A: Honest answer shows maturity:
1. Describe specific situation and mistake
2. Take responsibility, don't blame others
3. Explain what went wrong and why
4. What you learned from experience
5. How you applied learnings to prevent recurrence
Avoid: Making excuses, blaming, not learning

Q: Do you have any questions for us?

A: Always ask thoughtful questions:
1. What are current projects the team is working on?
2. What's the tech stack and how often is it updated?
3. How do you approach code reviews and mentorship?
4. What does a typical day look like for this role?
5. What are growth opportunities in first year?
Avoid: Salary, vacation, already covered topics

QUICK REFERENCE - JAVA CODE EXAMPLES

Object Creation
ClassName obj = new ClassName();

Method Overloading
public void add(int a, int b)
public void add(double a, double b)

Constructor
public ClassName() { } // Default
public ClassName(String name) { } // Parameterized

Abstract Class
abstract class Animal { abstract void sound(); }

Interface
interface Drawable { void draw(); }

try-catch-finally
try { } catch(Exception e) { } finally { }

Thread Creation
new Thread(() -> { [Link]('Running'); }).start();

Lambda Expression
[Link](item -> [Link](item));

Stream API
[Link]().filter(x -> x > 5).map(x -> x*2).collect([Link]());

HashMap
HashMap<String, Integer> map = new HashMap<>();
[Link]('key', value); value = [Link]('key');

INTERVIEW TIPS & BEST PRACTICES

Before Interview
• Research the company - Projects, tech stack, culture
• Review core Java concepts and OOP principles
• Prepare practical examples for each concept
 • Practice coding on whiteboard or online platforms
• Get good sleep night before interview

During Interview
• Listen carefully to questions before answering
• Think before speaking - pause if unsure
• Give examples and real-world scenarios
• Explain your approach before diving into code
• Be honest if you don't know something
• Maintain eye contact and positive body language

Common Mistakes to Avoid

• Not understanding the question - Ask for clarification
• Generic answers - Be specific with examples
• Rushing through code - Write clean, readable code
• Negative talk about previous employer/job
• Not asking questions - Shows interest and curiosity

FINAL WORDS FOR SUCCESS

Preparation is key to success in interviews. Master the fundamental OOP concepts and Java
basics, then practice coding problems regularly. Understanding the 'why' behind concepts is
more important than just memorizing facts.
Remember, interviewers not only assess technical knowledge but also your problem-solving
approach, communication skills, and attitude. Be confident but humble, showing willingness to
learn and grow.
Practice these concepts through coding projects, contribute to open-source, and keep learning
new technologies. The journey from fresher to experienced developer requires consistent effort
and dedication.
Good luck with your interviews! You've got this! 🚀