Caderno DS - Programação Web Orientada a Objetos [EAD Regular 2019.2 - ETEPAC].pdf

Programação Web
Orientada a Objetos
Cinthya Cavalcanti Flório
Leonardo Guimarães de Holanda
Curso Técnico em Desenvolvimento de Sistemas
Educação a Distância
2020

Programação Web
Orientada a Objetos
Curso Técnico em Desenvolvimento de Sistemas
Escola Técnica Estadual Professor Antônio Carlos Gomes da Costa
Educação a Distância
Recife
Março | 2020

Dados Internacionais de Catalogação na Publicação (CIP) de acordo com ISDB
F638p
Flório, Cinthya Cavalcanti.
Programação Web Orientada a Objetos: Curso Técnico em Desenvolvimento de Sistemas:
Educação a distância / Cinthya Cavalcanti Flório, Leonardo Guimarães de Holanda. – Recife:
Escola Técnica Estadual Professor Antônio Carlos Gomes da Costa, 2020.
96 p.: il.
Inclui referências bibliográficas.
Caderno eletrônico produzido para oferta EAD Regular em março de 2019 pela Escola
Técnica Estadual Professor Antônio Carlos Gomes da Costa.
1. Programação orientada a objetos (Computação). 2. Classes e objetos. 3. Java (Linguagem
de programação de computador). I. Título.
CDU – 004.438
Elaborado por Hugo Carlos Cavalcanti | CRB-4 2129
Professor(es) Autor(es)
Revisão
Américo Barros
Coordenação de Curso
Américo Barros
Coordenação Design Educacional
Deisiane Gomes Bazante
Design Educacional
Ana Cristina do Amaral e Silva Jaeger
Fernanda Paiva Furtado da Silveira
Izabela Pereira Cavalcanti
Jailson Miranda
Roberto de Freitas Morais Sobrinho
Descrição de imagens
Sunnye Rose Carlos Gomes
Catalogação e Normalização
Hugo Cavalcanti (Crb-4 2129)
Diagramação
Jailson Miranda
Coordenação Executiva
George Bento Catunda
Renata Marques de Otero
Manoel Vanderley dos Santos Neto
Coordenação Geral
Maria de Araújo Medeiros Souza
Maria de Lourdes Cordeiro Marques
Secretaria Executiva de
Educação Integral e Profissional
Escola Técnica Estadual
Professor Antônio Carlos Gomes da Costa
Gerência de Educação a distância

Sumário
Introdução..............................................................................................................................................6
1.Competência 01 | Conhecer os princípios e a importância da orientação a objeto ..........................7
1.1 Surgimento e importância da Programação Orientada a Objetos..............................................................7
1.2 Programação Orientada a Objetos x Programação Estruturada.................................................................7
1.3 Principais conceitos da Programação Orientada a Objetos..................................................................... 11
2.Competência 02 | Conhecer os conceitos de classe, herança, objeto, atributo e método .............19
2.1 Classe........................................................................................................................................................ 19
2.2 Objeto ...................................................................................................................................................... 20
2.3 Atributo.................................................................................................................................................... 21
2.4 Método..................................................................................................................................................... 23
2.4.1 Métodos get e set ................................................................................................................................. 25
2.5 Atributos e Métodos Estáticos................................................................................................................. 27
2.6 Construtor................................................................................................................................................ 30
2.7 Herança.................................................................................................................................................... 34
3.Competência 03 | Conhecer os conceitos de associação, encapsulamento, abstração, polimorfismo
e interface.............................................................................................................................................41
3.1 Abstração ................................................................................................................................................. 41
3.1.1 Classe Abstrata...................................................................................................................................... 41
3.2 Encapsulamento....................................................................................................................................... 49
3.3 Classe Final............................................................................................................................................... 52
3.3.1 Erro ao herdar de uma classe final ....................................................................................................... 55
3.4 Associação................................................................................................................................................ 56
3.5 Interface................................................................................................................................................... 57
3.6 Operadores this e parent......................................................................................................................... 63
3.7 Polimorfismo............................................................................................................................................ 65

4.Competência 04 | Implementar uma aplicação utilizando técnicas de orientação a objetos .........74
4.1 Configuração da Aplicação...................................................................................................................... 74
4.2 Classes da Aplicação................................................................................................................................ 78
4.3 Cadastrar, Alterar e Remover.................................................................................................................. 85
4.4 Buscar...................................................................................................................................................... 87
Conclusão .............................................................................................................................................93
Referências...........................................................................................................................................94
Minicurrículo do Professor...................................................................................................................95

6
Introdução
É com satisfação que dou a vocês as boas-vindas à disciplina de Programação Web
Orientada a Objetos. Os assuntos que serão tratados nesta disciplina fazem parte de uma área da
informática conhecida como Desenvolvimento de Software e envolvem a solução de problemas
através construção de algoritmos que utilizam o paradigma orientado a objetos.
O nosso caderno possui quatro competências. Na primeira vocês aprenderão sobre o
surgimento e a importância da programação orientada a objetos, além disso também será
apresentado um comparativo entre o paradigma orientado a objetos e o paradigma estruturado, e
por fim são mostrados os principais conceitos da programação orientada a objetos. Todos os
exemplos ilustrados estão relacionados à aplicação RestauranteFomeZero (fictícia criada pelos
autores) que será construída e explicada ao longo das competências utilizando a linguagem PHP.
Na segunda competência serão abordados os conceitos relativos a classe, objeto, atributo,
método, métodos get e set, atributos e métodos estáticos, construtor e herança. Na terceira
competência serão apresentados os conceitos relacionados a classe abstrata, encapsulamento, classe
final, associação, polimorfismo e interface.
Na quarta e última competência serão exibidas as etapas para implementar uma aplicação
utilizando técnicas de orientação a objetos. São demonstrados os passos para a configuração de uma
aplicação, desenvolvimento das classes desta aplicação e as funcionalidades de cadastro, alteração,
remoção e busca das suas informações em um banco de dados.
Desejo que vocês aproveitem ao máximo essa disciplina.
Para utilizar um ambiente de desenvolvimento on-line da linguagem PHP,
Acesse: https://3v4l.org/

Competência 01
7
1.Competência 01 | Conhecer os princípios e a importância da orientação
a objeto
1.1 Surgimento e importância da Programação Orientada a Objetos
Para desenvolver um software é preciso atravessar diversas etapas, desde o
planejamento até a entrega para o cliente. A engenharia de software é uma abordagem sistemática
e organizada que assegura a elaboração, construção e entrega do software. O sucesso da execução
dessas etapas depende de vários processos e subprocessos dentro da engenharia de software, como,
especificação dos requisitos, análise e projeto, desenvolvimento (programação), testes e
implantação.
A programação é uma etapa da engenharia de software que consiste em desenvolver um
software, que foi planejado nos estágios anteriores, por meio de uma linguagem de programação.
Atualmente, existem diversas linguagens de programação, que seguem diferentes paradigmas
(padrões ou modelos). Um desses paradigmas é a orientação a objetos.
O paradigma orientado a objetos surgiu devido à vários fatores, mas principalmente pela
necessidade de uma maior otimização e reutilização do código desenvolvido para construção dos
softwares. Durante muitos anos, vários desenvolvedores de software trabalharam na construção de
sistemas muito parecidos, que solucionavam praticamente os mesmos problemas. A fim de que os
desenvolvedores não tivessem que repetir toda vez os mesmos esforços, foi elaborada a
programação orientada a objetos.
1.2 Programação Orientada a Objetos x Programação Estruturada
No paradigma estruturado os blocos de comando se relacionam através de três
mecanismos básicos: sequência, decisão (condicional) e iteração (repetição). Utiliza-se o mecanismo
de sequência lógica para se chegar a um objetivo final, pois são operações elementares que um
programa pode executar em seu nível mais básico, como, operações aritméticas, de atribuição, entre
outros. Nesse contexto, também levamos em consideração as operações de entrada e saída de dados.
A Figura 1 apresenta um exemplo de estrutura sequencial.

Competência 01
8
Figura 1 - Exemplo de estrutura sequencial
Fonte: Ana Fernanda Gomes e Edilene Aparecida (Livro: Fundamentos da Programação de Computadores)
Descrição: Pseudocódigo representando uma estrutura sequencial, delimitado pelas palavras reservadas ALGORITMO e
FIM_ALGORITMO. Dentro uma representação de declaração de variáveis através da palavra reservada DECLARE e uma
abstração do código através do texto bloco de comandos.
Já o mecanismo de decisão compõe formas de selecionar quais operações serão
executadas (fluxos), de acordo com as ocorrências lógicas do algoritmo. Geralmente, existe um fluxo
principal na execução do programa no qual as estruturas de seleção permitem desviar, de forma
condicional, direcionando o algoritmo para outro fluxo. As Figuras 2 e 3 mostram um exemplo das
estruturas de decisão “se-então” e “se-então-senão”, respectivamente.
Figura 2 - Exemplo de estrutura condicional simples
Descrição: Pseudocódigo representando uma estrutura condicional, utilizando a palavra reservada SE para delimitar a
condição e as palavras reservadas ENTÃO INICIO e FIM para delimitar o conteúdo dentro da estrutura caso o resultado
da condição seja verdadeiro e uma abstração do código através dos textos comando 1 comando 2 comando 3.
Figura 3 - Exemplo de estrutura condicional composta
Descrição: Pseudocódigo representando uma estrutura condicional, utilizando a palavra reservada SE para delimitar a
condição e as palavras reservadas ENTÃO INICIO e FIM para delimitar o conteúdo dentro da estrutura caso o resultado

Competência 01
9
da condição seja verdadeiro e uma abstração do código através dos textos comando 1 comando 2. Além disso, o
pseudocódigo também possui uma condição alternativa caso o resultado da condição seja falso através das palavras
reservadas SENÃO INICIO e FIM para delimitar o conteúdo dentro da estrutura e uma abstração do código através dos
textos comando 3 comando 4.
O mecanismo de iteração possibilita que um bloco de comandos se repita várias vezes
durante a execução do programa. Estas estruturas são conhecidas como laços (loops). As Figuras 4 e
5 mostram um exemplo das estruturas de repetição “para” e “enquanto”, respectivamente.
Figura 4 - Exemplo de estrutura de repetição PARA
Descrição: Pseudocódigo representando uma estrutura de repetição, utilizando as palavras reservadas PARA, ATE e
FAÇA para estabelecer a repetição. É atribuído valor inicial para a variável J entre PARA e ATE, entre ATE e FAÇA está o
valor final. Em seguida, estão as palavras reservadas INICIO e FIM para delimitar o conteúdo dentro da estrutura de
repetição com uma abstração do código através dos textos comando 1 comando 2.
Figura 5 - Exemplo de estrutura de repetição ENQUANTO
Descrição: Pseudocódigo representando uma estrutura de repetição, utilizando as palavras reservadas ENQUANTO e
FAÇA para estabelecer a repetição. É atribuída uma condição entre ENQUANTO e FAÇA. Em seguida, estão as palavras
reservadas INICIO e FIM para delimitar o conteúdo dentro da estrutura de repetição com uma abstração do código
através dos textos comando 1 comando 2 comando 3.
O paradigma orientado a objetos foi idealizado para desenvolver softwares de forma mais
simples e abstrata em relação ao paradigma estruturado, tentando aproximar os códigos feitos nas
linguagens de programação às entidades existentes no mundo real. Devido a isso, na orientação a
objetos ocorre a modelagem dos sistemas abstraindo cada componente como um objeto, com suas
características e funcionalidades.
Pensar em termos de objetos é muito semelhante a como pensamos e agimos na vida
real, por exemplo, vamos imaginar um restaurante como modelo de um sistema a ser representado

Competência 01
10
com o uso de programação orientada a objetos. Diríamos que um Prato é o elemento principal e tem
diversas características como o nome, a quantidade de pessoas servidas, se possui acompanhamento
ou não, o preço, etc. Além disso tem várias funcionalidades associadas, como exibir o prato, forma
de pagamento, entre outros. Então no contexto do paradigma da programação orientada a objetos o
Prato seria a classe, as características seriam os atributos e as funcionalidades associadas seriam os
métodos. Os objetos seriam os pratos específicos, como por exemplo cozido (serve 2 pessoas, possui
acompanhamentos, custa R$ 44, 27), carne de sol (serve 3 pessoas, possui acompanhamentos, custa
R$ 24, 99) e feijoada (serve 4 pessoas, não possui acompanhamentos, custa R$ 69, 99). A Figura 6
apresenta um exemplo dos conceitos da orientação a objetos de acordo com a classe Prato.
Figura 6 - Exemplo dos conceitos da orientação a objetos de acordo com a classe Prato
Fonte: A autora
Descrição: Representação dos conceitos da orientação a objetos por meio de imagens e exemplos do mundo real. No
lado esquerdo está um retângulo azul com retângulos brancos menores dentro dele. No primeiro retângulo branco
possui o texto Classe(Prato) dentro dele, o segundo retângulo branco possui o texto Características(Atributos) dentro
dele e o terceiro e último retângulo branco possui o texto Funcionalidades(Métodos) dentro dele. Do lado direito estão
três imagens, são elas: um cozido, uma carne de sol e uma feijoada. Cada uma dessas três imagens estão ligadas ao
retângulo azul por meio de segmentos de reta contínuos também azuis, ao todo são três segmentos de reta, um para
cada imagem. Essas três imagens estão sendo englobadas por uma chave na cor laranja e que possui o texto Objeto no
centro canto direito.

Competência 01
11
Em comparação ao paradigma estruturado, a programação orientada a objetos
diferencia-se pela facilidade de reuso, manutenção e abstração. Realizar a modelagem do mundo real
com seu comportamento e características em termos de objetos é mais prático e eficiente do que
pensar em instruções e procedimentos, por exemplo, analise o Texto 1 - Paradigma Estruturado e o
Texto 2 - Paradigma Orientado a Objetos e verifique qual é o mais fácil de ser entendido.
Texto 1 - Paradigma Estruturado:
“Amanhã irei abrir a porta daquele veículo movido a combustível, entrarei, me sentarei,
darei a partida no motor, pisarei na embreagem, engatarei a primeira marcha, acelerarei, controlarei
a direção em que o carro irá se mover utilizando o volante ao mesmo tempo em que passarei as
marchas de acordo com a velocidade até chegar ao meu trabalho, onde, através da chave da ignição
o desligarei quando estiver parado na devida vaga do estacionamento”. (Exemplo do Prof. Jorge
Felliphe do IFRN).
Texto 2 - Paradigma Orientado a Objetos:
“Vou usar o meu carro para ir ao trabalho amanhã” (Exemplo do Prof. Jorge Felliphe do
IFRN).
Após realizar a leitura dos textos fica claro que o mais intuitivo e próximo da linguagem
humana é o texto 2.
1.3 Principais conceitos da Programação Orientada a Objetos
Da Figura 7 à Figura 13 é apresentada da primeira até a sétima parte de um resumo com
os principais conceitos da programação orientada a objetos. É mostrado o conceito de classe, objeto,
atributo, método, métodos get e set, atributos e métodos estáticos, construtor, herança, classe
abstrata, encapsulamento, classe final, associação, polimorfismo e interface.
Além disso, também é mostrada a descrição de cada um deles, com um exemplo de
utilização dos conceitos em uma linguagem de programação, por fim é exibido um exemplo prático
dos conceitos anteriormente citados. Todos os exemplos estão relacionados à aplicação
RestauranteFomeZero que será utilizada, construída e explicada ao longo das competências.

