Object Oriented Programming (OOPs) in Perl

Object-oriented programming: As the name suggests, Object-Oriented Programming or OOPs refers to languages that uses objects in programming. Object-oriented programming aims to implement real-world entities like inheritance, hiding, polymorphism, etc in programming. The main aim of OOP is to bind together the data and the functions that operate on them so that no other part of the code can access this data except that function. OOPs Concepts:

• Class
• Object
• Method
• Polymorphism
• Inheritance
• Encapsulation
• Abstraction

Let us learn about the different characteristics of an Object Oriented Programming language:

1. Class: A class is a user defined blueprint or prototype from which objects are created.  It represents the set of properties or methods that are common to all objects of one type. In general, class declarations can include these components, in order:
   1. Class name: The name should begin with a initial letter (capitalized by convention).
   2. Superclass(if any): The name of the class's parent (superclass), if any, preceded by the keyword 'use'.
   3. Constructors(if any):Constructors in Perl subroutines returns an object which is an instance of the class. In Perl, the convention is to name the constructor “new”.
   4. Body: The class body surrounded by braces, { }.
2. Object: It is a basic unit of Object Oriented Programming and represents the real life entities.  A typical Perl program creates many objects, which as you know, interact by invoking methods. An object consists of :
   1. State : It is represented by attributes of an object. It also reflects the properties of an object.
   2. Behavior : It is represented by methods of an object. It also reflects the response of an object with other objects.
   3. Identity : It gives a unique name to an object and enables one object to interact with other objects.
3. Method: A method is a collection of statements that perform some specific task and return result to the caller. A method can perform some specific task without returning anything. Methods are time savers and help us to reuse the code without retyping the code.
4. Polymorphism: Polymorphism refers to the ability of OOPs programming languages to differentiate between entities with the same name efficiently. This is done by Perl with the help of the signature and declaration of these entities. Polymorphism in Perl are mainly of 2 types:
   • Overloading in Perl
   • Overriding in Perl
5. Inheritance: Inheritance is an important pillar of OOP(Object Oriented Programming). It is the mechanism in perl by which one class is allowed to inherit the features(fields and methods) of another class. Important terminology:
   • Super Class: The class whose features are inherited is known as superclass(or a base class or a parent class).
   • Sub Class: The class that inherits the other class is known as subclass(or a derived class, extended class, or child class). The subclass can add its own fields and methods in addition to the superclass fields and methods.
   • Reusability: Inheritance supports the concept of "reusability", i.e. when we want to create a new class and there is already a class that includes some of the code that we want, we can derive our new class from the existing class. By doing this, we are reusing the fields and methods of the existing class.
6. Encapsulation: Encapsulation is defined as the wrapping up of data under a single unit. It is the mechanism that binds together code and the data it manipulates. Another way to think about encapsulation is, it is a protective shield that prevents the data from being accessed by the code outside this shield.
   • Technically in encapsulation, the variables or data of a class is hidden from any other class and can be accessed only through any member function of own class in which they are declared.
   • As in encapsulation, the data in a class is hidden from other classes, so it is also known as data-hiding.
   • Encapsulation can be achieved by: Declaring all the variables in the class as private and writing public methods in the class to set and get the values of variables.
7. Abstraction: Data Abstraction is the property by virtue of which only the essential details are displayed to the user. The trivial or the non-essentials units are not displayed to the user. Ex: A car is viewed as a car rather than its individual components. Data Abstraction may also be defined as the process of identifying only the required characteristics of an object ignoring the irrelevant details. The properties and behaviors of an object differentiate it from other objects of similar type and also help in classifying/grouping the objects. Consider a real-life example of a man driving a car. The man only knows that pressing the accelerators will increase the speed of car or applying brakes will stop the car but he does not know about how on pressing the accelerator the speed is actually increasing, he does not know about the inner mechanism of the car or the implementation of accelerator, brakes, etc in the car. This is what abstraction is.

here's an example of a simple Perl class and object:

# Define a class named Person
package Person;

sub new {
    my $class = shift;
    my $self = {
        _firstName => shift,
        _lastName  => shift,
        _ssn       => shift,
    };
    # Bless the reference as an object of the class
    bless $self, $class;
    return $self;
}

sub getFirstName {
    my ($self) = @_;
    return $self->{_firstName};
}

sub setFirstName {
    my ($self, $firstName) = @_;
    $self->{_firstName} = $firstName if defined($firstName);
    return $self->{_firstName};
}

1;  # End of package declaration, required in Perl

# Create a new Person object
my $person = Person->new("John", "Doe", "123-45-6789");

# Call the getFirstName method to get the first name of the person
my $firstName = $person->getFirstName();
print "First name: $firstName\n";

# Call the setFirstName method to change the person's first name
$person->setFirstName("Jane");
$firstName = $person->getFirstName();
print "New first name: $firstName\n";

First name: John
New first name: Jane

This program creates a new Person object with the properties firstName (set to "John"), lastName (set to "Doe"), and ssn (set to "123-45-6789"). It then calls the getFirstName() method to get the person's first name and prints it to the console.

Next, it calls the setFirstName() method to change the person's first name to "Jane". It then calls getFirstName() again to get the person's new first name and prints it to the console.

Here are some benefits of using Object-Oriented Programming (OOP) in Perl:

1. Code reusability: OOP allows you to define reusable classes that can be used in multiple parts of your program. This reduces the amount of code you need to write and makes your program more modular and maintainable.
2. Encapsulation: OOP allows you to encapsulate data and behavior within classes, which helps prevent accidental modification of data from outside the class. This also makes it easier to change the implementation details of a class without affecting the rest of the program.
3. Inheritance: Perl supports inheritance, which allows you to define a new class based on an existing class. This is useful when you want to create a new class that has similar behavior to an existing class but with some additional features.
4. Polymorphism: OOP allows you to define methods with the same name in different classes, and the appropriate method will be called based on the object's class. This makes it easier to write generic code that works with different types of objects.
5. Modularization: OOP encourages modular design by allowing you to split your program into smaller, more manageable classes. This makes it easier to understand and maintain large programs.

Overall, OOP in Perl can make your programs more modular, maintainable, and extensible. It provides a powerful set of tools for organizing and structuring your code, and it can help you write cleaner, more elegant programs.