Unit V: Object Oriented Programming and Problem Solving

Procedural Programming Paradigm

In the procedural programming language paradigm, a program is systematically divided into a specific number of subroutines, denoted as n, which operate on and access global data. To minimize and avoid the repetition of code, each individual subroutine is designed to perform a distinct, well-defined task. Subroutines are capable of interacting with one another; a subroutine that requires a service offered by another can simply call it. This paradigm relies on instructions such as ‘jump’, ‘goto’, and ‘call’ to alter the standard sequence of instruction execution. Popular examples of procedural programming languages include FORTRAN and COBOL.

The primary advantage of the procedural paradigm is its utility in writing programs that are simply correct. It is generally considered easier to write programs using this method compared to the older monolithic programming approach. However, there are significant disadvantages: writing these programs can become complex, there is no inherent concept of code reusability, and it demands substantial time and effort. Furthermore, procedural programs are often difficult to maintain. Because global data is shared across the entire program, it is susceptible to being altered mistakenly, leading to potential data integrity issues.

Structured Programming Paradigm

Structured programming, frequently referred to as modular programming, focuses on implementing a logical structure within a program to increase efficiency and ease of understanding. This paradigm is particularly useful for large-scale programs that necessitate a substantial development team where different members work on various parts of the same project. Structured programming utilizes a top-down approach, meaning the overall structure of the program is broken down into smaller, separate modules. This modularization groups related statements together and allows the code to be loaded into memory more efficiently while facilitating reuse in other programs.

In this paradigm, modules are coded and tested individually before being integrated into the overall program structure. This modular nature makes programs easier to write, debug, and comprehend. Advantages include the ability for users to view the "big picture" initially via modules before focusing on specific technical details later. Because each module is specialized for a single task and possesses its own local data, the program is easier to change and document. Furthermore, structured programming allows many programmers to collaborate on a single project simultaneously. The main disadvantage is that the paradigm is not data-centered, focusing instead on functions. Like procedural programming, global data is shared and may be modified unexpectedly, and the emphasis remains heavily on the code rather than the data.

Object-Oriented Programming (OOP) Paradigm

Object-oriented programming (OOP) represents a paradigm shift by treating data as the most critical element in software development. In OOP, all relevant data and tasks are grouped into entities called objects. It is simultaneous task-based and data-based, as operations (methods or functions) are grouped directly with the data they act upon. An object consists of specific data and the functions required to operate on that data. Programs requiring an object's service must access its methods through a specific interface, which dictates how to send messages (requests for operations) to the object.

OOP offers several advantages, specifically its ability to simulate real-world problems effectively since the physical world is comprised of objects. OOP programs are data-centered, and functions are tied directly to data, which is hidden and inaccessible to external functions. This paradigm follows a bottom-up approach and allows for the easy addition of new data and functions. Conversely, the disadvantages include a higher requirement for data protection, potential inability to work with existing systems, larger overall program sizes, and a general lack of suitability for smaller, simpler problems.

Comparative Analysis of Programming Paradigms

There is a fundamental difference between Procedural and Object-Oriented programming approaches. OOP is a problem-solving approach where computation is managed through objects, whereas Procedural programming utilizes a step-by-step list of instructions. In terms of maintenance, OOP makes development and maintenance easier, while Procedural programming becomes difficult to manage as projects grow in length. While OOP simulates real-world entities, Procedural programming focuses on functions and instructions. Security is also a major differentiator; OOP provides data hiding and prevents private data access, making it more secure than Procedural languages, which lack proper data binding. Examples of OOP include C++, Java, .Net, Python, and C#, while Procedural examples include C, Fortran, Pascal, and VB.

Fundamental Features of Object-Oriented Programming

Object-Oriented Programming is defined by several core features that distinguish it from other paradigms:

1. Classes: A class is a user-defined data type that serves as a blueprint or template for a set of similar objects. It describes the structure and behavior of objects, such as a "student" class with attributes like roll_no, name, course, and aggregate. Operations like getdata, setdata, and editdata can be performed on its data.

2. Objects: These are the basic units and run-time entities in an OOP system. Anything with its own properties, such as a flower with a name and fragrance, is an object. An object is a collection of data members and member functions (methods).

3. Methods and Message Passing: Methods are functions associated with a class that define the operations an object executes upon receiving a message. Only these methods can manipulate the object's data. Message passing is the communication between objects where one object asks another to invoke a method, often passing parameters such as $roll_no = 1$.

4. Inheritance: Known as the 'is-a' relation, this allows a new class (subclass or derived class) to be created from an existing class (superclass or parent class). The subclass inherits the attributes and behaviors of the superclass but can also include specialized features. This promotes code reusability. For example, 'undergraduate' and 'postgraduate' classes can inherit from a 'student' class.

