Object Oriented Programing

OOP Concepts

• Core components of Object-Oriented Programming (OOP):

  • Encapsulation

  • Abstraction

  • Inheritance

  • Polymorphism

Encapsulation

• Definition: Encapsulation is the idea that data inside an object is protected from the outside.

  • Example: A school may have a rule that once a student is assigned a StudentNumber, it should never be changed.

  • Also known as data hiding, it conceals data inside an object or class from any external code.

• Implementation in Python:

  • Use of hidden attributes stores data within the class.

  • Create public methods to allow external access to the hidden data:

  • A method that retrieves hidden data is termed an accessor, often called with a name that includes get.

  • A method that modifies hidden data is a mutator, often named with set.

  • Syntax for hidden variables:

  • A single underscore (e.g., _attribute) indicates the attribute should not be accessed directly.

  • A double underscore (e.g., __attribute) renames the variable to prevent conflicts with other libraries.

• Example of Accessor and Mutator:

  • Student class has methods to get or set student data.

  • A private attribute __StudentNumber ensures the student number cannot be altered externally, maintaining encapsulation rules.

Abstraction

• Definition: Abstraction allows users to interact with objects at a high level while hiding complex internal workings.

  • Example: The formula for calculating the area for different shapes varies, yet users just need to call the Area() method without worrying about the specifics.

• Implementation in Python using Abstract Base Classes (ABC):

  • Define a class from an ABC and create abstract methods using the keyword pass as placeholders.

• Example Code:

  • To create shapes (e.g., Rectangle and Circle), the shapes would inherit from the base class Shape and implement their own area computation methods.

Inheritance

• Definition: Inheritance allows a new class to acquire properties and methods from an existing class, facilitating code reusability.

  • Example: A parent class Employee can have subclasses such as Hourly and Salaried, inheriting common employee properties while adding their specific attributes.

• Benefits:

  • Reduces code duplication and aids maintainability.

  • Allows extending functionality by adding new methods in subclasses.

• Example:

  • Subclass Hourly can have a method to calculate hourly pay, while Salaried can have methods specific to salary calculations.

Polymorphism

• Definition: Polymorphism is the ability of different classes to respond to methods with the same name but varying implementations, showcasing diverse behaviors for the same method.

  • Example: The method fly() can behave differently in classes Bird and Airplane:

  • Bird: def fly(self): return “Flies in the sky”

  • Airplane: def fly(self): return “Flies with engines”

• Method Overloading: Involves creating methods that perform differently based on the number or type of parameters.

  • In Python, achieve this by testing parameters within a single method.

• Example:

  • def make_it_fly(entity): print(entity.fly()) allows you to input any object that has the fly method, showcasing polymorphism.

Implementing OOP in Python

• Classes:

  • Classes define new types grouping related variables (attributes) and functions (methods).

  • Instantiate classes to create objects with unique properties.

• Instantiation:

  • Operation to create instances from classes, calling the class by parentheses (e.g., my_time = Time()).

• Attributes and Methods:

  • Instance attributes can be unique to each object, while class attributes are shared across instances.

  • Access via dot notation (e.g., object.method()).

• Good Practices:

  • Use initial capitalization for class names (e.g., BankAccount, Employee).

Detailed Examples of Encapsulation, Inheritance, and Polymorphism

• Encapsulation Example (BankAccount):

  • Class implementation ensures the balance cannot be accessed directly, with public methods for deposits and withdrawals.

• Inheritance Example (Animal Classes):

  • Parent class Animal with a method make_sound is inherited by child classes like Dog and Cat, allowing them to define their unique sounds.

• Polymorphism Example (Various Flying Entities):

  • Different flying entities can utilize the same function signature but yield different behaviors, reinforcing polymorphism in design, showing how classes can be interchangeably used in function calls.

Connection and Applications

• The concepts of encapsulation, abstraction, inheritance, and polymorphism contribute to more maintainable, scalable, and understandable code, leading to enhanced software development practices. They mirror real-world relationships and interactions among entities, subsequently relatable to various real applications.

Conclusion

• Object-oriented programming provides a structured approach to programming through high levels of abstraction, encapsulation of data, efficient reuse of code through inheritance, and flexible behavior outcomes through polymorphism, all beneficial for complex system modeling and application development.

OOP Concepts

• Core components of Object-Oriented Programming (OOP):

  • Encapsulation: This fundamental concept involves bundling the data (attributes) and methods (functions) that operate on the data into a single unit known as a class. Data encapsulation restricts direct access to some of an object's components, which means that object data can only be modified via specific methods. This serves to protect the integrity of the object.

    • Example: In a school management system, if a student's StudentNumber is assigned, encapsulation ensures that this number remains unchanged after assignment unless access is granted through specific methods.

    • Also known as data hiding, encapsulation conceals the internal state of the object and restricts unauthorized access, which helps prevent unintended interference.

    • Implementation in Python involves the use of hidden attributes that store data within the class. Public methods are created as interfaces to allow external access to this hidden data, ensuring that any interactions with the object's data are controlled:

      • An accessor method retrieves hidden data, often prefixed with get (e.g., getStudentNumber()).

      • A mutator method modifies hidden data, usually prefixed with set (e.g., setStudentName()).

      • Syntax for hidden variables involves using a single underscore (e.g., _attribute) to signal that the attribute should not be accessed directly, while double underscores (e.g., __attribute) rename the variable to prevent naming conflicts with subclasses or modules.

    • Example of Accessor and Mutator: A Student class might contain methods to get or set student data. A private attribute __StudentNumber would ensure that the student number is immutable from outside the class, reinforcing encapsulation rules.

