PHP - Iniciando com OO

Aula 02 a 03 - Ambiente de trabalho / Paradigma funcional
Esse curso irá trabalhar com o servidor do PHP. Iniciamos com o comando:
php -S localhost:8081
Os principais paradigmas de programação são o paradigma procedural, o paradigma funcional e o paradigma de orientação a objetos.
O PHP inicialmente foi projetado para o paradigma funcional. A partir da versão 5 ele passou a suportar o paradigma de orientação a objetos.
O paradigma funcional é baseado na execução de funções e se utiliza principalmente delas para a execução dos processos.
Aula 04 a 05 - Paradigma OO / Iniciando OO
A principal vantagem da Orientação a Objetos é o reaproveitamento de Classes e Objetos dentro de um mesmo outros projetos.
A primeira coisa a se pensar são nas classes. Elas são "moldes" para os objetos que iremos utilizar.
Para criar métodos em PHP utilizamos a palavra reservada class (o nome das classes por convenção iniciam com letra maiúscula).
Dentro das classes as funções são chamadas métodos. Elas são declaradas da mesma forma que as funções normais, precedidas pelo tipo (inicialmente public).
Após criar uma classe devemos instanciá-la para um objeto com o operador new.
Uma vez instanciada podemos acessar através do objeto seus atributos e métodos com o sinal '->'.
class People
{
public function getHello($name)
{
return "Hello {$name}!";
}
}

$p = new People;

echo $p->getHello("Jean");

Aula 06 a 09 - Classes / Atributos / Métodos / Assinatura
As classes devem ser únicas. Segundo o padrão (pelo menos na época da aula) cada classe deve estar em um arquivo iniciado em letra maiuscula.
Criada a classe em seu respectivo arquivo, importamos ela com o require_once() ou outro método de importação.
A partir disso podemos instanciar quantos objetos quisermos com essa classe.
Dentro da classe podemos criar variáveis que são chamadas atributos. Esses atributos podem ser acessados por qualquer objeto instanciado a partir dela.
Para declarar variáveis utilizamos o tipo (por enquanto public) e o nome da variável.
Instanciado o objeto podemos acessar seus atributos utilizando o sinal '->':
$ferrari = new Car;
$ferrari->brand = 'Ferrari';
$ferrari->color = 'Red';
$ferrari->engine = 488;

Já os métodos são funções executadas dentro do objeto. Assim como os atributos os métodos também sãom iniciados ccom um tipo seguido da palavra chave function e o nome do método.
Uma vez definido o método ele também pode ser executado pelos objetos instanciados. Quando nos referimos a itens dentro da classe eles podem ser referidos com a palavra $this sempre precedida pelo $ no PHP.
class Car
{
public $brand;
public $color;
public $engine;

public function getEngine()
{
return $this->engine . ' horsepower';
}
}

Chamamos assinatura dos métodos os parametros necessários para sua execução (quando existirem). Podemos definir um valor default para as assinaturas:
public function getEngineAss($type = "cv")
{
return "{$this->engine} {$type}";
}
Caso necessário podemos definir o valor default como null.
Aula 10 - Heranças
Em OO herança ocorre quando uma classe recebe as propriedades de outra.
Quando temos uma classe filha que herdará os atributos e métodos de outra utilizamos a palavra reservada extends e devemos incluir o arquivo da classe pai no arquivo da classe filha.
Quando criamos uma classe filha, mesmo que ela esteja vazia, podemos acessar todos os atributos e métodos da classe pai.
As classes filhas podem ter seus próprios atributos e métodos, independentes da classe pai.
require_once('./Vehicle.php');

class Car extends Vehicle
{
public $doors;
}

Aula 11 a 12 - Construtor / Calling Parent
O construtor é uma função incluida na classe que define os parametros que 'devem' ser passados ao instanciar um objeto. Esse construtor é passado por herança e obriga também os filhos.
Da mesma forma como na assinatura, podemos definir valores default para os valores do construtor.
public function __construct($brand, $color = null)
{
$this->brand = $brand;
$this->color = $color;
}


Podemos alterar a forma como os dados são passados no construtor diretamente na classe filha. Para isso podemos criar um construtor na classe filha ou alterar parte do construtor herdado da classe pai.
Alterando o construtor na classe filha: public function __construct($brand, $color = null)
{
$this->brand = $brand;
$this->color = strtoupper($color);
}

Manipulando o construtor da classe pai:
public function __construct($brand, $color = null)
{
parent::__construct($brand, strtoupper($color)); }

Aula 13 a 14 - Private e Public / Protected
Os termos private e public relacionam-se a visibilidade ou aos chamados modificadores de acesso.
Os métodos e atributos definidos como public podem ser acessados fora da classe ou objeto. Já os definidos como private ficam restritos ao objeto.
Quando criamos atributos ou métodos private devemos criar métodos setters e getters:
class Car extends Vehicle
{
private $doors;

public function setDoors($doors)
{
$this->doors = $doors;
}
public function getDoors()
{
return $this->doors;
}
}

Já o modificador protected permite apenas o acesso nas classes filhas, mas não diretamente pelo código. Desse modo podemos manipular os atributos dentro das classes filhas (como parametro de um método por exemplo), mas não diretamente.
Aula 15 - Abstract Class
Classes abstratas são templates de classes que só podem ser extendidas para classes filhas. Elas não podem ser instanciadas com a palavra reservada new.
Já quando utilizamos o abstract em métodos, eles passam a ser obrigatórios nas classes filhas, ou seja, devem ser declarados na construção das classes filhas. Os métodos do tipo abstract não podem conter 'corpo', ou seja só podem ser declarados na classe pai e sua construção deve ser feita na classe filha.
A interface é um protótipo de classe que apenas define o que é necessário ao cria-la. Uma vez implementada em outra classe com o implemets essas classes e suas filhas DEVEM conter todos os métodos declarados na interface.
Ou seja a interface cria um padrão para a criação das classes.