Programação orientada a objetos é um estilo de programação que permite aos desenvolvedores agruparem tarefas semelhantes em classes. Isso ajuda a manter dentro do princípio "don't repeat yourself" (DRY) (em português, não se repita), além de facilitar a manutenção do código.

Termos Principais da Orientação a Objetos em PHP

Classe – matriz de onde vêm os objetos (só uma e não se trabalha com classes, elas servem apenas para a criação dos objetos)

Objeto – instância da classe (é com estes que trabalhamos)

Método – é como uma função, mas é subordinado à classe

Propriedade – são como variáveis, mas também são subordinadas à classe

Construtor – método iniciado automaticamente quando a classe é instanciada

Destrutor – chamado logo que todas as referências a um objeto forem removidas

$this-> - usado para referenciar um método ou variável da classe atual

parent:: - usado para referenciar a classe pai (herança)

extends – usado para indicar que a classe atual é “filha” de outra classe (herança)

public, protected e private – visibilidade dos membros da classe

Exemplo simples

<?php

class Classe1
{

    public function __construct()
    {
        print 'Construtor da classe pai<br>';
    }

    //private $propriedade1 = 'Variável 1';

    public $propriedade1 = 'Variável 1';

    public function funcao1()
    {

        return 'Função 1';
    }

    public function prop()
    {

        return $this->propriedade1;
    }
}

$obj1 = new Classe1();

print $obj1->funcao1(); // Método requer (), já propriedade, não

//print $obj1->propriedade1;

print "<br>" . $obj1->prop();

class Classe2 extends Classe1
{

    private $propriedade2 = 'Variável da classe filha<br>';

    public function funcao2()
    {

        print 'Função da classe filha<br>';
    }

    public function prop2()
    {

        print $this->propriedade2;
    }
}

$obj2 = new Classe2();

print $obj2->propriedade1;

print $obj2->prop2();


class Classe3 extends Classe1
{

    public function __construct()
    {

        parent::__construct();

        print 'Construtor da classe filha<br>';
    }

    private $propriedade2 = 'Variável da classe filha';

    public function funcao2()
    {

        return 'Função da classe filha';
    }

    public function prop2()
    {

        return $this->propriedade2;
    }
}

$obj3 = new Classe3();

print $obj3->prop2();

Exemplo didático

<?php
class MyClass
{
    public $public = 'Public';
    protected $protected = 'Protected';
    private $private = 'Private';
    function printHello()
    {
        echo $this->public;
        echo $this->protected;
        echo $this->private;
    }
}
$obj = new MyClass();
echo $obj->public; // Works echo $obj->protected; // Fatal Error echo $obj->private; // Fatal Error $obj->printHello(); // Shows Public, Protected and Private

Correspondência entre OO e Estruturada

Classe – Arquivo

Método – Função

Propriedade - Variável

Orientação a Objetos não é linguagem de programação, mas sim um paradigma adotado por algumas linguagens de programação.

Classes e Objetos

Classes são as matrizes dos objetos. O programador cria a classe uma única vez e depois trabalha somente com os objetos, que são a instância das classes.

O paradigma de orientação a objetos é muito popular atualmente, sendo implementado por praticamente todas as linguagens atuais. Como ele diz, é orientado a objetos, simulando o mundo real com seus objetos.

Vamos tomar como exemplo um carro, que todos conhecemos e vamos modelá-lo, criando algumas propriedades e métodos para ele. As propriedades são características, como cor, já os métodos são funcionalidades como correr, frear, etc (verbos).

Criando uma Classe

<?php

class Carro{

// Aqui fica o código da classe

}

?>

Instanciando a Classe

Instanciar a classe é armazená-la em uma variável objeto para então usar seus recursos.

$obj = new Carro(); // Também podemos usar assim: $obj = new Carro;

Nossa classe não tem conteúdo mas para visualizá-la podemos usar var_dump();

var_dump($obj);

Com isso aparece: object(Carro)#1 (0) { }

As classes são compostas de propriedades e métodos. Propriedades são similares às variáveis da linguagem procedural. Métodos são similares às funções. A grande diferença é que propriedades e métodos ficam dentro da classe e todo código OO fica dentro de classes.

