Module 7: Other Important OOP Concepts

The static keyword defines fields and methods that belong to the Class itself rather than to any specific instance. Exactly one copy of a static variable exists in memory (stored in the Metaspace/Class data area), regardless of how many instances are instantiated.

Static methods can be invoked directly on the class name (e.g., Math.sqrt(16)) without creating an instance. Crucially, static methods cannot access instance variables or invoke non-static methods without an explicit object reference because they possess no implicit this pointer.

In OOP, errors and unexpected conditions are modeled as first-class Exception Objects (subclasses of Throwable / Exception) instantiated at the point of failure and propagated up the active call stack.

• try block: Wraps risky code that might throw an abnormal condition.
• catch block: Intercepts specific exception object types and executes recovery logic.
• finally block: Guaranteed cleanup execution (closing DB sockets, file streams, releasing mutexes) regardless of whether an exception was raised.
• throw: Explicitly instantiates and triggers an exception object.

Generics (Java/C#) and Templates (C++) enable classes, interfaces, and methods to operate on parameterized types. They provide compile-time type safety while eliminating redundant boilerplate code.

Instead of writing separate classes like IntStack, StringStack, and ObjectStack, a developer writes a single generic Stack<T>. The compiler ensures that inserting an invalid type triggers a compile error, completely avoiding unsafe runtime type casts.

Coined by Robert C. Martin ("Uncle Bob"), the SOLID Principles are five fundamental architectural rules for designing clean, maintainable, and agile object-oriented software: