Encapsulation in Perl

Encapsulation is one of the core principles of Object-Oriented Programming (OOP). It involves bundling data (attributes) and methods (functions) into a single unit (class) and restricting direct access to some of the object's components, ensuring that the internal representation of the object is hidden from outside.

Perl is a multi-paradigm language, and it supports OOP, albeit in a more flexible manner than languages like Java or C++. Encapsulation in Perl can be achieved using packages and blessed references.

Here's a step-by-step guide to implementing encapsulation in Perl:

1. Creating the Class

In Perl, a class is essentially a package. Let's create a simple class Person.

package Person;

sub new {
    my $class = shift;
    my %args = @_;
    
    my $self = {
        _name  => $args{name},
        _age   => $args{age},
    };

    bless $self, $class;
    return $self;
}

1;  # Always end a module with a true value

2. Private Attributes

Notice the _ (underscore) prefix for the attributes _name and _age. It's a convention in Perl to denote private attributes/methods. Perl doesn't have true private attributes like other OOP languages. The underscore is a way to tell programmers, "Hey, don't access this directly!"

3. Public Methods to Access Private Attributes

To implement encapsulation, provide public methods to access or modify private attributes. This way, you can control and validate the data that's set or retrieved.

# Getter for name
sub get_name {
    my $self = shift;
    return $self->{_name};
}

# Setter for name
sub set_name {
    my $self = shift;
    my $new_name = shift;
    
    # Add validation if needed
    $self->{_name} = $new_name;
}

# Similarly, you can have getters and setters for _age

4. Encapsulating Methods

You can make methods private by not providing them outside of the package or by using a convention like prefixing them with an underscore.

# A private method
sub _private_method {
    # ... code here ...
}

5. Using the Encapsulated Class

To use the encapsulated class:

use Person;

my $person = Person->new(name => 'John', age => 30);

# Access name using getter
print $person->get_name();  # Outputs: John

# Modify name using setter
$person->set_name('Doe');
print $person->get_name();  # Outputs: Doe

Summary

Encapsulation in Perl is achieved using packages for classes and blessed references for objects.
Perl relies on conventions, like the underscore prefix, to denote private attributes or methods.
By providing public getter and setter methods, you can control access to an object's attributes, thereby encapsulating and protecting the data.

As with many aspects of Perl, encapsulation relies a lot on the discipline of the programmer. Perl gives you the tools to encapsulate, but it also trusts you with the freedom to decide how and when to use them.

Perl object-oriented programming encapsulation:

Description: Encapsulation is one of the four fundamental principles of object-oriented programming (OOP). It involves bundling the data (attributes) and methods (functions) that operate on the data into a single unit known as a class.

Example Code:

package MyClass;

sub new {
    my $class = shift;
    my $self = {
        _attribute => shift,
    };
    bless $self, $class;
    return $self;
}

sub get_attribute {
    my ($self) = @_;
    return $self->{_attribute};
}

sub set_attribute {
    my ($self, $value) = @_;
    $self->{_attribute} = $value;
}

1;

Private methods and attributes in Perl:
- Description: In Perl, encapsulation can be achieved by convention. Prefixing attribute names with an underscore indicates that they are private and should not be accessed directly from outside the class.
- Example Code:
```
package MyClass;

sub new {
    my $class = shift;
    my $self = {
        _attribute => shift,
    };
    bless $self, $class;
    return $self;
}

sub _private_method {
    # private method implementation
}

1;
```

Perl encapsulation example:

Description: Encapsulation in Perl involves creating a class with private attributes and methods, and providing public methods (accessors and mutators) to interact with the private members.

Example Code:

package MyClass;

sub new {
    my $class = shift;
    my $self = {
        _attribute => shift,
    };
    bless $self, $class;
    return $self;
}

sub get_attribute {
    my ($self) = @_;
    return $self->{_attribute};
}

sub set_attribute {
    my ($self, $value) = @_;
    $self->{_attribute} = $value;
}

1;

Perl Moose encapsulation:
- Description: Moose is a modern object system for Perl that provides a more declarative and convenient syntax for encapsulation, accessors, and more.
- Example Code:
```
package MyClass;
use Moose;

has '_attribute' => (
    is => 'rw',
    isa => 'Str',
);

1;
```

Information hiding in Perl:

Description: Information hiding is a key aspect of encapsulation. In Perl, it is achieved by marking attributes as private and providing controlled access through methods.

Example Code:

package MyClass;

sub new {
    my $class = shift;
    my $self = {
        _attribute => shift,
    };
    bless $self, $class;
    return $self;
}

sub get_attribute {
    my ($self) = @_;
    return $self->{_attribute};
}

sub set_attribute {
    my ($self, $value) = @_;
    $self->{_attribute} = $value;
}

1;

Perl accessors and mutators:

Description: Accessors (getters) and mutators (setters) are methods that provide controlled access to the private attributes of a class.

Example Code:

package MyClass;

sub new {
    my $class = shift;
    my $self = {
        _attribute => shift,
    };
    bless $self, $class;
    return $self;
}

sub get_attribute {
    my ($self) = @_;
    return $self->{_attribute};
}

sub set_attribute {
    my ($self, $value) = @_;
    $self->{_attribute} = $value;
}

1;

Encapsulation vs. abstraction in Perl:
- Description: Encapsulation and abstraction are related but distinct concepts. Encapsulation involves bundling data and methods into a single unit (class), while abstraction involves simplifying complex systems by modeling classes with essential features.
- Example Code:
```
# Encapsulation example (previous examples)
# Abstraction example: abstract class with method signatures
package Shape;

sub area {
    die "Subclasses must implement area method";
}

1;
```

Perl encapsulation in object-oriented design:

Description: Encapsulation is a fundamental principle in object-oriented design. It helps create modular and maintainable code by hiding implementation details and exposing a well-defined interface.

Example Code:

package MyClass;

sub new {
    my $class = shift;
    my $self = {
        _attribute => shift,
    };
    bless $self, $class;
    return $self;
}

sub get_attribute {
    my ($self) = @_;
    return $self->{_attribute};
}

sub set_attribute {
    my ($self, $value) = @_;
    $self->{_attribute} = $value;
}

1;