Propriedades

<?php
class Carro{
public $cor = ‘Verde’;
}

$obj = new Carro();
print 'A cor do carro é ' . $obj->cor;

Modificadores de Acesso ou de Visibilidade

Em orientação a objetos existe um bom recurso para controlar a visibilidade dos métodos e propriedades (realizar um encapsulamento), ou seja, uma forma de controlar o acesso à classe.

public – este modificador permite que qualquer um possa acessar propriedades e métodos

private – este define que somente pode ser acessada dentro da classe que a criou.

protected – este diz que somente dentro da classe onde foi criado ou nas classes filhas.

Experimente no exemplo anterior mudar public para private ou protected.

Ou seja, se queremos que um membro da classe seja visto por todos o tornamos public, caso contrário escolhemos private ou protected.

Métodos

Os métodos executam trechos de código em uma classe e retornam ou não algo e de algum tipo.

<?php
class Carro
{
    public $cor = "Verde";

    public function frear()
    {
        return "Método frear";
    }
}

$obj = new Carro();
print $obj->frear();


Outro Exemplo
     < ?php
class Car
ro{
    public $cor = "Verde";

    public function getCor
    (){
        return $this->cor;
    }

    public function setCor($novaCo
    r){
        $this->c o r=$novaCor;
    }
}

$obj = new Carro();
print 'Cor original   '.$obj->getCor();

$obj->setCor('Vermelho');
print '<br>Cor alterada, atual:   '.$obj->getCor();

Acessando Métodos e Propriedades

Obs.: Veja que para acessar propriedades e métodos de uma classe precisamos criar primeiro um objeto do tipo da classe, para depois, através da instância acessar métodos e propriedades públicos.

Usando a palavra reservada $this podemos referenciar métodos e propriedades de uma classe, mas somente estando dentro da classe. Usamos $this dentro da classe da mesma forma que usamos o nome do método ou propriedade fora da classe.

Podemos criar várias instâncias de uma classe. Seguindo o exemplo anterior:

<?php
class Carro
{
    public $cor = "Verde";

    public function getCor()
    {
        return $this->cor;
    }

    public function setCor($novaCor)
    {
        $this->cor = $novaCor;
    }
}


$obj = new Carro();
print 'Cor original ' . $obj->getCor();
$obj->setCor('Vermelho');
print '<br>Cor alterada: ' . $obj->getCor();

$obj2 = new Carro();
$obj2->setCor('Azul');
print '<br>Cor alterada, atual: ' . $obj2->getCor();

Métodos Mágicos

São métodos do PHP que são métodos especiais executados automaticamente sempre que alguma ação ocorre com objetos: __construct(), __destruct(), __toString(), etc. Ver outros: http://php.net/manual/pt_BR/language.oop5.magic.php

__construct() - executa todo o código em seu interior sempre que uma classe é instanciada.

__destruct() - será chamado assim que todas as referências a um objeto particular forem removidas ou quando o objeto for explicitamente destruído ou qualquer ordem na sequência de encerramento.

__toString() - converte o valor de um objeto em string.

Usemos estes métodos em um exemplo:

<?php
class Carro
{
    public $cor = "Verde";

    public function __construct()
    {
        echo 'A classe ' . __CLASS__ . ' foi instanciada.<br>';
    }

    public function __destruct()
    {
        echo '<br>Todas as referências desta classe ' . __CLASS__ . ' foram encessadas!<br>';
    }

    public function __toString()
    {
        print 'Usando o método mágico toString: ';
        return $this->getCor();
    }

    public function getCor()
    {
        return $this->cor;
    }

    public function setCor($novaCor)
    {
        $this->cor = $novaCor;
    }
}

$obj = new Carro();
echo $obj; // Permitido pela __toString();
print '<br>Cor original ' . $obj->getCor();
$obj->setCor('Vermelho');
print '<br>Cor alterada: ' . $obj->getCor();

Herança de Classes

Assim como existe herança para o ser humano, em orientação a objetos também existe uma implementação que se inspira na dos seres humanos.

Para herdar métodos e propriedades de outra classe usamos a palavra-chave extends.

class Onibus extends Carro{
// Código da classe Onibus
}

