Introdução à programação orientada a objetos
********************************************

.[perex]
O termo "OOP" significa Object-Oriented Programming (Programação orientada a objetos), que é uma forma de organizar e estruturar o código. A OOP nos permite ver um programa como uma coleção de objetos que se comunicam entre si, em vez de uma sequência de comandos e funções.

Na OOP, um "objeto" é uma unidade que contém dados e funções que operam com esses dados. Os objetos são criados com base em "classes", que podem ser entendidas como planos ou modelos para objetos. Quando temos uma classe, podemos criar sua "instância", que é um objeto específico criado a partir dessa classe.

Vamos ver como podemos criar uma classe simples no PHP. Quando definimos uma classe, usamos a palavra-chave "class" (classe), seguida pelo nome da classe e, em seguida, chaves que envolvem as funções da classe (chamadas de "métodos") e as variáveis da classe (chamadas de "propriedades" ou "atributos"):

```php
class Car
{
	function honk()
	{
		echo 'Beep beep!';
	}
}
```

Neste exemplo, criamos uma classe chamada `Car` com uma função (ou "método") chamada `honk`.

Cada classe deve resolver apenas uma tarefa principal. Se uma classe estiver fazendo muitas coisas, pode ser apropriado dividi-la em classes menores e especializadas.

Normalmente, as classes são armazenadas em arquivos separados para manter o código organizado e fácil de navegar. O nome do arquivo deve corresponder ao nome da classe, portanto, para a classe `Car`, o nome do arquivo seria `Car.php`.

Ao nomear as classes, é bom seguir a convenção "PascalCase", o que significa que cada palavra do nome começa com uma letra maiúscula e não há sublinhados ou outros separadores. Os métodos e as propriedades seguem a convenção "camelCase", ou seja, começam com uma letra minúscula.

Alguns métodos no PHP têm funções especiais e são prefixados com `__` (dois sublinhados). Um dos métodos especiais mais importantes é o "construtor", rotulado como `__construct`. O construtor é um método que é chamado automaticamente ao criar uma nova instância de uma classe.

Geralmente usamos o construtor para definir o estado inicial de um objeto. Por exemplo, ao criar um objeto que representa uma pessoa, você pode usar o construtor para definir sua idade, nome ou outros atributos.

Vamos ver como usar um construtor no PHP:

```php
class Person
{
	private $age;

	function __construct($age)
	{
		$this->age = $age;
	}

	function howOldAreYou()
	{
		return $this->age;
	}
}

$person = new Person(25);
echo $person->howOldAreYou(); // Outputs: 25
```

Neste exemplo, a classe `Person` tem uma propriedade (variável) `$age` e um construtor que define essa propriedade. O método `howOldAreYou()` fornece acesso à idade da pessoa.

A pseudovariável `$this` é usada dentro da classe para acessar as propriedades e os métodos do objeto.

A palavra-chave `new` é usada para criar uma nova instância de uma classe. No exemplo acima, criamos uma nova pessoa com 25 anos.

Você também pode definir valores padrão para os parâmetros do construtor se eles não forem especificados ao criar um objeto. Por exemplo:

```php
class Person
{
	private $age;

	function __construct($age = 20)
	{
		$this->age = $age;
	}

	function howOldAreYou()
	{
		return $this->age;
	}
}

$person = new Person;  // if no argument is passed, parentheses can be omitted
echo $person->howOldAreYou(); // Outputs: 20
```

Neste exemplo, se você não especificar uma idade ao criar um objeto `Person`, o valor padrão de 20 será usado.

O bom é que a definição da propriedade com sua inicialização por meio do construtor pode ser encurtada e simplificada da seguinte forma:

```php
class Person
{
	function __construct(
		private $age = 20,
	) {
	}
}
```

Para ser mais completo, além dos construtores, os objetos podem ter destrutores (método `__destruct`) que são chamados antes de o objeto ser liberado da memória.


