Orientação a Objetos é um paradigma de programação que organiza o código em torno de "objetos", que são instâncias de "classes". Esses objetos podem ter propriedades (dados) e métodos (funções) que definem seu comportamento.
Classes
Uma classe é como um "molde" ou "plano" que define as características e comportamentos de um objeto. Ela descreve os atributos (dados) e os métodos (ações) que os objetos dessa classe terão.
Pense em uma classe como a descrição de um tipo de objeto. Ela define o que o objeto pode fazer (métodos) e o que o objeto possui (propriedades/atributos), mas não cria o objeto em si.
Objetos
Um objeto é uma instância de uma classe. Ele é criado a partir da classe e representa uma entidade individual com os valores dos atributos definidos e a capacidade de executar os métodos especificados na classe.
Pense em um objeto como uma realização concreta da classe. Enquanto a classe é o plano, o objeto é o produto final criado a partir desse plano.
Exemplo de Classe e Objeto
<?php
// Definindo uma classe
class Carro {
// Propriedades
public $cor;
public $modelo;
// Método
public function ligar() {
return "O carro está ligado!";
}
}
// Criando um objeto
$meuCarro = new Carro();
// Atribuindo as propriedades do objeto
$meuCarro->cor = "Vermelho";
$meuCarro->modelo = "Fusca";
// Usando um método
echo $meuCarro->ligar(); // Saída: O carro está ligado!
Herança
A herança é um dos princípios fundamentais da Programação Orientada a Objetos (OOP) e permite que uma classe herde propriedades e métodos de outra classe. Em termos simples, herança possibilita a criação de uma nova classe (chamada de subclasse ou classe filha) que reutiliza, estende ou modifica o comportamento de uma classe existente (chamada de superclasse ou classe pai).
<?php
// Classe pai (superclasse)
class Veiculo {
public $marca;
public $modelo;
public function dirigir() {
echo "O veículo está sendo dirigido.";
}
}
// Classe filha (subclasse) que herda de Veiculo
class Carro extends Veiculo {
public $numeroDePortas;
// Método específico da classe filha
public function abrirPorta() {
echo "Abrindo uma porta do carro.";
}
// Sobrescrevendo um método da classe pai
public function dirigir() {
echo "O carro está sendo dirigido.";
}
}
// Criando um objeto da classe filha Carro
$meuCarro = new Carro();
$meuCarro->marca = "Toyota";
$meuCarro->modelo = "Corolla";
$meuCarro->numeroDePortas = 4;
// Acessando métodos da classe pai e da classe filha
$meuCarro->dirigir(); // Exibe "O carro está sendo dirigido."
$meuCarro->abrirPorta(); // Exibe "Abrindo uma porta do carro."
Encapsulamento
Prática de esconder os detalhes internos de um objeto e expor apenas o que é necessário para a interação com ele. Em outras palavras, encapsulamento permite que você controle como os dados de um objeto são acessados e modificados, protegendo-os de interferências externas indevidas.
Isso é feito através de modificadores de acesso (como public, private e protected) para determinar quais partes de um objeto podem ser acessadas de fora da classe.
- public: Propriedades e métodos podem ser acessados de qualquer lugar.
- private: Propriedades e métodos só podem ser acessados de dentro da própria classe.
- protected: Propriedades e métodos podem ser acessados dentro da própria classe e em subclasses.
<?php
class ContaBancaria {
private $saldo;
public function __construct($saldoInicial) {
$this->saldo = $saldoInicial;
}
// Método público para depositar
public function depositar($quantia) {
if ($quantia > 0) {
$this->saldo += $quantia;
}
}
// Método público para visualizar o saldo
public function obterSaldo() {
return $this->saldo;
}
// Método privado, acessível apenas dentro da classe
private function aplicarTaxa() {
$this->saldo -= 5; // Taxa de manutenção
}
}
$conta = new ContaBancaria(100);
$conta->depositar(50);
echo $conta->obterSaldo(); // Exibe 150
Polimorfismo
É um dos princípios fundamentais da Programação Orientada a Objetos (OOP) e refere-se à capacidade de diferentes classes utilizarem métodos com o mesmo nome, mas comportamentos distintos. Em outras palavras, o polimorfismo permite que o mesmo método seja implementado de formas diferentes em classes diferentes.
O termo polimorfismo vem do grego e significa "muitas formas", indicando que um único nome de método pode funcionar de maneira diferente dependendo do objeto que o invoca.
<?php
// Classe pai
class Animal {
public function emitirSom() {
echo "O animal faz um som.";
}
}
// Classes filhas que sobrescrevem o método emitirSom
class Cachorro extends Animal {
public function emitirSom() {
echo "O cachorro late.";
}
}
class Gato extends Animal {
public function emitirSom() {
echo "O gato mia.";
}
}
// Função que demonstra o polimorfismo
function fazerAnimalEmitirSom(Animal $animal) {
$animal->emitirSom();
}
// Criando objetos de diferentes classes
$cachorro = new Cachorro();
$gato = new Gato();
// Chamando o método com comportamento polimórfico
fazerAnimalEmitirSom($cachorro); // Exibe "O cachorro late."
fazerAnimalEmitirSom($gato); // Exibe "O gato mia."
Você pode executar o código em https://onecompiler.com/php
Top comments (0)