Assim, a classe Onibus herda todos os métodos e propriedades da classe Carro e também pode ainda definir seus próprios métodos e propriedades e ainda por cima pode sobrescrever os métodos e propriedades da classe Carro, que no caso é chamada de classe pai.

Exemplo:

<?php
class Carro
{
    private $cor = "Verde";
    public function __construct()
    {
        echo 'A classe ' . __CLASS__ . ' foi instanciada.<br>';
    }
    public function getCor()
    {
        return $this→cor;
    }
    public function setCor($novaCor)
    {
        $this→cor = $novaCor;
    }
}

class Onibus extends Carro
{
    public $pneus = 6;
    public $combustivel = "Diesel";
}

$objeto = new Onibus();
print $objeto->getCor();
print "<br>";
print $objeto->combustivel;

Observações importantes:

- Veja que o método __construct() foi executado automaticamente, sem nenhuma chamada a ele;
- Observe que o método getCor() tem () ao final mas a propriedade não tem, combustivel.

Sobrescrevendo Métodos e Propriedades

Quando uma classe herda de outra ela chama-se classe filha e a outra chama-se classe pai. A filha herda tudo da classe pai, todos os métodos e todas as propriedades, mas ela também pode sobrescrever qualquer um destes, bastando apenas que ela, a filha, declare novamente o que deseja sobrescrever. Se ela declarar um método ou propriedade que exista na classe pai, valerá o que a filha declarou, assim sobrescrevendo o da classe pai.

Veja:

<?php
class Carro
{
    private $cor = "Verde";
    public function __construct()
    {
        echo 'A classe ' . __CLASS__ . ' foi instanciada.<br>';
    }
    public function getCor()
    {
        return $this->cor;
    }
    public function setCor($novaCor)
    {
        $this->cor = $novaCor;
    }
}

class Onibus extends Carro
{
    public $pneus = 6;
    public $combustivel = "Diesel";

    public function __construct()
    {
        echo 'A classe ' . __CLASS__ . ' foi instanciada.<br>';
    }
}

$obj = new Onibus();

Veja que será executado o construtor da classe filha, Onibus e não o de Carro.

Herança é algo prático e não é engessado.

Usando parent::

Sobrescrevendo um método e preservando seu conteúdo original.

Para adicionar uma nova funcionalidade a um método e ao mesmo tempo manter todas as funcionalidades originais intactas, use “parent::”. :: é o operador de resolução de escopo e parent é pai, principal.

Veja:

<?php
class Carro
{
    private $cor = "Verde";
    public function __construct()
    {
        echo 'A classe ' . __CLASS__ . ' foi instanciada.<br>';
    }
    public function getCor()
    {
        return $this->cor;
    }
    public function setCor($novaCor)
    {
        $this->cor = $novaCor;
    }
}

class Onibus extends Carro
{
    public $pneus = 6;
    public $combustivel = "Diesel";

    public function __construct()
    {
        parent::__construct(); // Invoca o construtor da classe pai
        echo 'A classe ' . __CLASS__ . ' foi instanciada.<br>';
    }
}

$obj = new Onibus();

Veja o que mostra agora:

A classe Carro foi instanciada.
A classe Onibus foi instanciada.

Primeiro o construtor da classe pai e depois o da filha.

Métodos e propriedades estáticas

É o tipo de método ou propriedade que é meio que global e ainda mais fácil de ser acessada, pois podem ser acessados sem mesmo instanciar a classe. Classes também podem ser static.

Exemplo de uso:

<?php

class Estatica
{

    public static $nome = "João";

    public static $count = 0;

    public static function maisUm()
    {

        return "O valor é " . ++self::$count . "<br />";
    }
}

print Estatica::$nome;
print '<br>';
print Estatica::maisUm();

Existe muito mais recursos sobre Programação orientada a objetos no PHP, que você encontra em bons sites, livros e vídeo aulas, mas como o objetivo deste tutorial é de apenas mostrar o básico e de forma bem simplificada ficaremos por aqui. Se tiver se interessado pelo assunto faça uma boa busca sobre o assunto e procure bons recursos.

Usar um dos modernos CMS ou Framework é uma boa iniciativa para aprender Orientação a objetos.