Encapsulamento e modificadores de acesso

Bem-vindo à lição sobre encapsulamento! Nesta lição, você aprenderá como o encapsulamento ajuda a proteger os dados dentro das classes e como os modificadores de acesso controlam a visibilidade das propriedades e dos métodos das classes. Vamos nos aprofundar!

O que é encapsulamento?

Encapsulamento é a prática de agrupar dados (propriedades) e métodos que operam nesses dados dentro de uma classe e restringir o acesso direto a eles de fora da classe.

Principais características do encapsulamento:

• Protege o estado interno de um objeto.
• Fornece acesso controlado às propriedades da classe usando métodos.
• Ajuda a manter a integridade dos dados.

Dica: O encapsulamento é um conceito fundamental para criar aplicações seguras e modulares.

Modificadores de acesso em PHP

Os modificadores de acesso definem a visibilidade das propriedades e dos métodos de uma classe. O PHP fornece três níveis de visibilidade:

• public: Acessível de qualquer lugar.
• protected: Acessível apenas dentro da classe e de suas subclasses.
• private: Acessível apenas dentro da própria classe.

Ponto-chave: Use modificadores de acesso para controlar como as propriedades e os métodos são acessados e modificados.

Usando public propriedades

As propriedades declaradas como public podem ser acessadas e modificadas de qualquer lugar. Exemplo:

Dica: Use public para propriedades e métodos que devem ser acessados livremente.

<?php
  class Car {
    public $make;
    public $model;

    public function drive() {
      echo "The car is driving.";
    }
  }

  $car = new Car();
  $car->make = "Toyota";
  $car->model = "Corolla";

  echo "Make: " . $car->make . ", Model: " . $car->model;
  $car->drive();
?>

Usando private propriedades

As propriedades declaradas como private só podem ser acessadas dentro da classe. Exemplo:

Ponto-chave: Use private para propriedades que precisam ser protegidas contra modificações externas.

<?php
  class BankAccount {
    private $balance;

    public function __construct($initialBalance) {
      $this->balance = $initialBalance;
    }

    public function getBalance() {
      return $this->balance;
    }

    public function deposit($amount) {
      $this->balance += $amount;
    }
  }

  $account = new BankAccount(100);
  $account->deposit(50);
  echo "Balance: " . $account->getBalance(); // Outputs: Balance: 150
?>

Usando protected propriedades

As propriedades declaradas como protected são acessíveis dentro da classe e de suas classes filhas. Exemplo:

Ponto-chave: Use protected para permitir que as classes filhas acessem as propriedades e os métodos da classe pai.

<?php
  class Vehicle {
    protected $fuel;

    public function setFuel($fuel) {
      $this->fuel = $fuel;
    }
  }

  class Car extends Vehicle {
    public function getFuel() {
      return $this->fuel;
    }
  }

  $car = new Car();
  $car->setFuel("Gasoline");
  echo "Fuel: " . $car->getFuel(); // Outputs: Fuel: Gasoline
?>

Métodos de leitura e atribuição

O encapsulamento geralmente envolve o uso de métodos de leitura e atribuição para fornecer acesso controlado a propriedades privadas. Exemplo:

Dica: Use métodos de atribuição para validar os dados antes de modificar as propriedades.

<?php
  class User {
    private $password;

    public function setPassword($password) {
      $this->password = $password;
    }

    public function getPassword() {
      return $this->password;
    }
  }

  $user = new User();
  $user->setPassword("my_secure_password");
  echo "Password: " . $user->getPassword();
?>

Benefícios do encapsulamento

O encapsulamento oferece as seguintes vantagens:

• Protege o estado interno de um objeto.
• Melhora a facilidade de manutenção do código ao centralizar o controle sobre as propriedades.
• Impede modificações acidentais nos dados.
• Reforça a segurança ao restringir o acesso direto a dados confidenciais.

Ponto-chave: O encapsulamento é um princípio fundamental da POO segura e modular.

Muito bem!

Parabéns! Você aprendeu sobre encapsulamento e como os modificadores de acesso controlam a visibilidade das propriedades e dos métodos de uma classe. Na próxima lição, exploraremos o polimorfismo e como ele permite flexibilidade no comportamento dos objetos. Vamos continuar programando!