Conceito de Programação Orientada a Objetos (POO) em PHP com exemplos.

O que são OOPs?

A programação orientada a objetos é uma abordagem para o desenvolvimento de software que modela uma aplicação em torno de objetos do mundo real, como funcionários, carros e contas bancárias. Uma classe define as propriedades e os métodos de um objeto do mundo real. Um objeto é uma instância de uma classe.

Os três componentes básicos da orientação a objetos são:

• Análise orientada a objetos – funcionalidade do sistema
• Projeto orientado a objetos – arquitetura do sistema
• Programação orientada a objetos – implementação da aplicação

Princípios de programação orientada a objetos

Os três princípios fundamentais da POO são:

• Encapsulamento – Isso se refere a ocultar os detalhes de implementação e expor apenas os métodos. Os principais objetivos do encapsulamento são:
  • Reduza a complexidade do desenvolvimento de software – ao ocultar os detalhes da implementação e expor apenas as operações, o uso de uma classe torna-se fácil.
  • Proteja o estado interno de um objeto – o acesso às variáveis ​​da classe é feito por meio de métodos como get e set. Isso torna a classe flexível e fácil de manter.
  • Permitir que a implementação interna da classe seja alterada sem se preocupar em quebrar o código que utiliza a classe.
• Herança – Isso diz respeito à relação entre classes. A relação assume a forma de pai e filho. O filho utiliza os métodos definidos na classe pai. O principal objetivo da herança é:
  • Reutilização – várias classes filhas podem herdar da mesma classe pai. Isso é muito útil quando precisamos fornecer funcionalidades comuns, como adicionar, atualizar e excluir dados do banco de dados.
• Polimorfismo – Isso se refere à existência de uma única interface com diversas implementações diferentes. O principal objetivo do polimorfismo é:
  • Simplificar a manutenção de aplicativos e torná-los mais extensíveis.

OOPs Concepts em PHP

PHP é uma linguagem de script orientada a objetos; ela suporta todos os princípios acima. Os princípios acima são alcançados através de:

• Encapsulamento – através do uso dos métodos “get” e “set”, e modificadores de acesso.
• Herança – através do uso da palavra-chave extends
• Polimorfismo – através do uso da palavra-chave implements

Agora que temos o conhecimento básico de OOP e como ele é suportado em PHPVejamos, então, exemplos que implementam os princípios acima.

O que é UML?

A Linguagem de Modelagem Unificada (UML) é uma técnica usada para projetar e documentar sistemas orientados a objetos.

A UML produz diversos documentos, mas vamos analisar o diagrama de classes, que é muito importante para a programação PHP orientada a objetos.

Exemplo de diagrama de classes

Chave do Diagrama de Classes