Competência 01
12
Figura 7 – Resumo dos principais conceitos da programação orientada a objetos (Parte 1)
Fonte: A autora
Descrição: Representação de uma tabela com um resumo dos conceitos da orientação a objetos por meio de imagens e
exemplos do mundo real. A tabela é a primeira parte de um total de sete que compoẽ o resumo citado anteriormente.
Ela é formada por quatro linhas e quatro colunas predominantemente na cor azul e gradiente desta cor. Esta apresenta
o conceito, a descrição, um exemplo em código e um exemplo prático de: classe, objeto, atributo e método.

Competência 01
13
Fonte: A autora
exemplos do mundo real. A tabela é a segunda parte de um total de sete que compoẽ o resumo citado anteriormente.
Ela é formada por três linhas e quatro colunas predominantemente na cor azul e gradiente desta cor. Esta apresenta o
conceito, a descrição, um exemplo em código e um exemplo prático de: métodos get e set, atributos e métodos
estáticos e construtor.

Competência 01
14
Fonte: A autora
exemplos do mundo real. A tabela é a terceira parte de um total de sete que compoẽ o resumo citado anteriormente.
Ela é formada por uma linha e quatro colunas predominantemente na cor azul e gradiente desta cor. Esta apresenta o
conceito, a descrição, um exemplo em código e um exemplo prático de: herança.

Competência 01
15
Fonte: A autora
exemplos do mundo real. A tabela é a quarta parte de um total de sete que compoẽ o resumo citado anteriormente. Ela
é formada por uma linha e quatro colunas predominantemente na cor azul e gradiente desta cor. Esta apresenta o
conceito, a descrição, um exemplo em código e um exemplo prático de: classe abstrata.

Competência 01
16
Fonte: A autora
exemplos do mundo real. A tabela é a quinta parte de um total de sete que compoẽ o resumo citado anteriormente. Ela
é formada por três linhas e quatro colunas predominantemente na cor azul e gradiente desta cor. Esta apresenta o
conceito, a descrição, um exemplo em código e um exemplo prático de: encapsulamento, classe final e associação.

Competência 01
17
Fonte: A autora
exemplos do mundo real. A tabela é a sexta parte de um total de sete que compoẽ o resumo citado anteriormente. Ela
conceito, a descrição, um exemplo em código e um exemplo prático de: interface.

Competência 01
18
Fonte: A autora
exemplos do mundo real. A tabela é a sétima parte de um total de sete que compoẽ o resumo citado anteriormente. Ela
conceito, a descrição, um exemplo em código e um exemplo prático de: polimorfismo.

19
Competência 02
2.Competência 02 | Conhecer os conceitos de classe, herança, objeto,
atributo e método
2.1 Classe
Uma classe é formada por um agrupamento de variáveis (atributos) e funções (métodos),
que definem o estado e o comportamento comum de uma categoria de objetos do mesmo tipo. As
classes podem ser definidas como abstrações de objetos, pois estas são o molde ou a fôrma que
estrutura os objetos de acordo com os atributos e métodos especificados.
Fazendo uma comparação com a programação estrutura você poderia imaginar uma
classe como uma estrutura de dados, pois essas possuem informações de tipos abstratos. Contudo,
as classes possuem muito mais capacidade que uma estrutura de dados, por elas conterem os
métodos e também possuirem a flexibilidade de encapsular informações.
Para ficar mais claro o conceito de classe vamos pensar em um exemplo da vida real.
Imagine que você foi contratado pelo dono do restaurante Fome Zero para desenvolver um software.
Bacana não é? Então, o primeiro passo é pensar em como modelar os pedidos dos clientes. O cliente
deverá fazer um pedido através da solicitação de um prato (galinha à cabidela, cozido, carne de sol,
etc) ao restaurante. Sendo assim, é recomendado a criação da classe Prato.
Para declararmos uma classe, utilizamos a seguinte estrutura: primeiramente inserimos
a palavra-chave (também conhecida como palavra reservada) class, em seguida um nome que
identifique a classe e, por fim abre e fecha chaves {}. Dentro das chaves será inserido o corpo ou
escopo da classe. A Figura 14 apresenta a estrutura de classe chamada Prato.
DICA IMPORTANTE!
Uma classe representa uma entidade abstrata ou concreta, por isso na maioria
das vezes o nome da classe é um substantivo.

20
Competência 02
Figura 14 - Exemplo de classe Prato
Fonte: A autora
Descrição: Código-fonte escrito na linguagem PHP para construção de programa de computador. O código apresenta
uma classe vazia chamada Prato, que tem seu corpo delimitado pela abertura e fechamento de chaves. Todo o
conteúdo do código está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo PHP. A classe está
destacada através de um retângulo em vermelho com uma seta apontando para a palavra classe também em vermelho.
2.2 Objeto
Ao criamos uma classe o objetivo final é a geração de objetos que são representações
dessa classe. O objeto é a concretização de uma classe. É através dos objetos que é possível inicializar
os atributos e invocar os métodos. A partir da classe podem ser criados diversos objetos com
características e comportamentos diferentes dependendo dos valores fornecidos aos seus atributos
e dos valores dos parâmetros em seus métodos.
Vamos voltar ao exemplo do software para um restaurante. Pense que no software seja
preciso exibir todos os pratos que o restaurante fornece. Assim, será necessário instanciar os objetos
da classe Prato de acordo com os pratos reais fornecidos pelo restaurante.
Para instanciar um objeto, utilizamos a seguinte estrutura: primeiramente declaramos
uma variável sempre iniciando com o símbolo do cifrão $ e com um nome que identifique o objeto,
em seguida inserimos o sinal de igual = logo após acrescentamos a palavra-chave new, depois
adicionamos o nome da classe e, por fim colocamos ponto e vírgula. A Figura 15 apresenta a estrutura
do objeto $prato.
DICA IMPORTANTE!
Os nomes das Classes sempre iniciam com letra maiúscula. Caso o nome da classe
seja formado por mais de uma palavra, a primeira letra de cada palavra deverá iniciar
com letra maiúscula. Essa prática ou padrão é conhecido como CamelCase.

21
Competência 02
Figura 15 - Exemplo de objeto da classe Prato
Fonte: A autora
Descrição: Código-fonte escrito na linguagem PHP para construção de programa de computador. O código apresenta a
inclusão do arquivo prato.php e a criação de um objeto chamado $prato da classe Prato. Todo o conteúdo do código
está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo PHP. O objeto está destacado através de
um retângulo em vermelho com uma seta apontando para a palavra objeto também em vermelho.
2.3 Atributo
Os atributos ou propriedades são as características dos objetos. Os valores dessas
características definem o estado de um objeto, sendo assim é provável que, ao longo da utilização do
objeto, esses valores sofram alterações. Além disso, apesar de ser possível que objetos diferentes
possuam as mesmas características, os valores dos atributos são específicos de cada objeto e estes
só vão existir enquanto o objeto existir, ou seja, se o objeto for destruído os valores dos atributos
associados a ele também serão perdidos.
Mais uma vez vamos voltar ao exemplo do software para um restaurante. Se você está
pensando que iremos utilizar esse exemplo durante toda a disciplina você acertou! Agora, suponha o
prato possui uma série de características, como, nome, quantidade de pessoas servidas, se possui
acompanhamento, preço, entre outros. Todas essas características são os atributos dos objetos da
classe Prato. O valor destes atributos poderiam ser nome = galinha à cabidela ou quantidade de
pessoas servidas = 2, por exemplo.
Para declarar um atributo, utilizamos a seguinte estrutura: primeiramente declaramos um
modificador de acesso, em seguida uma variável sempre iniciando com o símbolo do cifrão $ e com
um nome que identifique o atributo e, por fim colocamos ponto e vírgula. Você pode estar se
perguntando “O que é um modificador de acesso?” Não se preocupe com isso por enquanto, esse
conceito será visto mais adiante. Com exceção do modificador de acesso todos os outros elementos
citados anteriormente são obrigatórios na declaração de um atributo. A Figura 16 apresenta a
estrutura do atributo $nome da classe Prato e a Figura 17 mostra um exemplo de inserção do valor
“Galinha à cabidela” ao atributo $nome do objeto $prato.

22
Competência 02
Figura 16 - Exemplo de atributo da classe Prato
Fonte: A autora
uma classe chamada Prato, com quatro atributos públicos, são eles: $nome, $quantidadePessoasServidas,
$possuiAcompanhamento e $preco. A classe Prato possui todo seu corpo delimitado pela abertura e fechamento de
chaves. Todo o conteúdo do código está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo PHP.
O atributo $nome está destacado através de um retângulo em vermelho com uma seta apontando para a palavra
atributo também em vermelho.
Figura 17 - Exemplo de inserção de um valor ao atributo nome do objeto prato
Fonte: A autora
inclusão do arquivo prato.php, a criação de um objeto chamado $prato da classe Prato e a atribuição do valor Galinha à
cabidela para o atributo nome do objeto $prato. Todo o conteúdo do código está inserido entre as tags de abertura
<?php e de fechamento ?> de arquivo PHP.
DICA IMPORTANTE!
Os nomes dos atributos e métodos sempre iniciam com letra minúscula. Caso o
nome do atributo ou método seja formado por mais de uma palavra, a primeira
letra de cada palavra deverá iniciar com letra maiúscula. Essa prática ou padrão é
conhecido como CamelCase.

23
Competência 02
2.4 Método
Os métodos são funcionalidades de uma classe. São as ações ou comportamentos que os
objetos poderão assumir. É através dos métodos que os objetos interagem e se comunicam. Para
cada método é necessário especificar uma assinatura que corresponda a uma descrição da atividade
que o método deverá executar. Os métodos podem receber nenhum parâmetro ou uma lista de
parâmetros, ou seja, uma ou diversas variáveis que podem ser passadas para serem utilizadas dentro
do corpo dos métodos. Além disso, também é possível retornar um resultado após a execução do
método, para isso é necessário a utilização da palavra-chave return no final do método seguida da
variável ou objeto que se deseja retornar.
No exemplo do software para um restaurante imagine que é preciso exibir as informações
relacionadas aos pratos. Para isso é necessário criar um método chamado exibirPrato. O objetivo
desse método é imprimir no navegador as informações relacionadas aos objetos do tipo Prato, como,
nome do prato, quantidade de pessoas servidas, se possui acompanhamento, preço. Verifique que
não foi necessário o método receber nenhum parâmetro nem retornar um resultado após a
execução.
A assinatura de um método, é composta pela seguinte estrutura: primeiramente
declaramos um modificador de acesso, em seguida acrescentamos a palavra-chave function, logo
após adicionamos um nome que identifique o método, posteriormente inserimos a lista de
parâmetros dentro dos parênteses e, por fim abre e fecha chaves {}. Dentro das chaves será inserido
o corpo ou escopo do método. Com exceção do modificador de acesso e da lista de parâmetros todos
os outros elementos citados anteriormente são obrigatórios na assinatura de um método. A Figura
18 apresenta a estrutura do método exibePrato da classe Prato. Os três pontos enfileirados um em
cima do outro no código, ,significam que parte do código está sendo omitida para que o foco seja
atribuído ao tópico do ensino está sendo destacado. Não se preocupe que mais adiante você irá
visualizar a classe Prato completa com todos os conceitos aprendidos até o momento. A Figura 19
mostra um exemplo de utilização dos métodos setNome, setQuantidadePessoasServidas,
setPossuiAcompanhamento, setPreco e exibePrato do objeto $prato.

24
Competência 02
Figura 18 - Exemplo de um método da classe Prato
Fonte: A autora
uma classe chamada Prato, com o método exibePrato sem parâmetros. A classe Prato possui todo seu corpo delimitado
pela abertura e fechamento de chaves. O método exibePrato também possui todo seu corpo delimitado pela abertura e
fechamento de chaves. O corpo do método exibePrato possui diversos comandos echo para impressão dos valores dos
atributos nome, quantidadePessoasServidas, possuiAcompanhamento e preço no navegador. Todo o conteúdo do
código está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo PHP. O método exibePrato está
destacado através de um retângulo em vermelho com uma seta apontando para a palavra método também em
vermelho.
Figura 19 - Exemplo de utilização dos métodos gets, sets e exibePrato pelo objeto prato
Fonte: A autora
inclusão do arquivo prato.php, a criação de um objeto chamado $prato da classe Prato com o parâmetro Prato Especial
no construtor. Além da atribuição do valor Galinha à cabidela para o método setNome, valor dois para o método
setQuantidadePessoasServidas, valor um para o método setPossuiAcompanhamento, valor cinquenta e dois reais e
trinta e seis centavos para o método setPreco do objeto $prato. E para finalizar também é chamado o método
exibePrato. Todo o conteúdo do código está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo
PHP.

25
Competência 02
2.4.1 Métodos get e set
Os métodos get e set são métodos que possuem atividades simples e bastante específicas,
ou seja, são direcionados exclusivamente para recuperar um valor, no caso do get, e inserir (setar)
um valor, no caso do set, nos atributos de uma classe. É uma boa prática sempre acessar os atributos
por meio dos métodos get e set.
A assinatura de um método get ou set, é composta pela seguinte estrutura: primeiramente
declaramos um modificador de acesso, em seguida acrescentamos a palavra-chave function, logo
após concatenamos get ou set antes do nome de um atributo do objeto o qual o método irá trabalhar,
desta forma, o nome do atributo também fará parte do nome do método e ajudará a identificar o
mesmo. Caso seja um método set, este receberá como parâmetro um valor que será setado no
atributo do objeto, por fim abre e fecha chaves {}. Dentro das chaves será inserido o corpo ou escopo
do método. Com exceção do modificador de acesso todos os outros elementos citados anteriormente
são obrigatórios na assinatura de um método get ou set. A Figura 20 apresenta a estrutura dos
métodos get e set da classe Prato e a Figura 21 mostra um exemplo de utilização do método setNome
com a inserção do valor “Galinha à cabidela” no atributo $nome do objeto $prato.
DICA IMPORTANTE!
Os três pontos enfileirados um em cima do outro no código significam que
parte do código está sendo omitida para que o foco seja atribuído ao tópico que
está destacado.
DICA IMPORTANTE!
É fortemente recomendado sempre usar verbos no nome dos métodos. Facilita o
entendimento e a manutenção do código.

