Master OOP vs Procedural Programming, SOLID Principles, and Java Fundamentals

Overview of Object‑Oriented Programming

Object‑oriented programming (OOP) emphasizes encapsulation, inheritance, and polymorphism, allowing developers to create low‑coupling, flexible systems that are easy to maintain, reuse, and extend.

Procedural vs. Object‑Oriented

Procedural programming offers higher performance because it avoids the overhead of object instantiation, making it suitable for resource‑constrained environments such as embedded systems or low‑level Linux development. Its drawback is poor maintainability, reusability, and extensibility.

Object‑oriented programming provides easier maintenance, reuse, and extension at the cost of lower raw performance.

SOLID Principles (optional)

Single Responsibility Principle (SRP) : a class should have only one reason to change.

Open‑Closed Principle (OCP) : software entities should be open for extension but closed for modification.

Liskov Substitution Principle (LSP) : objects of a superclass should be replaceable with objects of a subclass without affecting correctness.

Dependency Inversion Principle (DIP) : high‑level modules should depend on abstractions, not concrete implementations.

Interface Segregation Principle (ISP) : prefer many client‑specific interfaces over a single general‑purpose one.

Abstract Class vs Interface

Both cannot be instantiated and sit at the top of an inheritance hierarchy, requiring subclasses to implement abstract members. Key differences include declaration keywords ( abstract vs interface), ability to have constructors (only abstract classes), field modifiers, and multiple inheritance support (interfaces can be implemented multiple times, abstract classes can be extended only once).

Variables and Scope

Member variables are defined inside a class but outside any method; they exist as long as the object exists and are stored in heap memory. Local variables are defined inside methods, live only during method execution, and are stored on the stack.

Member variables have default initial values; local variables must be explicitly initialized before use.

Static vs. Instance Members

Static variables belong to the class, are allocated once when the class is loaded, and are shared by all instances. Instance variables belong to each object, each receiving its own copy.

Static methods can be invoked using the class name without creating an object and can only access static members. Instance methods require an object reference and can access both static and instance members.

Method Return Values

A method’s return value is the result produced after its execution, allowing the caller to use that result in further operations.

Parameter Passing in Java

Java uses pass‑by‑value. When an object reference is passed, the value of the reference is copied, so the method can modify the object’s fields but cannot reassign the caller’s reference.

Java Packages

Commonly used packages include java.lang, java.io, java.nio, java.net, java.util, and java.sql. The distinction between java and javax has largely disappeared; both are part of the standard API.

IO Streams

Java I/O streams are categorized by direction (input vs output), by unit (byte vs character), and by role (node vs processing streams). Core abstract classes are InputStream / Reader for input and OutputStream / Writer for output.

BIO, NIO, and AIO

BIO (Blocking I/O) : synchronous, each thread blocks while waiting for I/O; simple but limited scalability.

NIO (Non‑blocking I/O) : introduced in Java 1.4, uses channels, selectors, and buffers to allow a single thread to manage many connections.

AIO (Asynchronous I/O) : Java 7’s NIO2, provides true asynchronous operations based on callbacks and events.

Common java.nio.file.Files Methods

Files.exists()

– check if a path exists. Files.createFile() – create a new file. Files.createDirectory() – create a new directory. Files.delete() – delete a file or directory. Files.copy() – copy a file. Files.move() – move a file. Files.size() – get file size. Files.readAllBytes() – read file contents. Files.write() – write to a file.