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 {} :

1
2
3
4
5
<?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.

1
2
3
4
5
6
7
8
<?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.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?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.

1
2
3
4
5
6
7
8
9
10
<?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.

1
2
3
4
5
6
7
8
9
10
11
12
<?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.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?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).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
<?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.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
<?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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?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.

Ao fechar este aviso ou continuar navegando no site Nerd Calistênico, você aceita o uso de cookies.

Este site usa cookies para assegurar a melhor experiência para os nossos usuários. Consulte nossa política de privacidade.

Uma nova versão está disponível. Clique aqui para atualizar.