26
Competência 02
Figura 20 - Exemplo de métodos get e set da classe Prato
Fonte: A autora
uma classe chamada Prato, com os métodos getNome sem parâmetros e setNome com o parâmetro $valor. A classe
Prato possui todo seu corpo delimitado pela abertura e fechamento de chaves. Os métodos getNome e setNome
também possuem seus respectivos corpos delimitados pela abertura e fechamento de chaves. O método getNome
retorna o valor do atributo nome e o método setNome insere o valor do parâmetro no atributo nome. Todo o conteúdo
do código está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo PHP. Os métodos getNome e
setNome estão destacado através de um retângulo em vermelho com uma seta apontando para a expressão métodos
get e set também em vermelho.
Figura 21 - Exemplo de utilização dos métodos set no objeto prato
Fonte: A autora
inclusão do arquivo prato.php, a criação de um objeto chamado $prato da classe Prato e a atribuição do valor Galinha à
cabidela para o método setNome do objeto $prato. Todo o conteúdo do código está inserido entre as tags de abertura

27
Competência 02
2.5 Atributos e Métodos Estáticos
Para acessar qualquer atributo ou método de uma classe é necessário declarar e
instanciar um objeto, por exemplo, $prato = new Prato(); Se não for dessa maneira não será possível
acessar. Contudo, existe uma exceção para essa regra quando utilizamos a palavra-chave static.
Quando usamos static em um atributo ou método tornamos estes membros globais da
classe, logo é possível acessá-lo diretamente sem o intermédio de um objeto, pois estes não
pertencem somente a um único objeto individual e específico, mas à classe de forma geral.
Retornando ao exemplo do software para um restaurante. Suponha que o dono do
restaurante quer saber quantos pratos são servidos. Veja que essa informação está relacionada a
classe Prato como um todo em vez de objetos específicos. Assim, será criado o atributo estático
$quantidadePratosServidos na classe Prato e atribuído o valor zero.
Para declara um atributo estático, utilizamos a seguinte estrutura: primeiramente
declaramos um modificador de acesso, em seguida inserimos a palavra-chave static, logo após uma
variável sempre iniciando com o símbolo do cifrão $ e com um nome que identifique o atributo e, por
fim colocamos ponto e vírgula. Com exceção do modificador de acesso todos os outros elementos
citados anteriormente são obrigatórios na declaração de um atributo estático. A Figura 22 apresenta
DICA IMPORTANTE!
É fortemente recomendado sempre utilizar os métodos get e set para acessar os
atributos de um objeto.
DICA IMPORTANTE!
Não existe a necessidade de criação de um objeto para acessar atributos e métodos
estáticos.

28
Competência 02
a estrutura do atributo estático $quantidadePratosServidos da classe Prato já sendo inicializado com
o valor zero.
Figura 22 - Exemplo de atributo estático da classe Prato
Fonte: A autora
$possuiAcompanhamento e $preco. Além disso a classe Prato também possui um atributo estático
$quantidadePratosServidos inicializado com zero. A classe Prato possui todo seu corpo delimitado pela abertura e
fechamento de chaves. Todo o conteúdo do código está inserido entre as tags de abertura <?php e de fechamento ?>
de arquivo PHP. O atributo $nome está destacado através de um retângulo em vermelho com uma seta apontando para
a expressão atributo estático também em vermelho.
Para ter acesso a um atributo estático é preciso utilizamos a seguinte estrutura: nome da
classe, seguido de dois pontos dois pontos :: e nome do atributo estático, por exemplo,
Prato::$quantidadePratosServidos. A Figura 23 apresenta um exemplo de utilização do atributo
estático da classe Prato.
Figura 23 - Exemplo de utilização do atributo estático da classe Prato no método exibePrato
Fonte: A autora

29
Competência 02
uma classe chamada Prato, com o método exibePrato sem parâmetros. A classe Prato possui todo seu corpo delimitado
pela abertura e fechamento de chaves. O método exibePrato também possui todo seu corpo delimitado pela abertura e
fechamento de chaves. O corpo do método exibePrato possui diversos comandos echo para impressão dos valores dos
atributos nome, quantidadePessoasServidas, possuiAcompanhamento e preço no navegador. Além disso, o método
exibePrato também possui o atributo estático $quantidadePratosServidor que é chamado por meio do operador parent
para imprimir seu valor no navegador. Todo o conteúdo do código está inserido entre as tags de abertura <?php e de
fechamento ?> de arquivo PHP. O atributo estático $quantidadePratosServidor está destacado através de um retângulo
em vermelho com uma seta apontando para a expressão atributo estático também em vermelho.
Para que o dono do restaurante possa saber quantos pratos são servidos é preciso que
toda vez que um objeto da classe Prato for criado seja acrescentado o valor 1 ao conteúdo do atributo
estático $quantidadePratosServidos. A Figura 24 apresenta um exemplo de utilização do atributo
estático da classe Prato após a inicialização dos objetos e a Figura 25 mostra um exemplo do conteúdo
que será impresso no navegador após a execução do método exibePrato com o uso do atributo
estático $quantidadePratosServidos.
Figura 24 - Exemplo de utilização do atributo estático da classe Prato
Fonte: A autora
inclusão do arquivo prato.php, o atributo estático $quantidadePratosServidor inicializado pelo valor um e chamado por
meio do operador parent, a criação de um objeto chamado $prato da classe Prato com o parâmetro Prato Especial no
construtor, além da atribuição do valor Galinha à cabidela para o atributo nome, valor dois para o atributo
quantidadePessoasServidas, valor um para o atributo possuiAcompanhamento, valor cinquenta e dois reais e trinta e
seis centavos para o atributo preco do objeto $prato. E também é chamado o método exibePrato. Posteriormente logo

30
Competência 02
abaixo, é atribuído o valor dois ao atributo estático $quantidadePratosServidor que é chamado por meio do operador
parent. Adicionamente a isto também temos, a criação de um objeto chamado $prato da classe Prato com o parâmetro
Prato Caseiro no construtor, além da atribuição do valor Cozido para o atributo nome, valor dois para o atributo
quantidadePessoasServidas, valor um para o atributo possuiAcompanhamento, valor quarenta e quatro reais e vinte e
sete centavos para o atributo preco do objeto $prato. E para finalizar também é chamado o método exibePrato. Todo o
conteúdo do código está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo PHP.
Figura 25 - Exemplo de saída do atributo estático
Fonte: A autora
Descrição: Saída no navegador do código-fonte escrito na linguagem PHP para construção de programa de computador.
A saída apresenta a mensagem Aproveitem nosso delicioso Prato Especial Prato: Galinha à cabidela, depois aparecem os
dados relativos ao objeto $prato, são eles, serve 2 pessoa(s), possui acompanhamentos: sim, custa: R$ 52.36 e
quantidade pratos servidos: 1. Em seguida, é exibida a mensagem Aproveitem nosso delicioso Prato Caseiro Prato:
Cozido, mais adiante aparecem novos dados relativos ao objeto $prato, são eles, serve 2 pessoa(s), possui
acompanhamentos: sim, custa: R$ 44.27 e quantidade pratos servidos: 2.
2.6 Construtor
O construtor é um método especial pelo fato de executar alguma ação toda vez que um
objeto é criado. Você pode está se perguntando “Que tipo de ação eu iria querer executar ao
inicializar um objeto? ”. A ação a ser executada no construtor vai depender do que você precisa que
DICA IMPORTANTE!
Em PHP para termos acesso a uma propriedade estática dentro do corpo da classe
temos que usar a palavra-chave self acompanhada de dois pontos dois pontos ::

31
Competência 02
seu objeto faça imediatamente após ser criado, por exemplo, poderia ser a impressão de uma simples
mensagem ou a inicialização dos atributos com valores específicos.
Construtores podem não receber nenhum parâmetro ou uma lista de parâmetros, ou
seja, nenhuma, uma, ou diversas variáveis podem ser passadas para serem utilizadas dentro do corpo
do construtor. Diferentemente dos métodos, não é possível retornar um resultado após a execução
dos construtores.
A declaração de um construtor, na linguagem PHP, é composta pela seguinte estrutura:
primeiramente declaramos a palavra-chave function, em seguida acrescentamos o nome reservado
__construct(), logo após adicionamos a lista de parâmetros dentro dos parênteses e, por fim abre e
fecha chaves {}. Dentro das chaves será inserido o corpo ou escopo do construtor. Com exceção da
lista de parâmetros todos os outros elementos citados anteriormente são obrigatórios na declaração
de um construtor. A Figura 26 apresenta a estrutura do construtor da classe Prato.
Figura 26 - Exemplo da classe Prato com construtor
Fonte: A autora
$possuiAcompanhamento, $preco. Além disso, também possui um construtor com um parâmetro. A classe Prato possui
todo seu corpo delimitado pela abertura e fechamento de chaves. O construtor também possui todo seu corpo
delimitado pela abertura e fechamento de chaves. O corpo do construtor possui um comando echo para impressão no
navegador da mensagem Aproveitem nossos deliciosos e concatena com o valor do parâmetro. Todo o conteúdo do
código está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo PHP. O construtor está destacado
através de um retângulo em vermelho com uma seta apontando para a palavra construtor também em vermelho.
Outra diferença entre métodos e construtores é a forma de chamá-los, nos métodos basta
digitar o nome do método, seguido da lista de parâmetros caso possua. Nos construtores é preciso o

32
Competência 02
uso da palavra-chave new seguida pelo nome da classe e a lista de parâmetros caso possua. A Figura
27 apresenta um exemplo de um objeto da classe Prato com um construtor recebendo um parâmetro
chamado “Prato Especial”. E a Figura 28 mostra um exemplo de saída de um objeto da classe Prato
com construtor e o parâmetro passado anteriormente.
Figura 27 - Exemplo de objeto da classe Prato com construtor
Fonte: A autora
inclusão do arquivo prato.php, a criação de um objeto chamado $prato da classe Prato com o parâmetro Prato Especial
no construtor, além da atribuição do valor Galinha à cabidela para o atributo nome, valor dois para o atributo
quantidadePessoasServidas, valor um para o atributo possuiAcompanhamento, valor cinquenta e dois reais e trinta e
seis centavos para o atributo preco do objeto $prato. E também é chamado o método exibePrato. Todo o conteúdo do
código está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo PHP.
Figura 28 - Exemplo de saída do objeto da classe Prato com construtor
Fonte: A autora
dados relativos ao objeto $prato, são eles, serve 2 pessoa(s), possui acompanhamentos: sim e custa: R$ 52.36.
São muitos conceitos novos e muito conteúdo para ser absorvido!!!! Por isso a Figura 29
mostra a classe Prato completa (lembra que você viu isso no item 2.4 Método?), com todos os
conceitos aprendidos até o momento. Verifique todos os elementos destacados, a forma como os
componentes da classe estão dispostos, o nome dos atributos e métodos, compare o atributo estático
com os que não são estáticos, etc. Faça uma análise geral da classe Prato, isso vai lhe ajudar no
entendimento dos próximos assuntos que serão abordados.

34
Competência 02
Figura 29 - Exemplo da classe Prato com todos os conceitos visto até o momento
Fonte: A autora
$possuiAcompanhamento, $preco. Além disso, a classe Prato também possui um atributo estático
$quantidadePratosServidos inicializado com zero, um construtor com um parâmetro, um método chamado exibePrato e
métodos get e set para cada atributo. A classe Prato possui todo seu corpo delimitado pela abertura e fechamento de
chaves, assim como o corpo do construtor, do método exibePrato e dos métodos get e set. O corpo do construtor
possui um comando echo para impressão no navegador da mensagem Aproveitem nossos deliciosos e concatena com o
valor do parâmetro. Os métodos get não possuem parâmetros e set possuem o parâmetro $valor. Os métodos get
retornam o valor do atributo e o método set insere o valor do parâmetro no atributo. O corpo do método exibePrato
possui diversos comandos echo para impressão dos valores dos atributos nome, quantidadePessoasServidas,
possuiAcompanhamento e preço no navegador. Além disso, o método exibePrato também possui o atributo estático
$quantidadePratosServidor que é chamado por meio do operador parent para imprimir seu valor no navegador. Todo o
conteúdo do código está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo PHP. A classe, os
atributos, o construtor, o atributo estático, os métodos get e set e o método exibePrato estão destacados através de
retângulos em vermelho com cada seta apontando para as palavras também em vermelho, classe, atributo, construtor,
atributo estático, métodos get e set e método, respectivamente.
2.7 Herança
A herança é uma das características mais fortes da programação orientada a objetos e
uma das mais utilizadas. Esse conceito está diretamente ligado à reutilização de código, pois consiste
em podermos criar uma classe completamente nova a partir de outra classe já existente. A classe
nova pode manter todas as características da classe já existente ou pode sobrescrevê-las (não se
preocupe, sobreescrita é um conceito que será visto mais adiante), além de poder criar suas próprias
características adicionando novas funcionalidades. A classe nova recebe o nome de subclasse ou
classe filha e a classe já existente é chamada de superclasse ou classe pai.
À princípio, logo após serem criadas, as subclasses herdam (absorvem) todos os atributos
e métodos da superclasse. À medida que vão surgindo novas necessidades novos atributos e métodos
vão sendo acrescentados nas subclasses.
É possível que exista a necessidade de uma classe herdar outra classe que já herda de
alguma outra classe, formando uma hierarquia de classes. Imagine a seguinte situação: a classe C
herdar da classe B e a classe B herdar da classe A. Confuso não é? Calma que eu explico. Algumas
vezes esbarramos em determinadas situações em que é necessário uma classe herdar o estado e o
comportamento de classes anteriores. Nesse momento pense na hierarquia da sua família, seu pai
possui algumas características semelhantes ao seu avô e você possui algumas características
semelhantes do seu pai e do seu avô, correto? Pois então, o mesmo raciocínio é válido para a herança,
a classe C (filho) herdou da classe B (pai) e a classe B(pai) herdar da classe A (avô).

