Java Interview Q&A

Contributor:

Erica Madebeykin, MBA
🇬🇧MBA Merit
🇬🇧MSc Comp Sci student

Creation Date:
12th of August, 2026

---

Mind Mapping Flow

1. Define OOP
2. Classes, Modifiers and Constructors
3. The 4 Pillars of OOP Programming : *Encapsulation *Inheritance *Polymorphism *Abstraction
4. Encapsulation
5. Inheritance
6. Polymorphism
7. Abstraction
8. Exception Handling
9. IO Operations

Java OOP Interview Q & A

• Q1: Keyword Definitions
• Q2: Four Pillars of Object Oriented Programming
• 2.1 Q: What is Encapsulation
  • Key Concepts
  • Example
  • Q: Why use getters and setters?
  • Common Pitfall
• 2.2 What is Inheritance?
  • Example
  • Key Concepts
  • Q: When should you use inheritance?
  • Common Pitfall
• 2.3 What is Polymorphism?
  • Two Common Types
• What is Method Overloading?
  • Important
• What is Method Overriding?
  • Overloading vs Overriding
  • Easy Way to Remember
• 2.4 What is Abstraction?
  • Example
• Abstract Class vs Interface
  • Example: Abstract Class
  • Example: Interface
• Abstract Class vs Concrete Class
  • Where Do the Common Concepts Belong?
  • Common Interview Pitfalls
• Q3: Exceptions
  • 3.1 What is an Exception?
  • 3.2 Exception Hierarchy
  • 3.3 Checked vs Unchecked Exceptions
  • 3.4 try, catch, and finally
  • 3.5 throw vs throws
  • 3.6 Exception Propagation
  • 3.7 Multiple catch Blocks
  • 3.8 Try-with-Resources
  • 3.9 Custom Exceptions
  • 3.10 Common Exception Keywords
  • 3.11 Common Interview Comparisons
  • 3.12 final vs finally vs finalize()
  • 3.13 Common Interview Pitfalls
  • ⭐ 30-Second Interview Answer
• Q4: I/O Operations
  • 4.1 What is I/O?
  • 4.2 Input vs Output
  • Easy Memory Trick
  • 4.3 Byte Streams vs Character Streams
  • Byte Streams
  • Character Streams
  • Interview Answer
  • 4.4 InputStream vs Reader
  • 4.5 What is a Stream?
  • 4.6 Buffered I/O
  • Example
  • Why use buffering?
  • Interview Answer
  • 4.7 File vs Path
  • Example with File
  • Modern approach with Path
  • 4.8 Path and Files
  • 4.9 Reading and Writing Files
  • 4.10 IOException
  • 4.11 Try-with-Resources and I/O
  • Important
  • 4.12 File vs Stream
  • Easy Memory Trick
  • 4.13 Common I/O Classes
  • 4.14 Common Interview Comparisons
  • 4.15 Common Interview Pitfalls
  • ⭐ 30-Second Interview Answer
• Bonus: What is Software Development Life Cycle?

Q1: Keyword Definitions

Important Keyword definitions

Keyword / Construct	Meaning
class	Defines a class, a blueprint/template that defines properties and behavior
object	Instance of a class, actual thing created from the blueprint
interface	Defines an interface
extends	Inherits a class
implements	Implements an interface
this	Current object
super	Parent class
static	Belongs to class
final	Prevents further change/inheritance/overriding
finally	Executes after try/catch
finalize()	Legacy garbage collection cleanup method; deprecated
abstract	Defines incomplete abstraction
private	Class-level access
protected	Package + subclass access
public	Broad access
new	Creates an object
void	Indicates a method returns no value
main	Entry point of a Java application
if	Conditional execution
else	Alternative conditional branch
switch	Selects between multiple cases
break	Exits a loop or switch
continue	Skips to the next loop iteration
throw	Throws an exception
throws	Declares exceptions
try	Starts exception-handling/resource block
try-with-resources	Automatically closes resources
instanceof	Checks type relationship

Q2: Four Pillars of Object Oriented Programming

The four pillars of OOP are:

