A orientação a objetos é um paradigma de programação que utiliza "classes" e "objetos" como seus blocos de construção. Uma classe pode ser vista como um modelo ou um blueprint que descreve as características (atributos) e comportamentos (métodos) de um determinado tipo de entidade do mundo real. Por exemplo, um carro pode ser abstraído em uma classe, possuindo atributos como nome, cor, velocidade e peso, além de métodos como acelerar, frear e mudar de marcha.
A definição de uma classe em PHP segue esta estrutura:
class Veiculo {
public $nome = 'Veículo Genérico';
public function obterNome() {
return $this->nome;
}
}
Enquanto a classe é a descrição estrutural de um tipo, um objeto é uma instância concreta dessa classe. Pensando no exemplo do carro, a classe "Veiculo" seria a generalização, e um Audi A6 específico seria um objeto individual dessa classe.
Objetos são criados a partir de classes utilizando a palavra-chave new:
// Criação de uma instância da classe Veiculo
$meuVeiculo = new Veiculo();
echo $meuVeiculo->obterNome(); // Saída: Veículo Genérico
Podemos instanciar um objeto e atribuir valores aos seus atributos:
$meuVeiculo = new Veiculo();
$meuVeiculo->nome = 'Audi A6'; // Define o valor do atributo nome
echo $meuVeiculo->obterNome(); // Chama o método para obter o nome
Atributos de Classe
Variáveis definidas dentro de uma classe são chamadas de atributos (ou propriedades). Eles frequentemente se correlacionam com campos em um banco de dados. A declaração de atributos é feita com os modificadores de acesso public, protected ou private, seguidos pela declaração da variável. É possível definir valores padrão para os atributos, os quais devem ser constantes.
Significado dos modificadores de acesso:
public: Acessível de qualquer lugar.protected: Acessível pela própria classe, suas subclasses e a classe pai.private: Acessível apenas pela classe onde foi definida.
class Veiculo {
// Atributo público
public $nome = 'Veículo';
// Atributo protegido
protected $cor = 'Branco';
// Atributo privado
private $preco = 100000;
}
Por padrão, atributos são públicos. Atributos e métodos públicos são acessados usando o operador de objeto ->. Atributos estáticos são acessados com ::. Dentro de métodos da classe, a variável mágica $this se refere ao objeto atual. Atributos protegidos e privados não podem ser acessados diretamente de fora da classe, mas podem ser acessados por métodos internos.
$meuVeiculo = new Veiculo();
echo $meuVeiculo->nome; // Acessa atributo público
// echo $meuVeiculo->cor; // Erro: Atributo protegido não acessível externamente
// echo $meuVeiculo->preco; // Erro: Atributo privado não acessível externamente
Atributos protegidos e privados são acessíveis de dentro dos métodos da classe:
class Veiculo {
private $preco = '1000';
public function obterPreco() {
return $this->preco; // Acesso interno ao atributo privado
}
}
Métodos de Classe
Métodos são funções definidas dentro de uma classe. Assim como atributos, métodos podem ter modificadores de acesso public, protected ou private.
Definição de um método:
class Veiculo {
public function obterDescricao() {
return 'Este é um veículo.';
}
}
$meuVeiculo = new Veiculo();
echo $meuVeiculo->obterDescricao(); // Saída: Este é um veículo.
Métodos Estáticos
Métodos marcados com a palavra-chave static são chamados de métodos estáticos. Eles podem ser chmaados diretamente usando o nome da classe e o operador ::, sem a necessidade de instanciar um objeto.
class Veiculo {
public static function obterDescricaoEstatica() {
return 'Descrição estática de veículo.';
}
}
echo Veiculo::obterDescricaoEstatica(); // Saída: Descrição estática de veículo.
Construtores e Destrutores
O PHP 5 introduziu o método mágico __construct(), que é o construtor da classe. Ele é chamado automaticamente toda vez que um novo objeto é criado, sendo ideal para inicializações.
class Veiculo {
function __construct() {
print "Construtor do Veículo chamado.\n";
}
}
$meuVeiculo = new Veiculo(); // Chama o construtor
Se uma classe filha (subclasse) define seu próprio __construct, o construtor da classe pai não é chamado automaticamente. Para chamá-lo explicitamente, usa-se parent::__construct().
class Veiculo {
function __construct() {
print "Construtor da classe pai chamado.\n";
}
}
class Carro extends Veiculo {
function __construct() {
print "Construtor da classe filha chamado.\n";
parent::__construct(); // Chama o construtor da classe pai
}
}
$meuCarro = new Carro();
Da mesma forma, o PHP 5 suporta o método mágico __destruct(), o destrutor. Ele é executado quando um objeto não possui mais referências ou é explicitamente destruído.
class Veiculo {
function __construct() {
print "Construtor chamado.\n";
}
function __destruct() {
print "Destrutor chamado.\n";
}
}
$meuVeiculo = new Veiculo(); // Chama o construtor
echo "Objeto em uso...\n";
unset($meuVeiculo); // Chama o destrutor
O coletor de lixo do PHP geralmente cuida da destruição de objetos ao final da execução do script, tornando a chamada explícita a unset() raramente necessária.
Palavra-chave static em PHP
Atributos e métodos estáticos podem ser acessados sem instanciar a classe, usando NomeDaClasse::metodoEstatico(). Atributos estáticos não podem ser acessados com o operador ->.
class Veiculo {
private static $velocidadeMaxima = 120;
public static function obterVelocidadeMaxima() {
return self::$velocidadeMaxima;
}
}
echo Veiculo::obterVelocidadeMaxima(); // Acessa método estático
Métodos estáticos também podem ser chamados dinamicamente:
$nomeMetodo = 'obterVelocidadeMaxima';
$nomeClasse = 'Veiculo';
echo $nomeClasse::$nomeMetodo(); // Chama método estático dinamicamente
A variável $this não pode ser usada dentro de métodos estáticos. As palavras-chave self, parent e static são usadas para referenciar membros estáticos dentro da própria classe ou de classes relacionadas.
class Veiculo {
protected static $velocidadeAtual = 0;
public static function acelerar() {
self::$velocidadeAtual += 10;
}
public static function obterVelocidadeAtual() {
return self::$velocidadeAtual;
}
}
class CarroEsportivo extends Veiculo {
public static function ligarTurbo() {
parent::acelerar(); // Chama método estático da classe pai
}
}
CarroEsportivo::ligarTurbo();
echo CarroEsportivo::obterVelocidadeAtual(); // Saída: 10
Controle de Acesso em PHP
Os modificadores public, protected e private controlam a visibilidade de membros de classe. Membros public são acessíveis de qualquer lugar. Membros protected são acessíveis pela própria classe, subclasses e classe pai. Membros private são acessíveis apenas pela classe onde foram definidos.
Atributos de classe devem ser declarados com um modificador de acesso. O uso da palavra-chave var (legado) define atributos como públicos.
class Veiculo {
// public $velocidade = 10; // Sintaxe correta com modificador
public $nome; // Atributo público
}
Métodos podem ser public, private ou protected. Se nanhum modificador to especificado, o método é considerado público por padrão.
Comparação de Objetos em PHP
O operador de igualdade == compara se dois objetos da mesma classe possuem todos os seus atributos com os mesmos valores. O operador de identidade === verifica se duas variáveis referenciam exatamente o mesmo objeto na memória.
class Veiculo {}
$a = new Veiculo();
$b = new Veiculo();
$c = $a;
if ($a == $b) echo "a == b: Verdadeiro\n"; // Saída: a == b: Verdadeiro
if ($a === $b) echo "a === b: Verdadeiro\n"; // Saída: a === b: Falso
if ($a === $c) echo "a === c: Verdadeiro\n"; // Saída: a === c: Verdadeiro
Cópia de Objetos em PHP
A palavra-chave clone é usada para criar uma cópia de um objeto. Quando clone é utilizado, o método mágico __clone() é chamado, permitindo a personalização do processo de cópia.
class Veiculo {
public $nome = 'veiculo';
private $motor;
public function __construct() {
$this->motor = new stdClass(); // Exemplo de inicialização
}
public function __clone() {
// Cria uma nova instância do motor para a cópia
$this->motor = clone $this->motor;
}
}
$original = new Veiculo();
$original->nome = 'Carro Original';
$copia = clone $original;
// Modifica a cópia, o original não é afetado
$copia->nome = 'Carro Copiado';
var_dump($original);
var_dump($copia);
Serialização de Objetos
A função serialize() converte um objeto em uma representação de string, útil para armazenamento ou transmissão. unserialize() reconstrói o objeto a partir dessa string.
class Veiculo {
public $nome = 'veiculo';
}
$objOriginal = new Veiculo();
$stringSerializada = serialize($objOriginal); // Serializa o objeto
echo "Objeto serializado: " . $stringSerializada . "<br></br>";
$objDeserializado = unserialize($stringSerializada); // Desserializa a string
var_dump($objDeserializado);