Rodrigo Silva Luz / rodrigosilvaluz3@gmail.

com

Introdução à
1.1 Orientação a Objetos
Anotações

__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________

Documento produzido pela 4Linux

1
Rodrigo Silva Luz / rodrigosilvaluz3@gmail.com

2
Objetivos da Aula

Conceituar Paradigma de Programação Orientada a Objetos

Identificar Boas Práticas de Desenvolvimento

Anotações

__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________

Documento produzido pela 4Linux

2
Rodrigo Silva Luz / rodrigosilvaluz3@gmail.com

3
Paradigma de Programação Orientada a
Objetos

POLIMORFISMO HERANÇA

POO

ABSTRAÇÃO ENCAPSULAMENTO

Paradigma de Programação Orientada a Objetos

Programação Orientada a Objetos (POO) é um paradigma de programação baseado no

conceito de objetos abstraídos do mundo real, desenvolvido na década de 60.
Um objeto é uma estrutura que pode conter dados (atributos ou propriedades) e executar
ações (métodos). Um dos criadores desse conceito foi Alan Kay, que possuía conhecimento em
biologia e acreditava que um programa de computador poderia funcionar como o corpo humano
(células independentes que trabalham juntas para alcançar um objetivo).
Uma das primeiras linguagens orientadas a objeto foi a SmallTalk, que tornou possível a
criação de interface gráfica para os computadores.
Muitas das linguagens de programação mais utilizadas, como PHP, Java e Python, são
linguagens de programação multi paradigmas que suportam programação orientada a objetos em
maior ou menor grau, tipicamente em combinação com programação procedural imperativa.
Linguagens orientadas a objeto significativas incluem Java, C++, C#, Python, Lua, PHP, Ruby,
Perl, Objective-C, Dart, Swift, Scala, Common Lisp e Smalltalk.
Os quatro pilares que caracterizam uma linguagem orientada a objetos são: abstração,
encapsulamento, herança e polimorfismo.

Abstração
Abstrair um elemento do mundo real, representá-lo como um objeto, consiste em
considerarmos apenas suas propriedades mais relevantes de acordo com a aplicação. Dessa forma,
temos uma representação mais abrangente.

Documento produzido pela 4Linux

3
Rodrigo Silva Luz / rodrigosilvaluz3@gmail.com

É necessário dar uma identidade ao objeto, identificar suas características mais relevantes
que se tornarão propriedades do objeto e, por fim, identificarmos as ações que o objeto executará,
que serão traduzidas como métodos.
Um exemplo simples:
Imagine a abstração de um carro. Quais características nosso objeto carro possuiria? Cor,
quantidade de portas, potência do motor, modelo, combustível, etc.
E quais ações o carro executa? Dar partida no motor, acelerar, frear, trocar de marcha…

Encapsulamento
Encapsulamento é um conceito de programação orientada a objetos que associa os dados
às funções que manipulam os dados, mantendo ambos seguros contra interferência externa e má
utilização.
Alguns dados são resultado de operações complexas e não podem ser simplesmente
atribuídos. Imagine, por exemplo, o saldo de uma conta corrente, que é o resultado das diversas
entradas e saídas de dinheiro da conta. Não podemos simplesmente atribuir um valor a esta
propriedade, ela deve ser protegida.
Métodos podem ser definidos para conter regras sobre como atribuir corretamente o valor
das propriedades. Tais métodos são conhecidos como getters e setters, pois sua função é
justamente obter e definir o valor de uma propriedade.

Herança
A herança é uma característica muito interessante da programação orientada a objetos, pois
permite que façamos reuso de código. Um objeto herda todas as características de seu “ancestral”,
podendo fazer uso das propriedades e métodos herdados.
Podemos ter um objeto Pessoa com propriedades que representam características comuns
como nome, sobrenome, data de nascimento. E podemos ter um objeto Aluno que herda as
características de Pessoa e, ainda, acrescenta dados específicos como graduação, notas e cursos
que frequenta. Da mesma forma, podemos ter um Professor que também herda de Pessoa, mas
possui dados diferentes de Aluno, como as disciplinas que ensina.

Polimorfismo
O termo polimorfismo é originário do grego e significa "muitas formas" (poli = muitas,
morphos = formas). Um dos tipos de polimorfismo é a possibilidade de sobrescrever métodos
herdados.
Imagine uma situação em que você tem um objeto Conta que possui um método depositar.
Esse método simplesmente recebe um valor como parâmetro e o soma ao saldo da conta. Em
tipos diferentes de conta o depósito pode ser um processo mais complexo. Nesse caso, se
tivermos uma ContaPoupanca que herda de Conta, poderíamos alterar o método depositar de
ContaPoupanca, para que se adeque às necessidades.
Documento produzido pela 4Linux
4
Rodrigo Silva Luz / rodrigosilvaluz3@gmail.com