1. Encapsulation – controls access to an object's internal state.
2. Inheritance – allows a class to inherit and extend another class.
3. Polymorphism – allows the same interface/method call to have different behavior.
4. Abstraction – hides implementation details and exposes essential behavior.

Pillar	Core Idea	Common Keywords / Concepts
Encapsulation	Bundle data + behavior and control access to internal state	private, public, protected, getters, setters
Inheritance	Derive a class from another class	extends, parent/superclass, child/subclass, IS-A
Polymorphism	Same interface/method call, different behavior	Overloading, overriding, compile-time, runtime
Abstraction	Hide implementation details and expose essential behavior	abstract, interface, abstract class, concrete class

---

2.1 Q: What is Encapsulation

Encapsulation is the practice of bundling an object's data and the methods that operate on that data, while controlling direct access to its internal state.

Key Concepts

Concept	Definition
Data / State	Fields or attributes that store an object's information
Behavior	Methods that operate on the object's data
Access Modifiers	Control who can access a class member
private	Accessible only within the class
protected	Accessible within the class and its subclasses/package depending on language
public	Accessible from anywhere allowed by the language
Getter	Method used to read/access a value
Setter	Method used to modify a value
Information Hiding	Hiding internal implementation/state from outside code

Example

class BankAccount {
    private double balance;

    public double getBalance() {
        return balance;
    }

    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
}

Here, balance is private, so outside code cannot directly modify it.

Instead, the class controls how the value is accessed or changed.

Q: Why use getters and setters?

Getters and setters provide controlled access to an object's state and allow validation or business rules to be applied.

Common Pitfall

Encapsulation does NOT simply mean making everything private.

private is a tool used to achieve encapsulation.

The bigger idea is controlling access to and protecting an object's internal state.

---

2.2 What is Inheritance?

Inheritance allows a child/subclass to acquire and extend the properties and behavior of a parent/superclass.

It is commonly used to represent an IS-A relationship.

Example

class Animal {
    void eat() {
        System.out.println("Eating");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Barking");
    }
}

Dog IS-A Animal, so Dog inherits eat() from Animal.

Key Concepts

Concept	Definition
Superclass / Parent	The class being inherited from
Subclass / Child	The class that inherits from the parent
extends	Used for class inheritance in Java
IS-A	Relationship represented by inheritance
Code Reuse	Reusing inherited properties/behavior
Method Overriding	Subclass provides its own implementation of an inherited method

Q: When should you use inheritance?

Use inheritance when there is a genuine IS-A relationship and the child is logically a specialized version of the parent.

Common Pitfall

Don't use inheritance only because two classes share code.

Sometimes composition is a better design.

Inheritance = IS-AComposition = HAS-A

Example:

Dog IS-A Animal
Car HAS-A Engine

---

2.3 What is Polymorphism?

Polymorphism means "many forms." It allows the same interface or method call to have different behavior depending on the object or arguments involved.

Two Common Types

Type	Also Called	Determined At	Main Idea
Overloading	Compile-time polymorphism	Compile time	Same method name, different parameters
Overriding	Runtime polymorphism	Runtime	Subclass provides a different implementation

---

What is Method Overloading?

Overloading occurs when multiple methods have the same name but different parameter lists.

class Calculator {
    int add(int a, int b) {
        return a + b;
    }

    double add(double a, double b) {
        return a + b;
    }
}

The compiler determines which add() method to use based on the arguments.

Important

Changing only the return type does not create an overloaded method.

int add(int a, int b)
double add(int a, int b) // NOT valid overloading

---

What is Method Overriding?

Overriding occurs when a subclass provides its own implementation of a method inherited from its parent class.

class Animal {
    void makeSound() {
        System.out.println("Some sound");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Bark");
    }
}

Animal animal = new Dog();
animal.makeSound();

Output:

Bark

Even though the reference type is Animal, the actual object is Dog, so the overridden Dog implementation is executed.

Overloading vs Overriding

	Overloading	Overriding
Purpose	Multiple versions of a method	Replace/extend inherited behavior
Relationship	Usually within the same class	Requires inheritance
Parameters	Must be different	Must match the inherited method
Return type	Cannot differ only by return type	Must be compatible
Binding	Compile time	Runtime
Polymorphism	Compile-time	Runtime