• O caixa superior contém o nome da classe
• O caixa do meio contém as variáveis ​​de classe
• O caixa inferior contém os métodos da classe
• O menos (-) sinal significa escopo privado
• O mais (+) sinal significa escopo público
• O cerquilha (#) sinal significa escopo protegido

Como criar uma classe em PHP

A palavra-chave class é usada para definir uma classe em PHP. Abaixo estão as regras para criação de uma classe em PHP.

• O nome da classe deve começar com uma letra
• O nome da classe não pode ser uma palavra reservada do PHP
• O nome da classe não pode conter espaços

Vamos supor que queremos criar uma classe para representar animais. Começaremos identificando as características comuns a todos os animais.

• Todos os animais pertencem a uma família, como herbívoros, carnívoros, etc.
• Todos os animais comem comida

O diagrama abaixo mostra o diagrama de classes para o animal.

Vamos agora programar nossa classe Animal.

<?php
class Animal
{
    private $family;
    private $food;
    public function __construct($family, $food)
    {
        $this->family = $family;
        $this->food = $food;
    }
    public function get_family()
    {
        return $this->family;
    }
    public function set_family($family)
    {
        $this->family = $family;
    }
    public function get_food()
    {
        return $this->food;
    }
    public function set_food($food)
    {
        $this->food = $food;
    }
}
?>

AQUI,

• “private $family, $food” significa que as variáveis ​​não podem ser acessadas diretamente fora da classe (encapsulamento).
• “public function __construct($family…)” é o método construtor do PHP. Essa função é chamada sempre que uma instância da classe é criada. Nesse caso, estamos definindo a família e a comida.
• “public function get…()” é o método usado para acessar o valor da família ou do alimento (encapsulamento).
• “public function set…()” é o método usado para definir o valor da família ou do alimento (encapsulamento).

Como implementar herança em PHP

Trabalharemos com uma vaca e um leão. Tanto a vaca quanto o leão herdam da classe Animal.

O diagrama de classes abaixo mostra os relacionamentos.

Observe que a vaca herda da classe Animal e também define suas próprias variáveis ​​e métodos.

Vamos agora codificar a classe Cow.

<?php
class Cow extends Animal
{
    private $owner;
    public function __construct($family, $food)
    {
        parent::__construct($family, $food);
    }
    public function set_owner($owner)
    {
        $this->owner = $owner;
    }
    public function get_owner()
    {
        return $this->owner;
    }
}
?>

Vamos agora programar a classe Lion.

<?php
class Lion extends Animal
{
    public function __construct($family, $food)
    {
        parent::__construct($family, $food);
    }
}
?>

AQUI,

• A classe “… extends Animal” faz com que as classes Cow e Lion usem métodos da classe Animal (herança).

Como criar um objeto da classe

As classes Animal, Cow e Lion devem estar todas no mesmo diretório para simplificar.

Vamos agora criar a aplicação que utiliza as nossas classes.

Exemplo de classe PHP

<?php
require 'Animal.php';
require 'Cow.php';
require 'Lion.php';
$cow = new Cow('Herbivore', 'Grass');
$lion = new Lion('Carnivore', 'Meat');
echo '<b>Cow Object</b> <br>';
echo 'The Cow belongs to the ' . $cow->get_family() . ' family and eats ' . $cow->get_food() . '<br><br>';
echo '<b>Lion Object</b> <br>';
echo 'The Lion belongs to the ' . $lion->get_family() . ' family and eats ' . $lion->get_food();
?>

Testando nosso aplicativo

Vamos agora visualizar nossa aplicação em um navegador web.

Ambos os objetos reutilizam os métodos get_family e get_food herdados da classe Animal, o que demonstra a herança em ação.

Como implementar polimorfismo em PHP

Vamos supor que queremos desenvolver um aplicativo que se conecte a diferentes mecanismos de banco de dados, como... MySQL e SQL Servidor, mas usa a mesma interface uniforme. Podemos criar uma interface que define os métodos padrão e um abstracClasse t que implementa os métodos comuns.

• Interface – é semelhante a uma aula. Ele apenas define os métodos e parâmetros.
• Abstracclasse t – é uma classe que não pode ser usada para criar um objeto diretamente. Seu objetivo é fornecer implementações parciais ou completas de métodos comuns.

O diagrama de classes abaixo ilustra a relação entre nossos abstracClasse t, interface e classes de implementação.

Vamos agora definir nossos abdominais.tracclasse t.

<?php
abstract class DBCommonMethods
{
    private $host;
    private $db;
    private $uid;
    private $password;
    public function __construct($host, $db, $uid, $password)
    {
        $this->host = $host;
        $this->db = $db;
        $this->uid = $uid;
        $this->password = $password;
    }
}
?>

AQUI,

• “abdômentracA expressão "classe t" significa que a classe não pode ser usada diretamente para criar um objeto.
• “$host, $db…” são variáveis ​​de classe comuns a todas as implementações.
• “function __construct(…)” é o método construtor da classe que define os valores das variáveis ​​comuns na inicialização.

Vamos agora criar a interface que contém os métodos padrão, os quais serão implementados de forma diferente dependendo do mecanismo de banco de dados.

<?php
interface DBInterface
{
    public function db_connect();
    public function insert($data);
    public function read($where);
    public function update($where);
    public function delete($where);
}
?>

AQUI,

• “interface” é a palavra-chave para criar interfaces
• “função pública…(…)” são os métodos padrão que devem ser implementados

Vamos agora criar as classes concretas que estenderão a classe DBCommonMethods e implementarão a interface DBInterface. Primeiro, MySQLDriver.php:

<?php
class MySQLDriver extends DBCommonMethods implements DBInterface
{
    public function __construct($host, $db, $uid, $password)
    {
        parent::__construct($host, $db, $uid, $password);
    }
    public function db_connect() { /* connect code goes here */ }
    public function delete($where) { /* delete code goes here */ }
    public function insert($data)  { /* insert code goes here */ }
    public function read($where)   { /* read code goes here */ }
    public function update($where) { /* update code goes here */ }
}
?>

Em seguida, MSSQLServerDriver.php:

<?php
class MSSQLServerDriver extends DBCommonMethods implements DBInterface
{
    public function __construct($host, $db, $uid, $password)
    {
        parent::__construct($host, $db, $uid, $password);
    }
    public function db_connect() { /* connect code goes here */ }
    public function delete($where) { /* delete code goes here */ }
    public function insert($data)  { /* insert code goes here */ }
    public function read($where)   { /* read code goes here */ }
    public function update($where) { /* update code goes here */ }
}
?>

AQUI,

• A classe “…” estende “DBCommonMethods” e utiliza os métodos da classe “DBCommonMethods”.
• “… implementa DBInterface” garante que a classe forneça os métodos padrão, independentemente do driver de banco de dados utilizado.

O código usando as classes acima ficaria assim:

<?php $db = new MySQLDriver($host, $db, $uid, $password); ?>

Ou:

<?php $db = new MSSQLServerDriver($host, $db, $uid, $password); ?>

O restante do código seria o mesmo para ambos os drivers, como por exemplo:

<?php
$db->db_connect();
$db->insert($data);
?>

Isso é polimorfismo em ação: as mesmas chamadas de método funcionam em qualquer driver que implemente a interface, portanto, o código circundante nunca muda quando você troca de mecanismo de banco de dados.

Perguntas Frequentes