35
Competência 02
Retornando ao exemplo do software para um restaurante. Suponha que é preciso que
além da classe Prato também é necessário que exista a classe Prato Principal e a classe Prato
Promocional com características semelhantes a classe Prato. Todo Prato Principal é um Prato, pois é
uma extensão deste. Podemos nos referir a um Prato Principal como sendo um tipo de Prato. Se
alguém chegasse no restaurante e pedisse um Prato Principal seria a mesmo de pedir um Prato
porque um Prato Principal é um tipo especial de Prato. Essa é a ideia principal da herança. É muito
importante que você tenha isso em mente. O mesmo raciocínio pode ser aplicado para Prato
Promocional e Prato Principal. Todo Prato Promocional é um tipo especial de Prato Principal, o
primeiro é uma extensão do segundo. A Figura 30 apresenta a hierarquia das classes Prato, Prato
Principal e Prato Promocional.
Figura 30 - A classe Prato Promocional é filha de Prato Principal e neta de Prato
Fonte: A autora
Descrição: Representação da estrutura hierárquica das classes Prato, PratoPrincipal e PratoPromocional, na qual a
classe Prato (avô) está localizada no primeiro retângulo que está ligado por um segmento de reta contínuo ao segundo
retângulo onde está localizada a classe PratoPrincipal (pai) que também está relacionada, por um segmento de reta
contínuo, a classe PratoPromocional (filho).
Para utilização da herança é preciso seguir a estrutura: na declaração da subclasse após o
nome da subclasse adicionamos a palavra-chave extends, em seguida acrescentamos o nome da
superclasse e, por fim abre e fecha chaves {}. Realizado esse procedimento automaticamente todos
os atributos e métodos da superclasse poderão ser utilizados pela subclasse. Além disso, no PHP, é

36
Competência 02
preciso incluir na subclasse o arquivo onde está a superclasse, isso é feito através do nome reservado
include_once. A Figura 31 apresenta um exemplo de herança na qual a classe Prato Principal está
herdando da classe Prato.
Figura 31 - Exemplo de herança da classe Prato Principal

37
Competência 02
Fonte: A autora
Descrição: Código-fonte escrito na linguagem PHP para construção de programa de computador O código apresenta a
inclusão do arquivo prato.php, uma classe chamada PratoPrincipal, com dois atributos públicos, são eles:
$incluiRefrigerante e $servidoNaEntrada. Além disso, a classe Prato também possui um método chamado
exibePratoPrincipal e métodos get e set para cada atributo. A classe PratoPrincipal possui todo seu corpo delimitado
pela abertura e fechamento de chaves, assim como o corpo do método exibePratoPrincipal e dos métodos get e set. Os
métodos get não possuem parâmetros e set possuem o parâmetro $valor. Os métodos get retornam o valor do atributo
e o método set insere o valor do parâmetro no atributo. O corpo do método exibePratoPrincipal possui diversos
comandos echo para impressão dos valores dos atributos nome, quantidadePessoasServidas, possuiAcompanhamento,
incluiRefrigerante, servidoNaEntrada e preço no navegador. Todo o conteúdo do código está inserido entre as tags de
abertura <?php e de fechamento ?> de arquivo PHP. O relacionamento de herança está destacado através de um
retângulo em vermelho com uma seta apontando para a palavra herança também em vermelho.
A Figura 32 mostra um exemplo de criação do objeto $pratoPrincipal da classe Prato
Principal com todos os atributos herdados da classe Prato, além dos atributos $incluirRefrigerante e
$servidoNaEntrada que são próprios da classe Prato Principal. Só em objetos da classe Prato Principal
pode-se incluir refrigerante e ser servido na entrada. A Figura 33 apresenta a saída do objeto
$pratoPrincipal da classe Prato Principal.
Figura 32 - Exemplo de objeto da classe Prato Principal
Fonte: A autora
inclusão do arquivo prato_principal.php, a criação de um objeto chamado $pratoPrincipal da classe PratoPrincipal com
o parâmetro Prato do dia no construtor, além da atribuição do valor Feijoada para o atributo nome, valor quatro para o
atributo quantidadePessoasServidas, valor zero para o atributo possuiAcompanhamento, valor sessenta e nove reais e
noventa e nove centavos para o atributo preco, valor um para o atributo incluirRefrigerante e o valor zero para o
atributo servidoNaEntrada do objeto $pratoPrincipal. E também é chamado o método exibePratoPrincipal. Todo o

38
Competência 02
Figura 33 - Exemplo de saída da classe Prato Principal
Fonte: A autora
A saída apresenta a mensagem Aproveitem nosso delicioso Prato do dia Prato Principal: Feijoada, depois aparecem os
dados relativos ao objeto $pratoPrincipal, são eles, serve 4 pessoa(s), possui acompanhamentos: não, incluir
regrigerante: sim, é servido na entrada: não e custa: R$ 69.99.
A Figura 34 apresenta outro exemplo de herança na qual a classe Prato Promocional está
herdando da classe Prato Principal.
Indicamos que você assista esse vídeo como forma de ampliar seu
conhecimento sobre classes, objetos, herança e visibilidade
https://www.youtube.com/watch?v=mysYZdwLrPo

39
Competência 02
Figura 34 - Exemplo de herança da classe Prato Promocional
Fonte: A autora
inclusão do arquivo prato_principal.php, uma classe chamada PratoPromocional, com um atributo público,
$valorDesconto. Além disso, a classe PratoPromocional também possui um método chamado exibePratoPromocional e
métodos get e set para cada atributo. A classe PratoPromocional possui todo seu corpo delimitado pela abertura e
fechamento de chaves, assim como o corpo do método exibePratoPromocional e dos métodos get e set. Os métodos
get não possuem parâmetros e set possuem o parâmetro $valor. Os métodos get retornam o valor do atributo e o
método set insere o valor do parâmetro no atributo. O corpo do método exibePratoPromocional possui diversos
comandos echo para impressão dos valores dos atributos nome, quantidadePessoasServidas, possuiAcompanhamento,
incluiRefrigerante, servidoNaEntrada, preço e valor do desconto no navegador. Todo o conteúdo do código está inserido
entre as tags de abertura <?php e de fechamento ?> de arquivo PHP. O relacionamento de herança está destacado
através de um retângulo em vermelho com uma seta apontando para a palavra herança também em vermelho.

40
Competência 02
A Figura 35 mostra um exemplo de criação do objeto $pratoPromocional da classe Prato
Promocional com todos os atributos herdados da classe Prato Principal e consequentemente da
classe Prato também, além do atributo $valorDesconto que é próprio da classe Prato Promocional.
Só tem desconto o prato que está na promoção. A Figura 36 apresenta a saída do objeto $prato
Promocional da classe Prato Promocional.
Figura 35 - Exemplo de objeto da classe Prato Promocional
Fonte: A autora
inclusão do arquivo prato_promocional.php, a criação de um objeto chamado $pratoPromocional da classe
PratoPromocional com o parâmetro Prato Regional no construtor, além da atribuição do valor Carne de Sol para o
método setNome, valor três para o método setQuantidadePessoasServidas, valor um para o método
setPossuiAcompanhamento, valor zero para o método setIncluirRefrigerante, valor um para o método
setServidoNaEntrada, valor vinte e quatro reais e noventa e nove centavos para o método setPreco, valor cinco reais e
noventa e nove centados para o método setValorDesconto do objeto $pratoPromocional. E também é chamado o
método exibePratoPromocional. Todo o conteúdo do código está inserido entre as tags de abertura <?php e de
fechamento ?> de arquivo PHP.
Figura 36 - Exemplo de saída da classe Prato Promocional
Fonte: A autora
A saída apresenta a mensagem Aproveitem nosso delicioso Prato Regional Prato Promocional: Carne de Sol, depois
aparecem os dados relativos ao objeto $prato Promocional, são eles, serve 3 pessoa(s), possui acompanhamentos: sim,
incluir regrigerante: não, é servido na entrada: sim, custa: R$ 24.99 e valor do desconto: R$ 5.99

41
Competência 03
3.Competência 03 | Conhecer os conceitos de associação,
encapsulamento, abstração, polimorfismo e interface
3.1 Abstração
Uma das principais características do paradigma orientado a objetos é a abstração que,
em relação a computação, significa pensar em um nível mais elevado sem se preocupar com os
detalhes de implementação.
Essa característica é muito importante principalmente quando pensamos em como vamos
fazer a representação de objetos do mundo real no mundo virtual, ou seja, de que forma iremos
representar no nosso programa de computador os objetos do mundo real, com suas características e
comportamentos utilizando os conceitos da orientação a objetos como, classe, atributo, objeto, entre
outros.
Assim, continuaremos no aprendizado da programação web orientada a objetos pois,
quanto mais ampliarmos os conhecimentos mais fácil será fazermos abstração.
3.1.1 Classe Abstrata
Suponha que o dono do restaurante solicitou a você que inserisse a entidade Sobremesa
no software. Assim, seria preciso criar a classe Sobremesa. Além disso o dono do restaurante lhe falou
que essa classe deve possuir as mesmas características da classe Prato incluindo um atributo a mais
que é a temperatura que a sobremesa é servida. A Figura 37 apresenta um exemplo da classe
Sobremesa.

42
Competência 03
Figura 37 - Exemplo da classe Sobremesa sem herança
Fonte: A autora
Descrição: Código-fonte escrito na linguagem PHP para construção de programa de computador O código apresenta
uma classe chamada Sobremesa, com quatro atributos públicos, são eles, $nome, $quantidadePessoasServidas, $preco
e $temperaturaServida. Além disso, a classe Sobremesa também possui um método chamado exibeSobremesa e
métodos get e set para cada atributo. A classe Sobremesa possui todo seu corpo delimitado pela abertura e fechamento
de chaves, assim como o corpo do método exibeSobremesa e dos métodos get e set. Os métodos get não possuem
parâmetros e set possuem o parâmetro $valor. Os métodos get retornam o valor do atributo e o método set insere o
valor do parâmetro no atributo. O corpo do método exibeSobremesa possui diversos comandos echo para impressão
dos valores dos atributos nome, quantidadePessoasServidas, preço e temperaturaServida no navegador. Todo o
A Figura 38 apresenta um exemplo do objeto $sobremesa da classe Sobremesa e a Figura
39 ilustra a saída gerada pelo objeto $sobremesa da classe Sobremesa.
Figura 38 - Exemplo do objeto da classe Sobremesa sem herança

43
Competência 03
Fonte: A autora
inclusão do arquivo sobremesa.php, a criação de um objeto chamado $sobremesa da classe Sobremesa, com atribuição
do valor Taça de Sorvete para o atributo nome, valor um para o atributo quantidadePessoasServidas, valor cinco reais e
cinquenta e três centavos para o atributo preco, valor gelada para o atributo temperaturaServida do objeto $
sobremesa. E também é chamado o método exibeSobremesa. Todo o conteúdo do código está inserido entre as tags de
abertura <?php e de fechamento ?> de arquivo PHP.
Figura 39 - Exemplo de saída da classe Sobremesa sem herança
Fonte: A autora
A saída apresenta a mensagem Sobremesa: Taça Sorvete, depois aparecem os dados relativos ao objeto $sobremesa,
são eles, serve 1 pessoa(s), custa: R$ 5.53 e temperatura servida é: gelada.
Você observou que os atributos nome, quantidade de pessoas servidas e preço são os
mesmos atributos já existentes na classe Prato? Então, não seria melhor utilizar o reuso de código e
colocar a classe Sobremesa herdando da classe Prato? A resposta é não, pois além dos atributos
citados anteriormente a classe Prato possui um atributo a mais que é se possui acompanhamento. E
não faz sentido a classe Sobremesa possuir o atributo $possuiAcompanhamento. Como resolver essa
questão? Uma possível solução é através do uso de classes abstratas.
As classes abstratas são classes especiais, a principal diferença entre uma classe abstrata
e uma classe comum está no fato das abstratas não poderem ser instanciadas, sendo necessário a
criação de uma subclasse para herdá-la. Uma classe é caracterizada como abstrata por precisar ser
herdada por outra classe. As classes abstratas podem possuir diversos métodos, alguns podem ser
concretos, isto é, conter corpo (conteúdo) outros podem ser abstratos, ou seja, não possuem um
corpo, só assinatura. Nos casos dos métodos abstratos a responsabilidade de implementá-los é da
subclasse que herdar da classe abstrata.
Para solucionar a questão da classe Sobremesa poderíamos criar a classe abstrata Pedido
e as classes Prato e Sobremesa herdariam dela. A ideia é inserir todas as características semelhantes
das classes Prato e Sobremesa na classe abstrata Pedido, pois esta última não precisa ser instanciada.
No mundo real não faz sentido o cliente solicitar apenas um pedido, é preciso que o pedido seja um
prato ou uma sobremesa. A Figura 40 apresenta a hierarquia das classes Pedido, Prato e Sobremesa.

44
Competência 03
Figura 40 - As classes Prato e Sobremesa são filhas da classe pai Pedido
Fonte: A autora
Descrição: Representação da estrutura hierárquica das classes Pedido, Prato e Sobremesa, na qual a classe Pedido (pai)
está localizada no primeiro retângulo acima dos outros dois retângulos. Além disso também está ligado por um
segmento de reta contínuo ao segundo retângulo na esquerda onde está localizada a classe Prato (pai) ao terceiro
retângulo na direita onde está localizada a classe Sobremesa (filho).
Para declarar uma classe abstrata, utilizamos a seguinte estrutura: primeiramente
declaramos as palavras-chave abstract class, em seguida inserimos o nome da classe e, por fim
colocamos abre e fecha chaves {}. Dentro das chaves será inserido o corpo ou escopo da classe
abstrata. A Figura 41 apresenta a estrutura da classe abstrata Pedido com todos os atributos em
comum das classes Prato e Sobremesa e com o método abstrato exibePedido.

45
Competência 03
Figura 41 - Exemplo da classe abstrata Pedido
Fonte: A autora
uma classe abstrata chamada Pedido, com três atributos protegidos, são eles, $nome, $quantidadePessoasServidas e
$preco. Além disso, a classe Pedido também possui um método abstrato chamado exibePedido e métodos get e set
para cada atributo. A classe Pedido possui todo seu corpo delimitado pela abertura e fechamento de chaves, assim
como o corpo do método exibePedido e os métodos get e set. Os métodos get não possuem parâmetros e set possuem
o parâmetro $valor. Os métodos get retornam o valor do atributo e o método set insere o valor do parâmetro no
atributo. Todo o conteúdo do código está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo PHP.
O método abstrato exibePedido está destacado através de um retângulo em vermelho com uma seta apontando para a
expressão método abstrato também em vermelho.
A Figura 42 apresenta a classe Prato herdando da classe Pedido, apenas com o atributo
$possuiAcompanhamento e implementando o método exibePedido.