Easy Way to Remember

Overloading = same name, different parameters.Overriding = same method, different implementation.

---

2.4 What is Abstraction?

Abstraction means exposing the essential behavior of an object while hiding unnecessary implementation details.

Think:

What does it do? → Abstraction How does it do it? → Implementation

Example

interface Payment {
    void pay(double amount);
}

The interface tells us that a Payment can pay().

It does not expose how the payment is processed.

class CreditCardPayment implements Payment {

    public void pay(double amount) {
        // Credit card implementation
    }
}

The user of Payment does not need to know the internal implementation.

---

Abstract Class vs Interface

Both are commonly used to achieve abstraction, but they serve different purposes.

	Abstract Class	Interface
Main purpose	Define a common base/abstraction	Define a contract/capability
Abstract methods	Yes	Yes
Concrete methods	Yes	Yes, e.g. default/static methods in Java
Instance state/fields	Yes	No ordinary instance fields
Constructor	Yes	No
Class inheritance	A class can extend only one class	A class can implement multiple interfaces
Keywords	abstract, extends	interface, implements

Example: Abstract Class

abstract class Animal {

    abstract void makeSound();

    void eat() {
        System.out.println("Eating");
    }
}

The abstract class provides some common behavior but leaves makeSound() for subclasses to implement.

Example: Interface

interface Flyable {
    void fly();
}

class Bird implements Flyable {

    public void fly() {
        System.out.println("Flying");
    }
}

The interface defines a contract: any class implementing Flyable must provide fly().

---

Abstract Class vs Concrete Class

	Abstract Class	Concrete Class
Can be instantiated?	No	Yes
Can contain abstract methods?	Yes	No
Can contain implemented methods?	Yes	Yes
Main purpose	Provide a base/template for subclasses	Provide a complete implementation

Easy Way to Remember

Abstract = incomplete / cannot be directly instantiatedConcrete = complete / can be instantiated

---

Where Do the Common Concepts Belong?

This is the easiest way to organize everything for an interview:

OOP
│
├── 1. Encapsulation
│   ├── Data + methods
│   ├── Access control
│   ├── private / protected / public
│   ├── Getters / setters
│   └── Information hiding
│
├── 2. Inheritance
│   ├── Parent / child
│   ├── extends
│   ├── IS-A relationship
│   ├── Code reuse
│   └── Method overriding
│
├── 3. Polymorphism
│   ├── Overloading
│   │   └── Compile-time
│   │
│   └── Overriding
│       └── Runtime
│
└── 4. Abstraction
    ├── Hide implementation details
    ├── Abstract class
    ├── Concrete class
    └── Interface

---

Common Interview Pitfalls

Topic	Key Point
Encapsulation	Encapsulation is about controlling access to internal state, not simply making fields private.
Getters/Setters	Getters and setters are mechanisms for controlled access to an object's state.
Inheritance	Inheritance represents an IS-A relationship; code reuse is a benefit, not the only purpose.
Polymorphism	Polymorphism allows the same interface/method call to have different behavior.
Overloading	Same method name + different parameter list. Changing only the return type is not enough.
Overriding	A subclass provides its own implementation of an inherited method.
Abstraction	Abstraction is about hiding implementation details and exposing essential behavior.
Interface	An interface is primarily a contract/capability. Modern Java interfaces can also contain default and static methods.
Abstract Class	An abstract class can contain both abstract and concrete methods.
Concrete Class	A concrete class is not abstract and can be instantiated.
Inheritance vs Composition	Inheritance = IS-A; Composition = HAS-A.

---

⭐ 30-Second Interview Answer

The four pillars of OOP are Encapsulation, Inheritance, Polymorphism, and Abstraction.

Encapsulation bundles data and behavior together and controls access to an object's internal state.

Inheritance allows a child class to inherit and extend behavior from a parent class, representing an IS-A relationship.

Polymorphism allows the same interface or method call to have different behavior, commonly through overloading and overriding.