Namespaces .[#toc-namespaces]
-----------------------------

Os namespaces nos permitem organizar e agrupar classes, funções e constantes relacionadas, evitando conflitos de nomes. Você pode pensar neles como pastas em um computador, onde cada pasta contém arquivos relacionados a um projeto ou tópico específico.

Os namespaces são especialmente úteis em projetos maiores ou ao usar bibliotecas de terceiros, onde podem surgir conflitos de nomes de classes.

Imagine que você tenha uma classe chamada `Car` em seu projeto e queira colocá-la em um namespace chamado `Transport`. Você faria isso da seguinte forma:

```php
namespace Transport;

class Car
{
	function honk()
	{
		echo 'Beep beep!';
	}
}
```

Se quiser usar a classe `Car` em outro arquivo, precisará especificar de qual namespace a classe se origina:

```php
$car = new Transport\Car;
```

Para simplificar, você pode especificar no início do arquivo qual classe de um determinado namespace deseja usar, o que lhe permite criar instâncias sem mencionar o caminho completo:

```php
use Transport\Car;

$car = new Car;
```


Herança .[#toc-inheritance]
---------------------------

A herança é uma ferramenta de programação orientada a objetos que permite a criação de novas classes com base nas existentes, herdando suas propriedades e métodos e estendendo-os ou redefinindo-os conforme necessário. A herança garante a reutilização do código e a hierarquia de classes.

Em termos simples, se tivermos uma classe e quisermos criar outra derivada dela, mas com algumas modificações, podemos "herdar" a nova classe da original.

No PHP, a herança é implementada usando a palavra-chave `extends`.

Nossa classe `Person` armazena informações de idade. Podemos ter outra classe, `Student`, que estende a `Person` e acrescenta informações sobre o campo de estudo.

Vamos dar uma olhada em um exemplo:

```php
class Person
{
	private $age;

	function __construct($age)
	{
		$this->age = $age;
	}

	function printInformation()
	{
		echo "Age: {$this->age} years\n";
	}
}

class Student extends Person
{
	private $fieldOfStudy;

	function __construct($age, $fieldOfStudy)
	{
		parent::__construct($age);
		$this->fieldOfStudy = $fieldOfStudy;
	}

	function printInformation()
	{
		parent::printInformation();
		echo "Field of study: {$this->fieldOfStudy} \n";
	}
}

$student = new Student(20, 'Computer Science');
$student->printInformation();
```

Como esse código funciona?

- Usamos a palavra-chave `extends` para estender a classe `Person`, o que significa que a classe `Student` herda todos os métodos e propriedades de `Person`.

- A palavra-chave `parent::` nos permite chamar métodos da classe principal. Nesse caso, chamamos o construtor da classe `Person` antes de adicionar nossa própria funcionalidade à classe `Student`. E, da mesma forma, o método ancestral `printInformation()` antes de listar as informações do aluno.

A herança é destinada a situações em que há um relacionamento "é um" entre as classes. Por exemplo, um `Student` é um `Person`. Um gato é um animal. Ela nos permite, nos casos em que esperamos um objeto (por exemplo, "Person") no código, usar um objeto derivado (por exemplo, "Student").

É essencial perceber que o objetivo principal da herança **não** é evitar a duplicação de código. Pelo contrário, o uso incorreto da herança pode levar a um código complexo e de difícil manutenção. Se não houver uma relação "é um" entre as classes, devemos considerar a composição em vez da herança.

Observe que os métodos `printInformation()` nas classes `Person` e `Student` produzem informações ligeiramente diferentes. E podemos adicionar outras classes (como `Employee`) que fornecerão outras implementações desse método. A capacidade de objetos de classes diferentes responderem ao mesmo método de maneiras diferentes é chamada de polimorfismo:

```php
$people = [
	new Person(30),
	new Student(20, 'Computer Science'),
	new Employee(45, 'Director'),
];

foreach ($people as $person) {
	$person->printInformation();
}
```


Composição .[#toc-composition]
------------------------------

A composição é uma técnica em que, em vez de herdar propriedades e métodos de outra classe, simplesmente usamos sua instância em nossa classe. Isso nos permite combinar funcionalidades e propriedades de várias classes sem criar estruturas de herança complexas.

Por exemplo, temos uma classe `Engine` e uma classe `Car`. Em vez de dizer "Um carro é um motor", dizemos "Um carro tem um motor", que é uma relação de composição típica.

```php
class Engine
{
	function start()
	{
		echo 'Engine is running.';
	}
}

class Car
{
	private $engine;

	function __construct()
	{
		$this->engine = new Engine;
	}

	function start()
	{
		$this->engine->start();
		echo 'The car is ready to drive!';
	}
}

$car = new Car;
$car->start();
```

Aqui, o `Car` não tem todas as propriedades e métodos do `Engine`, mas tem acesso a eles por meio da propriedade `$engine`.

A vantagem da composição é a maior flexibilidade de design e a melhor adaptabilidade a mudanças futuras.


Visibilidade .[#toc-visibility]
-------------------------------

No PHP, você pode definir "visibilidade" para propriedades de classe, métodos e constantes. A visibilidade determina onde você pode acessar esses elementos.

1. **Public:** Se um elemento estiver marcado como `public`, isso significa que você pode acessá-lo de qualquer lugar, mesmo fora da classe.

2. **Protegido:** Um elemento marcado como `protected` é acessível somente dentro da classe e de todos os seus descendentes (classes que herdam dela).

3. **Private:** Se um elemento for `private`, você poderá acessá-lo somente na classe em que ele foi definido.

Se você não especificar a visibilidade, o PHP a definirá automaticamente como `public`.

Vamos dar uma olhada em um exemplo de código:

```php
class VisibilityExample
{
	public $publicProperty = 'Public';
	protected $protectedProperty = 'Protected';
	private $privateProperty = 'Private';

	public function printProperties()
	{
		echo $this->publicProperty;     // Works
		echo $this->protectedProperty;  // Works
		echo $this->privateProperty;    // Works
	}
}

$object = new VisibilityExample;
$object->printProperties();
echo $object->publicProperty;        // Works
// echo $object->protectedProperty;   // Throws an error
// echo $object->privateProperty;     // Throws an error
```

Continuando com a herança de classes:

```php
class ChildClass extends VisibilityExample
{
	public function printProperties()
	{
		echo $this->publicProperty;     // Works
		echo $this->protectedProperty;  // Works
		// echo $this->privateProperty;   // Throws an error
	}
}
```

Nesse caso, o método `printProperties()` no `ChildClass` pode acessar as propriedades públicas e protegidas, mas não pode acessar as propriedades privadas da classe principal.

Os dados e os métodos devem ser tão ocultos quanto possível e acessíveis somente por meio de uma interface definida. Isso permite que você altere a implementação interna da classe sem afetar o restante do código.


Palavra-chave final .[#toc-final-keyword]
-----------------------------------------

No PHP, podemos usar a palavra-chave `final` se quisermos impedir que uma classe, um método ou uma constante seja herdado ou substituído. Quando uma classe é marcada como `final`, ela não pode ser estendida. Quando um método é marcado como `final`, ele não pode ser substituído em uma subclasse.

O fato de saber que uma determinada classe ou método não será mais modificado nos permite fazer alterações com mais facilidade sem nos preocuparmos com possíveis conflitos. Por exemplo, podemos adicionar um novo método sem medo de que um descendente já tenha um método com o mesmo nome, levando a uma colisão. Ou podemos alterar os parâmetros de um método, novamente sem o risco de causar inconsistência com um método substituído em um descendente.

```php
final class FinalClass
{
}

// The following code will throw an error because we cannot inherit from a final class.
class ChildOfFinalClass extends FinalClass
{
}
```

Neste exemplo, a tentativa de herdar da classe final `FinalClass` resultará em um erro.


Propriedades e métodos estáticos .[#toc-static-properties-and-methods]
----------------------------------------------------------------------

Quando falamos de elementos "estáticos" de uma classe no PHP, queremos dizer métodos e propriedades que pertencem à própria classe, não a uma instância específica da classe. Isso significa que não é necessário criar uma instância da classe para acessá-los. Em vez disso, você os chama ou acessa diretamente por meio do nome da classe.

Lembre-se de que, como os elementos estáticos pertencem à classe e não às suas instâncias, você não pode usar a pseudovariável `$this` dentro dos métodos estáticos.

O uso de propriedades estáticas leva a um [código ofuscado e cheio de armadilhas |dependency-injection:global-state], portanto, você nunca deve usá-las, e não mostraremos um exemplo aqui. Por outro lado, os métodos estáticos são úteis. Aqui está um exemplo:

```php
class Calculator
{
	public static function add($a, $b)
	{
		return $a + $b;
	}

	public static function subtract($a, $b)
	{
		return $a - $b;
	}
}

// Using the static method without creating an instance of the class
echo Calculator::add(5, 3); // Output: 8
echo Calculator::subtract(5, 3); // Output: 2
```

Neste exemplo, criamos uma classe `Calculator` com dois métodos estáticos. Podemos chamar esses métodos diretamente sem criar uma instância da classe usando o operador `::`. Os métodos estáticos são especialmente úteis para operações que não dependem do estado de uma instância específica da classe.


Constantes de classe .[#toc-class-constants]
--------------------------------------------

Nas classes, temos a opção de definir constantes. Constantes são valores que nunca mudam durante a execução do programa. Ao contrário das variáveis, o valor de uma constante permanece o mesmo.

```php
class Car
{
	public const NumberOfWheels = 4;

	public function displayNumberOfWheels(): int
	{
		echo self::NumberOfWheels;
	}
}

echo Car::NumberOfWheels;  // Output: 4
```

Neste exemplo, temos uma classe `Car` com a constante `NumberOfWheels`. Ao acessar a constante dentro da classe, podemos usar a palavra-chave `self` em vez do nome da classe.


Interfaces de objeto .[#toc-object-interfaces]
----------------------------------------------

As interfaces de objetos funcionam como "contratos" para as classes. Se uma classe tiver que implementar uma interface de objeto, ela deverá conter todos os métodos que a interface define. Essa é uma ótima maneira de garantir que determinadas classes sigam o mesmo "contrato" ou estrutura.

No PHP, as interfaces são definidas usando a palavra-chave `interface`. Todos os métodos definidos em uma interface são públicos (`public`). Quando uma classe implementa uma interface, ela usa a palavra-chave `implements`.

```php
interface Animal
{
	function makeSound();
}

class Cat implements Animal
{
	public function makeSound()
	{
		echo 'Meow';
	}
}

$cat = new Cat;
$cat->makeSound();
```

Se uma classe implementar uma interface, mas nem todos os métodos esperados estiverem definidos, o PHP lançará um erro.

Uma classe pode implementar várias interfaces de uma vez, o que é diferente da herança, em que uma classe só pode herdar de uma classe:

```php
interface Guardian
{
	function guardHouse();
}

class Dog implements Animal, Guardian
{
	public function makeSound()
	{
		echo 'Bark';
	}

	public function guardHouse()
	{
		echo 'Dog diligently guards the house';
	}
}
```


Classes abstratas .[#toc-abstract-classes]
------------------------------------------

As classes abstratas servem como modelos de base para outras classes, mas você não pode criar suas instâncias diretamente. Elas contêm uma mistura de métodos completos e métodos abstratos que não têm um conteúdo definido. As classes que herdam de classes abstratas devem fornecer definições para todos os métodos abstratos da classe pai.

Usamos a palavra-chave `abstract` para definir uma classe abstrata.

```php
abstract class AbstractClass
{
	public function regularMethod()
	{
		echo 'This is a regular method';
	}

	abstract public function abstractMethod();
}

class Child extends AbstractClass
{
	public function abstractMethod()
	{
		echo 'This is the implementation of the abstract method';
	}
}

$instance = new Child;
$instance->regularMethod();
$instance->abstractMethod();
```

Neste exemplo, temos uma classe abstrata com um método regular e um método abstrato. Em seguida, temos uma classe `Child` que herda de `AbstractClass` e fornece uma implementação para o método abstrato.

Qual é a diferença entre interfaces e classes abstratas? As classes abstratas podem conter métodos abstratos e concretos, enquanto as interfaces definem apenas os métodos que a classe deve implementar, mas não fornecem nenhuma implementação. Uma classe pode herdar de apenas uma classe abstrata, mas pode implementar qualquer número de interfaces.


Verificação de tipo .[#toc-type-checking]
-----------------------------------------

Na programação, é fundamental garantir que os dados com os quais trabalhamos sejam do tipo correto. No PHP, temos ferramentas que oferecem essa garantia. A verificação de que os dados são do tipo correto é chamada de "verificação de tipo".

Tipos que podemos encontrar no PHP:

1. **Tipos básicos**: Incluem `int` (inteiros), `float` (números de ponto flutuante), `bool` (valores booleanos), `string` (strings), `array` (arrays) e `null`.
2. **Classes**: Quando queremos que um valor seja uma instância de uma classe específica.
3. **Interfaces**: Define um conjunto de métodos que uma classe deve implementar. Um valor que atende a uma interface deve ter esses métodos.
4. **Tipos mistos**: Podemos especificar que uma variável pode ter vários tipos permitidos.
5. **Void**: Esse tipo especial indica que uma função ou método não retorna nenhum valor.

Vamos ver como modificar o código para incluir tipos:

```php
class Person
{
	private int $age;

	public function __construct(int $age)
	{
		$this->age = $age;
	}

	public function printAge(): void
	{
		echo "This person is {$this->age} years old.";
	}
}

/**
 * A function that accepts a Person object and prints the person's age.
 */
function printPersonAge(Person $person): void
{
	$person->printAge();
}
```

Dessa forma, garantimos que nosso código espera e trabalha com dados do tipo correto, o que nos ajuda a evitar possíveis erros.

Alguns tipos não podem ser escritos diretamente no PHP. Nesse caso, eles são listados no comentário phpDoc, que é o formato padrão para documentar o código PHP, começando com `/**` e terminando com `*/`. Ele permite que você adicione descrições de classes, métodos e assim por diante. E também para listar tipos complexos usando as chamadas anotações `@var`, `@param` e `@return`. Esses tipos são usados por ferramentas de análise de código estático, mas não são verificados pelo próprio PHP.

```php
class Registry
{
	/** @var array<Person>  indicates that it's an array of Person objects */
	private array $persons = [];

	public function addPerson(Person $person): void
	{
		$this->persons[] = $person;
	}
}
```


Comparação e identidade .[#toc-comparison-and-identity]
-------------------------------------------------------

No PHP, você pode comparar objetos de duas maneiras:

1. Comparação de valores `==`: Verifica se os objetos são da mesma classe e têm os mesmos valores em suas propriedades.
2. Identidade `===`: Verifica se é a mesma instância do objeto.

```php
class Car
{
	public string $brand;

	public function __construct(string $brand)
	{
		$this->brand = $brand;
	}
}

$car1 = new Car('Skoda');
$car2 = new Car('Skoda');
$car3 = $car1;

var_dump($car1 == $car2);   // true, because they have the same value
var_dump($car1 === $car2);  // false, because they are not the same instance
var_dump($car1 === $car3);  // true, because $car3 is the same instance as $car1
```


O operador do `instanceof` .[#toc-the-instanceof-operator]
----------------------------------------------------------

O operador `instanceof` permite que você determine se um determinado objeto é uma instância de uma classe específica, um descendente dessa classe ou se implementa uma determinada interface.

Imagine que temos uma classe `Person` e outra classe `Student`, que é descendente de `Person`:

```php
class Person
{
	private int $age;

	public function __construct(int $age)
	{
		$this->age = $age;
	}
}

class Student extends Person
{
	private string $major;

	public function __construct(int $age, string $major)
	{
		parent::__construct($age);
		$this->major = $major;
	}
}

$student = new Student(20, 'Computer Science');

// Check if $student is an instance of the Student class
var_dump($student instanceof Student);  // Output: bool(true)

// Check if $student is an instance of the Person class (because Student is a descendant of Person)
var_dump($student instanceof Person);   // Output: bool(true)
```

A partir dos resultados, fica evidente que o objeto `$student` é considerado uma instância das classes `Student` e `Person`.


Interfaces fluentes .[#toc-fluent-interfaces]
---------------------------------------------

Uma "Interface Fluente" é uma técnica em OOP que permite encadear métodos em uma única chamada. Isso geralmente simplifica e esclarece o código.

O principal elemento de uma interface fluente é que cada método na cadeia retorna uma referência ao objeto atual. Isso é obtido com o uso do endereço `return $this;` no final do método. Esse estilo de programação é frequentemente associado a métodos chamados "setters", que definem os valores das propriedades de um objeto.

Vamos ver como seria uma interface fluente para o envio de e-mails:

```php
public function sendMessage()
{
	$email = new Email;
	$email->setFrom('sender@example.com')
		  ->setRecipient('admin@example.com')
		  ->setMessage('Hello, this is a message.')
		  ->send();
}
```

Neste exemplo, os métodos `setFrom()`, `setRecipient()` e `setMessage()` são usados para definir os valores correspondentes (remetente, destinatário, conteúdo da mensagem). Depois de definir cada um desses valores, os métodos retornam o objeto atual (`$email`), o que nos permite encadear outro método depois dele. Por fim, chamamos o método `send()`, que de fato envia o e-mail.

Graças às interfaces fluentes, podemos escrever códigos intuitivos e de fácil leitura.


Copiando com `clone` .[#toc-copying-with-clone]
-----------------------------------------------

No PHP, podemos criar uma cópia de um objeto usando o operador `clone`. Dessa forma, obtemos uma nova instância com conteúdo idêntico.

Se precisarmos modificar algumas de suas propriedades ao copiar um objeto, podemos definir um método `__clone()` especial na classe. Esse método é chamado automaticamente quando o objeto é clonado.

```php
class Sheep
{
	public string $name;

	public function __construct(string $name)
	{
		$this->name = $name;
	}

	public function __clone()
	{
		$this->name = 'Clone of ' . $this->name;
	}
}

$original = new Sheep('Dolly');
echo $original->name . "\n";  // Outputs: Dolly

$clone = clone $original;
echo $clone->name . "\n";     // Outputs: Clone of Dolly
```

Neste exemplo, temos uma classe `Sheep` com uma propriedade `$name`. Quando clonamos uma instância dessa classe, o método `__clone()` garante que o nome da ovelha clonada receba o prefixo "Clone of".


Características .[#toc-traits]
------------------------------

As características no PHP são uma ferramenta que permite o compartilhamento de métodos, propriedades e constantes entre classes e evita a duplicação de código. Você pode pensar nelas como um mecanismo de "copiar e colar" (Ctrl-C e Ctrl-V), em que o conteúdo de uma característica é "colado" nas classes. Isso permite que você reutilize o código sem precisar criar hierarquias de classe complicadas.

Vamos dar uma olhada em um exemplo simples de como usar características no PHP:

```php
trait Honking
{
	public function honk()
	{
		echo 'Beep beep!';
	}
}

class Car
{
	use Honking;
}

class Truck
{
	use Honking;
}

$car = new Car;
$car->honk(); // Outputs 'Beep beep!'

$truck = new Truck;
$truck->honk(); // Also outputs 'Beep beep!'
```

Neste exemplo, temos uma característica chamada `Honking` que contém um método `honk()`. Em seguida, temos duas classes: `Car` e `Truck`, ambas as quais usam a característica `Honking`. Como resultado, ambas as classes "têm" o método `honk()` e podemos chamá-lo em objetos de ambas as classes.

As características permitem o compartilhamento fácil e eficiente de código entre classes. Elas não entram na hierarquia de herança, ou seja, `$car instanceof Honking` retornará `false`.


Exceções
--------

As exceções na OOP nos permitem lidar com erros e situações inesperadas em nosso código. Elas são objetos que contêm informações sobre um erro ou uma situação incomum.

No PHP, temos uma classe interna `Exception`, que serve de base para todas as exceções. Ela tem vários métodos que nos permitem obter mais informações sobre a exceção, como a mensagem de erro, o arquivo e a linha em que o erro ocorreu etc.

Quando ocorre um erro no código, podemos "lançar" a exceção usando a palavra-chave `throw`.

```php
function division(float $a, float $b): float
{
	if ($b === 0) {
		throw new Exception('Division by zero!');
	}
	return $a / $b;
}
```

Quando a função `division()` recebe null como seu segundo argumento, ela lança uma exceção com a mensagem de erro `'Division by zero!'`. Para evitar que o programa seja interrompido quando a exceção for lançada, nós a capturamos no bloco `try/catch`:

```php
try {
	echo division(10, 0);
} catch (Exception $e) {
	echo 'Exception caught: '. $e->getMessage();
}
```

O código que pode lançar uma exceção é envolvido em um bloco `try`. Se a exceção for lançada, a execução do código será movida para um bloco `catch`, onde poderemos tratar a exceção (por exemplo, escrever uma mensagem de erro).

Após os blocos `try` e `catch`, podemos adicionar um bloco opcional `finally`, que é sempre executado, independentemente de a exceção ter sido lançada ou não (mesmo se usarmos `return`, `break` ou `continue` no bloco `try` ou `catch` ):

```php
try {
	echo division(10, 0);
} catch (Exception $e) {
	echo 'Exception caught: '. $e->getMessage();
} finally {
	// Code that is always executed whether the exception has been thrown or not
}
```

Também podemos criar nossas próprias classes de exceção (hierarquia) que herdam da classe Exception. Como exemplo, considere um aplicativo bancário simples que permite depósitos e saques:

```php
class BankingException extends Exception {}
class InsufficientFundsException extends BankingException {}
class ExceededLimitException extends BankingException {}

class BankAccount
{
	private int $balance = 0;
	private int $dailyLimit = 1000;

	public function deposit(int $amount): int
	{
		$this->balance += $amount;
		return $this->balance;
	}

	public function withdraw(int $amount): int
	{
		if ($amount > $this->balance) {
			throw new InsufficientFundsException('Not enough funds in the account.');
		}

		if ($amount > $this->dailyLimit) {
			throw new ExceededLimitException('Daily withdrawal limit exceeded.');
		}

		$this->balance -= $amount;
		return $this->balance;
	}
}
```

Vários blocos `catch` podem ser especificados para um único bloco `try` se você espera diferentes tipos de exceções.

```php
$account = new BankAccount;
$account->deposit(500);

try {
	$account->withdraw(1500);
} catch (ExceededLimitException $e) {
	echo $e->getMessage();
} catch (InsufficientFundsException $e) {
	echo $e->getMessage();
} catch (BankingException $e) {
	echo 'An error occurred during the operation.';
}
```

Nesse exemplo, é importante observar a ordem dos blocos `catch`. Como todas as exceções são herdadas de `BankingException`, se tivéssemos esse bloco primeiro, todas as exceções seriam capturadas nele sem que o código chegasse aos blocos `catch` subsequentes. Portanto, é importante que as exceções mais específicas (ou seja, aquelas que herdam de outras) estejam em uma posição mais alta na ordem do bloco `catch` do que suas exceções pai.


Iterações .[#toc-iterations]
----------------------------

No PHP, você pode percorrer objetos usando o loop `foreach`, da mesma forma que percorre uma matriz. Para que isso funcione, o objeto deve implementar uma interface especial.

A primeira opção é implementar a interface `Iterator`, que tem os métodos `current()` que retorna o valor atual, `key()` que retorna a chave, `next()` que passa para o próximo valor, `rewind()` que passa para o início e `valid()` que verifica se já estamos no final.

A outra opção é implementar uma interface `IteratorAggregate`, que tem apenas um método `getIterator()`. Ele retorna um objeto de espaço reservado que fornecerá a passagem ou pode ser um gerador, que é uma função especial que usa `yield` para retornar chaves e valores sequencialmente:

```php
class Person
{
	public function __construct(
		public int $age,
	) {
	}
}

class Registry implements IteratorAggregate
{
	private array $people = [];

	public function addPerson(Person $person): void
	{
		$this->people[] = $person;
	}

	public function getIterator(): Generator
	{
		foreach ($this->people as $person) {
			yield $person;
		}
	}
}

$list = new Registry;
$list->addPerson(new Person(30));
$list->addPerson(new Person(25));

foreach ($list as $person) {
	echo "Age: {$person->age} years\n";
}
```


Melhores práticas .[#toc-best-practices]
----------------------------------------

Depois de aprender os princípios básicos da programação orientada a objetos, é fundamental concentrar-se nas práticas recomendadas de OOP. Elas o ajudarão a escrever códigos que não sejam apenas funcionais, mas também legíveis, compreensíveis e de fácil manutenção.

1) **Separação de preocupações**: Cada classe deve ter uma responsabilidade claramente definida e deve tratar apenas de uma tarefa principal. Se uma classe fizer muitas coisas, pode ser apropriado dividi-la em classes menores e especializadas.
2) **Encapsulamento**: Os dados e métodos devem ser tão ocultos quanto possível e acessíveis somente por meio de uma interface definida. Isso permite que você altere a implementação interna de uma classe sem afetar o restante do código.
3) **Injeção de dependência**: Em vez de criar dependências diretamente em uma classe, você deve "injetá-las" do lado de fora. Para entender melhor esse princípio, recomendamos os [capítulos sobre Injeção de Dependência |dependency-injection:introduction].