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

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

Recomendados

Recomendados

Mais conteúdo relacionado

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

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

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