• Abstraction: This principle allows users to interact with complex systems through simplified interfaces while hiding the intricate details of the system's implementation. It helps reduce programming complexity by enabling the programmer to focus on interacting with the operation of objects rather than their inner workings.

  - **Example**: When calculating the area of different geometric shapes like circles or rectangles, users can simply call the **Area()** method without needing to know the specific formulas used in each shape's calculation, thus abstracting the complexity involved in these computations.
  
  - **Implementation in Python using Abstract Base Classes (ABC)**: By defining a class that inherits from an ABC, developers can create abstract methods that must be implemented by derived classes. Abstract methods are defined using the keyword **pass** as placeholders, ensuring that any subclass adheres to the intended interface while assuring that certain methods exist.
  
  - **Example Code**: In a geometric program, classes such as `Rectangle` and `Circle` could inherit from a base class called **Shape**, each implementing their calculation methods for area, thus simplifying user interaction with these shapes.
  

• Inheritance: A cornerstone of OOP that allows one class (the child class) to inherit attributes and methods from another class (the parent class). This mechanism promotes code reusability, as common functionality can be maintained in a single place.

  - **Example**: A parent class **Employee** might encapsulate common employee properties and behaviors, while subclasses such as **Hourly** and **Salaried** could inherit this information while adding specific attributes like hourly rate or annual salary.
  
  - **Benefits**:
      - Inheritance reduces code duplication and enhances maintainability, as changes only need to be made in the parent class.
      - It allows for extending functionality by adding new methods specific to subclasses without affecting the parent class.
  
  - **Example**: A subclass like **Hourly** could have a method that calculates hourly pay based on hours worked, while the **Salaried** subclass could contain methods tailored to annual salary calculations.
  

• Polymorphism: This allows objects of different classes to respond to the same method call in different ways, emphasizing flexibility in programming. Polymorphism enables a single interface to represent different underlying forms (data types).

  - **Example**: The method **fly()** could have different implementations in **Bird** and **Airplane** classes, where **Bird** might return a string indicating natural flight, while **Airplane** would indicate powered flight with engines:
      - **Bird**: `def fly(self): return “Flies in the sky”`
      - **Airplane**: `def fly(self): return “Flies with engines”`
  
  - **Method Overloading**: This involves defining multiple methods with the same name but different parameters. In programming, it is achieved by checking the type or number of parameters within a single method.
  
  - **Example**: A function named `make_it_fly(entity)` can accept any object that implements the **fly()** method, showcasing polymorphism, where functions can handle different objects seamlessly under a single interface.
  

• Implementing OOP in Python: This involves:

  • Classes: Classes provide a blueprint for creating objects, defining data attributes and functions that operate on this data.

  • Instantiation: This operation creates actual instances (objects) from a defined class using parentheses (e.g., my_time = Time()).

  • Attributes and Methods: Instance-specific attributes can differ per object, whereas class attributes are shared across all instances. Access to these attributes and methods is performed using dot notation (e.g., object.method()).

  • Good Practices: Class names should start with capital letters (e.g., BankAccount, Employee) to ensure clarity and adherence to convention.

• Detailed Examples of Encapsulation, Inheritance, and Polymorphism:

  • Encapsulation Example: In a BankAccount class, the internal balance is private and not directly accessible. Public methods are provided to allow deposits and withdrawals while ensuring that the account balance remains secure.

  • Inheritance Example: A parent class Animal may include basic functionalities (e.g., make_sound), while subclasses like Dog and Cat inherit these methods but implement their unique sounds (e.g., barking vs. meowing).

  • Polymorphism Example: Different flying entities (birds, airplanes, etc.) might implement the same method signature, fly(), yet produce varied behaviors based on their respective implementations. This demonstrates how classes can be interchangeably used in function calls.

• Connection and Applications: The application of encapsulation, abstraction, inheritance, and polymorphism not only promotes efficient coding practices but also enhances maintainability and scalability. These concepts mirror real-world relationships and interactions, contributing to systems that are more aligned with real-life scenarios.

• Conclusion: Object-oriented programming provides a robust framework for development, enabling more organized and modular code through abstraction, protecting data integrity via encapsulation, promoting code reuse through inheritance, and adaptable behavior via polymorphism, thus facilitating the modeling and implementation of complex systems in application development.