5. Polymorphism: This refers to having several different forms, allowing programmers to assign different meanings or usages to a method or operator in different contexts, particularly within class hierarchies.

6. Containership: Also known as composition or the 'has-a' relationship, this is the ability of a class to contain instances of other classes as member data (e.g., a Person class having a Student object as a member).

7. Reusability: This involves developing code that can be used across different programs or within the same program, achieved through inheritance, polymorphism, and containership.

8. Delegation: This allows more than one object to handle a request. An object receives a request and delegates the task to another object (the delegate). This emphasizes that complex objects are made of simpler ones, similar to how the human body consists of a heart, brain, and hands working together.

9. Data Abstraction: This process defines data and functions such that only essential details are revealed while implementation is hidden. It separates the interface (what you see) from the implementation (how it works), such as using a television without knowing its internal electronics.

10. Encapsulation: Also called data hiding, this is the technique of packing data and functions into a single class to hide implementation details. It utilizes access levels to protect data integrity: Public (lowest protection, accessible by any function), Protected (accessible by the class and its subclasses), and Private (highest protection, accessible only within the class).

Classes and Objects in Python

In Python, a class creates a new data type, and an object is an instance of that class. In fact, everything in Python is an object, including integers which are instances of the class int. The type() function can be used to determine an object's type. The syntax for defining a class starts with the class keyword followed by the class name and a colon. Class variables and methods, collectively known as class members, can be defined within. When a class is defined, a new namespace is created for the local scope. To use the class, one must instantiate it, which uses function notation. Once an object is created, the dot operator (.) is used to access its members. For instance, an object of class ABC might access a variable var using obj.var where the value might be $10$.

Data Abstraction and Hiding Through Classes

Data Abstraction and Encapsulation are vital for security. Abstraction focuses on providing only essential details to the outside world. Encapsulation organizes data and methods into a structure that prevents unauthorized access. In Python, encapsulation is managed through three access levels: Public members can be accessed from anywhere using the dot operator. Protected members are intended for use only within the class or its hierarchy. Private variables are defined with a double underscore prefix like __var and are accessible only from within the class where they are declared. This ensures that the internal state of an object is protected from external interference.

Method Definition and the self Argument

Class methods in Python are defined similarly to ordinary functions but must include self as the first argument. The self parameter refers to the specific instance of the object itself. While Python allows users to name this parameter anything, self is the standard convention for readability. When a method is called via an object, Python automatically provides the value for self, so it is not passed explicitly by the programmer. For example, in a student class, a method display(self) would use self.rollno to access that specific object's data.

The Initialization and Destruction of Objects

Python provides a unique method named __init__(), which is the initializer or constructor. This method is automatically executed when a new instance of a class is created and is used to initialize the class variables. It is prefixed and suffixed with double underscores. Conversely, the __del__() method acts as a destructor. It is automatically called when an object goes out of scope or is no longer used, allowing its resources to be returned to the system. While automatic, a programmer can explicitly delete an object using the del keyword to trigger the __del__() method.

Classification of Variables: Class vs Object Variables

Variables within a class are categorized into two types:

1. Class Variables (Static Variables): These are declared within the class but outside any method. Only one copy of a class variable exists, and it is shared across all instances. Any change made to a class variable by one object is reflected in all other objects. They are accessed using the syntax className.class_variable. For example, in a Car class, the number of wheels might be a class variable with a value of $4$ assigned universally.

2. Object Variables (Instance Variables): These are unique to each instance of a class. If there are $N$ objects, there are $N$ separate copies of these variables. Changes to an instance variable in one object do not affect others. These are typically initialized inside the __init__() method.

Access Control and Information Hiding

Private attributes and methods in Python are denoted by a double underscore prefix. These are strictly intended to be accessed only from within the class. However, if external access is absolutely necessary, Python utilizes a name-mangling syntax: objectName._className__privatevariable. Attempting to access a private variable like obj.__var2 directly will result in an error. Private methods function similarly, accessible internally but restricted externally unless specialized syntax is used.

Advanced Method Calling and Class Methods

One class method can call another class method using the self keyword. For example, method2 might contain a call to self.method1(). Additionally, Python supports "Class Methods," which differ from instance methods. Class methods are called by the class itself rather than an instance and use cls as the first argument instead of self. These are marked with the @classmethod decorator and are often used as "factory methods" to instantiate objects using different parameters. A practical example is a Rectangle class with an @classmethod named Square(cls, side) that returns a square instance by passing the same value for both length and breadth, allowing an area calculation such as $10 \times 10 = 100$.