Abstraction hides implementation details and exposes only the essential behavior, commonly using abstract classes and interfaces.

Q3: Exceptions

3.1 What is an Exception?

An exception is an object representing an abnormal condition that occurs during program execution and can disrupt the normal flow of a program.

Java allows exceptions to be thrown, caught, and propagated.

Example

int result = 10 / 0;

This causes an ArithmeticException.

We can handle it with:

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero");
}

Key Concepts

Concept	Meaning
Throw	An exception is generated/raised during execution
Catch	Handle the exception
Propagate	Pass an unhandled exception up the call stack
Handle	Take appropriate action when an exception occurs
:::

---

3.2 Exception Hierarchy

Throwable
├── Error
│   ├── OutOfMemoryError
│   └── StackOverflowError
│
└── Exception
    ├── RuntimeException
    │   ├── NullPointerException
    │   ├── ArithmeticException
    │   └── IndexOutOfBoundsException
    │
    └── Other checked exceptions
        ├── IOException
        ├── SQLException
        └── ...

Key Concepts

Type	Meaning
Throwable	Root type for things that can be thrown and caught
Exception	Represents conditions that applications may want to handle
RuntimeException	Base class for unchecked exceptions
Error	Represents serious problems that applications generally should not attempt to handle

Important: Throwable is the root of the hierarchy. Both Exception and Error extend Throwable.

---

3.3 Checked vs Unchecked Exceptions

What is the difference between Checked and Unchecked Exceptions?

	Checked Exception	Unchecked Exception
Checked by compiler?	Yes	No
Must be caught or declared?	Yes	No
Parent	Exception (excluding RuntimeException and its subclasses)	RuntimeException
Examples	IOException, SQLException	NullPointerException, IllegalArgumentException

Checked Exception

The compiler requires the exception to be either:

• handled with try-catch, or
• declared with throws.

void readFile() throws IOException {
    // ...
}

Unchecked Exception

The compiler does not require you to catch or declare it.

String name = null;

System.out.println(name.length());

This results in:

NullPointerException

Interview Answer

Checked exceptions are checked by the compiler and must be caught or declared. Unchecked exceptions are RuntimeException and its subclasses, so the compiler does not require them to be caught or declared.

Important Pitfall

Do not define checked exceptions as simply "recoverable" and unchecked exceptions as "programming errors."

The important technical distinction is:

Checked → compiler requires catch-or-declare.Unchecked → compiler does not require catch-or-declare.

---

3.4 try, catch, and finally

Q: How do you handle exceptions?

The basic structure is:

try     → code that may throw an exception
catch   → handles the exception
finally → cleanup code

Example

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Invalid calculation");
} finally {
    System.out.println("Cleanup");
}

Keywords

Keyword	Purpose
try	Contains code that may throw an exception
catch	Handles a matching exception
finally	Used for cleanup code
throw	Explicitly throws an exception
throws	Declares exceptions that a method may throw

About finally

finally normally executes after try/catch, whether or not an exception occurs.

It is not an absolute guarantee. For example, if the JVM terminates before the finally block can execute, it may not run.

For resource cleanup, try-with-resources is generally preferred.

---

3.5 throw vs throws

Q: What is the difference between throw and throws?

	throw	throws
Purpose	Actually throws an exception	Declares exceptions a method may throw
Location	Method body	Method signature
Example	throw new Exception();	method() throws Exception
Think	Action	Declaration
:::

throw

if (age < 18) {
    throw new IllegalArgumentException("Age must be 18 or older");
}

You're explicitly throwing an exception.

throws

void readFile() throws IOException {
    // ...
}

You're declaring that the method may throw an IOException.

Easy Memory Trick

throw = actually throwthrows = declare

---

3.6 Exception Propagation

Q: What happens if an exception is not handled?

If an exception is not caught in the current method, it propagates up the call stack until a matching catch block is found.

main()
  ↓
methodA()
  ↓
methodB()
  ↓
methodC()
  ↓
Exception occurs
  ↑
  │ propagates
  │
matching catch

Example

void methodC() {
    int x = 10 / 0;
}

void methodB() {
    methodC();
}

void methodA() {
    methodB();
}

