Object-Oriented Programming - 2

Overview of Object-Oriented Programming (OOP)

Object-oriented programming (OOP) is a programming paradigm that revolves around the concept of "objects" which combine data and functionalities. This paradigm emphasizes the use of classes, which are blueprints for creating objects. The core principles of OOP are encapsulated in the 4 Pillars: Encapsulation, Abstraction, Inheritance, and Polymorphism.

Basic Concepts of OOP

• Objects: Real-world entities that have attributes (variables) and behaviors (methods). For example, a car is an object that has properties like color and model.

• Classes: Definitions that create objects. They contain methods and define instance variables that are shared among the created objects.

• Methods: Functions defined within a class that describe the behaviors of an object.

• Pillars of OOP: 1) Encapsulation, 2) Abstraction, 3) Inheritance, 4) Polymorphism. Together, these principles enable code reusability, modularity, and easier maintenance.

Instances and Variables

Classes serve as templates from which objects are created, referred to as instances. For instance, a certain BMW car is an instance of the Car class. Each instance has specific attributes (like color and model) unique to that instance but similar methods applicable to all instances of that class.

Example of Attributes and Methods

The car object can be defined by certain behaviors:

• Methods: Start and Stop.

• Instance Variables: Total number of car instances, estimated at 1.4 billion worldwide.

Inheritance in OOP

Inheritance is a mechanism wherein a new class (subclass) derives properties and behaviors from another class (superclass). This allows for code reuse and the reduction of redundancy. The subclass inherits attributes and methods from the superclass, enabling it to implement or override functionalities as needed.

Example with Pokémon Classes

Using Pokémon as an illustrative example:

• The ElectricPokemon class inherits from the Pokemon class, sharing methods like attack() but specifying its own behavior.

class ElectricPokemon(Pokemon):
    def attack(self, other):
        other.decrease_hp(60)

This shows how subclasses can modify inherited methods to suit specific needs.

Polymorphism in OOP

Polymorphism allows methods to do different things based on the object invoking them. It can be implemented using method overriding. For instance, in the provided example, both the Electric and Water Pokémon classes define their variants of the attack method, demonstrating polymorphism in action.

Abstract Classes and Interfaces

Abstract classes lay the groundwork for other classes. They cannot be instantiated directly and contain abstract methods that classes inheriting from them must implement. Python provides an abc module for defining abstract base classes through decorators such as @abstractmethod.

Key Points about Abstract Classes

1. Cannot be instantiated directly.

2. Subclasses must implement abstract methods.

3. Can contain concrete methods applicable to all subclasses.

4. Facilitate a common interface across subclasses.

5. Share properties similar to regular classes.

Summary & Exercises

Through various lessons, students have been prompted to integrate these concepts into practical exercises involving vehicles, calculating fares, and animal behaviors, encouraging them to apply inheritance, method overrides, and abstract classes. This rigorous engagement is integral to their understanding of OOP and Python programming capabilities.