46
Competência 03
Figura 42 - Exemplo da classe Prato herando da classe abstrata Pedido
Fonte: A autora
inclusão do arquivo pedido.php e uma classe chamada Prato que extende da classe Pedido, com um atributo público,
$possuiAcompanhamento. Além disso, a classe Prato também possui um contrutor com um parâmetro, um método
chamado exibePedido e os métodos get e set para cada atributo. A classe Prato possui todo seu corpo delimitado pela
abertura e fechamento de chaves, assim como o corpo do método exibePedido e os métodos get e set. Os métodos get
não possuem parâmetros e set possuem o parâmetro $valor. Os métodos get retornam o valor do atributo e o método
set insere o valor do parâmetro no atributo. O corpo do método exibePedido possui diversos comandos echo para
impressão dos valores dos atributos nome, quantidadePessoasServidas, possuiAcompanhamento e preço no navegador.
Todo o conteúdo do código está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo PHP. O
relacionamento de herança e o método exibePedido estão destacados através de retângulos em vermelho com cada um
possuindo uma seta também em vermelho apontando para a palavra herança e a expressão implementação método
abstrato, respectivamente.
A Figura 43 apresenta a classe Sobremesa herdando da classe Pedido, apenas com o
atributo $temperaturaServida e implementando o método exibePedido.

47
Competência 03
Figura 43 - Exemplo da classe Sobremesa herando da classe abstrata Pedido
Fonte: A autora
inclusão do arquivo pedido.php e uma classe chamada Sobremesa que extende da classe Pedido, com um atributo
público, $temperaturaServida. Além disso, a classe Sobremesa também possui um contrutor com um parâmetro, um
método chamado exibePedido e os métodos get e set para cada atributo. A classe Sobremesa possui todo seu corpo
delimitado pela abertura e fechamento de chaves, assim como o corpo do método exibePedido e os métodos get e set.
Os métodos get não possuem parâmetros e set possuem o parâmetro $valor. Os métodos get retornam o valor do
atributo e o método set insere o valor do parâmetro no atributo. O corpo do método exibePedido possui diversos
comandos echo para impressão dos valores dos atributos nome, quantidadePessoasServidas, preco e
temperaturaServida no navegador. Todo o conteúdo do código está inserido entre as tags de abertura <?php e de
fechamento ?> de arquivo PHP. O relacionamento de herança e o método exibePedido estão destacados através de
retângulos em vermelho com cada um possuindo uma seta também em vermelho apontando para a palavra herança e a
expressão implementação método abstrato, respectivamente.
A Figura 44 apresenta um exemplo dos objetos $prato e $sobremesa das classes Prato e
Sobremesa, respectivamente e a Figura 45 ilustra a saída gerada pelos objetos $prato e $sobremesa
com a herança da classe abstrata Pedido.

48
Competência 03
Figura 44 - Exemplo de objeto da classe Prato e da classe Sobremesa com herança
Fonte: A autora
inclusão dos arquivos prato.php e sobremesa.php, a criação de um objeto chamado $prato da classe Prato com o
parâmetro Prato Especial no construtor, além da atribuição do valor Galinha à cabidela para o atributo nome, valor dois
para o atributo quantidadePessoasServidas, valor um para o atributo possuiAcompanhamento, valor cinquenta e dois
reais e trinta e seis centavos para o atributo preco do objeto $prato. E também é chamado o método exibePedido.
Adicionamente a isto também temos, a criação de um objeto chamado $sobremesa da classe Sobremesa, com
atribuição do valor Taça de Sorvete para o atributo nome, valor um para o atributo quantidadePessoasServidas, valor
cinco reais e cinquenta e três centavos para o atributo preco, valor gelada para o atributo temperaturaServida do
objeto $sobremesa. E também é chamado o método exibePedido. Todo o conteúdo do código está inserido entre as
tags de abertura <?php e de fechamento ?> de arquivo PHP.
Figura 45 - Exemplo de saída da classe Prato e da classe Sobremesa com herança
Fonte: A autora
dados relativos ao objeto $prato, são eles, serve 2 pessoa(s), possui acompanhamentos: sim e custa: R$ 52.36. Também
é apresentada a mensagem Sobremesa: Taça Sorvete, depois aparecem os dados relativos ao objeto $sobremesa, são

49
Competência 03
eles, serve 1 pessoa(s), custa: R$ 5.53 e temperatura servida é: gelada.
3.2 Encapsulamento
Encapsular significa esconder, ocultar, proteger em uma cápsula. No contexto da
programação orientada a objeto o encapsulamento é o mecanismo utilizado para oculta os detalhes
internos de implementação e isolar as informações das interferências externas e do uso indevido.
É possível aplicar este conceito através dos modificadores de acesso: public, protected e
private. Os modificadores de acesso são recursos que possibilitam restringir ou liberar o acesso aos
atributos e aos métodos das classes. Neste contexto a classe funciona como uma casca ou cápsula.
Geralmente, não é interessante que objetos de outras classes tenham a liberdade de alterar o valor
de um determinado atributo de um objeto. Em muitas situações, é necessário que apenas atributos
e métodos específicos sejam visíveis fora da classe.
É importante destacar que este recurso não é restrito apenas aos atributos e métodos,
também pode ser aplicado a outros componentes como classes e construtores. Além disso, todo
modificador de acesso precisa ser declarado antes do componente que será protegido. A Figura 46
apresenta os modificadores de acesso com suas respectivas descrições e a Figura 47 mostra um
resumo da visibilidade dos modificadores de acesso dentro da classe, nas subclasses e em qualquer
trecho do código.
DICA IMPORTANTE!
Uma classe abstrata existe para ser estendida (herdada).

50
Competência 03
Figura 46 – Resumo dos modificadores de acesso
Fonte: A autora
Descrição: Representação de uma tabela com três linhas e duas colunas predominantemente na cor azul e gradiente
desta cor. A tabela apresenta um resumo dos principais conceitos sobre os modificadores de acesso, public, protected e
private com suas respectivas descrições.
Figura 47 – Resumo da visibilidade dos modificadores de acesso
Fonte: A autora
Descrição: Representação de uma tabela com três linha e quatro colunas colunas predominantemente na cor azul e
gradiente desta cor. A tabela apresenta os modificadores de acesso, public, protected e private com seus respectivos
níveis de acesso indicando se é visível na própria classe, nas subclasses ou em qualquer trecho do código através do
texto sim ou não.
As Figuras 48 e 49 apresentam exemplos da utilização dos modificadores de acesso no
atributo $nome e no método getNome, respectivamente.

51
Competência 03
Figura 48 - Exemplo de modificador de ac esso do atributo nome da classe Prato
Fonte: A autora
$possuiAcompanhamento e $preco. Todo o conteúdo do código está inserido entre as tags de abertura <?php e de
fechamento ?> de arquivo PHP. O modificador de acesso public do atributo nome está destacado através de um
retângulo em vermelho com uma seta apontando para a expressão modificador de acesso também em vermelho.
Figura 49 - Exemplo de modificadores de acesso do método getNome da classe Prato
Fonte: A autora
$possuiAcompanhamento e $preco. A classe Sobremesa possui todo seu corpo delimitado pela abertura e fechamento
de chaves, assim como o corpo do método getNome. Todo o conteúdo do código está inserido entre as tags de
abertura <?php e de fechamento ?> de arquivo PHP. O modificador de acesso public do método getNome está
destacado através de um retângulo em vermelho com uma seta apontando para a expressão modificador de acesso
também em vermelho.
conhecimento sobre modificadores de acesso em PHP
https://www.youtube.com/watch?v=CuyXVxsElXs

52
Competência 03
3.3 Classe Final
As classes finais são classes especiais, a principal diferença entre uma classe final e uma
classe comum está no fato das finais não poderem ser herdadas. Classes finais não podem ser
estendidas por nenhuma subclasse, pois entende-se que esta deverá ser a classe final de uso.
Voltando ao exemplo do software para um restaurante imagine que o dono do
restaurante solicitou que você incluísse no software a entidade Cortesia. Assim, seria preciso criar a
classe Cortesia. Além disso, ele lhe falou que cada dia da semana o restaurante disponibiliza uma
cortesia diferente para o cliente. De acordo com a descrição anterior, seria interessante criar a classe
Cortesia como final, pois ela não precisaria ser herdada por nenhuma outra classe.
Para declarar uma classe final, utilizamos a seguinte estrutura: primeiramente
declaramos as palavras-chave final class, em seguida inserimos o nome da classe e, por fim colocamos
abre e fecha chaves {}. Dentro das chaves será inserido o corpo ou escopo da classe final. As Figuras
50 e 51 apresentam a estrutura da classe final Cortesia e um exemplo de utilização dos objetos $prato
e $cortesia, respectivamente. Por fim, a Figura 52 mostra a saída gerada pelos objetos $prato e
$cortesia das classes Prato e Cortesia.

53
Competência 03
Figura 50 - Exemplo da classe final Cortesia
Fonte: A autora
uma classe final chamada Cortesia, com um atributo público, $tipoCortesia. A classe Cortesia possui todo seu corpo
delimitado pela abertura e fechamento de chaves, assim como o corpo dos métodos get e set e do método
exibeCortesia que recebe um parâmetro. O corpo do método exibeCortesia faz a verificação do valor do parâmetro e
atribuí um valor diferente para o atributo $tipoCortesia de acordo com o dia da semana. Posteriomente, apresenta um
comando echo para impressão do valor do atributo tipoCortesia no navegador. Todo o conteúdo do código está inserido
entre as tags de abertura <?php e de fechamento ?> de arquivo PHP. O final está destacado através de um retângulo
em vermelho com uma seta apontando para a expressão classe final também em vermelho.

54
Competência 03
Figura 51 - Exemplo de objeto da classe Cortesia
Fonte: A autora
inclusão dos arquivos prato.php e cortesia.php, a criação de um objeto chamado $prato da classe Prato com o
Adicionamente a isto também temos, a criação de um objeto chamado $cortesia da classe Cortesia, com a passagem do
parâmetro terça-feira para o método exibeCortesia. Todo o conteúdo do código está inserido entre as tags de abertura
Figura 52 - Exemplo de saída das classes Prato e Cortesia
Fonte: A autora
Descrição: A saída apresenta a mensagem Aproveitem nosso delicioso Prato Especial Prato: Galinha à cabidela, depois
aparecem os dados relativos ao objeto $prato, são eles, serve 2 pessoa(s), possui acompanhamentos: sim e custa: R$
52.36. Além disso também é apresentada a mensagem a cortesia de hoje é: embalagem gratuita.

55
Competência 03
3.3.1 Erro ao herdar de uma classe final
As classes finais não permitem que outras classes herdem seus atributos e métodos, caso
isso acontecesse resultaria em erro. A Figura 53 apresenta um exemplo da classe
TesteHerancaClasseFinal herdando da classe final Cortesia, posteriormente a Figura 54 mostra um
exemplo de criaçãodo objeto $testeHerancaClasseFinal da classe TesteHerancaClasseFinal, e por fim
a Figura 55 ilustra a mensagem de erro que é exibida.
Figura 53 - Exemplo da classe TesteHerancaClasseFinal herdando da classe final Cortesia
Fonte: A autora
inclusão do arquivo cortesia.php, uma classe chamada TesteHerancaClasseFinal que estende da classe Cortesia. A classe
TesteHerancaClasseFinal possui todo seu corpo delimitado pela abertura e fechamento de chaves. Todo o conteúdo do
código está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo PHP.
Figura 54 - Exemplo de objeto da classe TesteHerancaClasseFinal herdando da classe final Cortesia
Fonte: A autora
inclusão do arquivo testeHerancaClasseFinal.php e a criação de um objeto chamado $testeHerancaClasseFinal da classe
TesteHerancaClasseFinal.
Figura 55 - Mensagem de erro exibida quando a classe TesteHerancaClasseFinal herda da classe final Cortesia
Fonte: A autora
Descrição: Mensagem de erro do código-fonte escrito na linguagem PHP para construção de programa de computador
ao extender a classe final testeHerancaClasseFinal.

56
Competência 03
3.4 Associação
Associação significa combinação, relação, união. No contexto da programação orientada
a objetos associação é um mecanismo no qual os objetos das classes possuem um vínculo entre si,
por exemplo, uma possível forma de associação ocorre quando uma classe contém um atributo que
é outra classe podendo utilizar os atributos e métodos da classe contida. A Figura 56 apresenta um
exemplo de utilização da associação através da classe Prato com um objeto da classe Cortesia.
DICA IMPORTANTE!
Não é possível declarar uma classe abstrata como final, pois a classe final não
pode ser herdada e a abstrata precisa ser herdada.

57
Competência 03
Figura 56 - Exemplo da classe Prato com associação
Fonte: A autora
inclusão do arquivo pedido.php e cortesia.php, uma classe chamada Prato que estende de Pedido, com dois atributos
públicos, $possuiAcompanhamento e $cortesia. A classe Prato possui todo seu corpo delimitado pela abertura e
fechamento de chaves, assim como o corpo dos métodos get e set e do construtor que recebe um parâmetro. Todo o
conteúdo do código está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo PHP. O atributo
cortesia e os métodos getCortesia e setCortesia estão destacados através de um retângulo em vermelho com uma seta
também em vermelho apontando para as expressões objeto cortesia e métodos get e set do objeto cortesia
respectivamente.
3.5 Interface
Imagine que agora o dono do restaurante solicitou a você que implementasse no software
uma funcionalidade para pagamento do Pedido. Todo pedido precisa ter um pagamento, porém a
forma de realizar o pagamento deve variar de acordo com o tipo do pedido, por exemplo, um pedido
do tipo Prato possui uma forma de pagamento diferente do pedido do tipo Sobremesa. Assim, para
solucionar essa questão é indicado a utilização de uma interface.
Interfaces são definidas de forma semelhante às classes, contudo, as interfaces contém
apenas as assinaturas dos métodos, ou seja, todos os métodos de uma interface são abstratos,
consequentemente não possuem corpo (conteúdo). Nas interfaces os corpos dos métodos precisam
obrigatoriamente permanecer vazios, pois o objetivo é abstrair a implementação do código. As
classes que implementarem a interface é que devem ser responsabilizar pelo corpo dos métodos.
Interfaces são tipos de contratos, pois especificam quais métodos uma classe deve
implementar, sem ter que definir como esses métodos serão implementados. A classe que
implementar uma interface não pode optar por implementar um método e outro não,
obrigatoriamente todos os métodos declarados na interface precisam ser implementados.
conhecimento sobre associação e relacionamento entre classes
https://www.youtube.com/watch?v=X6DTtj8Pfc0

58
Competência 03
Para declarar uma interface, utilizamos a seguinte estrutura: primeiramente declaramos
a palavra-chave interface, em seguida inserimos o nome da interface e, por fim colocamos abre e
fecha chaves {}. Dentro das chaves será inserido o escopo da interface (as assinaturas dos métodos).
As Figuras 57, 58 e 59 apresentam a estrutura da interface IPedido e um exemplo da classe Prato e
Sobremesa implementando a interface IPedido, respectivamente. Verifique que na classe Prato a
forma de pagamento é cartão de crédito/débito ou dinheiro e na classe Sobremesa a forma de
pagamento é cartão de crédito.
Figura 57 - Exemplo da interface IPedido com o método formaPagamento
Fonte: A autora
uma interface chamada IPedido com um método sem parâmetros chamado formaPagamento. A interface IPedido
possui todo seu corpo delimitado pela abertura e fechamento de chaves. Todo o conteúdo do código está inserido entre
as tags de abertura <?php e de fechamento ?> de arquivo PHP.
DICA IMPORTANTE!
Uma interface tem que ser puramente abstrata.