If methodC() doesn't catch the exception, it can propagate through methodB() and methodA().

If it reaches the top of the thread's call stack without being caught, the thread terminates and the exception is reported.

Interview Answer

Exception propagation means an uncaught exception moves up the call stack until a matching handler is found or the exception reaches the top of the thread's stack.

---

3.7 Multiple catch Blocks

Q: Can we have multiple catch blocks?

Yes.

try {
    // code
} catch (ArithmeticException e) {
    // handle arithmetic exception
} catch (NullPointerException e) {
    // handle null pointer exception
} catch (Exception e) {
    // handle other exceptions
}

Important Rule

More specific exceptions must come before more general exceptions.

Correct:

catch (ArithmeticException e) {

} catch (Exception e) {

}

Incorrect:

catch (Exception e) {

} catch (ArithmeticException e) {

}

The second catch is unreachable because Exception already catches ArithmeticException.

---

3.8 Try-with-Resources

Q: What is try-with-resources?

Try-with-resources automatically closes resources that implement AutoCloseable when the try block finishes.

Example

try (FileReader reader = new FileReader("file.txt")) {
    // use reader
} catch (IOException e) {
    // handle exception
}

The reader is automatically closed.

Why use it?

• Automatically closes resources
• Reduces cleanup code
• Helps prevent resource leaks
• Makes resource management safer and cleaner

Common examples:

• FileReader
• InputStream
• Database resources
• Network resources

Important Detail

If multiple resources are declared:

try (
    ResourceA a = ...;
    ResourceB b = ...
) {
    // ...
}

They are closed in reverse order of declaration:

ResourceB → ResourceA

---

3.9 Custom Exceptions

Q: Can we create our own exceptions?

Yes.

Custom exceptions allow us to represent application-specific exceptional conditions.

Checked Custom Exception

class InsufficientBalanceException extends Exception {

    public InsufficientBalanceException(String message) {
        super(message);
    }
}

Unchecked Custom Exception

class InvalidAmountException extends RuntimeException {

    public InvalidAmountException(String message) {
        super(message);
    }
}

Difference

extends Exception
    → Checked exception

extends RuntimeException
    → Unchecked exception

---

3.10 Common Exception Keywords

Keyword	Meaning
try	Defines code that may throw an exception
catch	Handles a matching exception
finally	Defines cleanup code that normally executes afterward
throw	Explicitly throws an exception
throws	Declares exceptions a method may throw

---

3.11 Common Interview Comparisons

Checked vs Unchecked

	Checked	Unchecked
Compiler checks it?	Yes	No
Must catch or declare?	Yes	No
Base type	Exception	RuntimeException
Example	IOException	NullPointerException
Main distinction	Compile-time requirement	No compile-time requirement

throw vs throws

	throw	throws
Purpose	Actually throws an exception	Declares possible exceptions
Location	Method body	Method signature
Example	throw new Exception();	method() throws Exception
Remember	Action	Declaration
:::

Exception vs Error

	Exception	Error
Parent	Throwable	Throwable
Meaning	Conditions applications may handle	Serious problems applications generally should not handle
Examples	IOException, RuntimeException	OutOfMemoryError, StackOverflowError
Typical handling	May be caught/handled	Generally not caught for recovery

---

3.12 final vs finally vs finalize()

	Meaning
final	Modifier used to restrict reassignment, overriding, or inheritance
finally	Block associated with try/catch, typically used for cleanup
finalize()	Deprecated object-finalization mechanism that should not be used

Easy Memory Trick

final = modifierfinally = cleanup blockfinalize() = deprecated old finalization mechanism

---

3.13 Common Interview Pitfalls

