PHP - Orientação a objetos

A Programação orientada a objetos permite que os desenvolvedores agrupem tarefas semelhantes em classes. O PHP não é uma linguagem que foi criada para ser orientada a objetos. Começando a dar suporte ao mesmo na versão 3, sendo melhorada na versão 4 e tendo um bom suporte na versão 5.3.

O primeiro e mais importante conceito de orientação a objetos é a classe, uma abstração do software de objetos similares, ou seja, um template do qual os objetos serão criados.

Na criação de uma classe, o nome é precedido da palavra reservada class e seguida de um par de chaves {} :

<?php
class Person {
  // conteúdo da classe
}
?>

Atributos/Propriedades

São elementos que definem uma classe, também são conhecidos como variáveis de classe. A palavra chave public determina a visibilidade da propriedade (vamos ver mais sobre isso no decorrer do artigo, na parte de visibilidade de propriedades e métodos). Depois disso, a propriedade é nomeada usando os padrões básicos de nomeação de variáves e é mostrado que não necessitam de valores iniciais.

<?php
// person.php
class Person {
  public $name;
  public $cpf;
  public $age;
}
?>

Métodos

São funções internas das classes que realizam algo, geralmente tomando por base os dados armazenados nas propriedades. Dentro dos métodos, as propriedades e outros métodos internos da classe são referenciados utilizando $this.

Construtor

O construtor da classe é um bloco declarado com o mesmo nome que a classe.

<?php
// person.php
class Person {
  public $name;
  public $cpf;
  public $age;
  
  //construtor da classe
  function Person(){
    $this->getPerson();
  }

  function getPerson(){
    $this->name = "Hemerson";
    $this->cpf = "123.123.123-22";
    $this->age = 29;
  }

  function getMessage(){
    return 'Meu nome é ' . $this->name;
  }
}
?>

Após criar a classe, ela pode ser instanciada e guardada em alguma variável usando a palavra chave new. O operador ->, permite acessar as propriedades e métodos de um objeto.

<?php
require_once 'person.php';

$person = new Person();

echo $person->name;
// Hemerson
echo $person->getMessage();
// Meu nome é Hemerson
?>

Métodos Mágicos

Ao invés de termos um método com o mesmo nome da classe para ser o construtor, o PHP provê o método __construct(), que é chamado automaticamente quando a classe é instanciada. Também há inúmeras constantes mágicas, como __CLASS__, que retorna o nome da classe. Podemos ver as constantes disponíveis no Manual do PHP. Os demais métodos mágicos podemos conferir no Manual.

<?php
class Person {
  public $name = "Hemerson";

  public function __construct(){
    echo 'Meu nome é ' . $this->name .' e a classe ' . __CLASS__ . ' foi instanciada';
  }
}

$person = new Person();
// Meu nome é Hemerson e a classe Person foi instanciada
?>

Herança de Classe

Na Orientação a objetos, as classes podem herdar métodos e propriedades de outra classe. Isso é possível utilizando a palavra chave extends.

<?php
class Person {
  public $name = "Hemerson";
  public $cpf = "123.123.123-22";
  public $age = 29;
  
  function __construct(){
    echo 'Essa classe é a ' . __CLASS__;
  }

  function getMessage(){
    return 'Meu nome é ' . $this->name;
  }
}

class Example extends Person {
  function __construct(){
    echo 'Essa classe é a ' . __CLASS__;
  }
}

$example = new Example();
// Meu nome é Hemerson
?>

Assim, temos superclasses e subclasses na orientação a objetos. Onde as superclasses são classes mãe, que não derivam de nenhuma outra classe e as subclasses são classes que são criadas a partir de outras classes. Podemos utilizar as palavras parent (se referindo a classe mãe) e self (se referindo a classe atual).

<?php
class Person {
  public $message = "Eu sou o Hemerson";
  
  public function __construct(){
    echo 'Essa classe é a ' . __CLASS__;
  }
  
  public function getMessage(){
    return $this->message."--";
  }
}

class Example extends Person {
  public $message = "Não sou o Hemerson";
  
  public function __construct(){
    echo parent::getMessage();
    echo self::getMessage();
    echo $this->getMessage();
  }
  
  public function getMessage(){
    return $this->message;
  }
}

$example = new Example();
// Não sou o Hemerson--
// Não sou o Hemerson
// Não sou o Hemerson
?>

Temos que ficar atentos, que quando há uma propriedade de mesmo nome na subclasse, a propriedade da superclasse será sobrescrita e o valor da subclasse passará a valer.

Visbilidade de Propriedades e Métodos

A visibilidade controla como e de onde as propriedades e métodos podem ser acessados. Há três palavras chaves para visibilidade: public, protected, e private. Também pode ser adicionado à sua visibilidade, a palavra chave static, o que permite que sejam acessados sem uma instanciação da classe. Se a visibilidade não é declarada, automaticamente se considera como public. O uso da declaração de variável com a palavra-chave var ainda é suportada por razões de compatibilidade e o mesmo é um sinônimo para a palavra-chave public.

• public - Podem ser acessados de qualquer lugar, tanto dentro quanto fora da classe.
• protected - Só pode ser acessado dentro da própria classe ou por uma classe herdeira.
• private - É acessível somente dentro da classe que os define.
• static - Podem ser acessados sem instanciar a classe.

<?php
class Person {
  public $name = 'Hemerson';
  protected $cpf = '123.123.123-22';
  private $status = true;

  function __construct(){
  }
}

class Example extends Person {
  function __construct(){
  }

  function getCpf(){
    return $this->cpf;
  }

  function getStatus(){
    return $this->status;
  } 
}

$person = new Person();
$example = new Example();

echo $person->name; // Hemerson

echo $example->name; // Hemerson
echo $example->getCpf(); // 123.123.123-22
echo $example->cpf; // FATAL ERROR Cannot access protected property Example::$cpf 

echo $example->getStatus(); // Undefined property: Example::$status
?>

Agora um exemplo com a adição da palavra chave static:

<?php
class Person {
  public static $message = 'Teste';
    
  public static function exampleMethod() {
    return self::$message;
  }
}

print Person::$message; // Teste

$person = new Person();

print $person->exampleMethod() . "\n"; // Teste
print $person->message . "\n";
// Accessing static property Person::$message as non static
// Undefined property: Person::$message
?>

Propriedades estáticas não podem ser acessadas através do operador ->.

Conclusão

Programação orientada a objetos é uma coisa linda. Pode parecer complicado no começo, mas como tudo, a prática e entender o que está fazendo, leva a perfeição. É só cair dentro dos estudos e ver as vantagens, que serão notadas. Facilidade na manutenção e organização, ajudando você e sua equipe.