59
Competência 03
Figura 58 - Exemplo da classe Prato implementando a interface IPedido
Fonte: A autora
inclusão do arquivo pedido.php e ipedido.php, uma classe chamada Prato que estende de Pedido e implementa de
IPedido, com um atributo público, $possuiAcompanhamento, além do construtor, dos métodos get e set e do método
exibePedido e formaPagamento ambos sem parâmetros. A classe Prato possui todo seu corpo delimitado pela abertura
e fechamento de chaves, assim como o corpo dos métodos get e set e do construtor que recebe um parâmetro. Todo o
conteúdo do código está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo PHP. O
relacionamento de implementação da interface e o método formaPagamento estão destacados através de um

60
Competência 03
retângulo em vermelho com uma seta também em vermelho apontando para a palavra interface e a expressão
implementação do método da interface respectivamente.
Figura 59 - Exemplo da classe Sobremesa implementando a interface IPedido
Fonte: A autora
Descrição: Código-fonte escrito na linguagem PHP para construção de programa de computador O código apresenta
uma classe chamada Sobremesa que estende de Pedido e implementa de IPedido, com um atributo público
$temperaturaServida. Além disso, a classe Sobremesa também possui um método chamado exibePedido e outro
chamado formaPagamento sem parâmetros e métodos get e set para o atributo. A classe Sobremesa possui todo seu
corpo delimitado pela abertura e fechamento de chaves, assim como o corpo do método exibeSobremesa e dos
métodos get e set. Os métodos get não possuem parâmetros e set possuem o parâmetro $valor. Os métodos get
retornam o valor do atributo e o método set insere o valor do parâmetro no atributo. O corpo do método
exibeSobremesa possui diversos comandos echo para impressão dos valores dos atributos nome,
quantidadePessoasServidas, preço, temperaturaServida e o retorno do método forma de pagamento no navegador.
Todo o conteúdo do código está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo PHP. O
relacionamento de implementação da interface e o método formaPagamento estão destacados através de um
retângulo em vermelho com uma seta também em vermelho apontando para a palavra interface e a expressão
implementação do método da interface respectivamente.

61
Competência 03
A Figura 60 apresenta um exemplo de utilização dos objetos $prato e $sobremesa,
respectivamente. Por fim, a Figura 61 mostra a saída gerada pelos objetos $prato e $sobremesa das
classes Prato e Sobremesa com a implementação da interface IPedido.
Figura 60 - Exemplo de objeto da classe Prato e da classe Sobremesa com interface
Fonte: A autora
inclusão dos arquivos prato.php e sobremesa.php, a criação de um objeto chamado $prato da classe Prato com o
Adicionamente a isto também temos, a criação de um objeto chamado $sobremesa da classe Sobremesa, com
atribuição do valor Taça de Sorvete para o atributo nome, valor um para o atributo quantidadePessoasServidas, valor
cinco reais e cinquenta e três centavos para o atributo preco, valor gelada para o atributo temperaturaServida do
objeto $sobremesa. E também é chamado o método exibePedido. Todo o conteúdo do código está inserido entre as
tags de abertura <?php e de fechamento ?> de arquivo PHP.

62
Competência 03
Figura 61 - Exemplo de saída da classe Prato e da classe Sobremesa com interface
Fonte: A autora
dados relativos ao objeto $prato, são eles, serve 2 pessoa(s), possui acompanhamentos: sim, custa: R$ 52.36 e as
formas de pagamento são: cartão de crédito/débito ou dinheiro. Também é apresentada a mensagem Sobremesa: Taça
Sorvete, depois aparecem os dados relativos ao objeto $sobremesa, são eles, serve 1 pessoa(s), custa: R$ 5.53,
temperatura servida é: gelada e a única forma de pagamento aceita é: cartão de crédito.
Observem que estamos sempre trabalhando sobre o mesmo exemplo para facilitar o
entendimento e a absorção do conhecimento. Por isso, a Figura 62 mostra um resumo da hierarquia
das classes e interface criadas até o momento para o exemplo do restaurante Fome Zero.
DICA IMPORTANTE!
Uma classe abstrata sem atributos e com todos os métodos abstratos poderia
facilmente ser transformada/substituída por uma interface.

63
Competência 03
Figura 62 - Resumo da hierarquia das classes até o momento
Fonte: A autora
Descrição: Representação da estrutura hierárquica da interface IPedido e das classes Pedido, Prato, Sobremesa,
PratoPrincipal, PratoPromocional e Cortesia. A classe abstrata Pedido está localizada no primeiro retângulo à esquerda
acima de outros dois retângulos, ligados por um segmento de reta contínuo, que possuem as classes Prato e
Sobremesa. Além disso a classe Prato também está ligada por um segmento de reta contínuo ao retângulo na esquerda
onde está localizada a classe PratoPrincipal e este ligado a classe PratoPromocional. Por fim, a classe final Cortesia e a
interface IPedido estão localizadas em retângulos à direita.
3.6 Operadores this e parent
Em algumas situações o nome do parâmetro de um método é o mesmo nome de um
atributo da classe isso pode gerar uma certa confusão, diante disso como diferenciá-los? No PHP
existe o operador $this que é utilizado para acessar membros não estáticos que estão disponíveis na
classe. Ao chamar este operador estamos indicando que queremos usar o atributo pertencente ao
objeto. Para utilizar esse operador primeiramente declaramos o $this, em seguida inserimos o
símbolo de uma flecha apontado para a direita -> e, por fim chamamos o atributo desejado.
conhecimento sobre interface, classe abstrata, atributo e método estático
https://www.youtube.com/watch?v=CXV49usnojU

64
Competência 03
O operador parent:: funciona de forma semelhante ao $this, contudo o parent é utilizado
para chamar membros da classe pai. A Figura 63 mostra um exemplo de utilização dos operadores
$this e parent:: na classe Prato principal.
Figura 63 - Exemplo de $this e parent na classe Prato principal
Fonte: A autora
inclusão do arquivo prato.php, uma classe chamada PratoPrincipal, com um método chamado exibePratoPrincipal sem
parâmetros. A classe PratoPrincipal possui todo seu corpo delimitado pela abertura e fechamento de chaves, assim
como o corpo do método exibePratoPrincipal. O corpo do método exibePratoPrincipal possui diversos comandos echo
para impressão dos valores dos atributos nome, quantidadePessoasServidas, possuiAcompanhamento,
incluiRefrigerante, servidoNaEntrada, preço e o retorno do método formaPagamento no navegador. O método
formaPagamento é chamado através do operador parent. Todo o conteúdo do código está inserido entre as tags de
abertura <?php e de fechamento ?> de arquivo PHP. Os operadores $this e parent estão destacados através de
retângulos em vermelho com cada seta também em vermelho apontando para as expressões utiliza o atributo da classe
e utiliza o método da classe pai, respectivamente.

65
Competência 03
3.7 Polimorfismo
Imagine que agora o dono do restaurante solicitou a você que implementasse a
funcionalidade para pagamento do Pedido de forma diferente em Prato Promocional, pois o Prato
Promocional só deverá aceitar dinheiro. Outra exigência é que Prato Principal deve possui a mesma
forma de pagamento da classe pai (Prato). Assim, para solucionar essa questão é indicado a utilização
de polimorfismo. A Figura 64 apresenta um resumo das formas de pagamento das classes Prato, Prato
Principal e Prato Promocional.
Figura 64 – Resumo do exemplo de formas de pagamento
Fonte: A autora
Descrição: Representação da estrutura hierárquica das classes Prato, PratoPrincipal e PratoPromocional, na qual a
classe Prato (pai) está localizada no primeiro retângulo que está ligado por um segmento de reta contínuo ao segundo
retângulo onde está localizada a classe PratoPrincipal (filho) que também está relacionada, por um segmento de reta
contínuo, a classe PratoPromocional (neto). A classe Prato possui uma seta apontando para a direita com o texto formas
de pagamento: cartão de crédito/débito ou dinheiro, A classe PratoPrincipal possui uma seta apontando para a direita
com o texto formas de pagamento: mesma forma da classe pai e a classe PratoPromocional possui uma seta apontando
para a direita com o texto formas de pagamento: dinheiro.
Polimorfismo significa ser capaz de assumir diversas formas. No contexto da programação
orientada a objetos polimorfismo se manifesta de várias maneiras, na sobreposição, na
generalização, na sobrecarga, entre outros. Neste ebook iremos enfatizar apenas o polimorfismo por
meio da sobreposição (sobreescrita), que é um mecanismo no qual uma ou mais subclasses têm
métodos com a mesma assinatura herdados de uma superclasse e estas possuem a liberdade de
inserirem o conteúdo que julgarem ser mais adequado no corpo métodos, ou seja, as subclasses vão
possuir métodos com o mesmo nome, a mesma lista de parâmetros, a mesma quantidade de

66
Competência 03
parâmetros e a mesma ordem dos parâmetros, porém implementações diferentes. Um dos principais
objetivos do polimorfismo é poder referenciar um objeto de várias formas diferentes.
A Figura 65 mostra um exemplo da classe Prato Principal utilizando o método
formaPagamento da classe pai (Prato) e a Figura 66 ilustra um exemplo da classe Prato Promocional
utilizando o polimorfismo através do método formaPagamento. Verifique que as classes Prato
Principal e Prato Promocional possuem o mesmo método com o mesmo nome e sem parâmetros,
porém com implementações diferentes.
Para ampliar seus conhecimentos sobre polimorfismo,
Acesse: http://tecnopode.blogspot.com/search?q=polimorfismo

67
Competência 03
Figura 65 - Exemplo da classe Prato Principal utilizando o método da classe pai
Fonte: A autora

68
Competência 03
inclusão do arquivo prato.php, uma classe chamada PratoPrincipal, com dois atributos públicos, são eles:
$incluiRefrigerante e $servidoNaEntrada. Além disso, a classe Prato também possui um método chamado
exibePratoPrincipal sem parâmetros e métodos get e set para cada atributo. A classe PratoPrincipal possui todo seu
corpo delimitado pela abertura e fechamento de chaves, assim como o corpo do método exibePratoPrincipal e dos
métodos get e set. Os métodos get não possuem parâmetros e set possuem o parâmetro $valor. Os métodos get
retornam o valor do atributo e o método set insere o valor do parâmetro no atributo. O corpo do método
exibePratoPrincipal possui diversos comandos echo para impressão dos valores dos atributos nome,
quantidadePessoasServidas, possuiAcompanhamento, incluiRefrigerante, servidoNaEntrada, preço e o retorno do
método formaPagamento no navegador. O método formaPagamento é chamado através do operador parent. Todo o
conteúdo do código está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo PHP. A chamada do
método formaPagamento está destacado através de um retângulo em vermelho com uma seta também em vermelho
apontando para a expressão utiliza o método da classe pai.

69
Competência 03
Figura 66 - Exemplo da classe Prato Promocional com polimorfismo
Fonte: A autora
inclusão do arquivo prato_principal.php, uma classe chamada PratoPromocional, com um atributo público,

70
Competência 03
$valorDesconto. Além disso, a classe PratoPromocional também possui um método chamado exibePratoPromocional
sem parâmetros, o método formaPagamento também sem parâmetros e os métodos get e set para cada atributo. A
classe PratoPromocional possui todo seu corpo delimitado pela abertura e fechamento de chaves, assim como o corpo
do método exibePratoPromocional e dos métodos get e set. Os métodos get não possuem parâmetros e set possuem o
parâmetro $valor. Os métodos get retornam o valor do atributo e o método set insere o valor do parâmetro no
atributo. O corpo do método exibePratoPromocional possui diversos comandos echo para impressão dos valores dos
atributos nome, quantidadePessoasServidas, possuiAcompanhamento, incluiRefrigerante, servidoNaEntrada, preço e
valor do desconto no navegador. O corpo do método formaPagamento possui apenas uma mensagem dinheiro de
retorno. Todo o conteúdo do código está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo PHP.
O método formaPagamento está destacado através de um retângulo em vermelho com uma seta apontando para a
palavra polimorfismo também em vermelho.
Para verificar a forma de pagamento do prato foi desenvolvido o método
verificarFormaPagamento que recebe como parâmetro um objeto da classe Prato, conforme ilustra
a Figura 67.

71
Competência 03
Figura 67 - Exemplo da classe Pedido com o método verificarFormaPagamento recebendo um objeto $prato
Fonte: A autora
uma classe abstrata chamada Pedido, com três atributos protegidos, são eles, $nome, $quantidadePessoasServidas e
$preco. Além disso, a classe Pedido também possui um método abstrato chamado exibePedido, um método chamado
verificarFormaPagamennto que recebe um objeto da classe Prato como parâmetro e métodos get e set para cada
atributo. A classe Pedido possui todo seu corpo delimitado pela abertura e fechamento de chaves, assim como o corpo
do método exibePedido, verificarFormaPagamento e dos métodos get e set. Os métodos get não possuem parâmetros e
set possuem o parâmetro $valor. Os métodos get retornam o valor do atributo e o método set insere o valor do
parâmetro no atributo. O corpo do método verificarFormaPagamento possui diversos comandos echo para impressão
dos valores do atributo nome e do método formaPagamento no navegador. Todo o conteúdo do código está inserido
entre as tags de abertura <?php e de fechamento ?> de arquivo PHP.

72
Competência 03
A Figura 68 apresenta um exemplo de utilização dos objetos $prato, $pratoPrincipal e
$pratoPromocional e a chamada do método estático verificarFormaPagamento da classe Pedido. Por
fim, a Figura 69 mostra a saída gerada pelos objetos $prato, $pratoPrincipal e $pratoPromocional das
classes Prato, PratoPrincipal e PratoPromocional com as diferentes formas de pagamento.
Figura 68 - Exemplo de objeto da classe Prato, Prato Principal e Prato Promocional com polimorfismo
Fonte: A autora
inclusão dos arquivos prato.php, prato_principal.php e prato_promocional.php, a criação de um objeto chamado $prato
da classe Prato com o parâmetro Prato no construtor. E também é chamado o método verificarFormaPagamento da
classe Pedido passando o objeto $prato como parâmetro. Adicionamente a isto também temos, a criação de um objeto
chamado chamado $pratoPrincipal da classe PratoPrincipal com o parâmetro Prato Principal no construtor. E também é
chamado o método verificarFormaPagamento da classe Pedido passando o objeto $pratoPrincipal como parâmetro.
Além disso também temos, a criação de um objeto chamado chamado $pratoPromocional da classe PratoPromocional
com o parâmetro Prato Promocional no construtor. E também é chamado o método verificarFormaPagamento da classe
Pedido passando o objeto $pratoPromocional como parâmetro.
Figura 69 - Exemplo de saída da classe Prato, Prato Principal e Prato Promocional com polimorfismo

