Prévia do material em texto
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
2021
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
2.ed. | Set. 2021
Professor(es) Autor(es)
Cinthya Cavalcanti Flório
Leonardo Guimarães de Holanda
Revisão
Cinthya Cavalcanti Flório
Leonardo Guimarães de Holanda
Coordenação de Curso
José Américo Teixeira de Barros
Coordenação Design Educacional
Deisiane Gomes Bazante
Design Educacional
Ana Cristina do Amaral e Silva Jaeger
Helisangela Maria Andrade Ferreira
Izabela Pereira Cavalcanti
Jailson Miranda
Roberto de Freitas Morais Sobrinho
Audiodescrição das imagens
Jonara Medeiros Siqueira
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 Programação no ciclo de vida do software ................................................................................................ 7
1.2 Paradigmas de Programação ...................................................................................................................... 9
1.3 Surgimento e Importância da Programação Orientada a Objetos ........................................................... 10
1.4 Programação Orientada a Objetos x Programação Estruturada .............................................................. 11
1.5 Principais conceitos da Programação Orientada a Objetos ..................................................................... 15
2.Competência 02 | Conhecer os conceitos de classe, herança, objeto, atributo e método.............. 24
2.1 Classe ........................................................................................................................................................ 24
2.2 Objeto ....................................................................................................................................................... 25
2.3 Atributo ..................................................................................................................................................... 26
2.4 Método ..................................................................................................................................................... 27
2.4.1 Métodos get e set .................................................................................................................................. 30
2.5 Atributos e Métodos Estáticos.................................................................................................................. 31
2.6 Construtor ................................................................................................................................................. 35
2.7 Herança ..................................................................................................................................................... 39
3.Competência 03 | Conhecer os conceitos de associação, encapsulamento, abstração, polimorfismo
e interface............................................................................................................................................. 47
3.1 Abstração .................................................................................................................................................. 47
3.1.1 Classe Abstrata....................................................................................................................................... 47
3.1.2 Erro ao instanciar uma classe abstrata .................................................................................................. 55
3.2 Encapsulamento ....................................................................................................................................... 56
3.2.1 Erro ao acessar atributo protected ou private ...................................................................................... 60
3.3 Classe Final ................................................................................................................................................ 61
3.3.1 Erro ao herdar de uma classe final ........................................................................................................ 64
3.4 Método Final ............................................................................................................................................. 65
3.5 Associação ................................................................................................................................................. 68
3.6 Interface .................................................................................................................................................... 69
3.7 Operadores this e parent .......................................................................................................................... 75
3.8 Polimorfismo ............................................................................................................................................. 77
4.Competência 04 | Implementar uma aplicação utilizando técnicas de orientação a objetos ......... 84
4.1 Configuração da Aplicação ....................................................................................................................... 84
4.2 Classes da Aplicação................................................................................................................................. 90
4.3 Cadastrar, Alterar e Remover .................................................................................................................. 96
4.4 Buscar ....................................................................................................................................................... 98
Conclusão ........................................................................................................................................... 103
Referências ......................................................................................................................................... 104
Minicurrículo do Professor ................................................................................................................. 105
6
Introdução
É com satisfação que dou a você 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 ebook possui quatro competências. Na primeira você aprenderá 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ãorelacionados à aplicação RestauranteFomeZero (que é fictícia, ou seja, criada pelos autores
para fins exclusivamente didáticos) que será construída e explicada ao longo das competências
utilizando a linguagem de programação PHP (Hypertext Preprocessor) juntamente com alguns dos
principais conceitos da orientação a objetos.
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 e como conectar a aplicação a um banco de dados. Serão
demonstrados todos os passos detalhadamente para o desenvolvimento das classes desta aplicação
e as funcionalidades de cadastro, alteração, remoção e consulta das suas informações em um banco
de dados e também como obter o servidor web XAMPP (X - sistema operacional, Apache, MariaDB,
PHP, Perl) para executar a aplicação.
Desejo que você aproveite ao máximo essa disciplina!
Para utilizar um ambiente de desenvolvimento on-line com a linguagem de
programação PHP, acesse: https://3v4l.org/
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 Programação no ciclo de vida do software
Para desenvolver um software primeiramente é preciso atravessar diversas etapas, que vão
desde do planejamento até a entrega final 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 e, desenvolvimento (programação).
Para melhorar a compreensão de como funciona o processo de desenvolvimento de um
software, a Figura abaixo ilustra um exemplo de um modelo de ciclo de vida do software.
Figura 1 - Modelo de ciclo de vida do software
Fonte: Engenharia de Software, 2004.
Audiodescrição da figura: Imagem, da esquerda para a direita, de modelo em cascata com as suas cinco fases, são elas:
definição de requisitos, projeto de sistemas e de software, implementação e teste de unidades, integração e teste de
sistemas e operação e manutenção. As fases são exibidas através de retângulos com setas apontando para a próxima
fase representando um efeito em cascata. Fim da Audiodescrição.
É importante destacar que existem diversos modelos de ciclo de vida do software, tais como,
espiral, interativo e incremental, modelo em V, evolutivo, entre outros. A Figura acima apresenta o
modelo em cascata para demostrar as diversas fases envolvidas na produção de um software. Esse
Competência 01
8
modelo foi selecionado como exemplo pelo fato dele ser muito simples, tradicional e bastante
conhecido. As fases que compõem o modelo em cascata são:
• Levantamento de requisitos: um dos objetivos dessa fase é capturar as funcionalidades que
o(s) cliente(s) ou usuário(s) desejam que o software possua. Geralmente essa fase é realizada
com a colaboração do cliente que solicitou o desenvolvimento do software ou do usuário que
fará uso do sistema no dia-a-dia;
• Projeto de sistemas e de software: é a fase onde são feitos muitos diagramas para
representar as decisões de projeto que foram tomadas. Além disso, também são definidas
várias características importantes do projeto, tais como a plataforma que o sistema irá
funcionar (cliente servidor, web, desktop, mobile), qual sistema operacional o software irá
executar (Linux, Windows, Mac), qual linguagem de programação o software será
desenvolvido (Java, C#, Python), entre muitos outros aspectos;
• Implementação e testes de unidade: também conhecida como etapa de programação, é
nesta fase onde a equipe de desenvolvimento irá utilizar uma ou mais linguagens de
programação (Java, C#, Python) para construir o software de acordo com o planejamento e
diagramação realizados nas fases anteriores. É também nessa fase que o desenvolvedor irá
implementar o(s) teste(s) de unidade para avaliar um trecho de código-fonte específico do
software;
• Integração e teste de sistemas: é nesta fase quando diferentes partes do sistema são
integradas a fim de analisar a corretude e completude do sistema como um todo. É também
nessa fase que o desenvolvedor irá implementar o(s) teste(s) de sistema para avaliar o código-
fonte de alguma funcionalidade ou módulo específico do software;
• Operação e manutenção: é a fase onde o sistema é instalado e colocado em uso no ambiente
de produção do cliente. Após a implantação do sistema é comum surgirem necessidades de
ajustes e melhorias no software, por isso a manutenção do sistema geralmente é uma
atividade contínua.
Agora que você está contextualizado com a programação dentro no ciclo de vida do software, é
importante aprender a diferenciar os principais paradigmas de programação. Vamos lá então?
Competência 01
9
1.2 Paradigmas de Programação
Atualmente, existem diversas linguagens de programação, que seguem diferentes
paradigmas, também chamados de padrões ou modelos. Muitos autores definem paradigma de
programação como um estilo de programação ou metodologia para estruturação e execução de um
programa de computador, ou seja, um paradigma de programação estabelece a forma como o(a)
desenvolvedor(a) irá abstrair os elementos existentes no mundo real e irá transmití-los para o código-
fonte que está sendo contruído. Em outras palavras, um paradigma de programação corresponde a
maneira que um(a) desenvolvedor(a) utiliza para resolver computacionalmente um problema do
mundo real através da construção de um software. Essa maneira possui um conjunto de regras bem
definidas e bastante específicas sobre como escrever programas de computador. Isso ocorre porque
um paradigma de programação determina o que é permitido ou proibido em uma linguagem de
programação, por exemplo, a linguagem de programação C é uma linguagem que segue o paradigma
estruturado e procedural e, devido a isso a utilização de herança não é permitida pois, essa é uma
característica exclusiva das linguagens de programação que seguem o paradigma orientado a objetos.
É importante destacar que um mesmo paradigma de programação ser utilizado por diversas
linguagens de programação diferentes. Quando uma linguagem de programação segue um
paradigma, ela precisa respeitar todas as regras estabelecidas pelo paradigma. Também pode existir
situações em que uma mesma linguagem de programação precise seguir mais de um paradigma, a
esses tipos de linguagens dá-se o nome de multi-paradigmas.
Alguns dos principais paradigmas de programação são:
• Programação Imperativa: consiste em uma sequência de comandos ou ações que tem como
objetivo mudar o estado de um programa. Exemplos de linguagens de programação que
seguem esse paradigma são Assembler, C e Cobol;
• Programação Estruturada: dá ênfase ao uso de três estruturas: seqüência, decisão e iteração.
Além disso, também utiliza bastante sub-rotinas e é muito eficiente para a resolução de
problemas simples e diretos. Exemplos de linguagens de programação que seguem esse
paradigma são Pascal, C e Cobol;
• Programação Funcional: permite aos desenvolvedores de software pensar em programas de
computador como avaliações de funções matemáticas, ou seja, o sistema pode ser pensado
Competência 01
10
como uma expressão a ser avaliada. Exemplos de linguagens de programação que seguem
esse paradigma são Haskell e Scala;
• Programação Orientada a Objetos: consiste em softwares que são projetadosusando o
conceito de classes, objetos, atributos, métodos, herança, entre outros. O software funciona
através da interação que ocorre entre os objetos das diversas classes existentes. Exemplos de
linguagens de programação que seguem esse paradigma são Smalltalk, Java e PHP (Hypertext
Preprocessor).
São muitas informações novas não é mesmo? Mas, tenha calma que a medida que você for
fazendo os exemplos e praticando o conteúdo você irá se familiarizar com todos os conceitos.
Entender o surgimento e importância da programação orientada a objetos é fundamental, vamos lá
então?
1.3 Surgimento e Importância da Programação Orientada 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.
Smalltalk foi a primeira linguagem de programação a inserir no mundo da computação os
conceitos da orientação a objetos. Ela foi desenvolvida por volta dos anos 70 em um projeto revolu-
cionáriono da empresa multinacional Xerox Corporation localizada nos Estatos Unidos.
Uma característica muito marcante da linguagem de programação Smalltalk é o fato de tudo
ser tratado como objetos, isso faz com que essa linguagem se torne muito complexa principalmente
para programadores iniciantes. Possivelmente esse foi um dos principais fatores para que ela não
amplamente utilizada na indústria e na academia. Apesar disso, essa linguagem trouxe uma nova
forma de pensar com o paradigma orientados a objetos, o que influenciou as principais linguagens de
programação que são mais utilizadas atualmente, como por exemplo, Java, C#, Ruby, Python, entre
muitas outras.
Competência 01
11
1.4 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 é levado em consideração as operações de entrada e saída de dados. O quadro
abaixo apresenta um exemplo de estrutura sequencial.
Quadro 1 - Exemplo de estrutura sequencial
Fonte: Fundamentos da Programação de Computadores, 2012.
Audiodescrição da figura: 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. Fim da Audiodescrição.
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. Os quadros abaixo mostram um exemplo das estruturas
de decisão “se-então” e “se-então-senão”, respectivamente.
Quadro 2 - Exemplo de estrutura condicional simples
Fonte: Fundamentos da Programação de Computadores, 2012.
Audiodescrição da figura: 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. Fim da Audiodescrição.
ALGORITMO
DECLARE
Bloco de comandos
FIM_ ALGORITMO
SE condição
ENTÃO INÍCIO
comando1
comando2
comando3
FIM
Competência 01
12
Quadro 3 - Exemplo de estrutura condicional composta
Fonte: Fundamentos da Programação de Computadores, 2012.
Audiodescrição da figura: 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.
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. Fim da Audiodescrição.
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). O quadro abaixo mostra
um exemplo das estruturas de repetição “para” e “enquanto”, respectivamente.
Quadro 4 - Exemplo de estrutura de repetição PARA
Fonte: Fundamentos da Programação de Computadores, 2012.
Audiodescrição da figura: 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. Fim da Audiodescrição.
SE condição
ENTÃO INÍCIO
comando1
comando2
FIM
SENÃO INÍCIO
comando3
comando4
FIM
PARA J ← valor inicial ATÉ valor final FAÇA
INÍCIO
comando1
comando2
FIM
Competência 01
13
Quadro 5 - Exemplo de estrutura de repetição ENQUANTO
Fonte: Fundamentos da Programação de Computadores, 2012.
Audiodescrição da figura: 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. Fim da Audiodescrição.
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, imagine um restaurante como modelo de um sistema a ser representado 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 abaixo
apresenta um exemplo dos conceitos da orientação a objetos de acordo com a classe Prato.
ENQUANTO condição FAÇA
INÍCIO
comando1
comando2
comando3
FIM
Competência 01
14
Figura 2 - Exemplo dos conceitos da orientação a objetos de acordo com a classe Prato
Fonte: Os autores
Audiodescrição da figura: 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á ligada 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. Fim da Audiodescrição.
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
Competência 01
15
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.5 Principais conceitos da Programação Orientada a Objetos
Da Tabela 1 à Tabela 7 é 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.
Para saber quais são as 5 melhores opções do mercado de IDE PHP, acesse:
https://blog.geekhunter.com.br/ide-para-php-e-js-qual-a-ideal/
Existem diversos aplicativos para criar e editar código-fonte PHP, um dos mais
bem avaliados é o AWD, ele pode ser instalado no android através do link:
https://play.google.com/store/apps/details?id=org.kidinov.awd&hl=pt&gl=US
https://blog.geekhunter.com.br/ide-para-php-e-js-qual-a-ideal/
https://play.google.com/store/apps/details?id=org.kidinov.awd&hl=pt&gl=US
Competência 01
16
Conceito Descrição Exemplo Código Exemplo Prático
Classe
É um modelo para a
criação de objetos.
Determina as
características e os
comportamentos que os
objetos devem possuir.
<?php
class Prato{
}
?>
Objeto
É uma instância da
classe. As classes são
apenas a abstração, os
objetos são o que de fato
utilizamos.
$prato = new Prato;
Atributo
É uma característica
associada ao objeto.
<?php
class Prato {
public $nome;
}
?>
Prato:
Carne de Sol
Galinha à cabidela
Feijoada
Cozido
Método
É uma funcionalidade da
classe, uma ação ou
comportamento que os
objetos poderão
assumir.
function
exibirPrato() {
echo "<center>";
echo "<b> Prato: "
. $this -> nome .
"</b><p>";
}
Prato Principal:
Serve 4 pessoa(s)
Possui acompanhamentos: não
Tabela 1 – Resumo dos principais conceitos da programação orientada a objetos (Parte 1)
Fonte: Os autores
Audiodescrição da figura: 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. Fim da Audiodescrição.
Competência 01
17
Conceito Descrição Exemplo Código Exemplo Prático
Métodos
get e set
São métodos
utilizados
para
encapsular
os atributos
de uma
classe.
function getNome() {
return $this->nome;
}
function setNome($nome) {
$this->nome = $nome;
}
?>
<?php
$prato = new Prato;
$ prato ->
setNome('Feijoada');
?>
Atributos
e
Métodos
estáticos
São membros
globais da
classe sendo
possível
acessar estes
membros
diretamente
sem o
intermédio
de um objeto.
<?php
class Prato {
static
$quantidadePratosServidos = 0;
}
?>
Prato::$quantidadePratos
Servidos = 1;
$prato = new Prato;
$prato -> nome =
'Galinha à cabidela';
Construtor
É o método
da classe que
é executado
sempre que
um objeto é
instanciado.
function
__construct($valor_mensagem) {
echo "<center><b>
Aproveitem nosso delicioso " .
$valor_mensagem .
"</b></center>";
}
$prato = new
Prato("Prato Especial");
$prato -> nome =
'Galinha à cabidela';
Tabela 2 – Resumo dos principais conceitos da programação orientada a objetos (Parte 2)
Fonte: Os autores
Audiodescrição da figura: 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 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. Fim da Audiodescrição.
Competência 01
18
Conceito Descrição Exemplo Código Exemplo Prático
Herança
É o processo de
criar uma classe
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,
além de poder
criar suas
próprias
características
adicionando
novas
funcionalidades.
<?php
class Prato {
}
?>
<?php
class PratoPrincipal extends
Prato {
}
?>
<?php
class PratoPromocional extends
PratoPrincipal{
}
?>
Tabela 3 – Resumo dos principais conceitos da programação orientada a objetos (Parte 3)
Fonte: Os autores
Audiodescrição da figura: 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 terceiraparte 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. Fim da
Audiodescrição.
Competência 01
19
Conceito Descrição Exemplo Código Exemplo Prático
Classe
abstrata
É um tipo de
classe especial,
pois 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.
<?php
abstract class Pedido{
}
?>
<?php
class Prato extends
Pedido{
}
?>
<?php
class Sobremesa
extends Pedido{
}
?>
Tabela 4 – Resumo dos principais conceitos da programação orientada a objetos (Parte 4)
Fonte: Os autores
Audiodescrição da figura: 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 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. Fim da
Audiodescrição.
Conceito Descrição Exemplo Código Exemplo Prático
Encapsulamento
É o mecanismo
utilizado para
ocultar os
detalhes internos
de
<?php
class Conexao{
private $host;
private $usuario;
private $senha;
private $banco;
private $conexao;
}
Competência 01
20
implementação.
É possível aplicar
este conceito
através dos
modificadores de
acesso: public,
protected e
private.
?>
Classe final
É um tipo de
classe especial,
pois a principal
diferença entre
uma classe final e
uma classe
comum está no
fato das finais
não poderem ser
herdadas.
<?php
final class Cortesia {
}
?>
Associação
É um mecanismo
no qual os
objetos das
classes possuem
um vínculo entre
si, por exemplo,
uma classe pode
conter um
atributo que é
outra classe.
<?php
class Prato extends Pedido{
public
$possuiAcompanhamento;
public $cortesia;
?>
Tabela 5 – Resumo dos principais conceitos da programação orientada a objetos (Parte 5)
Fonte: Os autores
Audiodescrição da figura: 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 quinta parte de um total de sete que compoẽ o resumo citado
Competência 01
21
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. Fim da Audiodescrição.
Conceito Descrição Exemplo Código Exemplo Prático
Interface
É uma classe vazia
que 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).
O objetivo é
abstrair a
implantação do
código. As classes
que
implementarem a
interface são as
que devem se
responsabilizar
pelo corpo dos
métodos.
<?php
interface IPedido {
function
formaPagamento();
}
?>
<?php
class Prato extends Pedido
implements IPedido {
}
?>
<?php
class Sobremesa extends
Pedido implements IPedido {
?>
Tabela 6 – Resumo dos principais conceitos da programação orientada a objetos (Parte 6)
Fonte: Os autores
Audiodescrição da figura: 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 sexta 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: interface. Fim da
Audiodescrição.
Competência 01
22
Conceito Descrição Exemplo Código Exemplo Prático
Polimorfismo
É um mecanismo
que permite que
duas ou mais
subclasses que
herdam de uma
mesma
superclasse
tenham métodos
iguais mas com
comportamentos
diferentes
definidos em
cada uma das
subclasses .
<?php
class Prato extends
Pedido implements
IPedido {
function
formaPagamento() {
return "cartão de
crédito/ débito ou
dinheiro";
}
}
?>
Tabela 7 – Resumo dos principais conceitos da programação orientada a objetos (Parte 7)
Fonte: Os autores
Audiodescrição da figura: 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 sétima 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: polimorfismo. Fim da
Audiodescrição.
Videoaula!
Na videoaula é explicado a importância e os principais conceitos da orientação a
objeto, assista.
Agora que você assistiu a videoaula e estudou esta competência, acesse o
Fórum de Dúvidas: Atividade Prática da Competência 01 e siga as orientações
para a realização da atividade prática.
Competência 01
23
O Podcast da competência 01 é mais um recurso para facilitar o aprendizado e
a absorção dos conteúdos dessa competência, ouça.
Competência 02
24
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, porque elas podem conter os
métodos e também possuem a flexibilidade de encapsular informações.
Para ficar mais claro o conceito de classe pense em um exemplo da vida real. Imagine que
você foi contratado pelo dono do RestauranteFomeZero para desenvolver um software. 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, é utilizada a seguinte estrutura: primeiramente deve ser
inserida 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. O quadro abaixo apresenta a estrutura de classe uma chamada Prato.
DICA IMPORTANTE!
Uma classe representa uma entidade abstrata ou concreta, por isso na maioria
das vezes o nome da classe é um substantivo.
Competência 02
25
Quadro 6 - Exemplo de classe Prato
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta uma classe vaziachamada 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.
Fim da Audiodescrição.
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.
Voltando 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 criar ou instanciar um objeto, é utilizada a seguinte estrutura: primeiramente é declarada
uma variável sempre iniciando com o símbolo do cifrão $ e com um nome que identifique o objeto,
em seguida é inserido o sinal de igual = logo após é acrescentada a palavra-chave new, depois é
adicionado o nome da classe e, por fim é colocado ponto e vírgula. O quadro abaixo 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.
<?php
class Prato{
}
?>
Competência 02
26
Quadro 7 - Exemplo de objeto da classe Prato
Fonte: Os autores
Audiodescrição da figura: 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. Fim da
Audiodescrição.
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 volte ao exemplo do software para um restaurante. Se você está pensando que
irá utilizar esse exemplo durante toda a disciplina você acertou! Agora, suponha que 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, é utilizada a seguinte estrutura: primeiramente é declarada 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 é colocado 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 no item 3.2 Encapsulamento da competência 3 deste ebook.
Importante destacar que todos os elementos citados no parágrafo anterior são obrigatórios
na declaração de um atributo. Os quadros abaixos apresentam a estrutura do atributo $nome da
<?php
include_once('prato.php');
$prato = new Prato;
?>
Competência 02
27
classe Prato e um exemplo de inserção do valor “Galinha à cabidela” ao atributo $nome do objeto
$prato, respectivamente.
Quadro 8 - Exemplo de atributo da classe Prato
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta 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. Fim da Audiodescrição.
Quadro 9 - Exemplo de inserção de um valor ao atributo nome do objeto prato
Fonte: Os autores
Audiodescrição da figura: 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, 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. Fim da Audiodescrição.
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
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.
<?php
include_once('prato.php');
$prato = new Prato;
$prato->nome = 'Galinha à cabidela';
?>
<?php
class Prato{
public $nome;
public $quantidadePessoasServidas;
public $possuiAcompanhamento;
public $preco;
}
?>
Competência 02
28
que o método deverá executar. Os métodos podem ser usados sem receber nenhum parâmetro ou
recebendo 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, tais
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 é declarado
um modificador de acesso, em seguida deve ser acrescentada a palavra-chave function, logo após é
adicionado um nome que identifique o método, posteriormente é inserida 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. O quadro abaixo
apresenta a estrutura do método exibirPrato 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.
Competência 0229
Quadro 10 - Exemplo de um método da classe Prato
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta uma classe chamada Prato, com o método exibirPrato sem parâmetros. A classe Prato possui todo seu
corpo delimitado pela abertura e fechamento de chaves. O método exibirPrato também possui todo seu corpo
delimitado pela abertura e fechamento de chaves. O corpo do método exibirPrato 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. Fim da
Audiodescrição.
O quadro abaixo mostra um exemplo de utilização dos métodos setNome,
setQuantidadePessoasServidas, setPossuiAcompanhamento, setPreco e exibirPrato() do objeto
$prato.
Quadro 11 - Exemplo de utilização dos métodos gets, sets e exibirPrato pelo objeto prato
Fonte: Os autores
Audiodescrição da figura: 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, 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 é
<?php
class Prato{
.
.
.
function exibirPrato() {
echo "<center>";
echo "<b> Prato: " .$this->nome. "</b><p>";
echo "Serve " .$this->quantidadePessoasServidas. " pessoa(s) </br>";
if ($this -> possuiAcompanhamento == 1) {
echo "Possui acompanhamentos: sim </br>";
} else {
echo "Possui acompanhamentos: não </br>";
}
echo "Custa: R$ " . $this -> preco . "</br>";
echo "Quantidade pratos servidos: " . Prato::$quantidadePratosServidos;
echo "</center><p>";
}
}
?>
<?php
include_once('prato.php');
$prato = new Prato;
$prato -> setNome('Galinha à cabidela');
$prato -> setQuantidadePessoasServidas(2);
$prato -> setPossuiAcompanhamento(1);
$prato -> setPreco(52.36);
$prato -> exibirPrato();
?>
Competência 02
30
chamado o método exibirPrato. Todo o conteúdo do código está inserido entre as tags de abertura <?php e de
fechamento ?> de arquivo PHP. Fim da Audiodescrição.
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 é
declarado um modificador de acesso, em seguida dever ser acrescentado a palavra-chave function,
logo após concatenado 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. Os quadros abaixo
apresentam a estrutura dos métodos get e set da classe Prato e 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.
Competência 02
31
Quadro 12 - Exemplo de métodos get e set da classe Prato
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta uma classe chamada Prato, com os métodos getNome sem parâmetros e setNome com o parâmetro
$nome. 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. Fim da
Audiodescrição.
Quadro 13 - Exemplo de utilização dos métodos set no objeto prato
Fonte: Os autores
Audiodescrição da figura: 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, 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 <?php e de fechamento ?> de arquivo PHP. Fim da Audiodescrição.
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.
DICA IMPORTANTE!
É fortemente recomendado sempre utilizar os métodos get e set para acessar os
atributos de um objeto.
<?php
include_once('prato.php');
$prato = new Prato;
$prato->setNome('Galinha à cabidela');
?>
<?php
class Prato{
function getNome() {
return $this->nome;
}
function setNome($nome) {
$this->nome = $nome;
}
?>
Competência 02
32
Quando é usado static em um atributo ou método esse torna-se membro global da classe,
logo é possível acessá-lo diretamente sem o intermédio de um objeto, pois este não pertence
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 à
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, é utilizada a seguinte estrutura: primeiramente é declarado
um modificador de acesso, em seguida deve ser inserida 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. O quadro abaixo
apresenta a estrutura do atributo estático $quantidadePratosServidos da classe Prato já sendo
inicializado com o valor zero.
Quadro 14 - Exemplo de atributo estático da classe Prato
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
DICA IMPORTANTE!
Não existe a necessidade de criação de um objeto para acessar atributos e
métodos estáticos.
<?php
class Prato{
public $nome;
public $quantidadePessoasServidas;public $possuiAcompanhamento;
public $preco;
public static $quantidadePratosServidos = 0;
.
.
.
}
?>
Competência 02
33
código apresenta uma classe chamada Prato, com quatro atributos públicos, são eles: $nome,
$quantidadePessoasServidas, $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. Fim da Audiodescrição.
Para ter acesso a um atributo estático é preciso utilizar a seguinte estrutura: nome da classe,
seguido de dois pontos dois pontos :: e nome do atributo estático, por exemplo,
Prato::$quantidadePratosServidos. O quadro abaixo apresenta um exemplo de utilização do atributo
estático da classe Prato.
Quadro 15 - Exemplo de utilização do atributo estático da classe Prato no método exibirPrato
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta uma classe chamada Prato, com o método exibirPrato sem parâmetros. A classe Prato possui todo seu
corpo delimitado pela abertura e fechamento de chaves. O método exibirPrato também possui todo seu corpo
delimitado pela abertura e fechamento de chaves. O corpo do método exibirPrato 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 exibirPrato 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. Fim da Audiodescrição.
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. Os quadros abaixo apresentam um exemplo de utilização do
atributo estático da classe Prato após a inicialização dos objetos e um exemplo do conteúdo que será
<?php
class Prato{
.
.
.
function exibirPrato() {
echo "<center>";
echo "<b> Prato: " .$this->nome. "</b><p>";
echo "Serve " .$this->quantidadePessoasServidas. " pessoa(s) </br>";
if ($this -> possuiAcompanhamento == 1) {
echo "Possui acompanhamentos: sim </br>";
} else {
echo "Possui acompanhamentos: não </br>";
}
echo "Custa: R$ " .$this->preco. "</br>";
echo "Quantidade pratos servidos: " .Prato::$quantidadePratosServidos;
echo "</center><p>";
}
}
?>
Competência 02
34
impresso no navegador após a execução do método exibirPrato com o uso do atributo estático
$quantidadePratosServidos, respectivamente.
Quadro 16 - Exemplo de utilização do atributo estático da classe Prato
Fonte: Os autores
Audiodescrição da figura: 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, 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 exibirPrato.
Posteriormente logo 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
exibirPrato. Todo o conteúdo do código está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo
PHP. Fim da Audiodescrição.
<?php
include_once('prato.php');
Prato::$quantidadePratosServidos = 1;
$prato = new Prato("Prato Especial");
$prato -> nome = 'Galinha à cabidela';
$prato -> quantidadePessoasServidas = 2;
$prato -> possuiAcompanhamento = 1;
$prato -> preco = 52.36;
$prato -> exibirPrato();
Prato::$quantidadePratosServidos = 2;
$prato = new Prato("Prato Caseiro");
$prato -> nome = 'Cozido';
$prato -> quantidadePessoasServidas = 2;
$prato -> possuiAcompanhamento = 1;
$prato -> preco = 44.27;
$prato -> exibirPrato();
?>
Competência 02
35
Quadro 17 - Exemplo de saída do atributo estático
Fonte: Os autores
Audiodescrição da figura: 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. Fim da Audiodescrição.
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 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.
DICA IMPORTANTE!
Em PHP para ter acesso a uma propriedade estática dentro do corpo da classe é
preciso usar a palavra-chave self acompanhada de dois pontos dois pontos ::
Aproveitem nosso delicioso Prato Especial:
Prato: Galinha à cabidela
Serve 2 pessoa(s)
Possui acompanhamentos: sim
Custa: R$ 52.36
Quantidade de pratos servidos: 1
Aproveitem nosso delicioso Prato Caseiro:
Prato: Cozido
Serve 2 pessoa(s)
Possui acompanhamentos: sim
Custa: R$ 44.27
Quantidade de pratos servidos: 2
Competência 02
36
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 é declarado um modificador de acesso, em seguida é preciso utilizar a palavra-chave
function, posteriormente deve ser acrescentado o nome reservado __construct(), logo após é
adicionada 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 do modificador de acesso e da
lista de parâmetros todos os outros elementos citados anteriormente são obrigatórios na declaração
de um construtor. O quadro abaixo apresenta a estruturado construtor da classe Prato.
Quadro 18 - Exemplo da classe Prato com construtor
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta uma classe chamada Prato, com quatro atributos públicos, são eles: $nome,
$quantidadePessoasServidas, $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 nosso delicioso “ 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. Fim da Audiodescrição.
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
<?php
class Prato{
public $nome;
public $quantidadePessoasServidas;
public $possuiAcompanhamento;
public $preco;
.
.
.
function __construct($valor_mensagem) {
echo "<center><b> Aproveitem nosso delicioso " .$valor_mensagem.
"</b></center>";
}
.
.
.
}
?>
Competência 02
37
uso da palavra-chave new seguida pelo nome da classe e a lista de parâmetros caso possua. Os
quadros abaixo apresentam um exemplo de um objeto da classe Prato com um construtor recebendo
um parâmetro chamado “Prato Especial” e um exemplo de saída de um objeto da classe Prato com
construtor e o parâmetro passado anteriormente.
Quadro 19 - Exemplo de objeto da classe Prato com construtor
Fonte: Os autores
Audiodescrição da figura: 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, 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 exibirPrato. Todo
o conteúdo do código está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo PHP. Fim da
Audiodescrição.
Quadro 20 - Exemplo de saída do objeto da classe Prato com construtor
Fonte: Os autores
Audiodescrição da figura: 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 e
custa: R$ 52.36. Fim da Audiodescrição.
São muitos conceitos novos e muito conteúdo para ser absorvido!!!! Por isso a figura abaixo
mostra a classe Prato completa, com todos os conceitos aprendidos até o momento. É importante
que verifique todos os elementos destacados, 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
<?php
include_once('prato.php');
$prato = new Prato("Prato Especial");
$prato -> setNome('Galinha à cabidela');
$prato -> setQuantidadePessoasServidas(2);
$prato -> setPossuiAcompanhamento(1);
$prato -> setPreco(52.36);
$prato -> exibirPrato();
?>
Aproveitem nosso delicioso Prato Especial
Prato: Galinha à cabidela
Serve 2 pessoa(s)
Possui acompanhamentos: sim
Custa: R$ 52.36
Competência 02
38
serão abordados.
Competência 02
39
Figura 3 - Exemplo da classe Prato com todos os conceitos visto até o momento
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta uma classe chamada Prato, com quatro atributos públicos, são eles: $nome,
$quantidadePessoasServidas, $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
exibirPrato 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 exibirPrato 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
exibirPrato 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 exibirPrato 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 exibirPrato 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. Fim da Audiodescrição.
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 que uma classe herde 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ô).
Competência 02
40
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 Principalcomo 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 abaixo apresenta a hierarquia das classes Prato, Prato Principal e Prato
Promocional.
Figura 4 - A classe Prato Promocional é filha de Prato Principal e neta de Prato
Fonte: Os autores
Audiodescrição da figura: 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). Fim da Audiodescrição.
Para utilização da herança é preciso seguir a estrutura: na declaração da subclasse após o
nome da subclasse é adicionada a palavra-chave extends, em seguida deve ser acrescentado 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, é preciso incluir na subclasse o arquivo onde está a superclasse, isso pode ser feito de várias
Competência 02
41
formas, uma delas é através do nome reservado include_once. O quadro abaixo apresenta um
exemplo de herança na qual a classe Prato Principal está herdando da classe Prato.
<?php
include_once ('prato.php');
class PratoPrincipal extends Prato {
public $incluiRefrigerante;
public $servidoNaEntrada;
function getIncluiRefrigerante() {
return $this -> incluiRefrigerante;
}
function getServidoNaEntrada() {
return $this -> servidoNaEntrada;
}
function setIncluiRefrigerante($valor) {
$this -> incluiRefrigerante = $valor;
}
function setServidoNaEntrada($valor) {
$this -> servidoNaEntrada = $valor;
}
function exibirPratoPrincipal() {
echo "<center>";
echo "<b> Prato Principal: " .$this-> nome."</b><p>";
echo "Serve " .$this->quantidadePessoasServidas. " pessoa(s) </br>";
if ($this -> possuiAcompanhamento == 1) {
echo "Possui acompanhamentos: sim </br>";
} else {
echo "Possui acompanhamentos: não </br>";
}
if ($this -> incluiRefrigerante == 1) {
echo "Inclui refrigerante: sim </br>";
} else {
echo "Inclui refrigerante: não </br>";
}
if ($this -> servidoNaEntrada == 1) {
echo "É servido na entrada: sim </br>";
} else {
echo "É servido na entrada: não </br>";
}
echo "Custa: R$ " .$this->preco. "</br>";
echo "</center><p>";
}
}
?>
Competência 02
42
Quadro 21 - Exemplo de herança da classe Prato Principal
Fonte: Os autores
Audiodescrição da figura: 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
exibirPratoPrincipal 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 exibirPratoPrincipal 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 exibirPratoPrincipal 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. Fim da Audiodescrição.
O quadro abaixo 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. O próximo quadro abaixo apresenta a
saída do objeto $pratoPrincipal da classe Prato Principal.
Quadro 22 - Exemplo de objeto da classe Prato Principal
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta a 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
exibirPratoPrincipal. Todo o conteúdo do código está inserido entre as tags de abertura <?php e de fechamento ?> de
arquivo PHP. Fim da Audiodescrição.
<?php
include_once('prato_principal.php');
$pratoPrincipal = new PratoPrincipal("Prato do dia");
$pratoPrincipal -> setNome('Feijoada');
$pratoPrincipal -> setQuantidadePessoasServidas(4);
$pratoPrincipal -> setPossuiAcompanhamento(0);
$pratoPrincipal -> setPreco(69.99);
$pratoPrincipal -> incluiRefrigerante = 1;
$pratoPrincipal -> servidoNaEntrada = 0;
$pratoPrincipal -> exibirPratoPrincipal();
?>
Competência 02
43
Quadro 23 - Exemplo de saída da classe Prato Principal
Fonte: Os autores
Audiodescrição da figura: 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 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. Fim da Audiodescrição.
O quadro abaixo apresenta outro exemplo de herança na qual a classe Prato Promocional
está herdando da classe Prato Principal.
Aproveitem nosso delicioso Prato do dia
Prato Principal: Feijoada
Serve 4 pessoa(s)
Possui acompanhamentos: não
Inclui refrigerante: sim
É servidor na entrada: não
Custa: R$ 69.99
Quantidade de pratos servidos: 2
<?php
include_once('prato_principal.php');
class PratoPromocional extends PratoPrincipal{
public $valorDesconto;
function getValorDesconto() {
return $this -> valorDesconto;
}
function setValorDesconto($valor) {
$this -> valorDesconto = $valor;
}
function exibirPratoPromocional() {
echo "<center>";
echo "<b> Prato Promocional: " .$this->nome. "</b><p>";
echo "Serve " .$this->quantidadePessoasServidas. " pessoa(s) </br>";
if ($this -> possuiAcompanhamento == 1){
echo "Possui acompanhamentos: sim </br>";
}else{
echo "Possui acompanhamentos: não </br>";
}
if ($this -> incluiRefrigerante== 1){
echo "Inclui refrigerante: sim </br>";
}else{
echo "Inclui refrigerante: não </br>";
}
Competência 02
44
Quadro 24 - Exemplo de herança da classe Prato Promocional
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador O
código apresenta a 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
exibirPratoPromocional 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 exibirPratoPromocional 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
exibirPratoPromocional 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. Fim da Audiodescrição.
O quadro abaixo 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. O próximo quadro abaixo apresenta
a saída do objeto $prato Promocional da classe Prato Promocional.
Quadro 25 - Exemplo de objeto da classe Prato Promocional
<?php
include_once('prato_promocional.php');
$pratoPromocional = new PratoPromocional("Prato Regional");
$pratoPromocional -> setNome('Carne de Sol');
$pratoPromocional -> setQuantidadePessoasServidas(3);
$pratoPromocional -> setPossuiAcompanhamento(1);
$pratoPromocional -> setIncluiRefrigerante(0);
$pratoPromocional -> setServidoNaEntrada(1);
$pratoPromocional -> setPreco(24.99);
$pratoPromocional -> valorDesconto = 5.99;
$pratoPromocional -> exibirPratoPromocional();
?>
if ($this -> servidoNaEntrada == 1){
echo "É servido na entrada: sim </br>";
}else{
echo "É servido na entrada: não </br>";
}
echo "Custa: R$ " .$this->preco. "</br>";
echo "Valor do desconto: R$ " .$this->valorDesconto. "</br>";
echo "</center><p>";
}
}
?>
Competência 02
45
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta a 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 exibirPratoPromocional. Todo o conteúdo do código está inserido entre as tags de abertura <?php e de
fechamento ?> de arquivo PHP. Fim da Audiodescrição.
Quadro 26 - Exemplo de saída da classe Prato Promocional
Fonte: Os autores
Audiodescrição da figura: 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 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. Fim da Audiodescrição.
Para ampliar seu conhecimento sobre classes, objetos, herança e visibilidade,
assista esse vídeo
https://www.youtube.com/watch?v=mysYZdwLrPo
Videoaula!
Na videoaula é explicado na prática os conceitos de classe, herança, objeto,
atributo e método, assista.
Aproveitem nosso delicioso Prato Regional
Prato Promocional: Carne de Sol
Serve 3 pessoa(s)
Possui acompanhamentos: sim
Inclui refrigerante: não
É servidor na entrada: sim
Custa: R$ 24.99
Valor do desconto: R$ 5.99
https://www.youtube.com/watch?v=mysYZdwLrPo
Competência 02
46
Agora que você assistiu a videoaula e estudou esta competência, acesse o
Fórum de Dúvidas: Atividade Prática da Competência 02 e siga as orientações
para a realização da atividade prática.
O Podcast da competência 02 é mais um recurso para facilitar o aprendizado e
a absorção dos conteúdos dessa competência, ouça.
Competência 03
47
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 se pensa em como fazer a
representação de objetos do mundo real no mundo virtual, ou seja, de que forma é possível
representar no programa de computador os objetos do mundo real, com suas características e
comportamentos utilizando os conceitos da orientação a objetos tais como classe, atributo, objeto,
entre outros.
Assim, continue no aprendizado da programação web orientada a objetos pois, quanto mais
ampliar os conhecimentos mais fácil será fazer abstrações.
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. O quadro abaixo apresenta um exemplo da classe
Sobremesa.
<?php
class Sobremesa {
public $nome;
public $quantidadePessoasServidas;
public $preco;
public $temperaturaServida;
function getNome() {
return $this -> nome;
}
Competência 03
48
Quadro 27 - Exemplo da classe Sobremesa sem herança
Fonte: Os autores
Audiodescrição da figura: 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 exibirSobremesa 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 exibirSobremesa 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 exibirSobremesa possui diversos
comandos echo para impressão dos valores dos atributos nome, quantidadePessoasServidas, preço e
temperaturaServida no navegador. Todo o conteúdo do código está inserido entre as tags de abertura <?php e de
fechamento ?> de arquivoPHP. Fim da Audiodescrição.
function getQuantidadePessoasServidas() {
return $this -> quantidadePessoasServidas;
}
function getPreco() {
return $this -> preco;
}
function getTemperaturaServida() {
return $this -> temperaturaServida;
}
function setNome($nome) {
$this -> nome = $nome;
}
function setQuantidadePessoasServidas($valor) {
$this -> quantidadePessoasServidas = $valor;
}
function setPreco($valor) {
$this -> preco = $valor;
}
function setTemperaturaServida($valor) {
$this -> temperaturaServida = $valor;
}
function exibirSobremesa() {
echo "<center>";
echo "<b> Sobremesa: " .$this->nome. "</b><p>";
echo "Serve " .$this->quantidadePessoasServidas. " pessoa(s) </br>";
echo "Custa: R$ " .$this->preco. "</br>";
echo "Temperatura que é servida: " .$this->temperaturaServida.
"</br>";
echo "</center><p>";
}
}
?>
Competência 03
49
Os quadros abaixo apresentam um exemplo do objeto $sobremesa da classe Sobremesa e
uma saída gerada pelo objeto $sobremesa da classe Sobremesa, respectivamente.
Quadro 28 - Exemplo do objeto da classe Sobremesa sem herança
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta a 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 exibirSobremesa. Todo o
conteúdo do código está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo PHP. Fim da
Audiodescrição.
Quadro 29 - Exemplo de saída da classe Sobremesa sem herança
Fonte: Os autores
Audiodescrição da figura: 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 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. Fim da Audiodescrição.
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
Aproveitem nossa deliciosa Sobremesa
Sobremesa: Taça Sorvete
Serve 1 pessoa(s)
Custa: R$ 5.53
Temperatura que é servida: Gelada
<?php
include_once('sobremesa.php');
$sobremesa = new Sobremesa;
$sobremesa -> setNome('Taça Sorvete');
$sobremesa -> setQuantidadePessoasServidas(1);
$sobremesa -> setPreco(5.53);
$sobremesa -> setTemperaturaServida('Gelada');
$sobremesa -> exibirSobremesa();
?>
Competência 03
50
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. 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 abaixo apresenta a hierarquia das classes Pedido, Prato e Sobremesa.
Figura 5 - As classes Prato e Sobremesa são filhas da classe pai Pedido
Fonte: Os autores
Audiodescrição da figura: Fluxograma, centralizado, com a 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). Fim da
Audiodescrição.
Competência 03
51
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. O quadro
abaixo apresenta a estrutura da classe abstrata Pedido com todos os atributos em comum das classes
Prato e Sobremesa e com o método abstrato exibirPedido.
Quadro 30 - Exemplo da classe abstrata Pedido
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta 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
exibirPedido 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 exibirPedido 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
<?php
abstract class Pedido {
protected $nome;
protected $quantidadePessoasServidas;
protected $preco;
function getNome() {
return $this -> nome;
}
function getQuantidadePessoasServidas() {
return $this -> quantidadePessoasServidas;
}
function getPreco() {
return $this -> preco;
}
function setNome($nome) {
$this -> nome = $nome;
}
function setQuantidadePessoasServidas($valor) {
$this -> quantidadePessoasServidas = $valor;
}
function setPreco($valor) {
$this -> preco = $valor;
}
abstract function exibirPedido();
}
?>
Competência 03
52
fechamento ?> de arquivo PHP. Fim da Audiodescrição.
O quadro abaixo apresenta a classe Prato herdando da classe Pedido, apenas com o atributo
$possuiAcompanhamento e implementando o método exibirPedido.
Quadro 31 - Exemplo da classe Prato herando da classe abstrata Pedido
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador O
código apresenta a 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 exibirPedido e os métodos get e set para cada atributo. A classe Pratopossui todo seu
corpo delimitado pela abertura e fechamento de chaves, assim como o corpo do método exibirPedido 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 exibirPedido 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
<?php
include_once('pedido.php');
class Prato extends Pedido{
public $possuiAcompanhamento;
function __construct($valor_mensagem) {
echo "<center><b> Aproveitem nosso delicioso ".$valor_mensagem.
"</b></center>";
}
function getPossuiAcompanhamento() {
return $this -> possuiAcompanhamento;
}
function setPossuiAcompanhamento($valor) {
$this -> possuiAcompanhamento = $valor;
}
function exibirPedido() {
echo "<center>";
echo "<b> Prato: " .$this->nome. "</b><p>";
echo "Serve " .$this-> quantidadePessoasServidas." pessoa(s) </br>";
if ($this -> possuiAcompanhamento == 1){
echo "Possui acompanhamentos: sim </br>";
}else{
echo "Possui acompanhamentos: não </br>";
}
echo "Custa: R$ " .$this->preco."</br>";
echo "</center><p>";
}
}
?>
Competência 03
53
arquivo PHP. Fim da Audiodescrição.
O quadro abaixo apresenta a classe Sobremesa herdando da classe Pedido, apenas com o
atributo $temperaturaServida e implementando o método exibirPedido.
Quadro 32 - Exemplo da classe Sobremesa herando da classe abstrata Pedido
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador O
código apresenta a 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 exibirPedido 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 exibirPedido 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 exibirPedido
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. Fim da Audiodescrição.
<?php
include_once('pedido.php');
class Sobremesa extends Pedido{
public $temperaturaServida;
function __construct($valor_mensagem) {
echo "<center><b> Aproveitem nossa deliciosa " .$valor_mensagem.
"</b></center>";
}
function getTemperaturaServida() {
return $this -> temperaturaServida;
}
function setTemperaturaServida($valor) {
$this -> temperaturaServida = $valor;
}
function exibirPedido() {
echo "<center>";
echo "<b> Sobremesa: " .$this-> nome. "</b><p>";
echo "Serve " .$this->quantidadePessoasServidas. " pessoa(s) </br>";
echo "Custa: R$ " .$this->preco. "</br>";
echo "Temperatura que é servida: " .$this->temperaturaServida.
"</br>";
echo "</center><p>";
}
}
?>
Competência 03
54
Os quadros abaixo apresentam um exemplo dos objetos $prato e $sobremesa das classes
Prato e Sobremesa e, uma saída gerada pelos objetos $prato e $sobremesa com a herança da classe
abstrata Pedido, respectivamente.
Quadro 33 - Exemplo de objeto da classe Prato e da classe Sobremesa com herança
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta a 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
exibirPedido. 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 exibirPedido. Todo o conteúdo do código está inserido entre as
tags de abertura <?php e de fechamento ?> de arquivo PHP. Fim da Audiodescrição.
<?php
include_once('prato.php');
$prato = new Prato("Prato Especial");
$prato -> setNome('Galinha à cabidela');
$prato -> setQuantidadePessoasServidas(2);
$prato -> setPossuiAcompanhamento(1);
$prato -> setPreco(52.36);
$prato -> exibirPedido();
include_once('sobremesa.php');
$sobremesa = new Sobremesa;
$sobremesa -> setNome('Taça Sorvete');
$sobremesa -> setQuantidadePessoasServidas(1);
$sobremesa -> setPreco(5.53);
$sobremesa -> setTemperaturaServida('Gelada');
$sobremesa -> exibirPedido();
?>
Competência 03
55
Quadro 34 - Exemplo de saída da classe Prato e da classe Sobremesa com herança
Fonte: Os autores
Audiodescrição da figura: 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 e
custa: R$ 52.36. 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 e temperatura servida é: gelada. Fim da
Audiodescrição.
3.1.2 Erro ao instanciar uma classe abstrata
As classes abstratas não permitem que sejam instanciados objetos delas mesmas, apenas das
suas subclasses então, caso um objeto fosse criado utilizando o construtor de uma classe abstrata o
resultado seria um erro. Os quadros abaixo apresentam um exemplo de criação do objeto
$testeClasseAbstrata da classe Pedido e a mensagem de erro que é exibida, respectivamente.
Quadro 35 - Exemplo de objeto da classe TesteHerancaClasseFinal herdando da classe final Cortesia
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta a inclusão do arquivo pedido.php e a criação de um objeto chamado $ testeClasseAbstrata da classe
abstrata Pedido. Fim da Audiodescrição.
Aproveitem nosso delicioso Prato Especial
Prato: Galinha à cabidela
Serve 2 pessoa(s)
Possui acompanhamentos: sim
Custa: R$ 52.36
Aproveitem nossa deliciosa Sobremesa
Sobremesa: Taça Sorvete
Serve 1 pessoa(s)
Custa: R$ 5.53
Temperatura que é servida: Gelada
<?php
include_once('pedido.php');
$testeClasseAbstrata = new Pedido();
?>
Competência 03
56
Quadro 36 - Mensagem de erro exibida quando um objeto é instanciado utilizando um construtorde uma classe
abstrata
Fonte: Os autores
Audiodescrição da figura: Mensagem de erro do código-fonte escrito na linguagem PHP para construção de programa
de computador ao criar um objeto a partir de uma classe abstrata. Fim da Audiodescrição.
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 ocultar 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 é recomendado 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. As tabelas
abaixo apresentam os modificadores de acesso com suas respectivas descrições e um resumo da
visibilidade dos modificadores de acesso dentro da classe, nas subclasses e em qualquer trecho do
código, respectivamente.
DICA IMPORTANTE!
Uma classe abstrata existe para ser estendida (herdada).
Fatal error: Uncaught Error: Cannot instantiate abstract class Pedido
Competência 03
57
Modificador Descrição
Public É o modificador de acesso que possui maior liberdade, pois permite que o
atributo ou método possa ser visível em qualquer parte do programa sem
problemas. É também o modificador padrão (default) em muitas linguages de
programação orientadas a objetos, ou seja, quando um elemento não tiver
modificador de acesso então este será public.
Protected É o modificador de acesso que possui liberdade intermediária, pois permite que
o atributo ou método possa ser visível apenas dentro da classe onde ele foi
declarado e nas suas subclasses.
Private É o modificador de acesso que possui menor liberdade, pois permite que o
atributo ou método possa ser visível apenas dentro da classe onde ele foi
declarado. É fortemente indicada a utilização desse modificador de acesso para
definir a visibilidade de atributos e métodos em uma classe.
Tabela 8 – Resumo dos modificadores de acesso
Fonte: Os autores
Audiodescrição da figura: 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. Fim da Audiodescrição.
Modificador É visível na própria
classe?
É visível nas suas
subclasses?
É visível em qualquer
trecho do código?
Public sim sim sim
Protected sim sim não
Private sim não não
Tabela 9 – Resumo da visibilidade dos modificadores de acesso
Fonte: Os autores
Audiodescrição da figura: 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. Fim da Audiodescrição.
O quadro abaixo apresenta um exemplo da utilização do modificador de acesso private no
atributo $possuiAcompanhamento e, do modificador de acesso public nos métodos get, set e
exibirPedido() da classe Prato.
Competência 03
58
Quadro 37 - Exemplo de utilização de modificadores de acesso na classe Prato
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta uma classe chamada Prato, com um atributo privado chamado $possuiAcompanhamento e um
método chamado exibirPedido(). A classe Prato possui todo seu corpo delimitado pela abertura e fechamento de
chaves, assim como o corpo dos seus métodos. Todo o conteúdo do código está inserido entre as tags de abertura
<?php e de fechamento ?> de arquivo PHP. Fim da Audiodescrição.
Ao instanciar objetos de uma classe que utilizam modificadores de acesso private ou
protected nos seus atributos, é preciso que sejam utilizados métodos get e set dos respectivos
atributos para acessá-los ou alterá-los, como pode ser visualizado nos exemplos dos quadros abaixo.
Ao utilizar modificadores de acesso a saída gerada pelo código-fonte não é alterada.
<?php
include_once('pedido.php');
class Prato extends Pedido{
private $possuiAcompanhamento;
function __construct($valor_mensagem) {
echo "<center><b> Aproveitem nosso delicioso ".$valor_mensagem.
"</b></center>";
}
public function getPossuiAcompanhamento() {
return $this -> possuiAcompanhamento;
}
public function setPossuiAcompanhamento($valor) {
$this -> possuiAcompanhamento = $valor;
}
public function exibirPedido() {
echo "<center>";
echo "<b> Prato: " .$this->nome. "</b><p>";
echo "Serve " .$this-> quantidadePessoasServidas." pessoa(s) </br>";
if ($this -> possuiAcompanhamento == 1){
echo "Possui acompanhamentos: sim </br>";
}else{
echo "Possui acompanhamentos: não </br>";
}
echo "Custa: R$ " .$this->preco."</br>";
echo "</center><p>";
}
}
?>
Competência 03
59
Os quadros abaixo apresentam um exemplo do objeto $prato da classe Prato e, uma saída
gerada pelo objeto $prato com a utilização dos modificadores de acessos private e public.
Quadro 38 - Exemplo de objeto da classe Prato utilizando modificadores de acessos private e public
Fonte: Os autores
Audiodescrição da figura: 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, 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 exibirPedido. Todo
o conteúdo do código está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo PHP. Fim da
Audiodescrição.
Quadro 39 - Exemplo de saída da classe Prato utilizando modificadores de acessos private e public
Fonte: Os autores
Audiodescrição da figura: 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 e
custa: R$ 52.36. Fim da Audiodescrição.
Indicamos que você assista esse vídeo como forma de ampliar seu
conhecimento sobre modificadores de acesso em PHP
https://www.youtube.com/watch?v=CuyXVxsElXs
<?php
include_once('prato.php');
$prato = new Prato("Prato Especial");
$prato -> setNome('Galinha à cabidela');
$prato -> setQuantidadePessoasServidas(2);
$prato -> setPossuiAcompanhamento(1);
$prato -> setPreco(52.36);
$prato -> exibirPedido();
?>Aproveitem nosso delicioso Prato Especial
Prato: Galinha à cabidela
Serve 2 pessoa(s)
Possui acompanhamentos: sim
Custa: R$ 52.36
https://www.youtube.com/watch?v=CuyXVxsElXs
Competência 03
60
3.2.1 Erro ao acessar atributo protected ou private
Os atributos de uma classe que possuem modificador de acesso protected são visíveis apenas
na própria classe em que foram declarados e nas classes que herdarem dela. Caso seja necessário
acessar ou alterar um atributo protected em algum outro local no código-fonte então, é preciso que
seja utilizado o método get ou set, respectivamente. Se um método get ou set não for utilizado uma
mensagem de erro será exibida e a execução do código será finalizada. Os quadros abaixo apresentam
um exemplo de acesso ao atributo $nome do objeto $prato da classe Prato e a mensagem de erro
que é exibida, respectivamente. Lembrando que o atributo $nome é declarado na classe abstrata
Pedido e possui o modificador de acesso protected.
Quadro 40 - Exemplo de acesso ao atributo protected nome da classe Prato
Fonte: Os autores
Audiodescrição da figura: 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, a criação de um objeto chamado $prato da classe Prato e o acesso ao
atributo $nome. Fim da Audiodescrição.
Quadro 41 - Mensagem de erro exibida quando um atributo protected é acessado fora da sua classe ou subclasse
Fonte: Os autores
Audiodescrição da figura: Mensagem de erro do código-fonte escrito na linguagem PHP para construção de programa
de computador ao acessar um atributo protected fora da sua classe ou subclasse. Fim da Audiodescrição.
Os atributos de uma classe que possuem modificador de acesso private são visíveis
exclusivamente na própria classe em que foram declarados. Caso seja necessário acessar ou alterar
um atributo private em algum outro local no código-fonte então, assim como o modificador de acesso
protected, é preciso que seja utilizado o método get ou set. Se um método get ou set não for utilizado
uma mensagem de erro será exibida e a execução do código será finalizada. Os quadros abaixo
apresentam um exemplo de acesso ao atributo $ possuiAcompanhamento do objeto $prato da classe
Prato e a mensagem de erro que é exibida, respectivamente.
<?php
include_once('prato.php');
$prato = new Prato("Prato Especial");
$prato->nome = 'Galinha à cabidela';
?>
Fatal error: Uncaught Error: Cannot access protected property Prato::$nome
Competência 03
61
Quadro 42 - Exemplo de acesso ao atributo private possuiAcompanhamento da classe Prato
Fonte: Os autores
Audiodescrição da figura: 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, a criação de um objeto chamado $prato da classe Prato e o acesso ao
atributo $possuiAcompanhamento. Fim da Audiodescrição.
Quadro 43 - Mensagem de erro exibida quando um atributo private é acessado fora da sua classe
Fonte: Os autores
Audiodescrição da figura: Mensagem de erro do código-fonte escrito na linguagem PHP para construção de programa
de computador ao acessar um atributo private fora da sua classe. Fim da Audiodescrição.
3.3 Classe Final
As classes finais são classes especiais, a principal diferença entre uma classe final e uma classe
comum (também chamada de classe concreta) está no fato das finais não poderem ser herdadas, ou
seja, um importante conceito da programação orientada a objetos, a herança, não poderá ser
utilizado quando uma classe é definida como final. Na linguagem de programação PHP, as classes
finais não podem ser estendidas por nenhuma subclasse, pois entende-se que uma classe final deverá
ser a última etapa de uma classe. Em outras linguagens de programação orientadas a objetos, como
java por exemplo, as classes finais não podem ser estendidas por classes concretas, porém é possível
que uma classe final herde de outra classe final.
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.
<?php
include_once('prato.php');
$prato = new Prato("Prato Especial");
$prato -> possuiAcompanhamento = 1;
?>
Fatal error: Uncaught Error: Cannot access private property Prato::$possuiAcompanhamento
Competência 03
62
Para declarar uma classe final, é utilizada a seguinte estrutura: primeiramente são declaradas
as palavras-chave final class, em seguida deve ser inserido o nome da classe e, por fim é colocado
abre e fecha chaves { }. Dentro das chaves será inserido o corpo ou escopo da classe final. Os quadros
abaixo apresentam a estrutura da classe final Cortesia, um exemplo de utilização dos objetos $prato
e $cortesia e uma saída gerada pelos objetos $prato e $cortesia da classe concreta Prato e da classe
final Cortesia, respectivamente.
<?php
final class Cortesia {
private $tipoCortesia;
public function getTipoCortesia() {
return $this -> tipoCortesia;
}
public function setTipoCortesia($valor) {
$this -> tipoCortesia = $valor;
}
public function exibirCortesia($valor) {
switch ($valor) {
case "segunda-feira" :
$tipoCortesia = "Música ao vivo";
break;
case "terça-feira" :
$tipoCortesia = "Embalagem gratuita";
break;
case "quarta-feira" :
$tipoCortesia = "Biscoito da sorte";
break;
case "quinta-feira" :
$tipoCortesia = "Entrega em casa grátis";
break;
case "sexta-feira" :
$tipoCortesia = "Refrigerante de graça";
break;
case "sábado" :
$tipoCortesia = "Peça 1 ganhe 2";
break;
case "domingo" :
$tipoCortesia = "Salada de frutas por conta da casa";
break;
default :
$tipoCortesia = "Entrega com menos de 300 metros de distância
não paga";
}
Competência 03
63
Quadro 44 - Exemplo da classe final Cortesia
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta 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 exibirCortesia que recebe um parâmetro. O corpo do método exibirCortesia 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. Fim da Audiodescrição.
Quadro 45 - Exemplo de objeto da classe Cortesia
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta a inclusão dos arquivos prato.php e cortesia.php, a criação de um objeto chamado $prato da classe
Prato com o parâmetro Prato Especial no construtor, alémda 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
exibirPedido. 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 exibirCortesia. Todo o conteúdo do código está inserido entre as
tags de abertura <?php e de fechamento ?> de arquivo PHP. Fim da Audiodescrição.
<?php
include_once('prato.php');
$prato = new Prato("Prato Especial");
$prato -> setNome('Galinha à cabidela');
$prato -> setQuantidadePessoasServidas(2);
$prato -> setPossuiAcompanhamento(1);
$prato -> setPreco(52.36);
$prato -> exibirPedido();
include_once('cortesia.php');
$cortesia = new Cortesia;
$cortesia -> exibirCortesia("terça-feira");
?>
echo "<center>";
echo "A cortesia de hoje é: " . $tipoCortesia . "<p>";
echo "</center><p>";
}
}
?>
Competência 03
64
Quadro 46 - Exemplo de saída das classes Prato e Cortesia
Fonte: Os autores
Audiodescrição da figura: 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. Fim da
Audiodescrição.
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. Os quadros abaixo apresentam um exemplo da classe
TesteHerancaClasseFinal herdando da classe final Cortesia, um exemplo de criação do objeto
$testeHerancaClasseFinal da classe TesteHerancaClasseFinal, e uma mensagem de erro que é exibida,
respectivamente.
Quadro 47 - Exemplo da classe TesteHerancaClasseFinal herdando da classe final Cortesia
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta a 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.
Fim da Audiodescrição.
<?php
include_once('testeHerancaClasseFinal.php');
$testeHerancaClasseFinal = new TesteHerancaClasseFinal();
?>
Aproveitem nosso delicioso Prato Especial
Prato: Galinha à cabidela
Serve 2 pessoa(s)
Possui acompanhamentos: sim
Custa: R$ 52.36
A cortesia de hoje é: Embalagem gratuita
<?php
include_once('cortesia.php');
class TesteHerancaClasseFinal extends Cortesia{
}
?>
Competência 03
65
Quadro 48 - Exemplo de objeto da classe TesteHerancaClasseFinal herdando da classe final Cortesia
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta a inclusão do arquivo testeHerancaClasseFinal.php e a criação de um objeto chamado
$testeHerancaClasseFinal da classe TesteHerancaClasseFinal. Fim da Audiodescrição.
Quadro 49 - Mensagem de erro exibida quando a classe TesteHerancaClasseFinal herda da classe final Cortesia
Fonte: Os autores
Audiodescrição da figura: Mensagem de erro do código-fonte escrito na linguagem PHP para construção de programa
de computador ao estender a classe final testeHerancaClasseFinal. Fim da Audiodescrição.
3.4 Método Final
Os métodos finais são métodos especiais, a principal diferença entre um método final e um
método comum está no fato dos finais não poderem ser sobrescritos, ou seja, uma subclasse classe
(também chamada de classe filha) poderá ter acesso aos métodos finais da superclasse (também
chamada de classe pai), contudo a subclasse classe não poderá reescrever as ações que são
executadas nos métodos finais superclasse.
Para declarar um método final, é utilizada a seguinte estrutura: primeiramente é declarado
um modificador de acesso, em seguida é preciso utilizar as palavras-chave final function, em seguida
deve ser inserido o nome do método, logo após é adicionada a lista de parâmetros dentro dos
parênteses e, por fim é colocado abre e fecha chaves { }. Dentro das chaves será inserido o corpo ou
escopo do método final. Os quadros abaixo apresentam a estrutura da classe Prato com um método
final, um exemplo de utilização do objeto $prato e uma saída gerada pelo objeto $prato da classe
Prato, respectivamente.
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.
Fatal error: Class TesteHerancaClasseFinal may not inherit from final class (Cortesia)
Competência 03
66
Quadro 50 - Exemplo da classe Prato declarando um método final
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta a inclusão do arquivo pedido.php e uma classe chamada Prato que extende da classe Pedido, com um
atributo privado, $possuiAcompanhamento. Além disso, a classe Prato também possui um contrutor com um
parâmetro, um método chamado exibirPedido, outro método chamado exibirMensagemParaCliente 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 dos métodos exibirPedido, exibirMensagemParaCliente e os métodos get e set. Os métodos get não
<?php
include_once('pedido.php');
class Prato extends Pedido{
private $possuiAcompanhamento;
public function __construct($valor_mensagem) {
echo "<center><b> Aproveitem nosso delicioso ".$valor_mensagem.
"</b></center>";
}
public function getPossuiAcompanhamento() {
return $this -> possuiAcompanhamento;
}
public function setPossuiAcompanhamento($valor) {
$this -> possuiAcompanhamento = $valor;
}
public function exibirPedido() {
echo "<center>";
echo "<b> Prato: " .$this->nome. "</b><p>";
echo "Serve " .$this-> quantidadePessoasServidas." pessoa(s)
</br>";
if ($this -> possuiAcompanhamento == 1){
echo "Possui acompanhamentos: sim </br>";
}else{
echo "Possui acompanhamentos: não </br>";
}
echo "Custa: R$ " .$this->preco."</br>";
echo "</center><p>";
}
public final function exibirMensagemParaCliente($nomeCliente) {
echo "<b><center>". $nomeCliente. " é um prazer ter você como nosso
cliente. Volte sempre !!!! </center></b>";
}
}
?>
Competência 03
67
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 exibirPedido possui diversos comandos echo para
impressão dos valores dos atributos nome, quantidadePessoasServidas, possuiAcompanhamento e preço no navegador.
O corpo do método exibirMensagemParaCliente possui um comando echo para impressão de uma mensagem de
despedida para o cliente no navegador. Todo o conteúdo do código está inserido entre as tags de abertura <?php e de
fechamento ?> de arquivo PHP. Fim da Audiodescrição.Quadro 51 - Exemplo de objeto da classe Prato chamando um método final
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta a inclusão dos arquivos prato.php e cortesia.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
exibirPedido. 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 exibirCortesia. Todo o conteúdo do código está inserido entre as
tags de abertura <?php e de fechamento ?> de arquivo PHP. Fim da Audiodescrição.
Quadro 52 - Exemplo de saída das classes Prato
Fonte: Os autores
Audiodescrição da figura: 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. Fim da
Audiodescrição.
<?php
include_once('prato.php');
$prato = new Prato("Prato Especial");
$prato -> setNome('Galinha à cabidela');
$prato -> setQuantidadePessoasServidas(2);
$prato -> setPossuiAcompanhamento(1);
$prato -> setPreco(52.36);
$prato -> exibirPedido();
$prato -> exibirMensagemParaCliente("João Luiz");
?>
Aproveitem nosso delicioso Prato Especial
Prato: Galinha à cabidela
Serve 2 pessoa(s)
Possui acompanhamentos: sim
Custa: R$ 52.36
João Luiz é um prazer ter você como nosso
cliente. Volte sempre !!!!
Competência 03
68
3.5 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. O quadro abaixo apresenta
um exemplo de utilização da associação através da classe Prato com um objeto da classe Cortesia.
Quadro 53 - Exemplo da classe Prato com associação
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta a 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. Fim da Audiodescrição.
<?php
include_once('pedido.php');
include_once('cortesia.php');
class Prato extends Pedido{
public $possuiAcompanhamento;
public $cortesia;
function __construct($valor_mensagem) {
echo "<center><b> Aproveitem nosso delicioso " . $valor_mensagem .
"</b></center>";
}
function getPossuiAcompanhamento() {
return $this -> possuiAcompanhamento;
}
function setPossuiAcompanhamento($valor) {
$this -> possuiAcompanhamento = $valor;
}
function getCortesia() {
return $this -> cortesia;
}
function setCortesia($valor) {
$this -> cortesia = $valor;
}
.
.
.
}
?>
Competência 03
69
3.6 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 ficam
vazios, pois o objetivo é abstrair a implementação do código. As classes que implementarem a
interface é que devem se 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.
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). Os
quadros abaixo apresentam a estrutura da interface IPedido e um exemplo das classes Prato e
Sobremesa implementando a interface IPedido, respectivamente. Verifique que na classe Prato a
Indicamos que você assista esse vídeo como forma de ampliar seu
conhecimento sobre associação e relacionamento entre classes
https://www.youtube.com/watch?v=X6DTtj8Pfc0
DICA IMPORTANTE!
Na maioria das linguagens de programação orientadas a objetos, uma interface
tem que ser puramente abstrata, ou seja, não pode conter métodos concretos.
https://www.youtube.com/watch?v=X6DTtj8Pfc0
Competência 03
70
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.
Quadro 54 - Exemplo da interface IPedido com o método formaPagamento
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta 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. Fim da Audiodescrição.
<?php
interface IPedido {
function formaPagamento();
}
?>
Competência 03
71
Quadro 55 - Exemplo da classe Prato implementando a interface IPedido
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta a 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 exibirPedido 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
<?php
include_once ('pedido.php');
include_once ('ipedido.php');
class Prato extends Pedido implements IPedido {
public $possuiAcompanhamento;
function __construct($valor_mensagem) {
echo "<center><b> Aproveitem nosso delicioso " .
$valor_mensagem . "</b></center>";
}
function getPossuiAcompanhamento() {
return $this -> possuiAcompanhamento;}
function setPossuiAcompanhamento($valor) {
$this -> possuiAcompanhamento = $valor;
}
function exibirPedido() {
echo "<center>";
echo "<b> Prato: " . $this -> nome . "</b><p>";
echo "Serve " . $this -> quantidadePessoasServidas . " pessoa(s)
</br>";
if ($this -> possuiAcompanhamento == 1) {
echo "Possui acompanhamentos: sim </br>";
} else {
echo "Possui acompanhamentos: não </br>";
}
echo "Custa: R$ " . $this -> preco . "</br>";
echo "As formas de pagamento aceitas são: " . $this ->
formaPagamento() . "</br>";
echo "</center><p>";
}
function formaPagamento() {
return "cartão de crédito/débito ou dinheiro";
}
}
?>
Competência 03
72
parâmetro. Todo o conteúdo do código está inserido entre as tags de abertura <?php e de fechamento ?> de arquivo
PHP. Fim da Audiodescrição.
Quadro 56 - Exemplo da classe Sobremesa implementando a interface IPedido
Fonte: Os autores
Audiodescrição da figura: 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 exibirPedido 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 exibirSobremesa 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
exibirSobremesa 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. Fim da
Audiodescrição.
<?php
include_once('pedido.php');
include_once('ipedido.php');
class Sobremesa extends Pedido implements IPedido{
public $temperaturaServida;
function getTemperaturaServida() {
return $this -> temperaturaServida;
}
function setTemperaturaServida($valor) {
$this -> temperaturaServida = $valor;
}
function exibirPedido() {
echo "<center>";
echo "<b> Sobremesa: " . $this -> nome . "</b><p>";
echo "Serve " . $this -> quantidadePessoasServidas . " pessoa(s)
</br>";
echo "Custa: R$ " . $this -> preco . "</br>";
echo "Temperatura que é servida: " . $this -> temperaturaServida .
"</br>";
echo "A única forma de pagamento aceita é: " . $this ->
formaPagamento() . "</br>";
echo "</center><p>";
}
function formaPagamento(){
return "cartão de crédito";
}
}
?>
Competência 03
73
Os quadros abaixo apresentam um exemplo de utilização dos objetos $prato e $sobremesa e,
uma saída gerada pelos objetos $prato e $sobremesa das classes Prato e Sobremesa com a
implementação da interface IPedido, respectivamente.
Quadro 57 - Exemplo de objeto da classe Prato e da classe Sobremesa com interface
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta a 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
exibirPedido. 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 exibirPedido. Todo o conteúdo do código está inserido entre as
tags de abertura <?php e de fechamento ?> de arquivo PHP. Fim da Audiodescrição.
<?php
include_once('prato.php');
$prato = new Prato("Prato Especial");
$prato -> setNome('Galinha à cabidela');
$prato -> setQuantidadePessoasServidas(2);
$prato -> setPossuiAcompanhamento(1);
$prato -> setPreco(52.36);
$prato -> exibirPedido();
include_once('sobremesa.php');
$sobremesa = new Sobremesa;
$sobremesa -> setNome('Taça Sorvete');
$sobremesa -> setQuantidadePessoasServidas(1);
$sobremesa -> setPreco(5.53);
$sobremesa -> temperaturaServida = 'Gelada';
$sobremesa -> exibirPedido();
?>
Competência 03
74
Quadro 58 - Exemplo de saída da classe Prato e da classe Sobremesa com interface
Fonte: Os autores
Audiodescrição da figura: 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 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. Fim da
Audiodescrição.
Observem que estamos sempre trabalhando sobre o mesmo exemplo para facilitar o
entendimento e a absorção do conhecimento. Por isso, a figura abaixo mostra um resumo da
hierarquia das classes e interface criadas até o momento para o exemplo do RestauranteFomeZero.
DICA IMPORTANTE!
Uma classe abstrata sem atributos e com todos os métodos abstratos poderia
facilmente ser transformada/substituída por uma interface.
Aproveitem nosso delicioso Prato Especial
Prato: Galinha à cabidela
Serve 2 pessoa(s)
Possui acompanhamentos: sim
Custa: R$ 52.36
As formas de pagamento aceitas são: cartão de crédito/débito ou dinheiro
Aproveitem nossa deliciosa Sobremesa
Sobremesa: Taça Sorvete
Serve 1 pessoa(s)
Custa: R$ 5.53
Temperatura que é servida: Gelada
A única forma de pagamento aceita é: cartão de crédito
Competência 03
75
Figura 6 - Resumo da hierarquia das classes até o momento
Fonte: Os autores
Audiodescrição da figura: Fluxograma, centralizado, de uma 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. Fim da
Audiodescrição.
3.7 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 umacerta 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.
Indicamos que você assista esse vídeo como forma de ampliar seu
conhecimento sobre interface, classe abstrata, atributo e método estático
https://www.youtube.com/watch?v=CXV49usnojU
https://www.youtube.com/watch?v=CXV49usnojU
Competência 03
76
O operador parent:: funciona de forma semelhante ao $this, contudo o parent é utilizado para
chamar membros da classe pai. O quadro abaixo mostra um exemplo de utilização dos operadores
$this e parent:: na classe Prato principal.
Quadro 59 - Exemplo de $this e parent na classe Prato principal
Fonte: Os autores
Audiodescrição da figura: 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 um método chamado
exibirPratoPrincipal sem parâmetros. A classe PratoPrincipal possui todo seu corpo delimitado pela abertura e
fechamento de chaves, assim como o corpo do método exibirPratoPrincipal. O corpo do método exibirPratoPrincipal
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. Fim da Audiodescrição.
<?php
include_once ('prato.php');
class PratoPrincipal extends Prato {
.
.
.
function exibirPratoPrincipal() {
echo "<center>";
echo "<b> Prato Principal: " . $this -> nome ."</b><p>";
echo "Serve " . $this -> quantidadePessoasServidas . " pessoa(s)
</br>";
if ($this -> possuiAcompanhamento == 1) {
echo "Possui acompanhamentos: sim </br>";
} else {
echo "Possui acompanhamentos: não </br>";
}
if ($this -> incluiRefrigerante == 1) {
echo "Inclui refrigerante: sim </br>";
} else {
echo "Inclui refrigerante: não </br>";
}
if ($this -> servidoNaEntrada == 1) {
echo "É servido na entrada: sim </br>";
} else {
echo "É servido na entrada: não </br>";
}
echo "Custa: R$ " . $this -> preco . "</br>";
echo "As formas de pagamento aceitas são: " .
parent::formaPagamento() . "</br>";
echo "</center><p>";
}
}
?>
Competência 03
77
3.8 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 abaixo apresenta um resumo das formas de pagamento das classes Prato,
Prato Principal e Prato Promocional.
Figura 7 – Resumo do exemplo de formas de pagamento
Fonte: Os autores
Audiodescrição da figura: Fluxograma, centralizado, de uma 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). Fim da Audiodescrição.
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
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.
Competência 03
78
Os quadros abaixo mostram um exemplo da classe Prato Principal utilizando o método
formaPagamento da classe pai (Prato) e 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
<?php
include_once ('prato.php');
class PratoPrincipal extends Prato {
public $incluiRefrigerante;
public $servidoNaEntrada;
function getIncluiRefrigerante() {
return $this -> incluiRefrigerante;
}
function getServidoNaEntrada() {
return $this -> servidoNaEntrada;
}
function setIncluiRefrigerante($valor) {
$this -> incluiRefrigerante = $valor;
}
function setServidoNaEntrada($valor) {
$this -> servidoNaEntrada = $valor;
}
function exibirPratoPrincipal() {
echo "<center>";
echo "<b> Prato Principal: " . $this -> nome . "</b><p>";
echo "Serve " . $this -> quantidadePessoasServidas . " pessoa(s)
</br>";
if ($this -> possuiAcompanhamento == 1) {
echo "Possui acompanhamentos: sim </br>";
} else {
echo "Possui acompanhamentos: não </br>";
}
http://tecnopode.blogspot.com/search?q=polimorfismo
Competência 03
79
Quadro 60 - Exemplo da classe Prato Principal utilizando o método da classe pai
Fonte: Os autores
Audiodescrição da figura: 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
exibirPratoPrincipal 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 exibirPratoPrincipal 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
exibirPratoPrincipal 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. Fim da
if ($this -> incluiRefrigerante == 1) {
echo "Inclui refrigerante: sim </br>";
} else {
echo "Inclui refrigerante: não </br>";
}
if ($this -> servidoNaEntrada== 1) {
echo "É servido na entrada: sim </br>";
} else {
echo "É servido na entrada: não </br>";
}
echo "Custa: R$ " . $this -> preco . "</br>";
echo "As formas de pagamento aceitas são: " . parent::formaPagamento()
. "</br>";
echo "</center><p>";
}
}
?>
<?php
include_once('prato_principal.php');
class PratoPromocional extends PratoPrincipal{
public $valorDesconto;
function getValorDesconto() {
return $this -> valorDesconto;
}
function setValorDesconto($valor) {
$this -> valorDesconto = $valor;
}
function exibirPratoPromocional() {
echo "<center>";
echo "<b> Prato Promocional: " . $this -> nome . "</b><p>";
echo "Serve " . $this -> quantidadePessoasServidas . " pessoa(s)
</br>";
Competência 03
80
Audiodescrição.
Quadro 61 - Exemplo da classe Prato Promocional com polimorfismo
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador O
código apresenta a 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
exibirPratoPromocional 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 exibirPratoPromocional 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 exibirPratoPromocional 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. Fim da Audiodescrição.
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
o quadro abaixo.
if ($this -> possuiAcompanhamento == 1){
echo "Possui acompanhamentos: sim </br>";
}else{
echo "Possui acompanhamentos: não </br>";
}
if ($this -> incluiRefrigerante == 1){
echo "Inclui refrigerante: sim </br>";
}else{
echo "Inclui refrigerante: não </br>";
}
if ($this -> servidoNaEntrada == 1){
echo "É servido na entrada: sim </br>";
}else{
echo "É servido na entrada: não </br>";
}
echo "Custa: R$ " . $this -> preco . "</br>";
echo "Valor do desconto: R$ " . $this -> valorDesconto . "</br>";
echo "A única forma de pagamento aceitas é: " . $this ->
formaPagamento() . "</br> </br>";
echo "</center><p>";
}
function formaPagamento(){
return "dinheiro";
}
}
?>
Competência 03
81
Quadro 62 - Exemplo da classe Pedido com o método verificarFormaPagamento recebendo um objeto $prato
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta 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
exibirPedido, 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 exibirPedido, 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
<?php
abstract class Pedido {
protected $nome;
protected $quantidadePessoasServidas;
protected $preco;
function getNome() {
return $this -> nome;
}
function getQuantidadePessoasServidas() {
return $this -> quantidadePessoasServidas;
}
function getPreco() {
return $this -> preco;
}
function setNome($valor) {
$this -> nome = $valor;
}
function setQuantidadePessoasServidas($valor) {
$this -> quantidadePessoasServidas = $valor;
}
function setPreco($valor) {
$this -> preco = $valor;
}
abstract function exibirPedido();
static function verificarFormaPagamento(Prato $prato) {
echo "<center>";
echo "<b> " . $prato ->getNome() . "</b><p>";
echo "A(s) forma(s) de pagamento aceita(s) é(são): " .$prato ->
formaPagamento();
echo "</center><p>";
}
}
?>
Competência 03
82
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. Fim da
Audiodescrição.
Os quadros abaixo apresentam um exemplo de utilização dos objetos $prato, $pratoPrincipal
e $pratoPromocional e a chamada do método estático verificarFormaPagamento da classe Pedido e,
uma saída gerada pelos objetos $prato, $pratoPrincipal e $pratoPromocional das classes Prato,
PratoPrincipal e PratoPromocional com as diferentes formas de pagamento, respectivamente.
Quadro 63 - Exemplo de objeto da classe Prato, Prato Principal e Prato Promocional com polimorfismo
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta a 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 $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 $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. Fim da
Audiodescrição.
<?php
include_once('prato.php');
include_once('prato_promocional.php');
include_once('prato_principal.php');
$prato = new Prato("Prato");
Pedido::verificarFormaPagamento($prato);
$pratoPrincipal = new PratoPrincipal("Prato Principal");
Pedido::verificarFormaPagamento($pratoPrincipal);
$pratoPromocional = new PratoPromocional("Prato Promocional");
Pedido::verificarFormaPagamento($pratoPromocional);
?>
Aproveitem nosso delicioso Prato
A(s) forma(s) de pagamento aceita(s) é (são): cartão de crédito/débito ou dinheiro
Aproveitem nossa deliciosa Prato Principal
A(s) forma(s) de pagamento aceita(s) é (são): cartãode crédito/débito ou dinheiro
Aproveitem nossa deliciosa Prato Promocional
A(s) forma(s) de pagamento aceita(s) é (são): dinheiro
Competência 03
83
Quadro 64 - Exemplo de saída da classe Prato, Prato Principal e Prato Promocional com polimorfismo
Fonte: Os autores
Audiodescrição da figura: 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, 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. Fim da Audiodescrição.
Videoaula!
Os exemplos deste ebook são explicados na videoaula de forma bastante
dinâmica, assista.
Agora que você assistiu a videoaula e estudou esta competência, acesse o
Fórum de Dúvidas: Atividade Prática da Competência 03 e siga as orientações
para a realização da atividade prática.
O Podcast da competência 03 é mais um recurso para facilitar o aprendizado e
a absorção dos conteúdos dessa competência, ouça.
84
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 alguns dos diversos conceitos da programação orientada a objetos, sempre
utilizando o exemplo do RestauranteFomeZero (aplicação fictícia criada pelos autores), agora é
preciso montar o ambiente para configurar a aplicação. Primeiro passo, para que a aplicação possa
ser executada é instalar o XAMPP (X - sistema operacional, Apache, MariaDB, PHP, Perl) que é uma
das ferramentas mais populares para desenvolvimento em PHP pois, é constituída por um conjunto
de módulos na qual é possível a utilização de um servidor web local.
Para obter o XAMPP você deve acessar o site oficial através do endereço eletrônico
https://www.apachefriends.org/pt_br/index.html. Após isso, será carregada a página inicial do site
conforme exibe a figura abaixo.
Figura 8 – Página inicial do site oficial do xampp
Fonte: https://www.apachefriends.org/pt_br/index.html
Audiodescrição da figura: Tela colorida, centralizada, da página inicial do site oficial do xampp com muitas cores, links,
menu textual, campo de busca e botões. Fim da Audiodescrição.
https://www.apachefriends.org/pt_br/index.html
85
Pelo fato do sistema operacional Windows ser amplamente utilizado no ambiente acadêmico
e corporativo então, este ebook continuará a explicação de como implementar uma aplicação
utilizando técnicas de orientação a objetos com o Windows. Contudo, você estudante deverá
selecionar o XAMPP de acordo com o sistema operacional que você já possui instalado no seu
computador.
Importante destacar que para instalar o XAMPP no sistema operacional Windows o requisito
mínimo é possuir Windows 2008 ou Windows 2012 ou Windows Vista ou Windows 7 ou Windows 8.
Computadores que possuem Windows XP ou Windows 2003 não suportam o XAMPP.
Após a instalação, você deverá executar o XAMPP. A figura abaixo mostra a tela inicial do
XAMPP com os módulos do Apache, MySQL e Tomcat em operação.
Figura 9 – Tela inicial do xampp
Fonte: Os autores
Audiodescrição da figura: 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. Fim da Audiodescrição.
86
A figura abaixo apresenta o diretório padrão do XAMPP onde a aplicação
RestauranteFomeZero deve ser inserida.
Figura 10 – Local da aplicação RestauranteFomeZero
Fonte: Os autores
Audiodescrição da figura: 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. Fim da Audiodescrição.
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 abaixo
apresentam a tela inicial do phpMyAdmin e a tela ao clicar na aba do SQL antes da execução do script,
respectivamente.
http://localhost/phpmyadmin
87
Figura 11 – Tela inicial do phpMyAdmin
Fonte: http://localhost/phpmyadmin
Audiodescrição da figura: 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. Fim da Audiodescrição.
Figura 12 – Tela do banco de dados antes da execução do script
Fonte: Os autores
Audiodescrição da figura: 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. Fim da Audiodescrição.
88
O quadro abaixo apresenta o script do banco de dados da aplicação RestauranteFomeZero.
Você deverá inserir essas informações no espaço em branco da figura anterior 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 próxima figura abaixo.
Quadro 65 – Script do banco de dados
Fonte: Os autores
Audiodescrição da figura: 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. Fim da
Audiodescrição.
CREATE DATABASE restaurantefomezero;
DROP TABLE IF EXISTS prato;
CREATE TABLE prato (
codigo int(11) NOT NULL AUTO_INCREMENT,
nome varchar(45) NOT NULL,
quantidadePessoasServidas int(2) NOT NULL,
preco varchar(45) NOT NULL,PRIMARY KEY (codigo)
);
INSERT INTO prato (codigo, nome, quantidadePessoasServidas, preco) VALUES
(NULL, 'Galinha à Cabidela', '2', '52,35');
INSERT INTO prato (codigo, nome, quantidadePessoasServidas, preco) VALUES
(NULL, 'Cozido', '2', '44,27');
INSERT INTO prato (codigo, nome, quantidadePessoasServidas, preco) VALUES
(NULL, 'Feijoada', '4', '69,99');
INSERT INTO prato (codigo, nome, quantidadePessoasServidas, preco) VALUES
(NULL, 'Carne de Sol', '3', '24,99');
89
Figura 13 – Tela do banco de dados após execução do script
Fonte: Os autores
Audiodescrição da figura: 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 inserções realizadas na tabela prato com as diferentes informações. Esse resultado está destacado por um
retângulo em vermelho. Fim da Audiodescrição.
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 abaixo apresenta a tela inicial da
aplicação.
http://localhost/RestauranteFomeZero/index.php
90
Figura 14 – Tela inicial da aplicação
Fonte: Os autores
Audiodescrição da figura: 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. Fim da
Audiodescrição.
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 utilize a classe Prato do 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. O quadro abaixo apresenta um exemplo da classe Prato.
<?php
class Prato {
private $codigo;
private $nome;
private $quantidadePessoasServidas;
private $preco;
public function __construct( $codigo, $nome, $quantidadePessoasServidas,
$preco){
$this->codigo = $codigo;
$this -> nome = $nome;
91
Quadro 66 – Exemplo da classe Prato
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta uma classe chamada Prato, com quatro atributos privados, 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 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. Fim da Audiodescrição.
A classe Conexao é onde todos os comandos relacionados ao banco de dados são processados.
$this -> quantidadePessoasServidas = $quantidadePessoasServidas;
$this -> preco = $preco;
}
public function getCodigo(){
return $this->codigo;
}
public function getNome() {
return $this -> nome;
}
public function getQuantidadePessoasServidas() {
return $this -> quantidadePessoasServidas;
}
public function getPreco() {
return $this -> preco;
}
public function setCodigo($valor){
$this->codigo = $valor;
}
public function setNome($valor) {
$this -> nome = $valor;
}
public function setQuantidadePessoasServidas($valor) {
$this -> quantidadePessoasServidas = $valor;
}
public function setPreco($valor) {
$this -> preco = $valor;
}
}
?>
92
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). O quadro abaixo mostra a um exemplo da classe Conexao.
Quadro 67 – Exemplo da classe Conexao
Fonte: Os autores
<?php
class Conexao{
private $host;
private $usuario;
private $senha;
private $banco;
private $conexao;
public function __construct($host, $usuario, $senha,$banco){
$this->host = $host;
$this->usuario = $usuario;
$this->senha = $senha;
$this->banco = $banco;
}
public function conectar(){
$this->conexao = mysqli_connect(
$this->host,
$this->usuario,
$this->senha,
$this->banco);
if (mysqli_connect_errno()) {
return false;
}
else
{
mysqli_query($this->conexao, "SET NAMES 'utf8';");
return true;
}
}
public function executarQuery($sql){
return mysqli_query($this->conexao, $sql);
}
public function obtemPrimeiroRegistroQuery($query){
$linhas = $this ->executarQuery($query);
return mysqli_fetch_array($linhas);
}
}
?>
93
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta a 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. Posteriormente, o código
apresenta 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. Fim da Audiodescrição.
A classe RepositorioPratos é utilizada para acessar e manipular às informações do banco de
dados. Esta será utilizadacomo intermediária entre a aplicação e o banco de dados, devido a isso ela
faz uso de um objeto da classe Conexao.
O único atributo 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.
Os quadros abaixo apresentam um exemplo da interface IRepositorioPrato e um exemplo da
classe RepositorioPratos implementando a interface IRepositorioPrato, respectivamente.
94
Quadro 68 – Exemplo da interface IRepositorioPrato
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta a 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. Fim da
<?php
interface IRepositorioPrato{
public function cadastrarPrato($prato);
public function removerPrato($codigo);
public function alterarPrato($prato);
public function consultarPrato($codigo);
public function getListarPrato();
}
?>
<?php
include_once('conexao.php');
include_once('prato.php');
include_once('irepositorio_prato.php');
class RepositorioPratos implements IRepositorioPrato {
private $conexao;
public function __construct(){
$this->conexao = new Conexao("127.0.0.1", "root", "",
"restaurantefomezero");
if ($this->conexao->conectar() == false) {
echo "Erro".mysqli_error();
}
}
public function cadastrarPrato($prato){
$nome = $prato->getNome();
$quantidadePessoasServidas = $prato->getQuantidadePessoasServidas();
$preco = $prato->getPreco();
$sql = "INSERT INTO prato (codigo, nome, quantidadePessoasServidas,
preco) VALUES (NULL, '$nome', '$quantidadePessoasServidas', '$preco')";
$this->conexao->executarQuery($sql);
}
public function removerPrato($codigo){
$sql = "DELETE FROM prato WHERE codigo = '$codigo'";
$this->conexao->executarQuery($sql);
}
95
Audiodescrição.
Quadro 69 – Exemplo da classe RepositorioPratos implementando a interface IRepositorioPrato
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta a 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
public function alterarPrato($prato){
$codigo = $prato->getCodigo();
$nome = $prato->getNome();
$quantidadePessoasServidas = $prato->getQuantidadePessoasServidas();
$preco = $prato->getPreco();
$sql = "UPDATE prato SET nome='$nome',
quantidadePessoasServidas='$quantidadePessoasServidas',
preco='$preco'WHERE codigo='$codigo'";
$this->conexao->executarQuery($sql);
}
public function consultarPrato($codigo){
$linha = $this->conexao->obtemPrimeiroRegistroQuery("SELECT * FROM
prato WHERE codigo='$codigo'");
$prato = new Prato($linha['codigo'], $linha['nome'],
$linha['quantidadePessoasServidas'], $linha['preco']);
return $prato;
}
public function getListarPrato(){
$listagem = $this->conexao->executarQuery("SELECT * FROM prato");
$arrayPratos = array();
while($linha = mysqli_fetch_array($listagem)){
$prato = new Prato($linha['codigo'], $linha['nome'],
$linha['quantidadePessoasServidas'], $linha['preco']);
array_push($arrayPratos, $prato);
}
return $arrayPratos;
}
}
$repositorio = new RepositorioPratos();
?>
96
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
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. Posteriormente, o código apresenta a 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 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ódigoigual 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 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. Fim da
Audiodescrição.
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 (HyperText Markup Language)
para utilizá-las no construtor do objeto $pratoRecebido. As informações contidas no formulário
correspondem aos atributos da classe Prato apresentada nesta competência. Após a contrução do
objeto $pratoRecebido, este será passado como parâmetro para os métodos cadastrarPrato e
alterarPrato.
Os quadros abaixo 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.
97
Quadro 70 –Chamada do método cadastrarPrato
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta a 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. Fim da Audiodescrição.
Quadro 71 –Chamada do método alterarPrato
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta a 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. Fim da Audiodescrição.
Quadro 72 – Chamada do método removerPrato
<?php
include_once('repositorio_pratos.php');
$pratoRecebido = new Prato(null, $_REQUEST['nome'],
$_REQUEST['quantidadePessoasServidas'], $_REQUEST['preco']);
$repositorio->cadastrarPrato($pratoRecebido);
header('Location: index.php');
exit;
?>
<?php
include_once('repositorio_pratos.php');
$pratoRecebido = new Prato($_REQUEST['codigo'], $_REQUEST['nome'],
$_REQUEST['quantidadePessoasServidas'], $_REQUEST['preco']);
$repositorio->alterarPrato($pratoRecebido);
header('Location: index.php');
exit;
?>
<?php
include_once('repositorio_pratos.php');
$repositorio->removerPrato($_REQUEST['codigo']);
header('Location: index.php');
exit;
?>
98
Fonte: Os autores
Audiodescrição da figura: Código-fonte escrito na linguagem PHP para construção de programa de computador. O
código apresenta a 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. Fim da
Audiodescrição.
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. Os quadros abaixo apresentam os detalhes da implementação do formulário.
99
<?php
include_once('repositorio_pratos.php');
$pratos = $repositorio->getListarPrato();
$destino = "incluir_prato.php";
if(isset($_GET['codigo'])){
$codigo = $_GET['codigo'];
$prato = $repositorio->consultarPrato($codigo);
$destino = "alterar_prato.php";
$oculto = '<input type="hidden" name="codigo" value="'. $codigo .'"
/>';
}
?>
<!DOCTYPE html>
<html lang="en">
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<meta charset="utf-8">
<title>Restaurante Fome Zero</title>
<meta name="viewport" content="width=device-width, initial-scale=1,
maximum-scale=1">
<link href="css/bootstrap.min.css" rel="stylesheet">
<link href="css/styles.css" rel="stylesheet">
</head>
<body>
<div class="wrapper">
<div class="box">
<div class="row">
<div class="column col-sm-3" id="sidebar">
<a class="logo" href="#"><span>Restaurante Fome
Zero</span></a>
<ul class="nav">
<li class="active">
<a href="index.php">Prato Principal</a>
</li>
<li>
<a href="index.php">Prato Promocional</a>
</li>
100
HTML. por meio da página index.php da aplicação. por meio da página index.php da aplicação. <li>
<a href="index.php">Sobremesa</a>
</li>
</ul>
</div>
<div class="column col-sm-9" id="main">
<div class="padding">
<div class="full col-sm-9">
<div class="col-sm-12" id="featured">
<div class="page-header text-muted">Restaurante Fome
Zero</div>
<form class="form-horizontal" action="<?=$destino;
?>" method="post">
<?= @$oculto; ?>
<fieldset>
<legend>Cadastrar/Alterar Prato</legend>
<div class="control-group">
<label class="control-label"for="prato">Nome</label>
<div class="controls">
<input id="nome" name="nome" type="text"
value="<?php echo isset($prato)?$prato-
>getNome():""; ?>" placeholder="" class="input-xxlarge" />
</div>
</div>
<div class="control-group">
<label class="control-label"
for="sinopse">Quantidade de Pessoas Servidas</label>
<div class="controls" >
<input id="quantidadePessoasServidas"
name="quantidadePessoasServidas" type="text"
value="<?php echo isset($prato)?$prato-
>getQuantidadePessoasServidas():""; ?>" placeholder="" class="input-xxlarge">
</div>
</div>
<div class="control-group">
<label class="control-label"
for="quantidade">Preço (R$)</label>
<div class="controls">
<input id="preco" name="preco" type="text"
value="<?php echo isset($prato)?$prato-
>getPreco():""; ?>" placeholder="" class="input-xxlarge">
</div>
</div>
<div class="control-group">
<label class="control-label" for=""></label>
<div class="controls">
101
Quadro 73 – Formulário HTML página index.php da aplicação
Fonte: Os autores
Audiodescrição da figura: 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
<input type="submit" class="btn btn-danger" value="Salvar" />
</div>
</div>
</fieldset>
</form>
</div>
<div class="col-sm-12" id="stories">
<div class="page-header text-muted divider">
Pratos Cadastrados
</div>
</div>
<table class="table table-hover">
<?php
while($pratoTemporario =
array_shift($pratos)){
?>
<tr>
<td class="col-md-6"> <?php echo $pratoTemporario-
>getNome() ?> </td>
<td class="col-md-1"><a class="btn btn-danger"
href="index.php?codigo=<?= $pratoTemporario->getCodigo(); ?>"
role="button">Alterar</a></td>
<td class="col-md-1"><a class="btn btn-danger"
href="remover_prato.php?codigo=<?= $pratoTemporario->getCodigo(); ?>"
role="button">Remover</a></td>
</tr>
<?php
}
?>
</table>
</div>
</div>
</div>
</div>
</div>
</div>
<script
src="//ajax.googleapis.com/ajax/libs/jquery/2.0.2/jquery.min.js"></script>
<script src="js/bootstrap.min.js"></script>
</body>
</html>
102
$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. Em seguida, o código apresenta a 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ário 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.
Posteriormente, o código apresenta a terceira parte da aplicação RestauranteFomeZero. É exibido o código de uma
listagem em html, com estilo css e alguns comandos php. 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. Fim da Audiodescrição.
Videoaula!
A videoaula dessa competência mostra a aplicação sendo executada e se
conectando a um banco de dados, assista.
Agora que você assistiu a videoaula e estudou esta competência, acesse o
Fórum de Dúvidas: Atividade Prática da Competência 04 e siga as orientações
para a realização da atividade prática.
O Podcast da competência 04 é mais um recurso para facilitar o aprendizado ea absorção dos conteúdos dessa competência, ouça.
103
Conclusão
Estudante,
Você chegou 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ê acha que é apenas isso? Não. Ainda existem muitos outros conteúdos para serem
aprendidos! 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ó precisa 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 você
tenha aproveitado ao máximo o material, a disciplina e queria aprender e se aprofundar mais, para
que possa se tornar um profissionail qualificado e bem-sucedido.
Bons Estudos e Sucesso!
104
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.
Ian, Sommerville. "Engenharia de software." 6a. edição, Addison-Wesley/Pearson (2003).
Krishnamurthi, Shriram, and Kathi Fisler. "Programming paradigms and beyond." The Cambridge
Handbook of Computing Education Research 37 (2019).
Cappellini, Chiara, and Christina Clark. "Small Talk: Baseline Findings 2019. A National Literacy Trust
Research Report." National Literacy Trust (2020).
105
Minicurrículo do Professor
Cinthya Cavalcanti Flório
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.
106
Leonardo Guimarães de Holanda
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).
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.
Introdução
1.Competência 01 | Conhecer os princípios e a importância da orientação a objeto
1.1 Programação no ciclo de vida do software
1.2 Paradigmas de Programação
1.3 Surgimento e Importância da Programação Orientada a Objetos
1.4 Programação Orientada a Objetos x Programação Estruturada
1.5 Principais conceitos da Programação Orientada a Objetos
2.Competência 02 | Conhecer os conceitos de classe, herança, objeto, atributo e método
2.1 Classe
2.2 Objeto
2.3 Atributo
2.4 Método
2.4.1 Métodos get e set
2.5 Atributos e Métodos Estáticos
2.6 Construtor
2.7 Herança
3.Competência 03 | Conhecer os conceitos de associação, encapsulamento, abstração, polimorfismo e interface
3.1 Abstração
3.1.1 Classe Abstrata
3.1.2 Erro ao instanciar uma classe abstrata
3.2 Encapsulamento
3.2.1 Erro ao acessar atributo protected ou private
3.3 Classe Final
3.3.1 Erro ao herdar de uma classe final
3.4 Método Final
3.5 Associação
3.6 Interface
3.7 Operadores this e parent
3.8 Polimorfismo
4.Competência 04 | Implementar uma aplicação utilizando técnicas de orientação a objetos
4.1 Configuração da Aplicação
4.2 Classes da Aplicação
4.3 Cadastrar, Alterar e Remover
4.4 Buscar
Conclusão
Referências
Minicurrículo do ProfessorMais conteúdos dessa disciplina
Increased-NKG2A-CD8--T-cell-exhaustion-in-patients-with-_2023_Mucosal-Immuno- 05 - Construtores
- Você está atuando como programador iniciante em uma empresa de software que desenvolve sistemas de controle financeiro -stamped
- Você foi contratado por uma startup de tecnologia para desenvolver um aplicativo leve de monitoramento cardíaco voltado-stamped
- a Explique por que a declaração e a inicialização correta de variáveis são tão importantes em linguagens como Java -stamped
- Após uma revisão, identificou-se que o programador também tentou declarar variáveis com nomes iniciando por números-stamped
- ATIVIDADE 1 - ESOFT - PROGRAMAÇÃO ORIENTADA A OBJETOS - 54_2025
- ATIVIDADE 1 - ESOFT - PROGRAMAÇÃO ORIENTADA A OBJETOS - 54_2025
- Como usar o Lombok no Java - Reduza código com simples anotações - Resumo
- USA 10 Site To Buy Telegram Accounts -From 1
- Buy Telegram Accounts -From 1
- 3) Uma característica importante para o projeto é o conhecimento da orientação espacial, pois é dependente desta análise o mapa de sol e sombra ide...
- om respeito aos pré-requisitos para o desenvolvimento de aplicativos para o sistema operacional Android, podemos afirmar: Escolha uma opção: a. É ...
- m texto é um objeto da classe _____, que é um tipo de ________. Os objetos da classe str, possuem certas operações, como por exemplo, in, _____, dentr
- Questão 18 Assinale a alternativa correta em relação a seguinte afirmação: m representa 0 elo entre todas as expectativas geradas pelos demais depa...
- onCreate(Bundle) onStart() onRestart() onResume() onPause() onStop() onDestroy() Relacione cada item acima com sua respectiva definição: ...
- Sobre classe e orientação a objeto em Kotlin avalie as assertivas abaixo: I. O construtor primário em Kotlin não pode ter nenhum código, portanto ...
- As características do modelo agrícola brasileiro fazem dessa atividade uma das que provocam danos significativos sobre a base dos recursos naturais...
- # Questão 1/10 - Programação Visual Um projeto em linguagem Java engloba alguns tipos de arquivos distintos. A evento B bytecode C código fonte D p...
- Quando falamos de metrologia industrial sempre pensamos em inovação e competitividade. Leia as frases a seguir e indique a afirmação incorreta sobre e
- O failover automático é uma técnica que permite a continuidade dos serviços mesmo após falhas em componentes críticos. Segundo Atchison (2020), ess...
- planejamento, o dimensionamento e o controle dos estoques são funções indispensáveis para uma boa gestão das operações produtivas, em qualquer orga...
- em equinos com radiografias que mostram rotação da terceira falange (P3) e erosões subcondrais no osso navicular é correto afirmar que: a) A síndrome
- em equinos com radiografias que mostram rotação da terceira falange (P3) e erosões subcondrais no osso navicular é correto afirmar que: a) Crioterapia
- Onde podemos armazenar os documentos eletrônicos da companhia?
- As raízes da equação ????2 − 9???? + ???? = 0 são números inteiros. O maior valor que ???? pode assumir é
A) 14.
B) 18.
C) 20.
D) 24.