5
Boas Práticas de Desenvolvimento

Boas Práticas
Apesar de todas as ferramentas que existem para auxiliar o trabalho e agilizar todo o
processo, é necessário que saibamos trabalhar com boas práticas, para que o projeto corra bem e
de forma eficiente, principalmente quando lidamos com um trabalho em grupo.
Há diversos princípios comuns de design que, assim como os design patterns, se tornaram
boas práticas através dos anos e ajudaram na formação de uma base sobre a qual softwares de
fácil manutenção e nível empresarial podem ser construídos. Abaixo, apresentamos um resumo dos
princípios mais conhecidos:

Keep It Simple, Stupid (KISS) – Mantenha isto simples, estúpido

É um princípio geral que valoriza a simplicidade do projeto e defende que toda a
complexidade desnecessária seja descartada. Serve como fórmula útil em diversas áreas como o
desenvolvimento de software, a animação, as diversas engenharias e no planejamento estratégico
e tático. Também é aplicado na Literatura, na Música e nas Artes em geral.

Don’t Repeat Yourself (DRY) – Não se repita

É um conceito de programação de computadores o qual propõe que cada porção de
conhecimento em um sistema deve possuir uma representação única, de autoridade e livre de
ambiguidades em todo o sistema. Esta expressão foi cunhada por Andy Hunt e Dave Thomas em
seu livro The Pragmatic Programmer. Ele se aplica amplamente, incluindo esquema de banco de
dados, plano de teste, compilação e mesmo documentação de software.

Documento produzido pela 4Linux

5
Rodrigo Silva Luz / rodrigosilvaluz3@gmail.com

Se este conceito for aplicado, a modificação de uma parte do sistema não leva a modificações
em outras partes não relacionadas. Adicionalmente, todos os elementos relacionados mudam de
forma previsível e uniforme, mantendo-se, portanto, sincronizados.

Tell, Don’t Ask – Diga, não pergunte

É um princípio que ajuda a lembrar que a orientação a objetos envolve o empacotamento de
dados com os métodos que operam nesses dados. Isso nos lembra que, ao invés de pedir dados a
um objeto e agir com base nesses dados, devemos dizer a um objeto o que fazer.

You Ain't Gonna Need It (YAGNI) – Você não vai precisar disso
É um princípio que sugere aos programadores que não adicionem funcionalidades ao código
fonte de um programa até que elas sejam realmente necessárias. Sempre se deve implementar
coisas que sejam realmente necessárias, nunca o que se prevê que possa ser um dia.

Separation of Concerns (SoC) – Separação de interesses

É um princípio de design para separar uma aplicação em seções distintas, de modo que cada
seção aborde um interesse separadamente.
Um interesse é um conjunto de informações que afeta o código de uma aplicação.
Uma aplicação que incorpora SoC adequadamente é chamada de modular. A modularidade e,
portanto, a separação de interesses, é obtida encapsulando informações dentro de uma seção de
código que possui uma interface bem definida. O encapsulamento é um meio de ocultar informação.
Projetos em camadas em sistemas de informação são outra forma de concretizar a separação
de interesses. Por exemplo, camada de apresentação, camada de lógica de negócios, camada de
acesso a dados, camada de persistência.
A separação de interesses resulta em graus mais altos de liberdade em algum aspecto do
projeto, implantação ou uso do programa. Comum entre estes é maior grau de liberdade para
simplificação e manutenção de código. Quando os interesses são bem separados, há graus mais
altos de liberdade para reutilização de módulos, bem como desenvolvimento e atualização
independentes. Como os módulos ocultam os detalhes de seus interesses por trás das interfaces,
aumentam os resultados de liberdade para melhorar ou modificar posteriormente a seção de código
de um único interesse, sem precisar conhecer os detalhes de outras seções e tampouco fazer
alterações correspondentes nessas seções. Os módulos também podem expor diferentes versões de
uma interface, o que aumenta a liberdade de atualizar um sistema complexo de maneira gradativa,
sem perda temporária de funcionalidade.
Separação de interesses é uma forma de abstração. Como na maioria das abstrações, as
interfaces devem ser adicionadas e geralmente há mais código de rede a ser executado. Portanto,
apesar dos muitos benefícios de interesses bem separados, muitas vezes há uma penalidade de
execução associada.

Documento produzido pela 4Linux

6
Rodrigo Silva Luz / rodrigosilvaluz3@gmail.com

Classes e Objetos
Propriedades e Métodos
1.2 Constantes de Objeto
Anotações

__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________

Documento produzido pela 4Linux

7
Rodrigo Silva Luz / rodrigosilvaluz3@gmail.com

8
Objetivos da Aula

Definir Classes e Objetos

Distinguir Propriedades e Métodos

Identificar Constantes de Objeto

Ilustrar como carregar Classes automaticamente (autoloading)

Anotações

__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________

Documento produzido pela 4Linux

8
Rodrigo Silva Luz / rodrigosilvaluz3@gmail.com

9
Classes e Objetos

Planta da casa CLASSE Casa construída OBJETO

Classes e Objetos

Uma classe é a definição de um objeto, todas as suas características e ações descritas. É

como a planta de uma casa, onde são especificados os cômodos, com suas medidas e posição
de portas e janelas.
Usamos a classe para fazer a abstração da entidade ou ato do mundo real. Criamos suas
propriedades e implementamos seus métodos de acordo com as necessidades da aplicação em
questão.
Para criarmos uma classe utilizamos a palavra-chave class, seguida do nome da classe e
um par de chaves, que englobam as definições de propriedades e métodos.

Para nomear a classe deve-se seguir alguns critérios:

♦ O nome não pode ser igual a uma palavra reservada do PHP;
♦ Deve começar com uma letra ou sublinhado;
♦ Pode conter qualquer sequência de letras, números e sublinhados;
♦ Usar letra maiúscula no início de cada palavra (StudlyCaps).

Documento produzido pela 4Linux

9
Rodrigo Silva Luz / rodrigosilvaluz3@gmail.com

Exemplo de definição simples de uma classe:

Uma vez que temos a classe definida, podemos criar um objeto. É importante compreender
bem os dois conceitos (Classe e Objeto).
Um objeto é a instância de uma classe, voltando à analogia da casa, se a classe é como a
planta de uma casa o objeto é a casa construída, o objeto é construído na memória do
computador e, a partir daí, suas propriedades e métodos podem ser utilizados.
Trabalhamos então com dois contextos, o de classe, onde definimos os recursos
necessários e o de objeto, onde temos as definições em execução.
Para criarmos um objeto (instância da classe) usamos a palavra-chave new, a não ser que
você tenha definido um método construtor que dispare um exceção em caso de erro, um objeto
sempre será criado.
É comum atribuir a uma variável a referência de um objeto, veja abaixo:

Se tivermos uma string com o nome da classe (em uma variável, por exemplo) e passarmos
essa string para o new, uma nova instância da classe será criada:

Documento produzido pela 4Linux

10
Rodrigo Silva Luz / rodrigosilvaluz3@gmail.com

11
Propriedades e Métodos

Planta da casa CLASSE

Propriedades Métodos

 Quantidade de cômodos
 Medidas dos cômodos  Trancar a portas
 Tamanho do terreno  Fechar as janelas
 Cor das paredes  Acender as luzes
 Tipo de piso  Abrir a torneira
 Pé direito  Ligar o ar condicionado
 Número da casa

Propriedades e métodos

Variáveis membros de uma classe são chamadas propriedades. Podemos também

encontrar sendo referidas através de termos como atributos ou campos.
As propriedades são definidas usando uma das palavras-chave public, protected ou private,
seguidas de uma declaração normal de variável. Essa declaração pode incluir sua inicialização,
porém deve ser um valor constante, ou seja, deve ser possível avaliá-lo em tempo de compilação e
não deve depender de informações de tempo de execução.
O nome das propriedades segue as mesmas regras do nome de classe, substituindo o
StudlyCaps por CamelCase.

Um método nada mais é do que uma função definida dentro de uma classe. Para definir um
método usamos as palavras-chave public, protected ou private, assim como a propriedade. O nome
do método também segue as mesmas regras do nome de propriedade.
Um método pode ou não conter parâmetros e retornar valores. Também podemos definir o
type hinting de parâmetros e de retorno.
Exemplo de definição simples de um método:

Documento produzido pela 4Linux

11
Rodrigo Silva Luz / rodrigosilvaluz3@gmail.com

12
Constantes de Objeto

Planta da casa CLASSE

Propriedades

 Quantidade de cômodos Variável

CONSTANTE
 Medidas dos cômodos Variável
 Tamanho do terreno Constante =
 Cor das paredes Variável VALORES
 Tipo de piso Variável IMUTÁVEIS!
 Pé direito Variável
 Número da casa Constante

Constantes de Objeto
Podemos definir constantes em uma classe. Por padrão, elas têm visibilidade pública. O valor
deve ser uma expressão constante, não podendo ser, por exemplo, uma variável, uma propriedade,
ou uma chamada a uma função. As constantes de classe são alocadas (carregadas na memória) por
classe, e não em cada instância da classe.

Para acessarmos uma propriedade ou método usamos o operador de acesso ->. As constantes
de classe são membros estáticos. Portanto, para acessá-las, utilizamos o operador de resolução de
escopo ::, conhecido como Paamayim Nekudotayim, que significa dois pontos duplos em Hebreu.

Documento produzido pela 4Linux

12
Rodrigo Silva Luz / rodrigosilvaluz3@gmail.com

13
Carregando Classes automaticamente
(autoloading)

Função __autoload()

Carregando Classes automaticamente (autoloading)

É comum ao desenvolver aplicações orientadas a objeto armazenar cada classe em um

arquivo .php com o mesmo nome da classe, pois assim temos maior modularidade e a manutenção
fica mais fácil, uma vez que estaremos editando arquivos que se referem às funcionalidades
específicas. Mas, por outro lado, um empecilho é gerado: a necessidade de escrever uma longa lista
de includes no início de cada script (um para cada classe).
Para resolver isso, desde o PHP 5 está disponível a função __autoload(). Com ela é possível
criar uma estrutura para carregar automaticamente qualquer classe necessária à aplicação.
Esta função foi descontinuada a partir do PHP 7.2, portanto, a estudaremos aqui com a
finalidade de ter um conhecimento importante para aplicações legadas e, mais adiante, serão
apresentadas novas formas de lidar com autoloading.

Documento produzido pela 4Linux

13
Rodrigo Silva Luz / rodrigosilvaluz3@gmail.com

Nossa classe de exemplo:

Exemplo de uso da função:

Documento produzido pela 4Linux

14
Rodrigo Silva Luz / rodrigosilvaluz3@gmail.com

15

Clonando Objetos
1.3
Anotações

__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________

Documento produzido pela 4Linux

15
Rodrigo Silva Luz / rodrigosilvaluz3@gmail.com

16
Objetivos da Aula

Explicar a clonagem de objetos utilizando a palavra-chave clone

Demonstrar o Método Mágico __clone()

Anotações

__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________
__________________________________

Documento produzido pela 4Linux

16
Rodrigo Silva Luz / rodrigosilvaluz3@gmail.com

17
Clonagem de objetos utilizando a palavra-
chave clone

$objeto 1 $objeto 1

$objeto 2 $objeto 2

Atribuir o valor de
uma variável à outra
NÃO É clonagem!

Clonando objetos

Temos a seguinte classe:

Para criarmos um novo objeto, utilizamos a palavra-chave new e uma atribuição à uma
variável, como demonstrado abaixo:

Fica fácil imaginar que se quisermos uma “cópia” deste objeto basta criarmos uma nova
variável “copiando” a primeira:

Documento produzido pela 4Linux

17
Rodrigo Silva Luz / rodrigosilvaluz3@gmail.com

Ao tentarmos alterar o valor de uma propriedade do segundo objeto percebemos que, na

verdade, alteramos os dois:

Veja a saída gerada no browser:

Na verdade, o que acontece é que temos somente um objeto e duas variáveis

armazenando a sua referência. Quando criamos o objeto, apenas sua referência é armazenada
na variável. Ao atribuirmos $objeto1 à $objeto2 estamos simplesmente determinando que duas
variáveis apontem para o mesmo objeto.
Se realmente desejamos duplicar o objeto, ter duas instâncias idênticas porém distintas,
devemos usar a palavra-chave “clone” para a atribuição do segundo objeto, ao invés de uma
atribuição simples.

Agora, temos de fato dois objetos:

Documento produzido pela 4Linux

18
Rodrigo Silva Luz / rodrigosilvaluz3@gmail.com

19
Método mágico __clone()

Método __clone()

__clone ( void ) : void

Depois que a clonagem se completa, se um método __clone() estiver definido, o objeto
recém criado terá seu método __clone() chamado, permitindo que qualquer propriedade seja
alterada.
Vamos alterar nossa classe Usuario, acrescentando o método __clone():

Documento produzido pela 4Linux

19
Rodrigo Silva Luz / rodrigosilvaluz3@gmail.com

E acrescentar mais alguns clones:

É possível usar o método __clone() para qualquer tipo de operação que deva ser feita nos
clones, logo após a clonagem.
Saída do script após as alterações:

Documento produzido pela 4Linux

20