73
Competência 03
Fonte: A autora
A saída apresenta a mensagem Aproveitem nosso delicioso Prato, depois aparece a forma de pagamento relativos ao
objeto $prato com a mensagem, a(s) forma(s) de pagamento aceita(s) é(são): cartão de crédito/débito ou dinheiro.
Também é apresentada a mensagem Aproveitem nosso delicioso Prato Principal, depois aparece a forma de pagamento
relativos ao objeto $pratoPrincipal com a mensagem, a(s) forma(s) de pagamento aceita(s) é(são): cartão de
crédito/débito ou dinheiro. E por último, Também é apresentada a mensagem Aproveitem nosso delicioso Prato
Promocional, depois aparece a forma de pagamento relativos ao objeto $pratoPromocional com a mensagem, a(s)
forma(s) de pagamento aceita(s) é(são): dinheiro.

74
Competência 04
4.Competência 04 | Implementar uma aplicação utilizando técnicas de
orientação a objetos
4.1 Configuração da Aplicação
Após conhecer diversos conceitos da programação orientada a objetos, sempre utilizando
o exemplo do restaurante Fome Zero, vamos agora montar nosso ambiente para configurar a
aplicação. Primeiro passo, para que nossa aplicação possa ser executada é preciso instalar o xampp
que é uma das ferramentas mais populares para desenvolvimento em PHP pois, é constituída por um
conjunto de módulos no qual torna-se possível a utilização de um servidor web local. A Figura 70
mostra a tela inicial do xampp com os módulos do Apache, MySQL e Tomcat em operação.
Figura 70 – Tela inicial do xampp
Fonte: A autora
Descrição: Tela inicial do xampp com a cor predominante cinza, os módulos do Apache, MySQL e Tomcat que estão em
operação estão na cor verde e com a ação Stop. Os outros módulos FileZilla e Mercury que estão desativados estão em
cinza com a ação Start. A tela é dividida em duas partes, do começo até o meio da tela existem diversos botões com
várias funcionalidades e informações, tais como, se o módulo está ativo, o PID e a porta. A segunda metade da tela do
meio até o final é formada por uma área em branco que é preenchida de acordo com as informações que são
configuradas na primeira metade da tela, com o horário e com o módulo que essas informações são configuradas.

75
Competência 04
A Figura 71 apresenta o diretório padrão do xampp onde a aplicação
RestauranteFomeZero deve ser inserida.
Figura 71 – Local da aplicação RestauranteFomeZero
Fonte: A autora
Descrição: Diretório padrão do xampp localizado em C:/xampp/htdocs no Windows 10 onde a aplicação do
RestauranteFomeZero deve ser inserida. Dentro deste mesmo diretório, de cima para baixo, estão as pastas: dashboard,
img, RestauranteFomeZero, webalizer, xampp, além dos arquivos .project, applications.html, bitnami.css, favicon.ico e
index.php.
O próximo passo é acessar o endereço interno http://localhost/phpmyadmin através do
navegador para entrar no phpMyAdmin e executar o script do banco de dados. As Figuras 72 e 73
apresentam a tela inicial do phpMyAdmin e a tela ao clicar na aba do SQL antes da execução do script,
respectivamente.

76
Competência 04
Figura 72 – Tela inicial do phpMyAdmin
Fonte: A autora
Descrição: Tela inicial do phpMyAdmin com a cor predominante cinza, diversos retângulos no centro separando as
informações relativas as definições gerais, as configurações de aspecto, o servidor de base de dados, o servidor web e o
phpMyAdmin. Do lado esquerdo uma estrutura de árvore com os detalhes do phpMyAdmin. Em cima consta uma barra
onde está escrito servidor 127.0.0.1 e logo abaixo da barra onde estão as abas de Banco de Dados, SQL, Estado, Contas
do usuário, Explorar, Importar, Configurações, Replicação, Variáveis e Mais.
Figura 73 – Tela do banco de dados antes da execução do script
Fonte: A autora
Descrição: Tela da aba SQL do phpMyAdmin com a cor predominante cinza. Em cima consta uma barra onde estão as
abas de Banco de Dados, SQL, Estado, Contas do usuário, Explorar, Importar, Configurações, Replicação, Variáveis,
Mapas de Caracteres e Mais. Logo abaixo está uma área em branco que é preenchida com os comandos sql
correspondentes ao script do banco de dados da aplicação. Abaixo constam alguns botões e no canto inferior direito
está o botão de Executar destacado por um retângulo em vermelho.

77
Competência 04
A Figura 74 apresenta o script do banco de dados da aplicação RestauranteFomeZero.
Você deverá inserir essas informações no espaço em branco da Figura 73 e em seguida clicar no botão
“Executar” localizado no canto inferior diretio destacado no retângulo em vermelho. Após isso o
resultado deverá ser igual a Figura 75.
Figura 74 – Script do banco de dados
Fonte: A autora
Descrição: Comandos sql correspondentes ao script do banco de dados da aplicação RestauranteFomeZero.
Primeiramente é criada a base de dados chamada restaurantefomezero posteriormente, deleta a tabela prato caso
exista. Em seguida, é criada a tabela prato com quatro atributos, são eles, codigo do tipo int not null, nome do tipo
varchar not null, quantidadePessoasServidas int not null, preco varchar not null. A chave primária é a coluna codigo.
Depois são realizadas quatro inserções na tabela prato com diferentes informações.
Figura 75 – Tela do banco de dados após execução do script
Fonte: A autora
Descrição: Tela do phpMyAdmin após a execução do script com a cor predominante cinza, uma tarja na cor verde
informando que os comandos sql foram executados com sucesso. Além disso, também é exibido o resultado das quatro

78
Competência 04
inserções realizadas na tabela prato com as diferentes informações. Esse resultado está destacado por um retângulo em
vermelho.
Após a realização dos procedimentos descritos anteriormente, o último passo é acessar o
endereço interno http://localhost/RestauranteFomeZero/index.php através do navegador para
visualizar a tela inicial da aplicação RestauranteFomeZero. A Figura 76 apresenta a tela inicial da
aplicação.
Figura 76 – Tela inicial da aplicação
Fonte: A autora
Descrição: Tela inicial da aplicação RestauranteFomeZero. Do lado esquerdo está uma imagem de um cozido, uma
feijoada e uma carne de sol, nesta ordem de cima para baixo. Em cima da imagem do cozido está o menu da aplicação
com as opções: Prato Principal, Prato Promocional e Sobremesa. No centro e no lado direito está o formulário para
cadastrar/alterar o prato com os campos: nome, quantidade de pessoas servidas e preço (R$). Abaixo dos campos está
o botão Salvar em amarelo. Posteriormente, é exibida a lista dos pratos que estão cadastrados no banco de dados com
o nome do prato do lado esquerdo e os botões Alterar e Remover do lado direito.
4.2 Classes da Aplicação
A aplicação RestauranteFomeZero tem como objetivo cadastrar, alterar, buscar e
remover pratos do restaurante. Para realizar essas operações vamos utilizar a classe Prato do nosso
exemplo. Os dados da classe Prato são: código, nome, quantidade de pessoas servidas e preço. Para
cada atributo desta classe são criados métodos get e set. A Figura 77 apresenta um exemplo da classe
Prato.

79
Competência 04
Figura 77 – Exemplo da classe Prato
Fonte: A autora
uma classe chamada Prato, com quatro atributos públicos, são eles: $codigo, $nome, $quantidadePessoasServidas e
$preco. Além disso, a classe Prato também possui métodos get e set para cada atributo e um construtor com quatro
parâmetros de acordo com os atributos. A classe Prato possui todo seu corpo delimitado pela abertura e fechamento de
chaves, assim como o corpo do construtor e dos métodos get e set. O corpo do construtor possui quatro linhas de
código correspondentes a atribuição do valor dos parâmetros aos atributos. Os métodos get não possuem parâmetros e

80
Competência 04
set possuem o parâmetro $valor. Os métodos get retornam o valor do atributo e o método set insere o valor do
parâmetro no atributo. Todo o conteúdo do código está inserido entre as tags de abertura <?php e de fechamento ?>
de arquivo PHP.
A classe Conexao é onde todos os comandos relacionados ao banco de dados são processados.
Esta classe está repleta de comentários no código explicando o funcionamento de cada método e o
papel de cada atributo. Os dados da classe Conexao são: host, usuário, senha, banco e conexão, e os
métodos são: conectar (para conectar com o banco de dados), executarQuery (para consultar as
informações no banco de dados) e obtemPrimeiroRegistroQuery (para retornar o primeiro registro
encontrado no banco de dados). As Figuras 78 e 79 mostram a primeira e a segunda parte do exemplo
da classe Conexao, respectivamente.
Figura 78 – Exemplo da classe Conexao (Parte 1)
Fonte: A autora
primiera parte de uma classe chamada Conexao, com cinco atributos privados, são eles: $host, $usuario, $senha,
$banco e $conexao. Além disso, a classe Prato também possui um construtor com quatro parâmetros de acordo com os
atributos, são eles: $host, $usuario, $senha e $banco. A classe Prato possui todo seu corpo delimitado pela abertura e
fechamento de chaves, assim como o corpo do construtor e dos métodos. O corpo do construtor possui quatro linhas
de código correspondentes a atribuição do valor dos parâmetros aos atributos.

81
Competência 04
Figura 79 – Exemplo da classe Conexao (Parte 2)
Fonte: A autora
segunda parte de uma classe chamada Conexao, com três métodos, são eles: conectar que não recebe parâmetros,
executarQuery e obtemPrimeiroRegistro que recebem um parâmetro cada. O corpo do método conectar possui uma
solicitação para conectar com o banco de dados e verifica se ocorreu algum erro, se não ocorreu configura a codificação
para UTF8 e retorna verdadeiro. O corpo do método executarQuery possui uma instrução para executar o comando sql
recebido como parâmetro e retornar os dados obtidos no banco de dados. O corpo do método obtemPrimeiroRegistro
possui uma instrução para executar o comando sql recebido como parâmetro e retornar apenas a primeira linha obtida
no banco de dados. Todo o conteúdo do código está inserido entre as tags de abertura <?php e de fechamento ?> de
arquivo PHP.
A classe RepositorioPratos é utilizada para acessar e manipular às informações do banco
de dados. Esta será utilizada como intermediária entre a aplicação e o banco de dados, devido a isso

82
Competência 04
ela faz uso de um objeto da classe Conexao. Esta classe contém diversos comentários ao longo do
código explicando o funcionamento de cada método e o papel do atributo.
O único dado da classe RepositorioPratos é um objeto da classe Conexao, e os métodos
são: cadastrarPrato (para inserir um novo objeto prato no banco de dados), alterarPrato (para
atualizar as informações de um prato já existente no banco), removerPrato (para excluir um objeto
prato no banco), buscarPrato (para consultar um objeto prato específico no banco) e getListaPrato
(para retornar todos os objetos pratos existentes no banco de dados). Observe que no construtor da
classe RepositorioPratos é instanciado o objeto $conexao e no construtor da classe Conexao são
passados os seguintes valores para os parâmetros: host = “127.0.0.1”, usuario = “root”, senha = “”,
banco = “restaurantefomezero”. Esses dados correspondem às informações relacionadas ao banco
de dados.
Também foi desenvolvida a interface IRepositorioPrato que serve de contrato com a
classe RepositorioPratos. Esta interface possui apenas a assinatura dos métodos: cadastrarPrato,
alterarPrato, removerPrato, buscarPrato e getListaPrato.
A Figura 80 apresenta um exemplo da interface IRepositorioPrato e as Figuras 81 e 82
mostram a primeira e a segunda parte do exemplo da classe RepositorioPratos implementando a
interface IRepositorioPrato, respectivamente.
Figura 80 – Exemplo da interface IRepositorioPrato
Fonte: A autora
uma interface chamada IRepositorioPrato, com quatro métodos, são eles: cadastrarPrato e alterarPrato que recebem
como parâmetro um objeto da classe Prato cada, removerPrato e buscarPrato que recebem como parâmetro o código
de objeto específico da classe Prato cada e, por fim, getListaPrato que recebe não parâmetros. A interface
IRepositorioPrato possui todo seu corpo delimitado pela abertura e fechamento de chaves. Todo o conteúdo do código
está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo PHP.

83
Competência 04
Figura 81 – Exemplo da classe RepositorioPratos implementando a interface IRepositorioPrato (Parte 1)
Fonte: A autora
inclusão dos arquivos conexao.php, prato.php e irepositorio_prato.php. Além disso também é apresentada a primeira
parte de uma classe chamada RepositorioPratos que implementa a interface IRepositorioPrato, com um atributo
privado $conexao. Além disso, a classe RepositorioPratos também possui um construtor, um método chamado
cadastrarPrato que recebe como parâmetro um objeto da classe Prato e outro chamado removerPrato que recebe
como parâmetro o código de objeto específico da classe Prato. A classe RepositorioPratos possui todo seu corpo
delimitado pela abertura e fechamento de chaves, assim como o corpo dos métodos. O corpo do construtor possui
instruções para conectar com o banco de dados através da criação do objeto $conexao da classe Conexao passando
como parâmetro: host = “127.0.0.1”, usuario = “root”, senha = “”, banco = “restaurantefomezero”, depois é verificado
se a conexão ocorreu com sucesso. Já o corpo do método cadastrarPrato possui instruções para atribuir o valor do
nome, quantidade de pessoas servidas e preço do objeto $prato as variáveis $nome, $quantidadePessoasServidas e
$preco, respectivamente. Em seguida, essas variáveis são passadas como parâmetro para execução do comando sql de
inserção na tabela prato do banco de dados utilizando a conexão já estabelecida anteriormente. Por outro lado, o corpo

84
Competência 04
do método removerPrato possui instruções para executar o comando sql de remoção de um objeto específico da classe
Prato que possua o código igual ao valor do parâmetro $codigo.
Figura 82 – Exemplo da classe RepositorioPratos implementando a interface IRepositorioPrato (Parte 2)
Fonte: A autora
apresentada a segunda parte de uma classe chamada RepositorioPratos. Além dos elementos citados anteriormente, a
classe RepositorioPratos possui mais três métodos, são eles: alterarPrato que recebe como parâmetro um objeto da
classe Prato, outro chamado buscarPrato que recebem como parâmetro o código de objeto específico da classe Prato e