Topic	Key Point
Exception vs Error	Both extend Throwable, but Error represents serious problems that applications generally should not attempt to handle.
Throwable	The root type of Java's throwable hierarchy.
Checked Exception	Must be caught or declared.
Unchecked Exception	RuntimeException and its subclasses; no compiler requirement to catch or declare.
throw vs throws	throw actually throws; throws declares.
finally	Normally executes after try/catch, but is not an absolute guarantee.
Multiple catch	More specific exceptions must come before more general ones.
Exception propagation	An uncaught exception moves up the call stack until handled or it reaches the top of the thread's stack.
Try-with-resources	Automatically closes AutoCloseable resources. Multiple resources close in reverse declaration order.
Custom exceptions	Extend Exception for checked exceptions or RuntimeException for unchecked exceptions.
Catching Exception everywhere	Can hide the actual problem; catch specific exceptions when appropriate.
Empty catch blocks	Can silently swallow failures and make debugging difficult.

---

⭐ 30-Second Interview Answer

An exception is an object representing an abnormal condition during program execution that can disrupt the normal flow of a program.

In Java, exceptions are part of the Throwable hierarchy, which contains Exception and Error. Exceptions can be checked or unchecked. Checked exceptions are verified by the compiler and must be caught or declared, while unchecked exceptions extend RuntimeException and don't have that requirement.

We use try and catch to handle exceptions, finally for cleanup, throw to explicitly throw an exception, and throws to declare exceptions a method may throw.

If an exception isn't handled, it propagates up the call stack. Java also provides try-with-resources to automatically close resources.

Q4: I/O Operations

4.1 What is I/O?

Q: What is I/O?

I/O (Input/Output) refers to reading data from a source and writing data to a destination.

• Input → data coming into the program
• Output → data going out of the program

Examples:

Input:
Keyboard
File
Network
Database

Output:
Console
File
Network
Database

In Java, I/O is primarily handled through the java.io package, while modern file operations are commonly handled through java.nio.file.

Key Concepts

Concept	Meaning
Input	Data coming into the program
Output	Data going out of the program
Read	Obtain data from a source
Write	Send data to a destination

---

4.2 Input vs Output

	Input	Output
Direction	Source → Program	Program → Destination
Purpose	Read data	Write data
Common classes	InputStream, Reader	OutputStream, Writer
Example	Read from a file	Write to a file

Easy Memory Trick

Input = readOutput = write

---

4.3 Byte Streams vs Character Streams

Q: What is the difference between Byte Streams and Character Streams?

	Byte Stream	Character Stream
Handles	Raw binary data	Text/character data
Main classes	InputStream, OutputStream	Reader, Writer
Unit	Bytes	Characters
Best for	Images, audio, PDFs, binary files	Text files
Examples	FileInputStream, FileOutputStream	FileReader, FileWriter

Byte Streams

Used for binary data.

try (InputStream input = new FileInputStream("image.jpg")) {
    int data;

    while ((data = input.read()) != -1) {
        // process byte
    }
} catch (IOException e) {
    e.printStackTrace();
}

Character Streams

Used for text data.

try (Reader reader = new FileReader("file.txt")) {
    int data;

    while ((data = reader.read()) != -1) {
        // process character
    }
} catch (IOException e) {
    e.printStackTrace();
}

Interview Answer

Byte streams handle raw binary data, while character streams are designed for text data. Byte streams use InputStream and OutputStream, while character streams use Reader and Writer.

---

4.4 InputStream vs Reader

Q: What is the difference between InputStream and Reader?

	InputStream	Reader
Type of data	Bytes	Characters
Used for	Binary data	Text data
Common subclass	FileInputStream	FileReader
Parent abstraction	Byte stream	Character stream

Similarly:

InputStream  → reading bytes
OutputStream → writing bytes

Reader       → reading characters
Writer       → writing characters

---

4.5 What is a Stream?

Q: What is a stream in Java I/O?

A stream represents a flow of data between a source and a destination.

For example:

File
  ↓
InputStream
  ↓
Java Program

or:

Java Program
  ↓
OutputStream
  ↓
File

A stream is not necessarily a file. Streams can work with:

• Files
• Memory
• Network connections
• Other streams

---

4.6 Buffered I/O

Q: What is buffering and why is it used?

Buffering temporarily stores data in memory so that I/O operations can be performed more efficiently.

Instead of performing an expensive I/O operation for every small piece of data, a buffer allows data to be processed in larger chunks.

Common classes:

BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWriter

Example

