Unit
- Definition: Object-oriented programming is a paradigm that organizes software design around data, or objects, rather than functions and logic. Each object represents an instance of a class and contains both data (attributes) and methods (behaviors) that operate on that data.
- Historical context: Simula-67 introduced classes and objects, but Smalltalk popularized OOP in the 1970s. By the 1990s, languages like C++, Java, and Python made OOP mainstream for large-scale industrial development.
- Core metaphor: Objects mirror real-world entities. For example, a
BankAccountobject has an attributebalanceand methodsdeposit()andwithdraw(). This alignment reduces the gap between problem domain and code. - Program structure: Instead of a single sequence of instructions, an OOP application consists of interacting objects that send messages to each other. This modularity helps multiple developers work on different objects concurrently.
- Language support: Most modern languages provide built-in syntax for classes, objects, inheritance, and polymorphism. Python uses
class, Java usesclassandinterface, JavaScript uses prototypal inheritance but now supports class syntax. - Benefits over procedural code: OOP reduces code duplication through inheritance, increases data security through encapsulation, and simplifies maintenance by grouping related data and behavior together.
- First program analogy: Writing a simple
Dogclass with attributesnameandageand a methodbark()demonstrates how a single class can create many unique dog objects. - Common misconceptions: OOP is not always the best choice for every problem; small scripts or data-processing pipelines may benefit more from functional or procedural styles. OOP excels when complexity arises from many interacting entities.
- Encapsulation in depth: Encapsulation hides internal state and requires all interaction through an object’s methods. This prevents external code from directly altering sensitive data. For example, a
BankAccountclass can keepbalanceprivate and only exposedeposit()andwithdraw()methods that enforce business rules like overdraft limits. - Inheritance and reuse: Inheritance allows a new class to acquire properties and methods of an existing class, promoting code reuse. A
SavingsAccountclass can inherit fromBankAccountand add a methodapply_interest(). Changes to the parent class automatically propagate to children, reducing maintenance effort. - Polymorphism explained: Polymorphism enables objects of different classes to respond to the same method call in their own way. For instance, a
Dogand aCatclass can each implement amake_sound()method. Code that callsmake_sound()on any animal object works without knowing the specific type. - Abstraction and interface design: Abstraction focuses on what an object does rather than how it does it. Abstract classes and interfaces define a contract that implementing classes must fulfill. For example, a
Shapeinterface might declare aarea()method, whileCircleandRectangleprovide their own calculation logic.
Code Example
Python
class Dog:
def __init__(self, name, age):
self.name = name
self.age = age
def bark(self):
print('Woof! My name is ' + self.name)
my_dog = Dog('Rex', 3)
my_dog.bark()The Dog class defines attributes name and age and a method bark(). The object my_dog is an instance of Dog, and calling bark() uses the object's specific name.
Quick Revision
- OOP organizes code around objects that contain data and behavior.
- Objects are instances of classes; classes act as blueprints.
- Real-world modeling makes code easier to understand and maintain.
- OOP languages provide built-in support for classes, inheritance, and polymorphism.