85
Competência 04
outro chamado getListaPrato que não recebe parâmetros. O corpo do método alterarPrato possui instruções para
atribuir o valor do código, nome, quantidade de pessoas servidas e preço do objeto $prato as variáveis $codigo, $nome,
$quantidadePessoasServidas e $preco, respectivamente. Em seguida, essas variáveis são passadas como parâmetro
para execução do comando sql de atualização do resgistro correspondente ao valor do atributo $codigo na tabela prato
do banco de dados utilizando a conexão já estabelecida anteriormente. Logo após, é criado um objeto $prato da classe
Prato e os dados obtidos da consulta ao banco de dados são inseridos neste objeto, que posteriormente é retornado
pelo método. Já o corpo do método buscarPrato possui instruções para executar o comando sql de consulta de um
objeto específico da classe Prato que possua o código igual ao valor do parâmetro $codigo. Por outro lado, o corpo do
método getListaPrato possui instruções para executar o comando sql de consulta de todos os registros da tabela Prato
do banco de dados. Depois, os dados obtidos são organizados para instanciar um objeto para cada registro retornado
do banco de forma a construir uma lista de objeto da classe Prato. Assim, a lista lista de objeto da classe Prato
construída é retornada no método. Para finalizar um objeto chamado $repositorio da classe RepositorioPratos é
instanciado. Todo o conteúdo do código está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo
PHP.
4.3 Cadastrar, Alterar e Remover
Para que as funcionalidades de cadastro, alteração e remoção de um objeto Prato sejam
executadas com sucesso é preciso que os métodos relacionados a estas funcionalidades recebam
informações fornecidas pelo usuário através de um formulário HTML para utilizá-las no construtor do
objeto $pratoRecebido. As informações contidas no formulário correspondem aos atributos da classe
Prato apresentada na Figura 77. Após a contrução do objeto $pratoRecebido, este será passado como
parâmetro para os métodos cadastrarPrato e alterarPrato.
As Figuras 83, 84 e 85 mostram a chamada dos métodos cadastrarPrato, alterarPrato e
removerPrato. Observe que o objeto $pratoRecebido do método cadastrarPrato não possui código,
pois é um objeto novo. Em vez disso foi inserida a palavra-reservada null. Já no objeto $pratoRecebido
do método alterarPrato o código é o primeiro parâmetro do construtor, pois é através do código que
será encontrado o objeto Prato para atualização dos dados. Diferentemente dos métodos anteriores,
para executar o método removerPrato não é necessário criar um objeto Prato basta passar o código
objeto como parâmetro.

86
Competência 04
Figura 83 – Chamada do método cadastrarPrato
Fonte: A autora
inclusão do arquivo repositorio_pratos.php. Além disso também é apresentada a instanciação de um objeto chamado
$pratoRecebido da classe Prato que está recebendo quatro parâmetros, são eles: código está recebendo o valor null e
nome, quantidade de pessoas servidas e preço que estão recebendo o valor obtido do formulário html. Em seguida, o
objeto $repositorio chama o método cadastrarPrato passando como parâmetro o objeto $pratoRecebido. E por fim o
processamento é redirecionado para a página de index.php. Todo o conteúdo do código está inserido entre as tags de
abertura <?php e de fechamento ?> de arquivo PHP.
Figura 84 – Chamada do método alterarPrato
Fonte: A autora
inclusão do arquivo repositorio_pratos.php. Além disso também é apresentada a instanciação de um objeto chamado
$pratoRecebido da classe Prato que está recebendo quatro parâmetros, são eles: código, nome, quantidade de pessoas
servidas e preço que estão recebendo o valor obtido do formulário html. Em seguida, o objeto $repositorio chama o
método alterarPrato passando como parâmetro o objeto $pratoRecebido. E por fim o processamento é redirecionado
para a página de index.php. Todo o conteúdo do código está inserido entre as tags de abertura <?php e de fechamento
?> de arquivo PHP.
Figura 85 – Chamada do método removerPrato
Fonte: A autora
inclusão do arquivo repositorio_pratos.php. Além disso também é apresentado o objeto $repositorio chamando o
método removerPrato passando como parâmetro o valor do código de um objeto específico da classe Prato obtido do
formulário html. E por fim o processamento é redirecionado para a página de index.php. Todo o conteúdo do código
está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo PHP

87
Competência 04
4.4 Buscar
Ao executar a aplicação do RestauranteFomeZero a tela inicial executa o método
getListaPrato que retorna todos os objetos Pratos existentes no banco de dados. Por outro lado, o
método buscarPrato retorna apenas um objeto Prato específico de acordo com o código que lhe foi
atribuído como parâmetro. Todas as informações fornecidas pelo usuário da aplicação são enviadas
através de um formulário HTML. As Figuras 86, 87 e 88 apresentam a primeira, segunda e terceira
parte dos detalhes da implementação do formulário HTML por meio da página index.php da
aplicação.

88
Competência 04
Figura 86 – Formulário HTML página index.php da aplicação (Parte 1)

89
Competência 04
Fonte: A autora
Descrição: Código-fonte escrito em PHP e html para construção de programa de computador. O código apresenta a
primeira parte da aplicação RestauranteFomeZero. Primeiramente é exibido um código em php no qual ocorre a
inclusão do arquivo repositorio_pratos.php. Posteriormente, é atribuído a um objeto chamado $pratos da classe Prato o
retorno da chamada do método getListaPrato sem parâmetros. Este método foi chamado pelo objeto $repositorio. Em
seguida, uma variável código é recebido através do método $_GET do formulário html. É realizada uma verificação com
a estrutura condicional if, ou seja, dentro dos parênteses do if é verificado se a variável código recebida possui algum
valor, caso verdadeiro dentro do corpo do if, que é delimitado por chaves, será atribuído a variável $código o valor da
variável verificada, adicionalmente o objeto $repositorio chama o método buscarPrato que recebe como parâmetro o
valor de $código. Além da página destino passar a ser o aquivo alterar_prato.php e de um campo oculto ser inserido no
formulário com o valor de $código. Todo o conteúdo do código php está inserido entre as tags de abertura <?php e de
fechamento ?> de arquivo PHP. Depois, é exibido um código em html que recebe como título Restaurante Fome Zero, o
estilo css vindo do arquivo styles.css e cria um menu na lateral esquerda da página com as opções de: Prato Principal,
Prato Promocional e Sobremesa. Ao clicar em qualquer uma das opções o usuário será direcionado para a página de
index.php.

90
Competência 04

91
Competência 04
Fonte: A autora
segunda parte da aplicação RestauranteFomeZero. É exibido o código de um formulário html, com estilo css e alguns
comandos php. O formulário html está posicionado no centro e no lado direito da tela para cadastrar/alterar um objeto
da classe Prato com os campos: nome, quantidade de pessoas servidas e preço (R$). Abaixo dos campos está o botão
Salvar. Ao clicar no botão salvar todas as informações capturadas no formulários serão processadas e de acordo com o
valor da variável $destino os dados serão enviados para uma paǵina que irá direcionar para um método de cadastro,
alteração ou remoção dos dados. Esse formulário também possui um campo oculto chamado $codigo que vai indicar se
os campos do formulário deverão exibir os valores de um objeto específico da classe Prato para serem alterados ou se
os campos devem permanecer em branco para que o usuário insira novas informações. Em cada campo do formulário
existe uma verificação para preencher o campo caso o valor retornado de um objeto específico da classe Prato não
esteja vazio
Fonte: A autora
terceira parte da aplicação RestauranteFomeZero. É exibido o código de uma listagem em html, com estilo css e alguns
comandos php.

92
Competência 04
A listagem é formada por meio de uma estrutura de repetição while que percorre uma lista de objetos da classe Prato
que foram retornadas do banco de dados. O registro retornado do banco é inserido em um objeto chamado
$pratoTemporario. A partir deste ponto é obtido o nome e o código do prato. O nome do prato está posicionado do
lado esquerdo e do lado direito estão os botões de Alterar e Remover. O botão de Alterar possui a funcionalidade de
capturar os dados de um objeto específico da classe Prato de acordo com a variável $codigo e preencher os campos do
formulário da página index.php com esses dados para que o usuário possa alterá-los. Já o botão de Remover possui a
funcionalidade de enviar as informações de um objeto específico da classe Prato de acordo com a variável $codigo para
ser removido do banco de dados.

93
Conclusão
Estudante,
Chegamos ao fim das quatro competências previstas para esta disciplina, nela tivemos a
oportunidade de aprender os princípios básicos da Programação Web Orientada a Objetos.
Começamos com os conceitos básicos como o surgimento e a importância da programação orientada
a objetos.
Depois foi apresentado um comparativo entre o paradigma orientado a objetos e o
paradigma estruturado, em seguida foi mostrado o conceito de diversos elementos do paradigma
orientado a objetos tais como: classe, objeto, atributo, método, métodos get e set, atributos e
métodos estáticos, construtor, herança, classe abstrata, encapsulamento, classe final, associação,
polimorfismo e interface. Os conceitos apresentados podem ser utilizados em qualquer outra
linguagem de programação para web desde que siga o paradigma orientado a objetos.
E por fim foram exibidas as etapas para implementar uma aplicação utilizando técnicas
de orientação a objetos. Foram demonstrados os passos para a configuração da aplicação,
desenvolvimento das classes da aplicação e as funcionalidades de cadastro, alteração, remoção e
busca das informações no banco de dados.
Vocês acham que acabou? Não acabou! É isso mesmo! A área de Desenvolvimento de
Software é muito abrangente e aplicável a incontáveis segmentos, educação, comércio, ciência e
tecnologia, gestão, segurança, entre outros. Impossível enxergar esta lista inteira, mas dá para
imaginar. Vocês só precisam imaginar uma solução para um problema e programá-la.
As possibilidades e oportunidades a partir dos conhecimentos adquiridos são infinitas,
imagine quando combinados com novos conhecimentos das próximas disciplinas. Espero que tenham
aproveitado ao máximo o material, a disciplina e queriam aprender e se aprofundar mais, para que
possam se tornar profissionais bem qualificados e bem-sucedidos.
Bons Estudos e Sucesso!

94
Referências
Arroyo, Alexandre e Santos, Fabio. Programação para a Web utilizando PHP. Centro de Computação
da Unicamp - DTTEC, 2002.
Ascencio, Ana Fernanda Gomes e De campos, Edilene Aparecida Verenuchi. Fundamentos da
programação de computadores: algoritmos, pascal, C/C++ (padrão ANSI) e java, 3° Edição, 2012.
Arroyo, Alexandre e Santos, Fabio. PHP Avançado. Centro de Computação da Unicamp - DTTEC, 2006.
Silva, Higor Ernandes Ramos e Ferreira, Leonardo Pimentel. São Paulo: Apostila do Curso de PHP
Orientado a Objetos. PET Sistemas de Informação, Faculdade de Computação, Universidade Federal
de Uberlândia, 2015.
Gilmore, W. Jason. Apress: Beginning PHP and MySQL 5: From Novice to Professional, 2° Edição,
2006.
Beighley, Lynn e Morrison , Michael. O'Reilly: Use a Cabeça – PHP com MySQL, 2009.
Dall'oglio, Pablo. Novatec: PHP Programando com Orientação a Objetos, 2018.

95
Minicurrículo do Professor
Possui formação superior em Análise e Desenvolvimento de Sistemas pelo Instituto
Federal de Educação, Ciência e Tecnologia de Pernambuco (IFPE), curso sequencial de formação
complementar em Análise de Testes de Software pelo Centro de informática da Universidade Federal
de Pernambuco (CIn-UFPE), especialização em Segurança da Informação pelo Centro de Estudos e
Sistemas Avançados do Recife (C.E.S.A.R), mestrado em Engenharia da Computação pela
Universidade de Pernambuco (UPE) e, atualmente possui doutorado em andamento em Ciência da
Computação pela Universidade Federal de Pernambuco (UFPE).
Possui 6 anos de experiência na área de Tecnologia da Informação, já atuou
profissionalmente exercendo atividades de: analista de sistemas, programadora, testadora e gerente
de configuração. Atualmente é professora de ensino à distância do curso técnico de Desenvolvimento
de Sistemas da Escola Técnica Estadual Professor Antônio Carlos Gomes da Costa (ETEPAC)
Possui conhecimento nas tecnologias: Java SE, JSP, JSF, DAO, JavaBeans, IDE Eclipse,
Hibernate, JPA, Spring para o controle das transações, Struts para arquitetura em camadas (MVC),
Container Apache Tomcat, Padrões de Projeto. Aplicação integrada com banco de dados Oracle,
MySQL e PostgreSQL.
Suas áreas de interesse são: engenharia de software, priorização de software, ciclo de
vida do software, metodologias ágeis, desenvolvimento de software, desenvolvimento web,
desenvolvimento mobile, plataformas de desenvolvimento, internet das coisas, técnicas de
inteligência artificial, entre outros.
Possui graduação em Engenharia de Computação pelo Centro Universitário de Barra
Mansa – (UBM), especialização em Segurança da Informação em Engenharia de Software pelo Centro
de Estudos de Sistemas Avançados do Recife (C.E.S.A.R), mestrado em Engenharia da Computação
pela Universidade de Pernambuco (UPE) e, atualmente possui doutorado em andamento em Ciência
da Computação pela Universidade Federal de Pernambuco (UFPE).

96
Possui 6 anos de experiência na área de Tecnologia da Informação, já atuou
profissionalmente exercendo atividades de: analista de sistemas, programador, testador e gerente
de configuração. Atualmente é professor de ensino à distância do curso técnico de Desenvolvimento
de Sistemas da Escola Técnica Estadual Professor Antônio Carlos Gomes da Costa (ETEPAC).
Possui conhecimento nas tecnologias: Java SE, JSP, JSF, DAO, JavaBeans, IDE Eclipse,
Hibernate, JPA, Spring para o controle das transações, Struts para arquitetura em camadas (MVC),
Container Apache Tomcat, Padrões de Projeto. Aplicação integrada com banco de dados Oracle,
MySQL e PostgreSQL e utilização de PL/SQL. Uso de ferramenta ETL e Shell Script.
Suas áreas de interesse são: engenharia de software, priorização de software, ciclo de
vida do software, metodologias ágeis, desenvolvimento de software, desenvolvimento web,
desenvolvimento mobile, plataformas de desenvolvimento, internet das coisas, técnicas de
inteligência artificial, técnicas de previsão de séries temporais, entre outros.

Caderno DS - Programação Web Orientada a Objetos [EAD Regular 2019.2 - ETEPAC].pdf

Caderno DS - Programação Web Orientada a Objetos [EAD Regular 2019.2 - ETEPAC].pdf

Mais conteúdo relacionado

Semelhante a Caderno DS - Programação Web Orientada a Objetos [EAD Regular 2019.2 - ETEPAC].pdf

Caderno DS - Programação Web Orientada a Objetos [EAD Regular 2019.2 - ETEPAC].pdf