try (BufferedReader reader =
         new BufferedReader(new FileReader("file.txt"))) {

    String line;

    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }

} catch (IOException e) {
    e.printStackTrace();
}

Why use buffering?

• Reduces the number of direct I/O operations
• Improves performance
• Provides convenient methods such as readLine()

Interview Answer

Buffering improves I/O performance by temporarily storing data in memory and reducing the number of direct I/O operations.

---

4.7 File vs Path

Q: What is the difference between File and Path?

	File	Path
Package	java.io	java.nio.file
API	Older API	Modern API
Represents	File/directory path	File/directory path
Recommended for new code?	Generally no	Yes
Common operations	exists(), mkdir()	Used with Files

Example with File

File file = new File("data.txt");

if (file.exists()) {
    System.out.println("File exists");
}

Modern approach with Path

Path path = Path.of("data.txt");

if (Files.exists(path)) {
    System.out.println("File exists");
}

For modern Java code, prefer Path and Files for file-system operations.

---

4.8 Path and Files

Q: What are Path and Files used for?

Path represents the location of a file or directory, while Files provides utility methods for performing file-system operations.

Example:

Path path = Path.of("data.txt");

Files.writeString(path, "Hello World");

String content = Files.readString(path);

System.out.println(content);

Common operations:

Method	Purpose
Files.exists()	Checks whether a path exists
Files.createFile()	Creates a file
Files.createDirectory()	Creates a directory
Files.delete()	Deletes a file or directory
Files.readString()	Reads a file as a String
Files.writeString()	Writes a String to a file
Files.copy()	Copies a file
Files.move()	Moves or renames a file

---

4.9 Reading and Writing Files

Q: How can you read a text file in Java?

For modern Java, a simple approach is:

Path path = Path.of("data.txt");

try {
    String content = Files.readString(path);
    System.out.println(content);
} catch (IOException e) {
    e.printStackTrace();
}

For larger files, reading line-by-line can be more appropriate:

try (BufferedReader reader = Files.newBufferedReader(path)) {

    String line;

    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }

} catch (IOException e) {
    e.printStackTrace();
}

Q: How can you write to a text file?

Path path = Path.of("data.txt");

try {
    Files.writeString(path, "Hello World");
} catch (IOException e) {
    e.printStackTrace();
}

---

4.10 IOException

Q: What is IOException?

IOException is a checked exception that indicates an I/O operation has failed or been interrupted.

Examples include problems involving:

• File access
• Reading/writing streams
• Network I/O
• Other I/O operations

Example:

try {
    String content = Files.readString(Path.of("data.txt"));
} catch (IOException e) {
    System.out.println("Could not read file");
}

Because IOException is checked, it must be caught or declared.

void readFile() throws IOException {
    String content = Files.readString(Path.of("data.txt"));
}

---

4.11 Try-with-Resources and I/O

Q: Why is try-with-resources important in I/O?

I/O resources should be closed after use. Try-with-resources automatically closes resources that implement AutoCloseable.

Example:

try (BufferedReader reader =
         new BufferedReader(new FileReader("data.txt"))) {

    String line = reader.readLine();

} catch (IOException e) {
    e.printStackTrace();
}

The reader is automatically closed when the try block finishes.

Important

Do not rely on finally to manually close resources when try-with-resources can be used.

Try-with-resources is safer and reduces the chance of resource leaks.

---

4.12 File vs Stream

Q: What is the difference between a File and a Stream?

	File	Stream
Represents	Stored data/location	Flow of data
Purpose	Represents a file or directory	Reads or writes data
Example	Path, File	InputStream, OutputStream, Reader, Writer
Think	Where the data is	How data moves

Easy Memory Trick

File/Path = whereStream = how data flows

---

4.13 Common I/O Classes

Class	Purpose
InputStream	Base class for byte input
OutputStream	Base class for byte output
Reader	Base class for character input
Writer	Base class for character output
FileInputStream	Reads bytes from a file
FileOutputStream	Writes bytes to a file
FileReader	Reads characters from a file
FileWriter	Writes characters to a file
BufferedReader	Buffered character input
BufferedWriter	Buffered character output
Path	Represents a file-system path
Files	Provides file-system operations

---

4.14 Common Interview Comparisons

Byte Stream vs Character Stream

	Byte Stream	Character Stream
Data	Binary/raw data	Text/characters
Classes	InputStream, OutputStream	Reader, Writer
Best for	Images, audio, PDFs	Text files

File vs Path

	File	Path
API	Older	Modern
Package	java.io	java.nio.file
File operations	Methods on File	Usually through Files
New code	Generally prefer Path	Recommended

InputStream vs Reader

	InputStream	Reader
Reads	Bytes	Characters
Data	Binary/raw	Text
Example	FileInputStream	FileReader

---

4.15 Common Interview Pitfalls

Topic	Key Point
Input vs Output	Input reads data into the program; output writes data from the program.
Byte vs Character streams	Byte streams are for raw/binary data; character streams are for text.
InputStream vs Reader	InputStream reads bytes; Reader reads characters.
OutputStream vs Writer	OutputStream writes bytes; Writer writes characters.
Buffering	Improves I/O performance by reducing direct I/O operations.
File vs Path	File is the older API; Path with Files is generally preferred for modern code.
Path vs Files	Path represents a location; Files performs file-system operations.
IOException	A checked exception commonly associated with I/O failures.
Resource closing	Use try-with-resources for AutoCloseable resources.
Streams	A Java I/O stream is a flow of data, not necessarily a file.
finally for closing resources	Possible, but try-with-resources is generally preferred.
Reading entire files	Convenient methods like readString() are useful for small files; large files may be better processed incrementally.

---

⭐ 30-Second Interview Answer

I/O stands for Input/Output and refers to reading and writing data between a program and an external source or destination.

In Java, byte streams such as InputStream and OutputStream handle raw or binary data, while character streams such as Reader and Writer handle text.

For file operations, modern Java commonly uses Path and Files from java.nio.file. I/O operations can throw checked exceptions such as IOException, which must be caught or declared.

For resources such as files and streams, try-with-resources should generally be used because it automatically closes the resources and helps prevent resource leaks.

Bonus: What is Software Development Life Cycle?

SDLC Table from HWU

Phase	Main Purpose	Key Activities	Relevant Roles	Java/OOP Connection
1. Planning	Define what needs to be built and why.	Set objectives, scope, budget, feasibility, and timeline.	Project Manager, Business Analyst	Understand project goals before designing classes and features.
2. Requirements Analysis	Identify what the system must do.	Gather functional and non-functional requirements; create the SRS.	Requirements Analyst, System Analyst	Convert requirements into use cases and system behavior.
3. Design	Create the technical blueprint.	Design architecture, modules, databases, interfaces, and data flow.	Software Architect, UI/UX Designer, Database Designer	Apply encapsulation, inheritance, abstraction, polymorphism, interfaces, and design patterns.
4. Development	Implement the software using code.	Write Java code, create classes and methods, perform unit testing, and integrate modules.	Java Developer, Backend Developer, Frontend Developer	Build reusable, maintainable, and loosely coupled object-oriented components.
5. Testing	Verify quality and find defects.	Perform functional, integration, system, performance, security, and regression testing.	QA Engineer, Automation Tester, Performance Tester	Use JUnit/TestNG to test classes, methods, and object behavior.
6. Deployment	Release the application to users.	Deploy to production, monitor the release, and provide documentation or training.	DevOps Engineer, System Administrator, IT Support	Package and deploy Java applications using tools such as Maven, Docker, or CI/CD pipelines.
7. Maintenance	Keep the software reliable and up to date.	Fix bugs, apply updates, improve performance, and adapt to new requirements.	Support Engineer, Maintenance Engineer, System Analyst	Refactor code, fix defects, improve scalability, and maintain backward compatibility.

Interview Flow

Planning → Requirements → Design → Development → Testing → Deployment → Maintenance

Short interview answer: “SDLC is the Software Development Life Cycle. It consists of seven phases: planning, requirements analysis, design, development, testing, deployment, and maintenance. In Java OOP projects, object-oriented principles are mainly applied during the design and development phases to create reusable, maintainable, and scalable software.”