Coleção UAB−UFSCar

Sistemas de Informação

Ednaldo Brigante Pizzolato

Introdução à programação
orientada a objetos
com C++ e Java
Introdução à programação
orientada a objetos com
C++ e Java
Reitor
Targino de Araújo Filho
Vice-Reitor
Pedro Manoel Galetti Junior
Pró-Reitora de Graduação
Emília Freitas de Lima
Secretária de Educação a Distância - SEaD
Aline Maria de Medeiros Rodrigues Reali

Coordenação UAB-UFSCar Conselho Editorial

Daniel Mill José Eduardo dos Santos
Denise Abreu-e-Lima José Renato Coury
Joice Lee Otsuka Nivaldo Nale
Valéria Sperduti Lima Paulo Reali Nunes
Oswaldo Mário Serra Truzzi (Presidente)

Secretária Executiva
Adriana Silva
Coordenadora do Curso de Sistemas de Informação
Sandra Abib

UAB-UFSCar EdUFSCar
Universidade Federal de São Carlos Universidade Federal de São Carlos
Rodovia Washington Luís, km 235 Rodovia Washington Luís, km 235
13565-905 - São Carlos, SP, Brasil 13565-905 - São Carlos, SP, Brasil
Telefax (16) 3351-8420 Telefax (16) 3351-8137
www.uab.ufscar.br www.editora.ufscar.br
uab@ufscar.br edufscar@ufscar.br
Ednaldo Brigante Pizzolato

Introdução à programação
orientada a objetos com
C++ e Java

2011
© 2010, Ednaldo Brigante Pizzolato

Concepção Pedagógica
Daniel Mill

Supervisão
Douglas Henrique Perez Pino

Equipe de Revisão Linguística

Ana Luiza Menezes Baldin
André Stahlhauer
Andréia Pires de Carvalho
Ângela Cristina de Oliveira
Jorge Ialanji Filholini
Mariucha Magrini Neri
Paula Sayuri Yanagiwara
Priscilla Del Fiori
Sara Naime Vidal Vital

Equipe de Editoração Eletrônica

Izis Cavalcanti
Juliana Greice Carlino
Rodrigo Rosalis da Silva

Equipe de Ilustração
Jorge Luís Alves de Oliveira
Thaisa Assami Guimarães Makino

Capa e Projeto Gráfico

Luís Gustavo Sousa Sguissardi

Ficha catalográfica elaborada pelo DePT da Biblioteca Comunitária da UFSCar

Pizzolato, Ednaldo Brigante.

P695i Introdução à programação orientada a objetos com
C++ e Java / Ednaldo Brigante Pizzolato. -- São Carlos :
EdUFSCar, 2010.
155 p. -- (Coleção UAB-UFSCar).

ISBN – 978-85-7600-204-8

1. Programação orientada a objetos (Computação). 2.

C++ (Linguagem de programação de computador). 3. Java
(Linguagem de programação de computador). 4. Classes e
objetos. I. Título.

CDD – 005.11 (20a)

CDU – 681.32.06

Todos os direitos reservados. Nenhuma parte desta obra pode ser reproduzida ou transmitida por qualquer
forma e/ou quaisquer meios (eletrônicos ou mecânicos, incluindo fotocópia e gravação) ou arquivada em qual-
quer sistema de banco de dados sem permissão escrita do titular do direito autoral.
........... Sumário
Apresentação. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

Unidade 1: Introdução

1.1 Primeiras palavras. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

1.2 Problematizando o tema. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

1.3 Linguagens imperativas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

1.3.1 Encapsulamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.3.2 Visibilidade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.3.3 Encapsulamento e visibilidade. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

1.4 Considerações finais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

1.5 Estudos complementares. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

Unidade 2: Introdução às linguagens de programação C++ e Java

2.1 Primeiras palavras. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

2.2 Problematizando o tema. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

2.3 A História das linguagens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

2.4 C++ e Java – estrutura básica de um programa. . . . . . . . . . . . . . 24

2.5 Considerações finais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

2.6 Estudos complementares. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

Unidade 3: Introdução à orientação a objetos

3.1 Primeiras palavras. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

3.2 Problematizando o tema. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

3.3 O paradigma OO. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

3.4 Classes e objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

3.5 Elementos de uma classe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

3.6 Diagrama de classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

3.7 Relacionamento entre classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .43

3.8 Exemplos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

3.9 Considerações finais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

Unidade 4: Introdução à sobrecarga

4.1 Primeiras palavras. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

4.2 Problematizando o tema. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

4.3 Sobrecarga de métodos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

4.4 Sobrecarga de operadores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

4.5 Exemplos em Java. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

4.6 Considerações finais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

4.7 Estudos complementares. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

Unidade 5: Alocação dinâmica de memória

5.1 Primeiras palavras. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

5.2 Problematizando o tema. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

5.3 Revisão. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

5.4 Alocação de atributos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

5.5 Construtor de cópia. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

5.6 Alocação de objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

5.7 Exemplo em C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

5.8 Considerações finais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

Unidade 6: Composição e herança

6.1 Primeiras palavras. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91

6.2 Problematizando o tema. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91

6.3 Composição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91

6.4 Herança . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

6.5 Exemplo em Java. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

6.6 Exemplo em C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

6.7 Considerações finais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102

Unidade 7: Polimorfismo

7.1 Primeiras palavras. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

7.2 Problematizando o tema. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

7.3 Polimorfismo paramétrico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

7.3.1 Templates em C++. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

7.3.2 Generics em Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109

7.4 Polimorfismo de inclusão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

7.4.1 Polimorfismo de inclusão em C++ . . . . . . . . . . . . . . . . . . . . . . . . 110

7.4.2 Polimorfismo de inclusão em Java. . . . . . . . . . . . . . . . . . . . . . . . 114

7.5 Considerações finais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116

Unidade 8: Classes abstratas

8.1 Primeiras palavras. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119

8.2 Problematizando o tema. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119

8.3 Definição de classes abstratas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119

8.4 Classes abstratas em Java e em C++ . . . . . . . . . . . . . . . . . . . . . . 120

8.4.1 Exemplos em Java. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

8.4.2 Exemplos em C++. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

8.5 Considerações finais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

Apêndice A. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123

Apêndice B. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

Referências. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
Apresentação

Este livro é para quem já sabe algoritmos e já construiu programas em

linguagens como C ou Pascal. O leitor deve, portanto, ter familiaridade com os
conceitos básicos de programação, tais como o conceito de variáveis, escopo,
entrada e saída de dados, estruturas de seleção, estruturas de repetição, sub-
programas (funções e procedimentos), passagem de valores por valor ou por
referência, entre outros. Apesar de este livro abordar tais conceitos, não tem
como objetivo principal a explicação dos mesmos.

O leitor já deve saber, também, que existem várias linguagens de progra-

mação (C++, C#, Java, Pascal, Delphi, Fortran, Algol, PL/I, Cobol, Lisp, Prolog
– só para citar algumas), mas talvez não saiba a razão da existência de tantas
linguagens. Algumas foram concebidas por questões de aplicação (para serem
científicas ou mais voltadas a transações comerciais ), enquanto outras foram
criadas em decorrência do próprio avanço tecnológico. Todas as linguagens têm
em comum o fato de terem uma sintaxe e uma semântica bem definida. Podem
ser interpretadas ou compiladas e, normalmente, estão relacionadas a um de-
terminado paradigma de programação. Alguns dos paradigmas de programação
existentes são:

• Programação Imperativa (ou Procedural);

• Programação Orientada a Objetos;

• Programação Concorrente;

• Programação Lógica;

• Programação Funcional.

Espera-se que o leitor já tenha tido contato com alguma linguagem repre-
sentante do paradigma imperativo ou procedural (por incluir procedimentos e
funções) e tenha tido oportunidade de implementar programas usando tal lin-
guagem. Exemplos de linguagens do paradigma imperativo ou procedural são
C, Pascal, Fortran e PL/I. Também se espera que o leitor saiba o que seja pro-
gramação estruturada.

O conhecimento prévio do que são algoritmos e como elaborá-los, bem

como o conhecimento prévio de uma linguagem de programação e dos concei-
tos de programação estruturada contribuirá para o entendimento dos conceitos
de orientação a objetos e das linguagens C++ e Java aqui abordadas.

A opção por duas linguagens permitirá que o leitor teste os conceitos de

orientação a objetos em ambientes diferentes e verifique que alguns conceitos
estão presentes em uma linguagem e não em outra. 11
 Os principais objetivos deste livro são:

• Apresentar ao(à) leitor(a) o paradigma de orientação a objetos e seus

principais conceitos;

• Fornecer conhecimentos sobre as linguagens de programação C++ e

Java;

• Mostrar como os conceitos de programação orientada a objetos podem

ser implementados em ambas as linguagens (quando possível);

• Permitir que o(a) leitor(a) crie aplicativos em Java utilizando os conceitos

de orientação a objetos com interface gráfica.

Pedirei permissão ao(a) leitor(a) para tratá-lo(a) por você daqui em diante.

12
Unidade 1

Introdução
1.1 Primeiras palavras

Para entender o paradigma de orientação a objetos e sua importância é

preciso entender qual foi o primeiro paradigma de programação, suas linguagens
representativas, seus problemas e como ocorreu a transição (evolução) para o
paradigma de orientação a objetos.

Esta unidade objetiva apresentar uma visão geral sobre o paradigma impe-
rativo e o orientado a objetos. Mais detalhes podem ser obtidos em livros sobre
paradigmas e linguagens de programação.

1.2 Problematizando o tema

Por que não utilizamos nossa linguagem para transmitir para a máquina
(computador ou robô) nossas ideias ou intenções? Na verdade, é preciso enten-
der que o computador atual trabalha com a linguagem binária (zeros e uns) e que
tudo o que queremos que ele faça deve ser especificado em forma de algoritmo e,
posteriormente, traduzido para a linguagem da máquina. Um algoritmo especifica
quais ações devem ser feitas/tomadas e em qual ordem. As linguagens de pro-
gramação devem representar de forma clara e objetiva o que está especificado
no algoritmo. Queremos que as intenções ou ideias sejam transmitidas de forma
a não causar dúvidas ao computador ou robô. Não podemos conceber que um
computador pare de executar uma ação e tente adivinhar o que o programador
gostaria, na realidade, que fosse feito. Por exemplo: “robô, por favor, tome seu
lubrificante agora” e “robô, por favor, tome o ônibus das 3 para ir ao centro da
cidade” são frases que utilizam o mesmo verbo (tomar) para situações completa-
mente diferentes. O robô deve entender que a primeira ação significa engolir e a
segunda ação significa utilizar o meio de transporte coletivo para se deslocar até
o centro da cidade.

Também temos uma ideia natural de que as ações devem respeitar uma de-
terminada ordem. Por exemplo, para a troca de um pneu furado é necessário des-
parafusar o pneu e também é necessário erguer o carro para que outro pneu seja
colocado. Entretanto, se dispusermos apenas de equipamento mecânico (chave
de roda) para desparafusar a roda, não é aconselhável que o carro seja erguido
antes que as porcas sejam afrouxadas. O contato do pneu com o solo impede
que a roda gire e facilita o processo. Também não devemos retirar as porcas inteira-
mente com o carro no solo, sob o risco de que ele tombe e cause algum acidente.
Se houver passageiros, também é importante que eles saiam do carro antes de
ele ser erguido. Não se pode ordenar que os passageiros saiam se eles não
existirem. É preciso que existam comandos que possibilitem a mudança de fluxo
15
 (execução de um conjunto de ações se uma determinada condição for satisfeita).
Dessa forma, sequência de comandos, estruturas de seleção e de repetição fazem
parte das chamadas linguagens imperativas.

1.3 Linguagens imperativas

Inicialmente, uma linguagem imperativa era composta de comandos sim-

ples, tais como atribuição, comandos condicionais e comandos de desvio de fluxo.
Com a combinação desses comandos (o que ocorria, por exemplo, em Fortran-IV)
era possível implementar qualquer algoritmo, pois a mudança de valor de uma va-
riável era obtida por meio do comando de atribuição, um conjunto de comandos
poderia ser executado a partir da avaliação de uma expressão condicional e a
repetição de um conjunto de comandos poderia ser conseguida por intermédio
da combinação de comandos de desvio de fluxo com comandos condicionais. O
uso combinado de tais comandos possibilita representar qualquer algoritmo que
se deseje elaborar. Isso também é conhecido como “Touring Complete”. De acor-
do com Tucker & Noonan (2007), uma linguagem imperativa é uma linguagem
“Touring Complete” e também apresenta as seguintes características:

• Estruturas de controle (seleção e repetição);

• Entrada e saída de dados;

• Tratamento de erro e de exceções;

• Abstração procedural;

• Expressões e comandos de atribuição;

• Bibliotecas de apoio.

Deve-se notar que os paradigmas de programação orientada a objetos, pro-

gramação funcional e programação lógica também contemplam o conceito de
“Touring Complete”.

Dentro do contexto do paradigma de linguagens imperativas está a pro-

gramação estruturada. Nela, evita-se que o fluxo de execução seja desviado de
forma desorganizada. Isso porque o comando de desvio de fluxo de execução
normalmente empregado era o goto (vá para). Com a introdução da programa-
ção estruturada, procurou-se organizar o código e deixá-lo mais legível. Entraram
em cena os comandos de repetição que estabeleciam regras para o desvio de
fluxo de execução sem deixar de satisfazer o “Touring Complete”.

16
Figura 1 Representação de código de repetição estruturado e não estruturado.

Do ponto de vista visual, uma repetição, ou loop, poderia ser representada

por um colchete que indica na extremidade superior o início da repetição e na
extremidade inferior o final desta. A Figura 1 apresenta a visão estruturada à es-
querda e a visão não estruturada à direita. São apenas 2 repetições, mas já é pos-
sível se ter uma ideia do que pode acontecer com um código não estruturado.

Apesar da organização do código, ainda havia um problema central com as

linguagens imperativas: o foco nas funções e não nos dados. Isso talvez explicasse
os longos prazos de desenvolvimento de sistemas, os elevados orçamentos, a
insatisfação dos clientes, etc. Do ponto de vista técnico, o levantamento de requi-
sitos e o projeto de software tinham especificações e representações muito dife-
rentes das utilizadas pelos programadores. Os dados, por outro lado, não eram
protegidos (o foco era nas funções), o que dificultava a garantia da integridade
das informações. Também era difícil reaproveitar o código, fazendo com que uma
mesma ideia fosse implementada novamente ou seu código fosse duplicado e
adaptado. Porém, mudanças em uma parte do código poderiam gerar altos cus-
tos de manutenção para garantir que não havia inconsistências. Era necessária,
ainda, a reformulação da documentação (quando existente). Os profissionais pas-
saram a concentrar os esforços na solução do problema (modificação do código)
e não na documentação. A falta de documentação contribuía para a geração de
sistemas ineficientes, com custos ainda mais elevados de manutenção. Era pre-
ciso um novo conceito, um novo paradigma para superar os desafios da área. É
nesse contexto que surgiu o paradigma de orientação a objetos. Mas ele não sur-
giu de repente. Foi um processo gradual, que se iniciou em 1967 com a linguagem
Simula-67. Nela havia um esforço em transferir também para os dados a ideia de
abstração de procedimentos. A ideia de abstração de dados procura permitir que
o programador crie novos tipos de dados que sejam mais adequados ao proble-
ma que está tentando resolver. Envolve, também, os conceitos de encapsulamento
e visibilidade.

1.3.1 Encapsulamento

Não é preciso recorrer a um dicionário para inferir sobre as ideias envolvidas

em encapsulamento. Encapsulamento vem de encapsular, que significa colocar 17
 em cápsulas. Cápsulas podem nos remeter à ideia de remédios ou de foguetes
tripulados. Uma cápsula de remédio é um envoltório que protege seus compo-
nentes contra a incidência de luz, umidade e contato com impurezas que possam
comprometer seu desempenho. Também são projetadas para, em contato com
nosso estômago, liberar gradativamente o remédio.

Cápsulas de foguete são desenhadas para proteger a vida dos integrantes

da missão tripulada. Permitem que eles recebam fluxo contínuo de oxigênio e que
sejam protegidos contra o frio e o calor intenso, além de outros riscos.

Em ambos os casos, pode-se observar que a palavra cápsula está associada

a proteção.

O conceito pode ser mais abrangente. Em uma busca pela World Wide Web
podemos encontrar a seguinte definição de cápsula fonocaptora:

Trata-se de um transdutor em miniatura que, ao percorrer as ondulações dos

sulcos de vinil, transforma as vibrações mecânicas em impulsos elétricos,
que por sua vez serão amplificados, resultando em som audível.1

Assim, podemos aplicar o conceito de cápsula também para ações. Na ver-

dade, a própria medicina aprimorou o conceito de cápsula criando a “cápsula
endoscópica”. Ela é um dispositivo similar a uma cápsula de remédio, que con-
tém uma microcâmera para capturar imagens do intestino. A microcâmera fica
protegida, pelo envoltório da cápsula, da ação dos ácidos presentes em nosso
organismo. A mesma cápsula protege nosso organismo de eventuais perfurações
que podem ser causadas pela microcâmera.

De uma forma bem simples podemos verificar que uma cápsula tem a função
de reunir um conjunto de elementos em um único dispositivo e também de prote-
ger o material interno de ações indevidas do ambiente externo. A proteção está
associada à visibilidade, abordada a seguir. A Unidade 3 apresentará exemplos de
classes nas quais os conceitos de encapsulamento e visibilidade serão utilizados.

1.3.2 Visibilidade

A visibilidade está relacionada à propriedade de ser visto ou não. Algo é visível

quando está exposto. Aumentar a visibilidade implica em aumentar a exposição.
Diminuir a visibilidade também está relacionado com a diminuição de exposição.

Um objeto pode tanto estar ao alcance da visão (e, portanto, ser visível) como
pode estar escondido. O conceito de visibilidade, em programação orientada a

1 Disponível em: <http://pt.wikipedia.org/wiki/Cápsula_fonocaptora>. Acesso em: 22 fev. 2010.

18
objetos, está mais associado aos componentes que ao próprio objeto. Seria como
termos uma cápsula de remédio dividida em duas partes, sendo uma delas trans-
parente e a outra não. Pela parte transparente conseguimos ver o que há dentro
daquela parte da cápsula, mas não temos ideia do que há dentro da outra parte
(pois está escondida).

1.3.3 Encapsulamento e visibilidade

Quando colocamos todos os componentes eletrônicos de um liquidificador

em um compartimento, estamos escondendo-os do usuário e, ao mesmo tem-
po, encapsulando. O usuário terá acesso às funcionalidades do liquidificador por
meio dos botões de ligar e desligar, bem como dos botões de velocidade.

Outro exemplo seria o aparelho de televisão. Seus componentes eletrônicos

estão encapsulados em um compartimento que é responsável pela sintonia dos
canais e pela apresentação das imagens recebidas. As funcionalidades, apesar
de estarem presentes dentro do compartimento, são acessíveis aos usuários a
partir de botões externos ou do controle remoto. O encapsulamento, em ambos os
exemplos, permite que os componentes eletrônicos fiquem protegidos do acesso
direto do usuário. Não imaginamos alguém sintonizando um canal de televisão
agindo diretamente nos dispositivos eletrônicos, utilizando-se de uma chave de
fenda. Assim, os projetistas dos equipamentos pensaram nas funcionalidades às
quais os usuários teriam acesso e criaram os botões ou controles externos. So-
mente esses botões são visíveis aos usuários.

Outra vantagem do encapsulamento pode ser compreendida por meio dos

mesmos exemplos: a composição. Construímos chips eletrônicos a partir da com-
binação de circuitos em um componente, chamado circuito integrado. Combina-
mos as funcionalidades de vários circuitos integrados em uma placa. Criamos
um dispositivo eletrônico a partir da combinação de várias placas. Se você abrir
seu computador, verá várias placas (placa mãe, placa de vídeo, placa de som,
etc.). Se você abrir seu aparelho de DVD, também verá várias placas, e assim por
diante. Com a composição é possível construir dispositivos de forma mais rápida,
como exige a indústria eletroeletrônica.

1.4 Considerações finais

Nesta unidade apresentamos o paradigma de linguagem de programação im-

perativa, bem como alguns problemas relacionados a ela. Indicamos que havia a
necessidade de um novo paradigma que focasse não somente o código, mas tam-
bém os dados. Introduzimos alguns conceitos importantes, como encapsulamento 19
 e visibilidade, que serão úteis quando da introdução ao paradigma de orientação
a objetos.

Na próxima unidade serão introduzidas as linguagens de programação C++

e Java, em preparação para a apresentação dos conceitos de orientação a objetos.
Orientações sobre ambientes de programação para as duas linguagens podem
ser obtidas no Apêndice A deste livro.

1.5 Estudos complementares

O(a) leitor(a) que desejar obter mais informações sobre paradigmas de pro-
gramação poderá consultar o livro:
TUCKER, A. B.; NOONAN, R. E. Programming Languages: Principles and Paradigms.
New York: McGraw-Hill, 2007.

O paradigma de linguagem de programação imperativa é apresentado no

capítulo 12.

Outra leitura sugerida é a do livro:

MITCHELL, J. C.; APT, K. Concepts in Programming Languages. Cambridge: Cambridge
University Press, 2001.

No capítulo 1 são apresentadas as linguagens de programação, os princi-

pais objetivos e a história das linguagens de programação. Na parte 2 do livro são
apresentados os conceitos da programação imperativa em 4 capítulos.

20
Unidade 2

Introdução às linguagens de programação

C++ e Java
2.1 Primeiras palavras

Nesta unidade você terá contato com os principais comandos das lingua-
gens C++ e Java. A apresentação dos comandos não é detalhada, visto que se
supõe que o leitor já tenha tido contato com a linguagem de programação C.
Os conceitos de orientação a objetos não serão apresentados ainda. O objetivo
principal da unidade é fazer com que o leitor tenha familiaridade com as duas
linguagens, para que possa entender os conceitos de orientação a objetos que
serão apresentados na próxima unidade.

Para melhor compreensão dos programas e conceitos apresentados, é

aconselhável que o leitor implemente os códigos desta unidade. Sugere-se a
consulta ao Apêndice A deste livro, caso tenha dúvidas sobre os ambientes de
programação para ambas as linguagens.

2.2 Problematizando o tema

Existem alguns casos em que o conhecimento apenas da teoria é o suficiente

para exercer a profissão. Em alguns casos o adjetivo teórico vem associado a ela.
Um caso exemplar é o físico teórico. O físico teórico trabalha com as teorias da
física e não tem muito diálogo com os físicos práticos. Entretanto, outras profis-
sões requerem a prática do ofício. É o caso de chef de cozinha, garçom, médico,
odontologista, etc. Um exemplo clássico é o de piloto de aeronaves, em que as
horas de voo contam como experiência e como habilitação para pilotar aviões de
maior porte.

Apesar de ser possível, é pouco provável que uma pessoa que esteja
aprendendo a programar computadores consiga se tornar um(a) exímio(a)
programador(a) apenas com as informações teóricas. Em geral, sugere-se que
o(a) aprendiz(a) coloque os conceitos em prática. Esta unidade apresentará
conceitos seguidos de pequenos exemplos que facilitarão o aprendizado das
linguagens C++ e Java.

Ah, você notará que as duas linguagens são muito parecidas. Por isso, antes
de apresentarmos as estruturas básicas das duas linguagens, cabe apresentar
um pouco da história das linguagens de programação que influenciaram ambas.

23
 2.3 A História das linguagens

Com a Internet é fácil satisfazer nossas curiosidades. Por exemplo, pode-

mos, por meio de uma simples pesquisa na World Wide Web (www), descobrir
que Plankalkul2 foi a primeira linguagem de programação, criada em 1945 por
Konrad Zuse, na Alemanha. Fortran é a linguagem de programação de computa-
dores mais velha ainda em uso. Foi criada nos anos 1950 por John Backus e seu
nome vem de FORmula TRANslation, o que denota sua vocação para a compu-
tação que envolve cálculo. Existem alguns dialetos de FORTRAN muito famosos,
como o Fortran-77 e o Fortran-90. Em várias árvores genealógicas de linguagens
de programação (sim, existem árvores genealógicas que indicam a ordem de
aparecimento das linguagens de programação!) a linguagem Fortran aparece lá
nas origens. Outra linguagem que influenciou significativamente a sintaxe e a
estrutura das linguagens mais recentes foi a Algol. As linguagens de programa-
ção orientadas a objeto foram influenciadas por essas linguagens. Infelizmente,
a quantidade de linguagens de programação é superior a 200, portanto não con-
seguiríamos representar corretamente toda essa história. Aqui, nossa intenção
é apenas demonstrar que C++ e Java são parentes. Por isso você notará muita
semelhança entre elas.

Bom, se desejássemos simplificar a história da linguagem C++, poderíamos

dizer que ela sofreu grande influência da linguagem C with classes (que originou-se
de C) e da Simula. C (1971) originou-se da linguagem B (1968), que se originou de
BCPL (1967), que se originou de CPL (1963), que se originou de Algol.

Java, por outro lado, originou-se de OAK, que teve influência de várias outras
linguagens de programação: ADA, OBJECTIVE-C, C++, CEDAR, SMALLTALK e
SCHEME. Note que Java sofre influência de C++ (e, portanto, de C também!).

2.4 C++ e Java – estrutura básica de um programa

O C++ foi desenvolvido por Bjarne Stroustrup, dos Bell Labs, durante a dé-
cada de 1980 com o objetivo de implementar uma versão distribuída do núcleo
(kernel) do sistema operacional Unix. Stroustrup percebeu que a linguagem
Simula possuía características bastante interessantes para o desenvolvimento
de softwares, mas era muito lenta para uso prático. Resolveu combinar suas
características com as da linguagem C (rápida e portável para diversas plata-
formas) de forma a construir uma nova linguagem mais poderosa. Inicialmente
denominou-a C with classes, que em português significa C com classes. De-
pois, mudou seu nome para C++.

24 2 Plankalkul é uma combinação de duas palavras: plan e kalkul. Kalkul significa cálculo e plan
significa plano. Mais informações sobre essa linguagem podem ser obtidas em Sebesta (2009).
 // meu primeiro programa em C++
#include <iostream>
using namespace std;

int main (){

cout << “Olá pessoal!“ << endl;
return 0;
}

Em 1985 foi lançada a primeira edição do livro sobre a linguagem, chamado

The C++ Programming Language. Um exemplo bem simples de código C++ é
apresentado no código anterior. É importante destacar que ainda não há uso do
conceito de orientação a objetos.

A primeira linha do código apresentado é um comentário de linha. Em C++

é possível realizar comentários em uma única linha ou mesmo em parte dela.
Todo o texto colocado após as duas barras será ignorado pelo compilador. Um
comando válido da linguagem antes das barras duplas será executado normal-
mente. Diferentemente dos comentários da linguagem C, não há a necessidade
de se colocar outras duas barras para indicar o final do comentário. Ele termina
automaticamente com o final da linha.

Outra possibilidade de comentário é a utilização do /* e */. Todo o texto inse-

rido após a combinação /* será considerado comentário até que a combinação */
seja encontrada. A última combinação indica o final dos comentários.

Você já deve saber que comentários ajudam na compreensão do código e fa-

zem parte da chamada documentação interna. Tenha o hábito de fazer comentários
em seu código. Isso facilitará a compreensão futura das ideias nele contidas.

A próxima linha de código é uma diretiva de pré-processamento. Nela há a

indicação de se inserir o arquivo chamado iostream.h. Uma dúvida muito comum
é com relação ao uso de <> ou “ ” para delimitar o nome. Se você utilizar o primei-
ro conjunto de limitadores, estará deixando claro para o compilador que deseja
que o arquivo seja procurado na pasta includes do compilador. O uso das aspas
indicará para o compilador que o arquivo a ser inserido está na pasta corrente.
O arquivo iostream.h em questão é necessário para que sejam utilizados os
comandos de entrada e saída de dados. Um exemplo de saída de dados é apre-
sentado na linha anterior ao return 0; e será comentado em breve.

A declaração using namespace std; indica ao compilador que estaremos uti-

lizando o namespace std. Isso evitará que tenhamos que escrever, por exemplo, o
comando std::cout. É uma linha muito frequente em programas da linguagem C++.
25
 O programa principal está em uma função chamada main – assim como em
um programa da linguagem C – que pode ou não ter um tipo de retorno. Se você
declarar que a função main retorna um inteiro, então a função deverá retornar
um inteiro antes de ser finalizada. No código exemplo em questão, o comando
return 0; existe exatamente porque há um tipo de retorno para a função main (int
main). Se o código tivesse sido escrito com tipo de retorno void, então não haveria
necessidade do comando return.

O comando de saída cout << “Olá pessoal!” << endl; é uma simplificação do
comando printf da linguagem C. O comando em questão imprimirá a mensagem
“Olá pessoal!” e em seguida mudará de linha. O comando endl significa final de
linha. É equivalente ao “\n” da linguagem C. Na verdade, também é possível utilizar
o \n em C++. O comando equivalente ao apresentado anteriormente com \n seria:

cout << “Olá pessoal !\n“;

Assim como a saída de dados ficou mais simples, a entrada de dados tam-
bém. O código a seguir calcula a média de 3 notas de um aluno. As notas são
digitadas e a média calculada é exibida na tela.

// cálculo da média de 3 notas em C++

// diretiva de pré-processamento
// indica para incluir o arquivo iostream.h
#include <iostream>

// declaração do namespace
using namespace std;

// programa principal
int main (){
float media, nota, soma;
int i;
soma = 0;

// loop for idêntico ao da linguagem C

for (i=0;i<3;i++) {
cout << “Nota da prova“ << i;
cin >> nota;
soma = soma + nota;
}
26
 // cálculo da média
media = soma / 3;
// exibição do resultado na tela
cout << “Média = “ << media << endl;
return 0;
}

Quem está familiarizado com um código em C verá que existem poucas

diferenças para a linguagem C++ referentes aos comandos básicos. A princi-
pal diferença está nos comandos de entrada e saída. Aliás, como a linguagem
C é um subconjunto da linguagem C++, quem sabe a linguagem C terá pouco
trabalho para aprender a linguagem C++. No novo exemplo, o único comando
novo é o de entrada de dados (cin >> nota). Note que, diferentemente da lingua-
gem C, a linguagem C++ não exige formatação dos dados. A entrada de dados
tornou-se mais simples. É necessária, no entanto, uma atenção especial aos di-
recionadores << e >>. O primeiro está associado ao cout e indica saída de dados,
ao passo que o segundo está associado ao cin e indica entrada de dados. Assim
como o cout permite a escrita de várias informações por meio da combinação de
direcionadores de saída, o cin também permite a leitura de vários valores a partir
da combinação de direcionadores de entrada. Se houvéssemos escrito o código
sem loop, teríamos que ter criado 3 variáveis para nota (chamemos de nota1,
nota2 e nota3). O comando para leitura das 3 notas poderia ser:

cin >> nota1 >> nota2 >> nota3;

Note que cin apenas faz leitura de dados. Se houver a necessidade de que
uma informação seja apresentada para o usuário (geralmente isso acontece), então
é preciso utilizar o comando cout. Não é possível exibir uma mensagem para o
usuário utilizando o cin.

Outras diferenças importantes entre C e C++ são a declaração de variáveis

lógicas por meio do tipo bool e a declaração de constantes.

Para representar variáveis lógicas, o C não tinha um tipo definido. Era preci-
so utilizar variáveis inteiras e interpretar seus valores como sendo valores lógicos.
Em C o 0 (zero) representa o valor booleano falso, enquanto o 1 (um) representa
o valor verdadeiro. Em C++ é possível deixar o código mais limpo nesse sentido,
pelo uso do tipo de dado bool. Com ele é possível criar uma variável que aceite
os valores verdadeiro ou falso.

Com relação ao uso de constantes, em C, a declaração de uma constante

acontecia com o uso da diretiva #define. Tal diretiva simplesmente substituía, em 27
 tempo de compilação, a cadeia de caracteres pelo valor. Por exemplo, se o pro-
grama necessitasse utilizar PI, então em C teríamos uma diretiva:

#define PI 3.14159

Em todos os locais onde houvesse a palavra PI, a mesma seria substituída

por 3.14159. Note que não há tipo de dados associado. É apenas uma substitui-
ção simples de um valor por outro.

Em C++ é possível definir um tipo para uma posição de memória e informar

que a mesma será constante, ou seja, o programa não poderá alterar seu conteúdo
dali em diante. Um exemplo de declaração de constante seria:

const float PI = 3.14159;

Nesse caso o compilador não substitui a cadeia de caracteres PI por 3.14159.

Na verdade, o valor é armazenado e PI é utilizado como se fosse uma variável
(só que é constante).

Vamos, agora, criar um programa em Java semelhante ao nosso primeiro

programa em C++.

Mas antes, vamos contar um pouco sobre a linguagem Java. Ela foi de-
senvolvida nos laboratórios da Sun Microsystems no início dos anos 1990, com
o objetivo de ser uma linguagem-base de projetos de software para produtos
eletrônicos. Sim, o objetivo era colocar código em torradeiras e geladeiras! Mas
o programa desenvolvido em linguagem C não era tão genérico, dependia muito
da plataforma alvo. Na melhor das hipóteses, tinha que ser recompilado. No início
dos anos de 1990, Patrick Naughton, James Gosling e Mike Sheridan, três cientis-
tas da Sun, começaram a definir as bases para o projeto de uma nova linguagem
de programação que não contivesse os conhecidos problemas das linguagens
tradicionais, como C e C++. Especificaram a linguagem e a denominaram OAK.
Entretanto, por problemas de Copyright, tiveram que a renomear para Java, em
homenagem ao café que consumiam na Sun. A linguagem criada é mais simples
que C++, pois não tem sobrecarga de operadores, structs, unions, aritmética de
ponteiros e herança múltipla. Além disso, existe o gerenciamento de memória
(garbage collection), que evita o vazamento de memória. Conquistou atenção
devido a sua aplicação na World Wide Web, em que programas Java possibilitam
a criação de animações (por meio de applets). Mas isso veremos mais tarde.

O grande diferencial da linguagem Java é a independência de plataforma.

Java consegue tal independência porque seu compilador não gera instruções
28 específicas de uma plataforma, mas sim código intermediário, denominado
bytecode. Bytecode pode ser descrito como uma linguagem de máquina des-
tinada a um processador virtual que não existe fisicamente. Para que o código
possa ser executado é preciso que exista uma máquina virtual Java (ou JVM),
que interpretará o código intermediário e executará as instruções conforme o pla-
nejado. Assim, máquinas virtuais devem ser instaladas nas máquinas alvo e se-
rão responsáveis pela “conversa” com o processador. Um código Java compilado
gerará um código intermediário, que poderá ser submetido a qualquer máquina
virtual e será executado sem a necessidade de recompilação. Isso é diferente de
um código escrito em C++ e compilado para um processador específico. Apesar
de o programador ter que fazer pouca ou nenhuma alteração no código C++, ele
terá, no mínimo, que o recompilar. Isso não será necessário para o código Java.
Por outro lado, para executar um programa em Java é necessário que a platafor-
ma alvo tenha uma máquina virtual Java.

Vamos, então, examinar um programa simples escrito em Java. O programa

deverá ser criado em um arquivo chamado teste.java, pois estamos criando uma
classe em Java chamada teste. Os programas em Java devem ser armazenados
em arquivos cujos nomes sejam iguais ao da classe com a extensão .java.

class teste
{
// classe teste sem nada
// declaração de main()
public static void main(String args[])
{
System.out.println(“Olá pessoal“);
}
}

Esse código pode ser escrito em um editor de texto simples e compilado

com o comando de linha javac. Para executá-lo, basta digitar o comando java
teste no prompt de comando. Não se esqueça de que a pasta corrente deve ser a
pasta em que o programa foi gravado.

Esse exemplo simples mostra que não precisamos incluir arquivo algum. Há
uma função principal chamada main (em C++ também há!) que não retorna valor
algum. A saída de dados é realizada pelo comando println (escrita com mudança
de linha), acionado pela linha de código:

29
 System.out.println(“...“);

import javax.swing.JOptionPane;
class teste {
public static void main(String args[]) {
String x;
x = JOptionPane.showInputDialog(null, “Digite uma msg: “);
System.out.println(x);
}
}

As chaves servem para delimitar o início e o fim de uma estrutura ou bloco

de código, da mesma forma que acontece em C e C++.

Antes de iniciarmos um exemplo do cálculo da média de 3 valores em Java, é

conveniente estudar o programa do código anterior. Ele introduz a leitura em Java.

Sim, agora temos um comando de importação que é um pouco parecido

com o include do C++, visto anteriormente. Como Java é puramente orientado a
objetos, tudo nele refere-se a classes. O reuso de classes já escritas é simples.
Basta informar apenas onde estão. Assim, o comando import da primeira linha
indica que utilizaremos a classe JOptionPane, do pacote swing, que está dentro
do pacote javax. Podemos importar classes das seguintes formas:

a) import javax.swing.*;

b) import javax.swing.nome_da_classe;

No primeiro caso (a), todas as classes do pacote swing são visíveis. No se-
gundo caso (b), apenas a classe especificada está visível. Alternativamente, po-
deríamos ter omitido o comando import e ter escrito o comando de leitura assim:

x = javax.swing.JOptionPane.showInputDialog (...);

Ou seja, informaríamos o nome completo da classe. Ah, os imports mais

utilizados são:

import java.awt.*; // GUI.

import java.awt.event.*; // GUI event listeners.
import javax.swing.*; // Mais GUI.
import java.util.*; // estruturas de dados
import java.io.*; // entrada e saída
import java.text.*; // Classes de formatação.
30
import java.util.regex.*; // Expressões regulares
 Bom, a declaração de String é algo novo para quem conhece C, mas será
algo familiar em breve para os aprendizes de C++ e Java, pois String está presen-
te em ambas as linguagens. String, na verdade, é um tipo de dados utilizado para
armazenar uma cadeia de caracteres. Assim, o resultado da chamada da “função”
(vamos, por enquanto, chamar showInputDialog de função) será atribuído a uma
cadeia de caracteres cujo nome é x. Por fim, imprimimos o que foi lido. Enquanto
não estiver familiarizado com ambientes de programação como o NetBeans, você
pode testar os códigos aqui apresentados apenas utilizando um editor de texto
simples e os comandos javac e java no prompt de comando, como já indicado.

Para elaborar o programa do cálculo da média de 3 valores, precisamos

fazer a leitura de 3 valores em ponto flutuante (float ou double) e efetuar a divisão
por 3. A leitura, assim como no programa apresentado em C++, pode ser feita
dentro de um loop for:

import javax.swing.JOptionPane;
import java.lang.*;
class teste
{
public static void main(String args[])
{
float nota, media, soma = 0;
int i;
for (i=0;i<3;i++)
{
nota = Float.parseFloat(JOptionPane.showInputDialog(
null, “Digite uma nota: “));
soma = soma + nota;
}
media = soma/3;
System.out.println(media);
}
}

Para converter o valor lido por JOptionPane.showInputDialog em float é pre-

ciso chamar a “função” (novamente, vamos chamar de função, por enquanto) de
conversão de tipo para converter de String para float. O valor convertido é ar-
mazenado em nota e o processo é semelhante ao apresentado no exemplo do
código C++ para a mesma funcionalidade. Um estudo mais cuidadoso das duas
linguagens verificará que existem muitas similaridades entre ambas. As estrutu-
ras de seleção (if e switch) são iguais, assim como as de repetição, as expres-
sões aritméticas e lógicas, os operadores aritméticos e lógicos e assim por diante.
31
 Existem poucas diferenças entre as duas linguagens. Uma delas é o tipo de dado
boolean para armazenar valores lógicos (em C++ é bool). Outra diferença está no
trabalho com vetores e matrizes. Em Java, para se declarar um vetor de inteiros
chamado dias_do_mes, precisamos fazer as seguintes declarações:

int dias_do_mes[ ];
dias_do_mes = new int[12];

A primeira linha apenas indica ao compilador que haverá um vetor. A variável

é automaticamente ajustada para null quando o primeiro comando termina. So-
mente após a alocação (por meio do comando new int seguido do tamanho do
vetor) é que o vetor passa a existir. Em Java, não é preciso preocupar-se com a
devolução da memória alocada para o sistema operacional. Isso é automatica-
mente feito pelo sistema interno de coleta de lixo. Uma vantagem da linguagem
Java é, portanto, o controle efetivo da memória utilizada. Outros exemplos neste
livro permitirão melhor conhecimento de ambas as linguagens.

2.5 Considerações finais

Nesta unidade vimos um pouco da história das linguagens C++ e Java. Am-
bas são muito parecidas e os códigos aqui apresentados comprovam tais se-
melhanças. Para o leitor familiarizado com a linguagem C, aprender ambas as
linguagens não será um grande problema.

2.6 Estudos complementares

Existem diversos livros dedicados ao aprendizado de C++ e Java para ini-

ciantes. O livro indicado a seguir apresenta os principais comandos da linguagem
Java de forma clara e didática.
ARAÚJO, D. L.; REIS, F. G. Desenvolvendo com Java 2: para iniciantes. Rio de Janeiro:
Book Express, 2000.

32
Unidade 3

Introdução à orientação a objetos

3.1 Primeiras palavras

Com o aumento da complexidade dos sistemas e a necessidade cada vez

maior de reuso de códigos já implementados, surgiu a necessidade de um novo
paradigma de programação (orientação a objetos) que trouxesse mais flexibilida-
de e segurança na tarefa de codificação e mais economia para as indústrias de
softwares. Considerando-se que um programa de computador tem código e tem
informações (também chamadas de dados), há a possibilidade de se focar no có-
digo ou nos dados. Focar no código significa considerar importantes os aconteci-
mentos, ao passo que focar nos dados significa considerar importante o que está
sofrendo a ação dos acontecimentos. O primeiro enfoque apresenta problemas
com o aumento do tamanho dos sistemas. O segundo enfoque, inspirado nos
objetos do mundo real, permite a construção de soluções computacionais tendo
os dados como elementos centrais.

Nesta unidade apresentaremos mais detalhes do segundo enfoque, bem

como maneiras de implementar soluções baseadas em orientação a objetos, tan-
to em C++ como em Java.

3.2 Problematizando o tema

A chamada “crise do software” foi um termo utilizado nos anos 1970 para
expressar as dificuldades relacionadas com o desenvolvimento de softwares
em comparação com a crescente demanda. Um paralelo em economia seria, de
um lado, um aumento considerável da demanda (feita pelos consumidores) por um
produto (por exemplo, televisor) e, de outro lado, a incapacidade da indústria de
fornecer a quantidade solicitada do referido produto. Geralmente isso gera um
efeito indesejável, que é o aumento da inflação. O problema com o desenvolvi-
mento dos softwares era ainda maior, pois não existiam técnicas eficientes de
desenvolvimento de software. Utilizando ainda o paralelo com a economia, seria
o equivalente a ter no mercado produtos (televisores) não muito confiáveis!

Apesar da existência do paradigma de programação estruturada, a forma de

programar não permitia a reutilização eficiente de código. Além disso, manuten-
ções corretivas podiam causar efeitos indesejáveis no resto do código, uma vez
que dados e funções existiam de forma independente.

Para que o problema fique claro, vamos imaginar que temos um carrinho de
controle remoto. Do ponto de vista da programação, imaginemos que o controle
remoto seja uma função. Imaginemos, agora, que a indústria responsável pela
confecção do carrinho deseje lançar um novo brinquedo: um avião. Se a indústria
houvesse planejado um controle remoto mais geral (prevendo as funcionalidades
35
 para carrinhos, helicópteros, aviões, barcos e submarinos), seria bem mais fácil
fazer adaptações no projeto do controle remoto para o lançamento do novo pro-
duto. Entretanto, sem um projeto geral de controle remoto como base, a indústria
teria 3 caminhos:

1. Utilizar o mesmo controle remoto do carrinho no avião;

2. Adaptar o controle remoto do carrinho para o avião;

3. Construir um novo controle remoto para o avião.

A utilização do mesmo controle remoto para o avião teria um grave proble-

ma: a utilização indevida da funcionalidade da marcha ré, pois aviões não voam
de ré! Esse problema poderia causar sérios prejuízos financeiros à indústria.

Adaptar o controle remoto do carrinho para o avião poderia ser uma solução
interessante. Entretanto, limitações projetadas para o carrinho (como velocidade)
poderiam não ser aplicáveis ao avião. Além disso, do ponto de vista de progra-
mação, teríamos algumas funcionalidades semelhantes (ir para frente) que apre-
sentariam implementações diferentes (uma para o controle remoto do carrinho e
outra para o controle remoto do avião), apesar de serem idênticas. Mais ainda,
uma alteração na funcionalidade “ir para frente” em carrinhos implicaria em alterar
o código do programa em 2 partes distintas. Imaginemos que a empresa tivesse
optado por tal estratégia para todos os produtos lançados e podemos entender o
grau de complexidade da tarefa de manutenção.

Por fim, a construção de uma nova solução. Seria a mais conveniente, mas
certamente teria maior custo e atrasaria o lançamento do produto (o que pode
significar perda considerável da fatia do mercado para um concorrente que esteja
acompanhando suas tendências).

O paradigma de orientação a objetos permite, em desenvolvimento de

software, algo similar ao que permitiria para uma indústria um projeto mais
genérico de um produto. É o que veremos nesta unidade.

3.3 O paradigma OO

Basicamente, o paradigma de orientação a objetos utiliza os mesmos princí-

pios utilizados na construção de hardwares (com o uso de componentes básicos
como transistores, resistores, fusíveis, diodos, chips, etc.). Os “objetos” já existen-
tes são utilizados para produzir novos “objetos”.

A analogia com o hardware é muito interessante e oportuna. Um chip é, por

sua vez, formado por milhões de transistores interligados de forma específica,
36
que depende da funcionalidade para a qual foi projetado. Chips podem ser interco-
nectados formando placas (por exemplo, a placa de modem, a placa de vídeo do
computador, a placa de processamento de dados de um carro, etc.). Na verdade,
tudo o que você imaginar de equipamento eletrônico atual contém placas, que, por
sua vez, contêm chips, que contêm resistores, transistores, etc.

O paradigma de orientação a objetos objetiva mimetizar o que ocorre com o

hardware, utilizando um conceito bem comum de nosso mundo: objetos.

Formalmente, para uma linguagem ser considerada orientada a objetos ela

precisa implementar quatro conceitos básicos:

1. Abstração: habilidade de modelar características do mundo real.

2. Encapsulamento: habilidade da unidade de proteger os dados e permitir

que apenas suas operações internas tenham acesso a eles.

3. Herança: mecanismo que permite a) a criação de novos objetos por meio

da modificação de algo já existente e b) o vínculo do objeto criado com o
objeto antigo. É um conceito muito conhecido na natureza.

4. Polimorfismo: capacidade de uma unidade ter várias formas.

Para entender abstração, precisaremos utilizar um exemplo: carro. Um carro

é um veículo que transporta pessoas. Normalmente tem 4 rodas (existem carros
com 3 rodas), uma direção (existem alguns – de instrução – com 2 direções),
bancos, vidros, etc. Abstrair é imaginar algo geral que pode ser aplicado a carros.
Quando você imagina o seu carro, você está transformando o abstrato em con-
creto, pois ele tem certas características que o diferem de outros carros e pode
ser tocado, dirigido, etc. Retornaremos aos conceitos de abstrato e concreto mui-
to em breve.

Encapsulamento já foi abordado anteriormente neste livro. Por favor, recorra

ao item 1.3.1 para recordar. Em linguagens orientadas a objeto o encapsulamento
acontece quando escondemos os atributos e métodos do programador (usando
private). Assim, ele não pode acessar diretamente tais membros da classe.

Herança já é um conceito mais fácil de entender. Herdamos a capacidade

de nos alimentarmos com leite quando pequenos (pois somos mamíferos), a cor
dos olhos, o tamanho do nariz, etc. Se as características são misturadas de pai e
mãe, dizemos que a herança é dupla, ao passo que se fossem herdadas de um
único ser (clonagem) seria uma herança simples.

Uma analogia com a clonagem pode ser explorada para transmitir o concei-
to de herança em computação. É importante, entretanto, definir o que é clonagem
do ponto de vista biológico. A palavra clone (do grego klon, significa “broto”) é 37
 utilizada para designar a forma de geração de indivíduos por reprodução assexua-
da. Poderia ser definida como o processo em que são produzidas cópias fiéis de
outro indivíduo, ou seja, um clone.

Utilizando o exemplo da ovelha, imaginemos que um cientista deseje criar

uma ovelha verde. Uma ovelha verde seria uma ovelha normal com uma carac-
terística nova: cor verde. Se o procedimento de clonagem estiver bem dominado
e se for possível inserir um gene que determina a cor da pena do papagaio no
clone, em poucos dias é possível ter uma ovelha verde. Tal conceito (herança) é
muito importante em orientação a objetos, pois é possível criar um novo objeto a
partir de um modelo já criado.

Por fim, precisamos entender polimorfismo. Imaginemos poder criar uma

peça de xadrez que seja especial. Ela pode ora se transformar em cavalo (obede-
cendo todas as regras da peça cavalo), ora se transformar em torre (obedecendo
todas as regras da peça torre), ora em peão e assim por diante. Assim como tal
peça seria muito interessante em um jogo de xadrez, um objeto com tal capacida-
de em computação pode ser muito útil.

3.4 Classes e objetos

Precisamos, inicialmente, entender melhor o que é uma classe em compu-

tação (e o que seria um objeto). Uma classe seria um modelo (carimbo) de um
objeto. Objeto seria sua concretização (quando o carimbo é usado em conjunto
com a tinta), ou seja, uma instância da classe.

Quando alguém fala em cadeira, temos uma representação abstrata em

nossa mente do que é uma cadeira. É uma “coisa” que tem um assento, um en-
costo e pés. A representação mais simplista é a apresentada na figura a seguir.
Entretanto, a cadeira pode ter dois pés, ou mesmo uma estrutura com uma haste
e rodinhas. Ela pode ter um projeto diferenciado (e por isso mesmo custar mais).
Exemplos de cadeiras podem ser vistos na Figura a seguir:

Figura 2 Cadeiras comuns.

Note que são cadeiras, mas que são diferentes do modelo apresentado
anteriormente. Na verdade, nossa mente tem uma representação complexa de
38 cadeira que aceita todos esses exemplos. Uma classe deve prever um conjunto
de características para o objeto a ser criado a partir do molde, bem como um
conjunto de ações que o objeto poderá executar. No exemplo da cadeira, isso
se aplica ao tipo de pé, ao tipo de encosto, se é uma cadeira com rodinhas, se é
uma cadeira de balanço, qual o material de sua estrutura (madeira, aço, metal ou
plástico), seu revestimento (pano, couro, verniz), etc. Como você pode perceber,
especificar um molde para uma cadeira é algo complexo.
Outro exemplo poderia ser uma lâmpada. Ela pode ser incandescente ou
fluorescente, pode ser de bastão ou ter o formato clássico, ter várias voltagens,
potências, cores, marcas, etc.

Mais um exemplo: uma empilhadeira. Ela tem uma cor, uma altura, uma
capacidade de carga, um ângulo máximo de giro, tem uma velocidade máxima de
movimentação, etc. Tudo isso se configura no conjunto de características do
futuro objeto (ainda estamos falando de classe!). Tal empilhadeira pode realizar as
seguintes (entre várias) funções: 1) movimentar-se para frente; 2) movimentar-se
para trás; 3) girar Z graus para a direita; 4) girar Z graus para a esquerda;
5) pegar a carga; etc. Tais funções se configuram em ações que o futuro objeto
poderá realizar.

Ações são chamadas de métodos, enquanto as características são cha-

madas de atributos.

A empilhadeira utilizada como exemplo é uma instância (um objeto) da clas-

se empilhadeira (“carimbo”), pois tem características (altura específica, cor, etc.)
e ações determinadas.

Para deixar bem claro o conceito de classe e objeto, podemos imaginar

a classe cachorro. Um molde ou carimbo genérico seria aquele que permitisse
“guardar” informações, tais como nome, altura, peso, idade, raça, cor dos olhos,
tamanho do rabo, etc. Um exemplo de um cachorro poderia ser o meu. O Rex tem
uma raça específica, uma altura, peso, etc. Ele é uma “instância” da classe ca-
chorro. Não consigo tocar na classe cachorro, mas consigo tocar em um exemplo
da classe cachorro, que é o Rex. Meu cachorro é um objeto da classe cachorro.

Ah, um objeto pode interagir com outro e mudar suas características! Po-
deríamos utilizar um objeto “spray” para pintar (uma ação de “spray”) a empi-
lhadeira e, assim, mudar um valor de seus atributos (o atributo cor). Quando
pensamos em objetos, as coisas ficam mais claras.

Existem vários outros exemplos de classes, como “conta bancária”, “decla-

ração de imposto de renda”, etc.

39
 3.5 Elementos de uma classe

Como explicado anteriormente, a classe tem um nome (empilhadeira, ca-

chorro, spray, etc.) e dois tipos importantes de elementos: atributos e métodos.

Quando pensamos em uma caixa, podemos imaginar suas características:

material, tamanho, textura, cor, etc. Esses são alguns dos exemplos. Seu estado –
aberta ou fechada – também é outro exemplo de atributo. As ações abrir e fechar
são exemplos de métodos da classe caixa.

Outro exemplo já citado seria o da lâmpada. O tipo de lâmpada, a cor, a vol-

tagem, a potência e o estado da lâmpada (acesa, apagada ou queimada) seriam
exemplos de atributos. Acender, apagar e queimar a lâmpada seriam exemplos
de métodos. Em breve apresentaremos um exemplo de código para a lâmpada.

typedef struct data

{
int dia, mes, ano;
} data;

Em termos de linguagem de programação, classes diferem de estruturas

(structs) no quesito proteção de dados. No exemplo da data, podemos ver um con-
junto de dados (dia, mês e ano) sendo empacotado em um mesmo “volume”. Entre-
tanto, não há nenhum mecanismo que impeça o programador de criar uma variável
do tipo data (por exemplo, data_nascimento) e de atribuir o valor 45 para mês. Sim,
não faz sentido colocar o valor 45 em mês, visto que existem apenas 12 meses e é
por isso que devemos criar “estruturas” que impeçam tal situação. Assim, é interes-
sante que possamos controlar os valores assumidos pelos elementos da estrutura
de forma que dia, mês e ano tenham sempre valores válidos.

Isso nos faz pensar sobre o uso do controle remoto do ar-condicionado (ou
do videocassete, do aparelho de DVD, do televisor, etc.) para realizar algumas
funções de nosso interesse. Um controle remoto de um aparelho de ar-condicio-
nado tem teclas para ligar e desligar, controlar a velocidade do ventilador, da pá
de distribuição do ar e também para controlar a temperatura (e principalmente
para controlar a temperatura!). Mais ainda, o controle remoto não permite que di-
minuamos a temperatura para menos de um valor pré-determinado (em torno de
15ºC) ou aumentemos para um valor superior a outro valor pré-determinado (em
torno de 27ºC). Isso permite que o aparelho funcione corretamente e não congele
ou derreta. O fabricante do aparelho projetou um controle remoto que protege o ob-
jeto que industrializa e comercializa. Ninguém que utilize o controle remoto poderá
modificar a temperatura para um nível inferior a 15ºC ou superior a 27ºC. Assim,
40
temos com classes mais que simplesmente um “empacotamento”. Temos um
empacotamento de dados e código que permite a consistência das informações
presentes. Mantendo a analogia com o exemplo do ar-condicionado, os dados só
poderão ser modificados segundo as “funções” das teclas do controle remoto.
A classe esconderá seus dados (visibilidade) e permitirá que apenas alguns mé-
todos sejam disponibilizados para alteração deles. Se criássemos a classe data,
precisaríamos de métodos (não chamamos mais de funções) que mantivessem
a consistência destes. Um método poderia ser atribuir_dia(int x). O valor x deve,
nesse exemplo, ser verificado para saber se é um valor válido. Ele depende do
mês e do ano da data. Se o mês for fevereiro e o ano for bissexto, então o dia
poderá assumir valores entre 1 e 29. Assim, se x estiver dentro desses limites,
dia poderá receber o valor em x. Caso contrário, dia poderá receber um valor pa-
drão (1, por exemplo). Se o mês for agosto, x poderá estar entre 1 e 31. Se for
setembro, entre 1 e 30.

Também poderíamos ter um método de adicionar um dia à data. Isso faria

com que a data fosse sendo modificada conforme percorremos um calendário.
Mais ainda, mudaria de mês automaticamente quando um dia fosse acrescen-
tado ao final do último dia do mês anterior. E permitiria, inclusive, o controle da
mudança de ano, uma vez que do dia 31/12 de um determinado ano deve-se,
automaticamente, mudar para o dia 01/01 do ano seguinte.

3.6 Diagrama de classes

Uma forma muito comum de se representar classes é por meio do diagrama

de classes da UML (Unified Modeling Language). Com ele, é possível representar
visualmente uma classe. Também é possível representar a relação entre elas (o
que será visto mais adiante).

Uma classe, em UML, é representada por um retângulo com 3 partes. Na par-

te superior encontra-se o nome da classe, na intermediária os atributos e na inferior
os métodos. O nome da classe deve ser em negrito e, geralmente, é um substan-
tivo em que a primeira letra é maiúscula. Na parte intermediária do diagrama são
apresentados os atributos ou características da classe. Além do nome do atributo,
devemos especificar sua visibilidade, que pode ser:

~: as classes de um pacote podem ser usadas;

+: público;
#: protegido;
-: privado.

41
 Normalmente você verá os atributos tendo visibilidade privada (-). Isso sig-
nifica que somente os métodos da classe podem acessá-los. Visibilidade privada
impede que os valores sejam acessados diretamente. Para se alterar um atributo
privado é preciso que exista um método que todos possam acionar (acesso pú-
blico) relacionado a ele. Tal método controlará os valores que o atributo poderá
assumir. Assim, acesso público é um acesso irrestrito e acesso privado é um
acesso restrito. O modo de acesso protegido está relacionado com herança e
será discutido oportunamente.

Vale ressaltar que structs em C seriam equivalentes a uma classe sem mé-
todos com atributos de acesso irrestrito. Ou seja, sem proteção alguma. Agora
já temos isso bem claro.

Bom, voltando aos atributos, estes têm tipo de dado e podem ainda apre-
sentar um valor padrão. Note que na classe a seguir, o atributo Nome é do tipo
String e o valor padrão, representado pelo símbolo de igual, é Ednaldo:

Pessoa
+Nome : String = “Ednaldo“
+Idade : int = 43

...
...
+fazer_aniversario()

Em breve falaremos mais a respeito do valor padrão. Agora temos os méto-

dos. Note que ambos estão com acesso público. É importante que a classe tenha
métodos públicos para que os dados possam ser modificados. A classe em questão
é incompleta e apresenta apenas alguns métodos. O método fazer_aniversário(),
quando acionado, altera o valor de idade. Se o método fazer_aniversário fosse pri-
vado, então não poderia ser acionado diretamente. Um método será privado ape-
nas em casos especiais. Imagine uma impressora com alarme sonoro para indicar
o final da tinta do cartucho. O alarme deverá ser acionado quando a quantidade
de tinta chegar a um nível crítico e não quando o usuário desejar escutar o som
do alarme. Assim, tal impressora não teria um “botão” chamado alarme para o
usuário acionar. O método imprimir_documento da impressora iria, automatica-
mente, diminuindo a quantidade de tinta do cartucho. Quando chegasse a um
nível crítico, acionaria o método alarme.

Já que iniciamos a discussão sobre a classe impressora, podemos tentar

representá-la.
42
 Impressora
-Cor : String
-Tipo : String
-Velocidade : int
-Capacidade : int
-Qualidade_impressão : char
-Nível_reservatório : float
-Estado : bool

+Imprimir()
+Trocar_suprimento()
+Ligar()
+Desligar()
-Alarme()

Uma impressora pode ser colorida ou monocromática (preto e branco), pode

ser a laser, a jato de tinta, matricial ou a jato de cera, tem determinada velocidade
de impressão, capacidade de suportar uma determinada quantidade de papéis
em sua bandeja, pode imprimir em qualidade de texto rápido, qualidade alta ou
mesmo qualidade de foto, pode armazenar o nível de tinta dos cartuchos (ou de
toner), etc. Existem muitos outros atributos de uma impressora! E existem algu-
mas ações que uma impressora realiza, entre elas a mais óbvia: imprimir! E todos
sabemos que uma impressora imprime se estiver ligada (estado = ligado), que a
impressão consome tinta, etc.

3.7 Relacionamento entre classes

Existem vários relacionamentos entre classes. Nosso foco será apenas nas
relações de herança e composição. A relação de herança é aquela em que uma
classe herda características de uma classe mais genérica. Normalmente é re-
conhecida por meio da relação é-um. “Um cachorro é um mamífero” indica que
cachorro herda características de uma classe mais genérica, que é a classe ma-
mífero. Na verdade, a classe mamífero é mais genérica, pois permite que vários
animais herdem características dela (tigre, gato, cavalo, etc.).

Outro relacionamento importante é o de composição. Ele é reconhecido

pela relação tem. Um carro tem uma direção, tem 4 rodas, etc. Um funcionário
tem data de nascimento, departamento, etc. Ou seja, data de nascimento é um
atributo do tipo data.
43
 Tanto com herança quanto com composição é possível fazer reuso de clas-
ses já criadas. Esse é um dos grandes atrativos da orientação a objetos, que faz
com que seja fortemente adotada nas fábricas de software.

3.8 Exemplos

Agora vamos ver exemplos simples de classes em C++ e em Java. Os rela-

cionamentos do tipo herança e composição serão vistos na Unidade 6.

Vamos começar com um exemplo de lâmpada. Construir uma lâmpada ge-

nérica não é tão simples assim. Uma lâmpada tem voltagem, potência, tipo (fluo-
rescente, incandescente), marca e cor, entre outros possíveis atributos. Ah, e pode
estar acesa, apagada ou queimada. Como o objeto da classe lâmpada deve ter
seus valores definidos logo após sua declaração, isso significa que é preciso que a
classe tenha um construtor que atribua valores iniciais dos atributos para aquele
objeto. Vejamos uma implementação simples em C++ feita no Netbeans:

#include <stdlib.h>
#include <iostream.h>
using namespace std;
class lâmpada {
private:
    int voltagem;
bool estado;
public:
lampada(); // construtor sem parâmetro
   lampada(int v); // construtor com parâmetro
  void ligar_desligar(); // simula o interruptor de ligar/
// desligar
    bool get_estado(); // obtém o estado da lâmpada
    int get_voltagem(); // obtém a voltagem da lâmpada
    void imprime(); // imprime os atributos da lâmpada
};

Note que em C++ a definição da classe deve terminar com ponto e vírgula
(;). Os atributos normalmente estão na área private da classe e os métodos na
área public. Isso acontece porque desejamos proteger o acesso aos atributos, de
forma a evitar que o objeto tenha valores indevidos. Imagine que a lâmpada possa
ser somente 110 ou 220V. E se alguém desejasse que a lâmpada assumisse o
valor 145V para a voltagem? Em C, você se lembra, isso era possível, visto que
44 struct apenas agrupava valores, mas não os protegia. Agora, com a definição do
tipo de acesso private para voltagem e estado, se o programador criar um objeto
chamado lâmpada_sala, então ele poderá acionar apenas os métodos ligar_des-
ligar( ), get_estado( ), get_voltagem( ) e imprime( ). Note que os construtores não
estão na lista. Isso significa que não podem ser acionados pelo programador. Um
construtor é acionado apenas quando há a declaração de um objeto e tal aciona-
mento acontece de forma automática. No caso anterior, pode-se observar a exis-
tência de dois construtores. Um construtor tem o mesmo nome da classe, mas
não tem tipo de retorno. Assim, quando houver uma classe ABC, deverá existir
um construtor – cujo nome será ABC – que será o responsável pela inicialização
do objeto. Se houver dois ou mais construtores, então, o compilador identificará
qual será chamado a partir do número e tipo dos parâmetros que estão na lista
de parâmetros. A combinação nome do método e lista de parâmetros é conhecida
como assinatura. Métodos com o mesmo nome, mas com assinaturas distintas,
são diferentes. Em orientação a objetos isso significa sobrecarregar o método.
No caso em tela, ocorre uma sobrecarga de construtor. Veremos mais a respeito de
sobrecarga na próxima unidade.
Se no programa principal o programador criar o objeto L sem parâmetro,
então o construtor sem parâmetros é chamado. Caso contrário, se o programador
definir o objeto L(220), então a lâmpada L terá 220V.

lampada::lampada(){
  voltagem = 110;
   estado = false;
}
lampada::lampada(int v){
    if (v == 110 || v == 220)
    voltagem = v;
    else
  voltagem = 110;
estado = false;
}

Os dois construtores são apresentados no código anterior. Note que a

voltagem será 110 sempre que o valor for diferente de 220. Isso impedirá a cria-
ção de um objeto com voltagem diferente de 110 ou 220V e a lâmpada sempre
estará desligada (estado = false).

A partir do exemplo apresentado pode-se inferir sobre a função do cons-

trutor: inicializar os atributos do objeto. Ou seja, após a declaração do objeto,
ele poderá ser utilizado imediatamente, pois seus atributos foram preenchidos. O
construtor serve, então, para inicializar o objeto. 45
 void lampada::ligar_desligar( ){
  estado = !estado;
}

Para acender ou apagar uma lâmpada é necessário apenas acionar o in-

terruptor. O método inverterá o estado da lâmpada. Se estava apagada, ficará
acesa. Se estava acesa, ficará apagada.

Os métodos get (do inglês pegar, obter) são responsáveis pela obtenção dos
valores armazenados nos atributos de acesso restrito (private). Note que não é
possível acessar o atributo de forma direta simplesmente pelo fato de que tal ato
poderia quebrar toda a segurança do objeto. Lembre-se que, se alguém pode
acessar o atributo estado para imprimir seu valor na tela, também pode acessá-lo
para modificá-lo.

bool lampada::get_estado( ) {    return estado;}

int lampada::get_voltagem( ){    return voltagem;}
void lampada::imprime( ) {
    cout << “estado  = “ << estado << endl;
    cout << “voltagem = “ << voltagem << endl;
}

Note, também, que o compilador sabe a qual classe o método pertence por
intermédio do operador de escopo ::. Isso significa que, na verdade, o método
tem um nome e um sobrenome. Como exemplo, utilizemos o método imprime
do último código. É um método cujo nome é imprime e o sobrenome é lâmpada
(pertence à classe lâmpada). Seu tipo de retorno é void, ou seja, não há tipo de
retorno. Por isso, em seu código, não há o comando return.

Os métodos get_voltagem e get_estado também pertencem à classe lâm-

pada (pelo “sobrenome”). Entretanto, tais métodos retornam valores (o objetivo de
um método get é retornar um valor). Note, também, que o retorno ocorre por cópia.
Ou seja, uma cópia do valor armazenado em voltagem ou em estado é retornada.
E note, também, que o método tem direito (por pertencer à classe) de acessar os
dados private. Somente membros da classe podem acessar os dados restritos. Isso
faz sentido, pois caso contrário, nada poderia acessar os atributos (ou métodos)
de acesso restrito. Poderíamos, então, modificar o tipo de acesso de private para
impossible ou forbidden (brincadeira, não existem tais tipos de acesso!).

Continuando, precisamos mostrar o uso da classe lâmpada.

46
 int main(int argc, char** argv) {
    lampada sala(9), cozinha(220), escritorio;
escritorio.imprime();
     cout << “estado das lampadas \n“;
    cout << “sala “ << sala.get_estado() << endl;
    cout << “cozinha “ << cozinha.get_estado() << endl;
    cout << “escritorio “ << escritorio.get_estado() << endl;
    sala.ligar_desligar();
...
    return (EXIT_SUCCESS);
}

Os objetos sala, cozinha e escritório indicam as lâmpadas criadas para tais

cômodos. Toda lâmpada cujo parâmetro seja diferente de 110 ou 220V terá volta-
gem assumida como 110V. Se não houver parâmetro (caso da lâmpada do escri-
tório), tal lâmpada será 110V. O comando escritório.imprime( ) acionará o método
imprime( ), que será responsável por imprimir os dados da lâmpada do escritório.
A lâmpada da sala será acesa (pois todas são criadas desligadas) quando o mé-
todo ligar_desligar( ) for acionado.

Como informado anteriormente, a classe poderia ser mais complexa. Po-

deríamos ter que simular o estado “queimada”. Também poderíamos indicar que
uma lâmpada só poderia ser acesa se não estivesse queimada, se seu estado
estivesse indicando que está apagada e estivesse conectada na rede de energia
elétrica. Sim, porque quando você compra uma lâmpada em uma loja, ela supos-
tamente não está queimada, mas não poderá ser acesa, visto que não está ligada
à rede elétrica.

Outro fato digno de nota no código é que não há um método set para alterar
a voltagem da lâmpada, por exemplo. Se ela é criada com uma voltagem X, per-
manecerá com tal voltagem até que se queime e seja inutilizada.

47
 class horario //nome da classe
{ //início da declaração da classe
private: //especificador de acesso.
int hora; //atributo hora
int minuto; //atributo minuto
int segundo; //atributo segundo
public: //especificador de acesso.
horario(); //construtor
horario(int,int,int); //construtor com 3 parâmetros
acerta_hora(int); //método acerta_hora
acerta_minuto(int); //método acerta_minuto
acerta_segundo(int); //método acerta_segundo
~horario(); //destruidor
}; //fim da classe.
//atenção: não esqueça o ;

Agora vamos utilizar a classe horário para comparar uma implementação

feita em C++ com sua equivalente em Java.

A definição da classe horário está bem explicada, não? Existem 3 atribu-

tos, vários métodos, 2 construtores e um destruidor. A primeira observação é
com relação a algo muito simples, mas que, muitas vezes, causa transtornos:
o ponto e vírgula no final da declaração. Se você não colocar ponto e vírgula
no final da definição do protótipo da classe, isso lhe causará problemas para
compilar o programa.

A especificação do código dos métodos pode vir logo após a declaração

da classe. Alternativamente, um método pode ser definido dentro da decla-
ração da classe. No exemplo a seguir, o construtor sem parâmetros tem sua
implementação dentro da declaração da classe. Tal implementação pode ser feita,
portanto, tanto dentro como fora da declaração da classe!

class horario {
private:
int hora;
int minuto;
int segundo;
public:
horario() { hora = 10; minuto = 5; Segundo = 2;}
horario(int,int,int);
48 acerta_hora(int);
 acerta_minuto(int);
acerta_segundo(int);
~horario();
};
horario::horario(int a, int b, int c) {
hora = minuto = segundo = 0;
if (a >=0 && a < 24)
hora = a;
...
}

O outro construtor, os métodos e o destruidor (ou destrutor) deverão ser

implementados fora da classe.

Já vimos pelo exemplo da classe lâmpada que para definir o método fora
da classe devemos especificar a qual classe ele pertence. Assim, o construtor
com parâmetros deverá ter nome e sobrenome, como no exemplo de código
apresentado.

Provavelmente você já sabe completar o código escondido do construtor

horário. Note que no protótipo não havia necessidade de especificar os nomes
dos parâmetros. Aqui há.

O destruidor (ou destrutor) tem um código muito simples. Na verdade é o

código mais fácil já visto:

horario::~horario() { }

Sim, o código é vazio. Para casos em que não exista alocação dinâmica de
memória, os destruidores são simples e não precisam nem de declaração. Para
os casos de alocação dinâmica de memória, o destrutor é necessário, pois é ele
que devolve a memória emprestada pelo construtor no momento da alocação
dinâmica.

Vale relembrar que tanto o construtor como o destrutor não são acionados
pelo programador. O construtor é acionado no momento da declaração do objeto
e o destruidor é acionado quando termina o escopo do objeto.

Todos os outros métodos devem ter o especificador da classe seguido do

operador de escopo (::) seguido do nome do método. Lembre-se que, dentro
do método, é importante verificar se os parâmetros passados satisfazem os
critérios da classe. Os métodos são o meio de acesso aos atributos. Se não
verificarem os dados passados deixarão que os atributos assumam valores inde-
vidos. E isso é contrário ao “espírito” de orientação a objetos. 49
 Agora, a implementação em Java. Como informado, utilizaremos o exemplo
da classe Horário, que deve armazenar hora, minuto e segundo. Vamos criar dois
arquivos com extensão .java. O primeiro – referente à classe Horário – deverá se
chamar Horário.java. O segundo – referente ao programa principal responsável
pelo teste do uso da classe Horário – se chamará testeHorario.java.

public class Horario {

private int hora, minuto, segundo;
public Horario() { hora = 0; minuto = 0; segundo = 0;}
public Horario(int a, int b, int c) {
hora = minuto = segundo = 0;
if (a < 24 && a >= 0) hora = a;
if (b < 60 && b >= 0) minuto = b;
if (c < 60 && b >= 0) segundo = c;
}
public void setHora(int a) {
if (a < 24 && a >= 0) hora = a;
}
public void setMinuto(int a) {
if (a < 60 && a >= 0) minuto = a;
}
public void setSegundo(int a) {
if (a < 60 && a >= 0) segundo = a;
}
public int getHora() { return hora; }
public int getMinuto() { return minuto; }
public int getSegundo() { return segundo; }
}

A classe Horário deverá restringir o acesso aos 3 atributos já mencionados, a

partir do especificador de acesso private. Sim, private em C++ e private em Java!

Como já foi indicado neste livro, você poderá comprovar que C++ e Java são
linguagens muito parecidas.

A classe Horário deverá ser delimitada pelo abre chaves ({) e o fecha chaves
(}). Mas note que, diferentemente de C++, em Java não há ponto e vírgula após o
} que indica final da classe.

Outra questão importante a ser observada no código é a verificação dos va-

lores que serão atribuídos aos atributos. Note que todos os valores, quer no cons-
trutor quer nos métodos set, devem ser verificados. Hora deve sempre ficar entre
50
0 e 24; minuto e segundo sempre entre 0 e 60. Mas isso não é novidade! Você já
foi alertado sobre isso quando a classe Horário para C++ foi apresentada.

Bom, a classe Horário está pronta e pode ser compilada. Na linha de co-
mando, digite:

javac Horário.java

O comando javac aciona o compilador java e se o código estiver correto

gerará o arquivo Horário.class.

Precisamos de um programa principal para utilizar a classe Horário. Sim, em

Java também é necessário um programa principal (main).

public class testeHorario {

public static void main(String[] args) {
Horario almoco = new Horario(12,0,0);
System.out.println(almoco.getHora());
}
}

O objeto almoço é criado por meio do comando new Horario. No exemplo, o

objeto foi criado com os parâmetros 12, 0 e 0. Isso significa que o horário arma-
zenado em almoço será 12h00.

Para imprimir o valor hora armazenado no objeto, busca-se o valor a partir

do método getHora( ) e promove-se a saída por intermédio do println.

Outro exemplo interessante de classe é o jogo da velha. Consiste em um

tabuleiro com peças O e X que devem ser colocadas alternadamente pelo jogador
1 e pelo jogador 2. A classe deve controlar as jogadas, saber a vez do jogador, sa-
ber se um jogador fez uma jogada incorreta ou não, detectar se o jogo já terminou
e se houve um ganhador ou não. Sempre que uma jogada correta for realizada e
o jogo não houver terminado, então a classe solicitará que o outro jogador efetue
sua jogada. O jogo deve iniciar com as posições vazias. Uma jogada válida é uma
jogada dentro do tabuleiro em uma posição ainda não ocupada por nenhuma peça.
Vejamos o protótipo da classe.

51
 class jogo {
private:
char tab[3][3]; // armazena jogadas
int jogadas; // controla total de jogadas
char jogador; // controla de quem é a vez
public:
jogo( ); // inicializa o jogo
bool terminou( ); // jogo terminou?
char verifica_vencedor( ); // quem venceu?
bool posicionar_peca(int, int); // posicionar peça
void jogar( ); // inicia o jogo
void limpa_tela( ); // limpa a tela
void troca_jogador( ); // troca jogador
void desenhar_tabuleiro( ); // desenha tabuleiro
};

Deve-se escolher um símbolo – por exemplo * – para indicar que o local

ainda não foi preenchido. O atributo jogadas será responsável por controlar o
total de jogadas já realizadas. Deve iniciar-se com o valor zero e ter seu valor
incrementado em uma unidade a cada nova jogada. Dessa forma, servirá para
controlar o final do jogo (pois um jogo da velha tem, no máximo, nove jogadas).
Assim, se o tabuleiro houver sido preenchido e não houver vencedor, então o jogo
terminou e houve empate. O código do método de controle de fim de jogo será
apresentado em breve. Por fim, o atributo jogador. Ele armazenará o símbolo do
jogador da vez.

jogo::jogo( ) {
int i, j;
for (i=0;i<3;i++)
for (j=0;j<3;j++)
tab[i][j] = ’*’;
jogadas = 0;
srand(time(NULL)); // inicializa semente para sorteio
if (rand( ) % 2 == 0) jogador = ’X’;
else jogador = ’O’;
}

Voltando ao construtor, deve-se observar que há a chamada de srand. Para

que isso ocorra é preciso incluir time.h no código. Srand permite inicializar a se-
mente do gerador de números aleatórios. Isso permitirá que sempre que um
52
“sorteio” for realizado, ele possa ser diferente do sorteio anterior. O parâmetro
time(NULL) garante que isso aconteça. Se o parâmetro for um valor constante,
então os sorteios serão viciados (sempre a mesma coisa, não importa quantas
vezes você rode o programa). Ou seja, se o jogador a iniciar a partida for X quando
o parâmetro for 3, então sempre o jogador X iniciará a partida! Com time(NULL)
isso não é verdade. Uma vez pode ser o X e outra pode ser o O. O sorteio é feito
por meio da chamada da função rand( ). Seu resultado é um número inteiro que
será dividido, nesse caso, por 2. Se o resto for 0, então será o jogador X a iniciar
a partida, caso contrário será o jogador O.

Bom, vamos agora ao código do método de verificação se o jogo terminou

ou não. Se já ocorreram 9 jogadas, então não há mais espaço disponível para
novas jogadas. Caso o número de jogadas seja menor que 9, então é preciso
verificar se já houve um vencedor. Se houve, então o jogo terminou.

bool jogo::terminou( ) {
if (jogadas < 9 && verifica_vencedor( ) == ’*’)
return false;
else
return true;
}

O método verifica_vencedor retornará O caso o vencedor seja o jogador

cujo símbolo é o O, X caso o vencedor seja o jogador cujo símbolo é o X ou * caso
não haja vencedor.

O método verifica_vencedor deverá verificar se há repetição do mesmo sím-

bolo (O ou X) em qualquer uma das 3 colunas, em qualquer uma das 3 linhas
e nas duas diagonais (principal e secundária). Se o símbolo X – por exemplo
– satisfizer tal condição, então ele será o símbolo a ser retornado pelo método,
indicando que o vencedor é o X.

O método posiciona_peca(int x, int y) deverá, dadas as coordenadas x e y,

posicionar a peça do jogador. Se as coordenadas estiverem corretas (dentro do
tabuleiro) e se a posição estiver desocupada (tab[x][y] == ‘*’), então a jogada é
válida. A referida posição deverá receber o jogador da vez (tab[x][y] = jogador)
e será preciso verificar se o jogador da vez ganhou. Sempre após uma jogada
válida é preciso trocar o jogador da vez. Uma jogada inválida resultará em uma
mensagem de aviso para o usuário e uma solicitação de nova jogada. Você con-
segue terminar o código do jogo?

Bom, mais exemplos de classes em C++ e em Java podem ser vistos no

Apêndice B. 53
 3.9 Considerações finais

Nesta unidade foi possível entrar em contato com alguns conceitos do

paradigma de orientação a objetos. Exemplos comentados em C++ e em Java
puderam ilustrar os conceitos básicos de orientação a objetos. Outros exemplos
no Apêndice B poderão contribuir para melhor entendimento do assunto.

54
Unidade 4

Introdução à sobrecarga
4.1 Primeiras palavras

Quem é acostumado a programar em C, por exemplo, não consegue com-

preender a razão pela qual existem sobrecargas de métodos e operadores em
linguagens como C++. Nesta unidade serão vistas as duas formas de sobrecarga:
métodos e operadores.

Na verdade, você já viu um pouco de sobrecarga de métodos na unidade

anterior. Talvez não tenha aceitado com tranquilidade o fato do construtor ho-
rário ter tido duas implementações diferentes (uma sem parâmetros e outra
com 3 parâmetros). Isso ocorre em C++ (e em Java também) quando um méto-
do apresenta o mesmo nome que outro, mas suas assinaturas são diferentes.
Assinatura é o binômio nome do método e lista de parâmetros. Duas listas de
parâmetros A e B são iguais se contiverem o mesmo número de parâmetros e
se o tipo de dado do elemento ai da lista A for igual ao tipo do elemento bi da lista
B, considerando-se que A = {a1, a2, ..., an} e B = {b1, b2, ..., bn}. Nesta unidade, além
da sobrecarga de métodos, você verá, também, a sobrecarga de operadores (so-
mente para C++, pois Java não apresenta tal característica).

4.2 Problematizando o tema

Muitas vezes, nos deparamos com a seguinte situação: temos uma função
em C++ que é responsável pelo cálculo do quadrado de um número. E ela funciona
para valores inteiros. Mas e se desejássemos que ela funcionasse também para
valores decimais? Na verdade, deveríamos criar outra função com o mesmo có-
digo, mas tipos de parâmetros diferentes! Replicar o código apenas por causa do
tipo de parâmetro não faz muito sentido, faz? Mas a sobrecarga de métodos é
mais que isso, e você verá detalhes em breve.

Outra questão importante é poder representar operações lógicas e aritméti-

cas de forma natural, como fazemos com dados do tipo inteiro, double ou float. É
desejável que a operação

C = A + B;

tenha significado para inteiros, floats e doubles, mas também para vetores,
matrizes, números complexos, frações, etc. Se A, B e C fossem objetos da classe
fração, então o comando apresentado seria a atribuição para o objeto C do resul-
tado da soma de duas frações. Lindo, não? É o que também será abordado nesta
unidade.
57
 4.3 Sobrecarga de métodos

Quando um método é declarado, ele tem uma assinatura, ou seja, um nome

e um conjunto de parâmetros. Se declaramos dois métodos com o mesmo nome,
mas com listas de parâmetros diferentes, dizemos que estamos sobrecarregando
o referido método. Vejamos o exemplo a seguir.

class vetor
{
private:
float v[10];
public:
vetor(); // construtor não tem tipo de retorno!
void adiciona(float); // adiciona um float a
// todos os elementos
void adiciona(vetor); // adiciona um outro vetor ao atual
...
};

Os métodos adiciona(float) e adiciona(vetor) são diferentes, pois o primeiro

permite que um número seja adicionado a todos os elementos do vetor enquanto
o segundo permite que um vetor seja adicionado ao atual.

Vamos entender o contexto. Imaginemos o objeto A da classe vetor com os

elementos {1, 2, 3, 4, 5, 6, 7, 8, 9 e 10}. A deve ser declarado no programa prin-
cipal (ou em algum subprograma) da seguinte forma:

Vetor A;

Em seguida, algum método de atribuição deve existir para trocar os valores

iniciais do vetor (vamos supor que o construtor inicialize tudo com 0) para a se-
quência 1, 2, 3...

for (i=0;i<10;i++)
A.atribui(i,i+1);

Assim, a posição 0 do vetor (lembre-se que os índices iniciam em zero) re-

ceberá o valor 1, a posição 1 o valor 2 e assim por diante.

Agora, vamos supor que alguém deseje transformar a sequência {1, 2, 3,...,10}
58 em {2, 3, 4,...,11} por meio da chamada do método adiciona:
 A.adiciona(1);

Tal método deverá adicionar o valor 1 a cada elemento do vetor.

Mas alguém poderia ter criado um objeto B e, em um determinado momento do

código, desejasse fazer com que C = A + B. Para tanto, deveria fazer o seguinte:

C.zera();
C.adiciona(A);
C.adiciona(B);
C.imprime();

Supondo B = {_1, _2, _3,..., _10} o resultado apresentado pelo método im-
prime para o objeto C seria:

{0,0,0,0,0,0,0,0,0,0,0}

Note que o método adiciona, nesse caso, passa um vetor e não um único
número. Os nomes são iguais, mas as operações não! Ah, e o programa saberá
qual método chamar apenas pela assinatura!

4.4 Sobrecarga de operadores

Muito interessante (e legal) é poder declarar 3 matrizes A, B e C e fazer a

seguinte operação:

C = A + B;

Isso significa que a linguagem C++ permite que alguns operadores possam
ter sua funcionalidade estendida para outros tipos de dados. E com a “inteligên-
cia” embutida na linguagem, é possível fazer a seguinte operação:

C = A + 1;

Sim, é possível misturar tipos! É um pouco mais complicado, mas nada

do outro mundo. Nesses casos um cuidado extra deve ser tomado: C = A + 1;
e C = 1 + A; são coisas diferentes que devem ter o mesmo comportamento!

Vamos ver como fazer a soma de dois vetores (com o operador +) em C++.
A declaração de operador de adição em C++ tem a seguinte sintaxe:
59
 Tipo_retorno operator+ (parâmetros);

1. Vetor Vetor::adicao(vetor x)
2. {
3. vetor z;
4. int i;
5. for (i=0;i<x.tam;i++)
6. z.elemento[i] = elemento[i] + x.elemento[i];
7. z.tam = tam;
8. return z;
9. }

O tipo de retorno de um operador deverá ser definido pelo programador,

assim como os parâmetros. Antes de prosseguir com as explicações da sintaxe,
é preciso explicar o funcionamento dos operadores. Um operador funciona de for-
ma semelhante a um método. No código anterior, a linha 1 indica que um objeto
do tipo vetor será retornado pela função adicao (sem acentuação), que o método
se chama adicao, que pertence à classe vetor e que um parâmetro do tipo vetor
(x) é passado para esse método.

Pelo código, é possível deduzir que tam é um atributo de vetor (provavel-

mente armazena o número de elementos do vetor) e elemento é outro atributo
(que armazena cada valor do vetor). Assim, o que se deseja é que os elementos
de z sejam a soma dos elementos do vetor atual com os elementos do vetor x.
Sim, tem um tal de vetor atual!

O que acontece é que quando uma chamada de método é feita, ela é feita
por um objeto. Provavelmente, em algum lugar do código (que pode ser no pro-
grama principal, por exemplo), haveria, em nosso exemplo, a seguinte linha de
comando:

a.atribui(b.adicao(c));

Ou seja, b (o vetor atual) aciona o método adicao passando o objeto c como

parâmetro (que no método tem o nome trocado para x). Os atributos de b (tanto
tam como elemento) são acessados sem problemas. Na operação de adição, um
objeto temporário z é criado dentro do método para armazenar a soma do objeto
atual (agora você entendeu, não?) com o objeto passado por parâmetro. Quem
acionou o método? A resposta é b! O resto do código é simples. Todos os elemen-
tos de z são a soma dos respectivos elementos do objeto atual com os elementos
de x.
60
 Não se deve esquecer de atribuir o valor de tam ao objeto z!

E como a mágica acontece quando o operador entra no lugar do método?

Funciona como se fosse o método adicao, mas com nome diferente:

a.operator=(b.operator+(c));

O operador de atribuição é invocado pelo objeto a e o operador de adição é

invocado pelo objeto b. A sintaxe fica transparente para o programador:

a = b + c;

Bom, temos a atribuição! Ela tem algumas explicações extras! Existem duas
coisas novas: & (na primeira linha) e o return *this (antes do fecha chaves).

Vetor & Vetor::operator=(vetor x) {

int i;
for (i=0;i<x.tam;i++)
elemento[i] = x.elemento[i];
tam = x.tam;
return *this;
}

O & significa que o método retornará uma referência do próprio objeto que
chamou. Isso permite alterar o valor atual do objeto. Você deve ter muito cuidado
com o uso de referências. Sempre que houver TIPO & na declaração significa
que haverá o retorno de uma referência para um objeto do tipo TIPO. E sempre que
você fizer uma declaração de um tipo dentro de um método (como o objeto z do
método de adição), ele automaticamente desaparecerá após o fim do método.
Seu escopo (sua vida) terminará após o encerramento do método. Assim, você
não poderá utilizar TIPO & e fazer o retorno de um objeto z criado dentro de um
método. Claro?!

Bom, o *this significa que o código está retornando o objeto atual. Se você
quer atualizar o valor do elemento que está invocando o método de atribuição,
então deve utilizar & e *this.

Um fato importante é que o método é acionado por um objeto que está à sua
esquerda. E isso causa algum problema quando fazemos a seguinte operação:

a = 1 + b;
61
 Quem aciona o método de adição? Não pode ser o número 1, pois os inteiros
trabalham com tipos pré-definidos e o vetor que estamos trabalhando não era
conhecido dos inteiros até agora!

Existe um truque aqui! Você pode utilizar a declaração friend. Friend indica
amizade e permite que um objeto acesse os dados de outro. Se dentro da classe
vetor houver uma declaração explícita de que um método X externo à classe é
friend dela, então X poderá acessar os dados daquela classe.

Exemplo:

classe vetor {
friend vetor operator+(int, vetor);
… // demais declarações da classe
};

Nesse caso, operator+ é friend da classe vetor. A chamada do operador

seria da seguinte forma:

a = operator+(1,b);

Sim, o número 1 e o objeto b são passados por parâmetro. Note que, nesse
caso, não há um objeto que invoca o método (porque ele não pertence a nenhu-
ma classe!).

O método em questão seria definido fora da classe:

vetor operator+(int x, vetor z) {

vetor k;
int i;
k.tam = z.tam;
for (i=0;i<k.tam;i++)
k.elemento[i] = 1 + z.elemento[i];
return k;
}

É claro que poderia ter sido bem mais simples:

vetor operator+(int x, vetor z)

{
return (z+1);
62 }
 Não entendeu? Se você já definiu um operador de adição para ser acionado
sempre que o objeto pertencente à classe estiver à esquerda do operador, en-
tão quando ele estiver à direita acionará o operador externo à classe (aquele do
friend), que acionará o operador da classe (apenas trocando a ordem de chama-
da). Simples, não?

Aproveitando a deixa do friend, se for desejável utilizar os operadores de

entrada e saída (>> e <<) para fazer a leitura ou impressão de dados de sua nova
classe, então será preciso defini-los como “amigos” da classe:

class vetor {
friend ostream &operator<< (ostream &, vetor);
friend istream &operator>>(istream &, vetor &);
…
};

Nesse caso, a classe vetor está declarando amizade à classe ostream e à

classe istream, deixando que elas acessem os dados de vetor de forma a ler ou
escrever informações. Os símbolos & são necessários para que operações no
formato a seguir sejam possíveis:

cin >> a >> b >> c; // leitura de 3 vetores

ou

cout << a << b << c; // impressão de 3 vetores

Friend pode ser utilizado para declaração de amizade de uma classe a um

método/função ou a outra classe.

Voltando à questão da sobrecarga de operadores, os operadores apresen-

tados no quadro a seguir podem ser sobrecarregados em C++.

Quadro 1 Operadores que podem ser sobrecarregados.

+ - * / % ^ & |
~ ! = < > += -= *=
/= %= ^= &= |= << >> >>=
<<= == != <= >= && || ++
-- ->* , -> [] () new Delete

63
 Ainda existem dois operadores (pré e o pós incremento) que precisam ser
explicados. O pré-incremento ocorre quando fazemos a operação ++x. Já o pós-
incremento ocorre quando o operador aparece após o objeto. Assim, poderíamos
ter os valores internos de nosso objeto vetor sendo atualizados tanto por um
como por outro operador. A tarefa do pré-incremento é atualizar o objeto antes
de utilizá-lo, enquanto a tarefa do pós-incremento é exatamente oposta a esta, ou
seja, utilizá-lo antes de incrementá-lo. Para simplificar, vamos supor que estejamos
trabalhando com inteiros (vamos voltar aos objetos em breve), e que o valor de
x seja 2. A linha de código z = x++ + 2; faz com que z seja 4 e que x se torne 3.
Se, entretanto, a linha de código fosse z = ++x + 2; o x também seria 3 após a
execução da linha, mas z seria 5!

Para reproduzir tal comportamento nas classes que criamos, precisaremos

de duas declarações:

vetor &operator++(); // pré-incremento

vetor operator++(int); // pós-incremento

O pré-incremento fornecerá uma referência ao valor (e, como não há

parâmetro sendo passado, espera-se que o retorno seja *this), enquanto o
pós-incremento retorna uma cópia do valor. O parâmetro passado é chamado
de fantasma. Acompanhe o código a seguir.

vetor & vetor::operator++(){

int i;
for (i=0;i<tam;i++) // poderia ser, também, i<thistam
elemento[i] = elemento[i]+1; //ou thiselemento[i]...
return *this;
}

Fácil? Todos os elementos do vetor são incrementados e o *this é retornado.

Agora vamos para o pós-incremento. Quem observar com atenção o código a se-
guir verá que existe um truque genial! O objeto é atualizado (as mudanças ocor-
rem no this), mas o valor retornado é uma cópia do antigo (que foi devidamente
armazenado em aux!). Assim, em uma operação envolvendo o pós-incremento, o
valor utilizado será o antigo (porque utilizará a resposta retornada pelo método),
mas na próxima oportunidade que o objeto for utilizado, ele já terá o valor novo!

64
 vetor vetor::operator++(int z) {
vetor aux = *this;
int i;
for (i=0;i<tam;i++) // poderia ser, também, i<thistam
elemento[i] = elemento[i]+1; // ou thiselemento[i]...
return aux;
}

4.5 Exemplos em Java

Em Java não há sobrecarga de operadores. Existem apenas sobrecargas

de métodos e de construtores. Assim como em C++, a sobrecarga de métodos
e de construtores acontece pela diferenciação da assinatura. No exemplo a se-
guir, será apresentada a classe caixote, com largura, altura e profundidade. Serão
criados 3 construtores para inicializar um objeto da classe: um sem parâmetros,
outro com um parâmetro e outro com três parâmetros.

class caixote {
// atributos
private double largura, altura, profundidade;
// construtor sem parâmetros
// cria um caixote padrão de tamanho 1
caixote( ) { largura = 1; altura = 1; profundidade = 1;}
// cria um caixote com tamanho L (se L for positivo)
caixote( double L) {
if (L > 0) largura = altura = profundidade = L;
else largura = altura = profundidade = 1;
}
// cria um caixote com dimensões L x A x P desde que
// cada uma das dimensões seja positiva
caixote(double L, double A, double P) {
if (L > 0) largura = L;
else largura = 1;
if (A > 0) altura = A;
else altura = 1;
if (P > 0)
profundidade = P;
else
profundidade = 1;
}
65
 // método de cálculo do volume do caixote
double volume( ) {
return largura * altura * profundidade;
}
}

O programa principal deve acionar cada construtor por meio do operador

new. Para se criar um objeto chamado c1 utilizando o construtor com 3 parâme-
tros, o comando seria:

caixote c1 = new caixote(5,6,7);

Note que isso é um pouco diferente do que acontece em C++. Em C++

teríamos os mesmos 3 construtores, mas o objeto c1 seria declarado assim:

caixote c1(5,6,7);

Um código exemplo do programa principal em Java que utiliza caixote seria

o apresentado a seguir.

class caixoteDemo {
public static void main(String args[]) {
caixote c1 = new caixote(5,10,15);
caixote c2 = new caixote( );
caixote c3 = new caixote(15);
double vol1, vol2, vol3;
vol1 = c1.volume();
...
System.out.println(“ vol 1 = “ + vol1);
}
}

4.6 Considerações finais

Nesta unidade foram apresentados os principais conceitos relacionados

com sobrecarga de construtores e de métodos. Alguns exemplos ilustraram como
seria a utilização de sobrecarga, tanto em C++ como em Java.

66
 Além disso, foi apresentada a sobrecarga de operadores, que torna o código
C++ mais legível e intuitivo. Com ele é possível que operações como A = B + C;
ocorram também para classes definidas pelo programador (tais como fração, nú-
mero complexo, coordenadas polares, matrizes, etc.). Tal facilidade não existe
em Java.

4.7 Estudos complementares

Alguns livros como os da série How to Program (DEITEL & DEITEL, 2009a,
2009b) abordam o assunto sobrecarga. Em Deitel & Deitel (2009a) há um capítulo
inteiramente dedicado à sobrecarga de operadores. Um comando pouco explorado
nesta unidade foi o friend, que é explorado com um pouco mais de detalhes em
Deitel & Deitel (2009a).

67
Unidade 5

Alocação dinâmica de memória

5.1 Primeiras palavras

Ponteiros e alocação dinâmica de memória são dois temas que, normalmen-

te, causam arrepios nos estudantes. Como são assuntos importantes, podemos
rever o que são ponteiros, como se comportam e qual a relação entre ponteiros e
alocação dinâmica de memória. Assim, nesta unidade, além de abordarmos aloca-
ção dinâmica de memória para classes, também faremos uma revisão de ponteiros,
passagem de parâmetros (por valor e por referência), ponteiro para funções e alo-
cação dinâmica de memória.

5.2 Problematizando o tema

Existem dois conceitos a serem revistos: ponteiros e alocação dinâmica de

memória. Vamos começar pela alocação dinâmica! Você já imaginou criar um
programa que calcule a média de uma classe com 50 alunos? Simples, não? E se
a classe tiver 200 alunos? Ah, é melhor fazer um programa que contemple uma
classe muito grande então, não é?! Mas um programa que contemple uma classe
com muitos alunos (vamos dizer 1.000 alunos) ainda pode ser inadequado para
quem tenha/tem uma classe especial com 1.001 alunos ou para quem tenha/tem
um computador com pouca capacidade de memória RAM. Se a instituição que
utilizará seu programa criou uma classe especial com 1.001 alunos, seu progra-
ma não lhe será útil. Se, por outro lado, a instituição é de pequeno porte e adquiriu
um computador usado com pouca capacidade de memória e suas classes são
com no máximo 20 alunos, seu programa está superdimensionado. Às vezes, o
superdimensionamento é tal que a execução de programas em computadores
com pouca capacidade de memória se torna inviável.

Sempre que você optar pela escolha de um tamanho fixo antes da execução
do programa, o compilador providenciará a alocação prévia da memória a ser
utilizada e isso não poderá ser modificado durante a execução de seu programa.
Isso se chama alocação estática de memória e se contrapõe ao conceito de
alocação dinâmica de memória.

A alocação dinâmica, por outro lado, permite que seu programa aguarde até
o momento da execução e consulte o usuário para saber qual a quantidade de me-
mória que deverá ser alocada para executar a tarefa. Como cada usuário fornecerá
uma resposta e como a decisão da quantidade de memória utilizada ficará adiada
para quando o usuário executar o programa, isso se chama alocação dinâmica de
memória. Percebe-se que com a alocação dinâmica de memória, o programa se
adequará à necessidade do usuário.

Ponteiros trabalham em sintonia com a alocação dinâmica de memória (afi-

71
nal de contas, apontam para uma área de memória), mas não só isso. Ponteiros
 podem apontar para uma área de dados já alocada (quer dinâmica, quer estatica-
mente) ou mesmo para uma área de código. Sim, ponteiros podem apontar para
uma função, por exemplo! Dessa forma, tornam-se coringas em programação e,
se bem empregados, são muito úteis.

Um dos empregos de ponteiros é na passagem de parâmetros para funções

e procedimentos.

5.3 Revisão

Os dados de um programa estão armazenados na memória primária (me-

mória RAM) do computador. Cada dado é referenciado por um endereço, por
exemplo, 0 x 3EFF34, 0 x 4AFE52 e assim por diante. Não é conveniente progra-
mar utilizando endereços. Além de dificultar a tarefa de criação do programa, este
se torna ilegível quando houver a necessidade de se fazer alguma alteração no
código. Assim, convencionou-se atribuir um nome significativo (por isso você não
deve utilizar xy34 como um nome de variável) para uma posição de memória que
armazenará um determinado valor. Por exemplo, uma variável salário pode arma-
zenar um valor decimal (com centavos) que signifique o salário de um funcionário.
Não devemos nos esquecer de que uma variável é uma posição de memória e,
portanto, tem um endereço. No mundo real, nos referimos às pessoas pelo nome:
o Joãozinho, a Mariazinha, etc. É claro que o Joãozinho tem um endereço, assim
como a Mariazinha, mas não falamos “a menina que mora na Rua São Paulo, no
número 1234 é bonita”. Falamos: “a Ana é bonita”. No ambiente de programação
utilizamos os nomes de variáveis para referenciar uma posição de memória. Ou
seja, utilizamos nomes no lugar de endereços.

Existem situações em que um objeto pode estar com uma pessoa em um

determinado momento e com outra em outro momento. Nesses casos é con-
veniente ter alguém responsável por nos indicar quem está com o objeto. Um
exemplo simples é o locutor de rádio acompanhando uma partida de futebol. Ele
é o responsável por nos informar quem é que está com a bola no exato instante.
Poderia ser o operador de uma câmera de TV acompanhando a mesma partida.
O operador “aponta” a câmera para a posição onde se encontra o jogador que
está com a bola. Se desejarmos saber quem está com a bola, perguntamos ao
locutor ou ao operador. A Figura 3 apresenta uma imagem aérea de um campo de
futebol com jogadores. Note que, sem um apontador, não é possível saber quem
está com a bola!

72
Figura 3 Representação aérea de um campo de futebol.

Não podemos nos esquecer de que o locutor e o operador também são

pessoas que têm nome e endereço!

Assim, um ponteiro é uma posição de memória que também tem um endereço

e que armazena um endereço de outra variável. Pelo fato de armazenar um ende-
reço, dizemos que ele “aponta” para um lugar (Figura 4).

Figura 4 Ponteiros em ação.

Se existem as áreas de dados reservadas para os inteiros, para os floats,

etc., existem as áreas reservadas para os ponteiros para inteiros, ponteiros para
floats, entre outros. Poderíamos imaginar tais áreas como vilas. Existe a vila dos
inteiros, a vila dos floats, a vila dos doubles e também a vila dos ponteiros para
inteiros, ponteiros para floats, ponteiros para char, etc. Em C, uma declaração
de ponteiro para inteiro é feita da seguinte forma: int *p;

Como o endereço de uma variável é obtido por meio do operador &, em C

podemos indicar que um ponteiro aponta para o local onde a variável está, a partir
da expressão a seguir.

p = &x; /* x é uma variável do tipo inteiro */

Assim, vamos ilustrar os conhecimentos adquiridos até aqui apenas com

as variáveis p e x. Suponhamos que p esteja no endereço 0 x 0205FF e que x 73
 esteja no endereço 0 x 45AD3E. Quando fazemos uma operação de atribuição
(como x = 4), na verdade estamos colocando o valor 4 na posição 0 x 45AD3E.
A operação p = &x indica que a variável p (que é um ponteiro e, portanto, ar-
mazena um endereço) terá o valor 0 x 45AD3E armazenado. Ou seja, a posição
de memória 0 x 0205FF guarda o valor 0 x 45AD3E. Se fizermos a operação *p
= 5, na verdade estamos modificando o valor da variável x, porque estamos
colocando no endereço dela um novo valor. Se houvesse outra variável inteira
y e se o computador tivesse que executar o comando p = &y, isso significaria que
qualquer operação de atribuição envolvendo o ponteiro p não mais atingiria x (so-
mente atingiria y).

O endereço de p continuaria sendo o mesmo! O que mudaria seria o valor

guardado em p. Ah, e se houvéssemos feito a operação p++, isso significaria
que p apontaria para a próxima variável inteira vizinha de y. Utilizando a Figura 4
como elemento de apoio, a operação p++ faria com que a seta apontasse para o
minirretângulo imediatamente à direita da posição atual.

E para saber quem está com a bola agora? Pergunte ao operador da câmera,
ou seja, utilize o operador *:

z = *p; /* z é uma variável do tipo inteiro */

Como p armazena o endereço de uma variável, não podemos fazer a atribui-

ção z = p! Isso faria com que um endereço fosse armazenado em um local onde só
inteiros são aceitos (assumindo que z é do tipo inteiro). E se você fizesse z = &p,
isso faria com que o endereço da variável p (do ponteiro) fosse atribuído à variável
z (também incorreto). O operador *, quando associado a um ponteiro, permite recu-
perar o valor armazenado no endereço para o qual ele aponta. Seria o equivalente
a saber o nome da pessoa que está com a bola nesse exato momento!

Em C, podemos utilizar ponteiros para apontar para uma variável única, para
um vetor, para uma matriz bidimensional, etc. Uma aplicação simples seria criar um
programa (ou função) para informar se uma cadeia de caracteres é palíndroma ou
não. Algo é palíndroma se a leitura feita da direita para a esquerda for igual à leitura
feita da esquerda para a direita. “ELE” é uma cadeia de caracteres que satisfaz tal
propriedade.

Vamos construir a solução para o problema do palíndromo utilizando fun-

ção e ponteiros. A primeira coisa que notamos é que a cadeia de caracteres é
passada como ponteiro. Na verdade, uma cadeia de caracteres é definida como
um ponteiro para a posição inicial e terminada com um símbolo especial (‘\0’).
Quando passamos a cadeia de caracteres para a função, na verdade estamos

74 passando o endereço inicial da cadeia.

 int palíndromo(char *cadeia) {
/* declaração das variáveis locais */
char *inicio, *fim; /* ponteiros */
/* tamanho da cadeia de caracteres */
int tam;
/* strlen fornece o tamanho de cadeia */
tam = strlen(cadeia);
/* aponta para a primeira posição de cadeia */
inicio = &cadeia[0];
/* última posição antes do \0 */
fim = &cadeia[tam-1];
while (inicio < fim && *inicio == *fim) {
inicio++;
fim--;
}
if (inicio >= fim)
return 1;
else
return 0;
}

Os ponteiros inicio e fim apontam para a primeira e para a última posição

da cadeia de caracteres, respectivamente. Atenção especial neste momento, pois
o final real da cadeia de caracteres (‘\0’) não nos interessa no contexto do pa-
líndromo. O que nos interessa é o último caractere da cadeia. O \0 é apenas um
símbolo especial da linguagem para controlar cadeias de caracteres!

O ponteiro inicio apontará para a primeira posição da cadeia assim que a

operação inicio = &cadeia[0] for executada. Tal operação indica que inicio armaze-
nará o endereço da primeira posição da cadeia passada para a função. O mesmo
raciocínio vale para a operação fim = &cadeia[tam-1].

Como a cadeia de caracteres é formada por posições consecutivas de me-

mória, o endereço inicial é menor que o endereço final. Seria equivalente a dizer
que em uma rua com casas numeradas em ordem crescente, alguém estivesse
apontando para a primeira casa da rua e outra pessoa estivesse apontando para
a última casa da rua. Como a numeração é crescente, sabe-se que a pessoa no
começo da rua apontará para um número (endereço) menor que o apontado pelo
colega no final da rua. Daí o significado da primeira parte da expressão lógica
(inicio < fim && *inicio == *fim). A segunda parte da expressão é referente ao
conteúdo apontado por cada ponteiro. Para ser palíndroma, a cadeia tem que ter
a primeira letra igual à última, a segunda igual à penúltima e assim por diante.
75
 Em nossa metáfora de rua, seria o equivalente a ter um morador na casa 1 com
o mesmo nome do morador da última casa e assim por diante.

Por fim, o código interno do loop significa ir para a posição seguinte no

caso do ponteiro inicio e para a posição anterior no caso do ponteiro fim. Se
mantivermos nossa metáfora da rua, seria o equivalente a fazer com que a pes-
soa no começo da rua desse um passo em direção à pessoa no final (inicio++)
da rua e esta, por sua vez, também desse um passo em direção à pessoa no
início da rua (fim_ _).

Se eles se cruzarem (inicio > fim), significa que a cadeia é palíndroma. Se

não se cruzarem, significa que o conteúdo de um ponteiro não equivalia ao
conteúdo de outro ponteiro!

Já que sabemos como ponteiros se comportam com variáveis definidas pre-

viamente à execução, podemos investigar, agora, seu comportamento quando se
utiliza alocação dinâmica de memória.

Em alocação dinâmica, o que se deseja é solicitar ao sistema que forneça

um endereço a partir do qual se possam armazenar informações. Vamos começar
com algo simples: uma variável.

A alocação é solicitada a partir do comando malloc (ou calloc). Se a solici-

tação for satisfeita, um endereço é retornado. Caso contrário, NULL é retornado.

p = (int *) malloc(sizeof(int));

Como a função malloc retorna um ponteiro genérico, é preciso realizar a

conversão do ponteiro para o tipo desejado. No exemplo, a conversão é feita para
inteiro. Como é ponteiro, é preciso ter o símbolo *. Malloc aloca uma quantidade
de posições de memória de um determinado tamanho. Assim, a função malloc
precisa ser informada do tamanho desejado de memória a ser alocada. No caso,
a intenção era utilizar uma posição para inteiro.

Se a solicitação não for atendida, então NULL será retornado. Assim, é

preciso verificar se obtivemos o que solicitamos:

if (p == NULL) {
printf(“Solicitação não atendida! \n“);
exit(1);
}

A partir daí a coisa é simples! Basta utilizar o ponteiro da mesma forma que
76 foi utilizado anteriormente. É importante observar que quando uma alocação de
memória é feita, um espaço da área de dados é reservada para seu uso. De-
pois de utilizá-lo, você deve devolvê-lo ao dono para que, caso alguém deseje,
possa utilizá-lo. Se você só realizar solicitações de alocação e não fizer nenhuma
devolução será equivalente a um aluno que vai à biblioteca e só faz empréstimos
sem devolver. Os livros emprestados não estarão disponíveis para que outros pos-
sam utilizá-los. Em C a devolução é feita com o comando free. Lembre-se de
utilizá-lo!

...
int *x;
/* vetor com 10 posições */
x = (int *) malloc(10 * sizeof(int));
if (x != NULL)
{
for (i=0;i<10;i++)
x[i] = i;
... /* outras operações */
free(x); /* devolver a memória para o sistema */
x = NULL; /* por questões de segurança */
}
...

No exemplo, o ponteiro x recebe um endereço de memória que pode arma-

zenar 10 posições de inteiros. Assim, x passa a ser vetor. Se malloc não conse-
guir as 10 posições consecutivas que foram solicitadas, ele retornará NULL. O
exemplo é esquemático e mostra uma inicialização arbitrária de x (cada elemento
recebe um valor equilavente a sua posição no vetor). Várias outras operações
podem ser feitas com tal vetor e não foram apresentadas por questão de espaço.
Após a utilização, há a devolução do espaço solicitado a partir do comando free.
Ah, e se você estiver trabalhando com estruturas? O que acontece? Vamos, pri-
meiramente, declarar uma estrutura.

typedef struct data {

int dia, mes, ano;
} data;

77
 Utilizamos data por ser uma estrutura a ser explorada também em orienta-
ção a objetos e por servir como elemento de comparação. A estrutura em ques-
tão tem 3 elementos (dia, mês e ano). Se houvéssemos declarado uma variável
dia_independencia do tipo data, poderíamos fazer a atribuição do dia assim:

dia_independencia.dia = 7;

Mas, e se houvéssemos criado uma variável feriado como um ponteiro para

data (data *feriado;)? Nesse caso, seria necessário fazer uma alocação dinâmica
de memória (afinal, o que existe é um ponteiro para armazenar um endereço e
não um espaço para armazenar 3 valores!).

feriado = (data *) malloc(sizeof(data));

if (feriado != NULL)
{
/* trabalho com um elemento da estrutura */
feriado->dia = 7;
...
free(feriado); /* liberação de memória */
feriado = NULL; /* questões de segurança */
}

5.4 Alocação de atributos

Em algumas situações é interessante que o atributo seja alocado dinami-

camente. Geralmente isso ocorre com vetores e matrizes. Um atributo em C++
alocado dinamicamente deve ser declarado como ponteiro. Neste item será apre-
sentado o exemplo de uma fila de pessoas, que serão identificadas pelos três pri-
meiros dígitos do documento de identidade. A fila em questão não tem prioridade,
ou seja, um idoso ou gestante deve obedecer a ordem cronológica de entrada
para ser atendido.

Para inserir uma pessoa na fila deve-se utilizar o método inserir (int), em que
o parâmetro a ser passado é a identificação da pessoa. Se a fila já estiver cheia, o
método deverá retornar o valor booleano falso, que indicará que a pessoa não pôde
ser inserida na fila.

A retirada de uma pessoa da fila acontece com o uso do método retirar( ). O

método deve retornar a identificação da primeira pessoa da fila e também deve
promover sua reorganização. Ou seja, o segundo da fila deve ocupar a primeira
78
posição, o terceiro da fila deve ocupar a segunda posição e assim por diante. É
uma simulação do que acontece em filas reais.

5.5 Construtor de cópia

Toda vez que um método retorna à cópia de um objeto e toda vez que cria-
mos um objeto utilizando outro como exemplo (lembra-se do exemplo da ove-
lha?), o construtor de cópia entra em ação.

Assim, é fácil entender a missão do construtor de cópia: criar uma cópia do

objeto em questão.

Um construtor de cópia é fácil de ser identificado. Ele tem o mesmo nome

da classe, não retorna nenhum valor e tem como parâmetro uma referência para
um objeto da mesma classe. Ou seja, se a classe se chama X, então o construtor
de cópia seria:

X::X(X&) { ... }

O primeiro X indica o nome da classe, o segundo o nome do método (cons-

trutor) e o terceiro é uma referência a um objeto da classe de mesmo nome. Deve
ser, obrigatoriamente, uma referência para a classe X, uma vez que se assim não
o fosse, configurar-se-ia em chamada por cópia. E uma chamada com parâmetro
passado por cópia obrigaria a chamada do construtor de cópia. Mas se o cons-
trutor de cópia fizesse uma chamada por cópia isso não teria fim nunca. Seria um
loop infinito.

Um construtor de cópia normalmente não chama a atenção, visto que não

aparece em muitos códigos. O fato é que se um construtor de cópia não for criado
pelo programador, ele será fornecido automática e gratuitamente pelo compila-
dor. Sim, o compilador criará um construtor de cópia para você sempre que for
necessário.

Um leitor mais curioso fará a seguinte pergunta: “mas se o compilador cria

um construtor de cópia para mim, então qual o grande problema?” Por que este
item 5.5?

Para melhor compreensão, vamos apresentar um exemplo de construtor

de cópia.

79
 class vetor {
private:
int elementos[10];
int total;
public:
vetor( ); // construtor sem parâmetros
vetor(vetor &); // construtor de cópia
...
};

O vetor em questão armazena um conjunto de valores no conjunto ele-

mentos e também controla o total de valores armazenados. Ou seja, se o total
for igual a 10, sabe-se, com certeza, que não é possível colocar mais informa-
ções no vetor. Pode-se convencionar o vetor como tendo valores positivos. Nes-
se caso, o construtor poderia inicializá-lo com um valor negativo, por exemplo.
Assim, compreendemos como ficaria o construtor: teria um loop para inicializar
todos os elementos do vetor e também teria a atribuição total = 0; como de-
monstrado no exemplo a seguir.

vetor::vetor( ) {
int i;
for (i=0;i<10;i++)
elementos[i] = -1;
total = 0;
}

E o construtor de cópia, como seria? Deve fazer a cópia dos elementos

passados por referência. Ou seja, todos os elementos de x são copiados. E se
o código não for criado, o compilador gerará um código exatamente igual para
seu programa.

vetor::vetor(vetor &x) {
int i;
for (i=0;i<10; i++)
elementos[i] = x.elementos[i];
total = x.total;
}

Mas e se o vetor fosse criado com alocação dinâmica? Vamos entender o

que o construtor padrão (oferecido pelo compilador) faria em tal situação.
80
 Com alocação estática, o construtor padrão simplesmente copia tudo para
um novo objeto, conforme a Figura 5:

Figura 5 Esquema de cópia de um construtor de cópia padrão.

Mas, e se a classe contiver um ponteiro? Em tal situação, o compilador fará

o que sempre fez, ou seja, copiar o conteúdo do velho para o novo. Mas isso não
é exatamente o que queremos! Copiar o conteúdo do ponteiro significa copiar o
endereço para o local que ele aponta. Ou seja, vai apontar para o mesmo local
que o original. O mais grave é que se o objeto original for destruído, o vetor origi-
nal também será destruído! E para onde apontará a cópia?

Figura 6 Cópia rasa.

No exemplo da Figura 6, os dados da classe original são copiados para a

classe cópia, inclusive o ponteiro. Como ele aponta para um endereço X de me-
mória, a cópia também apontará para aquele endereço. Se a classe original for
destruída, o vetor também será. Mas a cópia continuará apontando para aquele
local (que não está mais disponível). O desejável é uma cópia profunda, ou seja,
81
uma cópia que cria um novo vetor.
 Figura 7 Cópia profunda.

A eliminação tanto do original como da cópia não traria problemas para o

código.
Do ponto de vista de código, significa fazer uma alocação dinâmica dentro
do construtor de cópia, para que seja criado um novo vetor. Na figura anterior é
possível ver uma classe cópia que contém um ponteiro (assim como a classe ori-
ginal), mas que aponta para outro endereço de memória. Os dados armazenados
no vetor original são copiados para o novo vetor alocado. Se a classe original for
destruída, a cópia não será afetada.

vetor::vetor(vetor &x) {
int i;
elementos = new int [10]; // alocação do novo vetor
for (i=0;i<10; i++)
elementos[i] = x.elementos[i];
total = x.total;
}

Assim, o novo construtor de cópia vai ter uma cópia de todos os elementos
do vetor original, mas não terá a fragilidade de apontar para o mesmo local do
original.

5.6 Alocação de objetos

Na discussão sobre construtor de cópia foi apresentado um exemplo de

alocação dinâmica de um atributo pertencente à classe (para construção de um
vetor). Mas a alocação pode ocorrer na declaração do objeto. Imagine que exista
82 um ponteiro *C da classe circulo. Sua declaração seria:
 circulo *C;

Ou seja, *C é um ponteiro para um elemento da classe circulo. Para poder

utilizá-lo, é preciso fazer a alocação dinâmica do ponteiro *C. Para criar um único
objeto da classe circulo utilizando *C, deve-se utilizar o seguinte comando:

*C = new circulo;

Se a alocação foi bem-sucedida (havia espaço em memória para a alocação),

então, a partir desse momento, C++ pode armazenar as informações da classe.
Há um pequeno detalhe: os métodos de C++ só poderão ser acessados pelo
operador  (o mesmo ocorre quando trabalhamos com struct e ponteiro!). E uma
vez que ocorreu a alocação, será preciso devolver a memória alocada ao final de
sua utilização. Ou seja, será preciso utilizar o delete!

Ah, se a alocação não foi bem-sucedida, então será preciso terminar a

execução do código e informar o usuário a respeito do erro encontrado.

5.7 Exemplo em C++

Como exemplo, vamos utilizar a classe fila. Queremos ter uma fila de ele-
mentos (vamos utilizar letras) que tenha um tamanho máximo definido pelo
programador. Se ele não definir nada, então será criada uma fila padrão de
tamanho 10. Na fila, o procedimento é atender aquele que está em primeiro
lugar. Quando o primeiro da fila for atendido, todos os outros devem mudar de
posição. Ou seja, quem estava em segundo passa a ficar em primeiro, quem
estava em terceiro passa para segundo e assim por diante. Resumindo, o fun-
cionamento é igual ao de uma fila de padaria. A seguir serão apresentados os
principais trechos do código C++.

class fila {
private:
    char *elemento;
    int tammax, tam_atual;
public:
    fila();
    fila(int);
    ~fila();
    bool insere(char);
83
     char retira();
    void imprime();
};

No exemplo anterior, encontra-se a definição da classe com o ponteiro

para os elementos do vetor (chamado elemento), além dos atributos tammax e
tam_atual (que controlam o tamanho máximo e o tamanho atual), bem como os
métodos insere, retira e imprime. Também estão presentes os construtores (com
e sem parâmetro e o destrutor). O método insere deve ter um character como
parâmetro (o elemento que será inserido) e deve retornar um valor lógico (bool)
caso a operação seja bem-sucedida e o método retira deve apenas retornar o
elemento que foi retirado da fila. Deve haver alguma convenção para que um valor
seja retornado caso a fila esteja vazia.

fila::fila()
{
cout << “ construtor sem parâmetro“ << endl;
elemento = new char[10];
if (elemento != NULL) {
tammax=10;
tam_atual=0;
} else
exit (1);
}

O código do construtor sem parâmetros é bem simples. Há a solicitação de

memória (new) com o tamanho indicado (10) e o tipo (char). O resultado da alo-
cação é retornado para o ponteiro elemento. Se não for NULL, então a operação
terá sido bem-sucedida e os atributos tammax e tam_atual podem ser atualiza-
dos. Tammax indicará o tamanho máximo da fila e tam_atual indicará quantos
elementos estão na fila (no momento da criação a fila está vazia).

O construtor com parâmetro é muito parecido, mas um detalhe deve ser

levado em consideração: o tamanho (que será passado por parâmetro) deve
ser testado. Caso contrário, alguém poderá solicitar um vetor de tamanho nega-
tivo e isso causará problemas para o programa. Tente fazê-lo.

O destrutor também é bem simples. A tarefa dele é devolver (por meio do

comando delete) o que foi emprestado. É boa prática apontar o ponteiro que não
está mais sendo utilizado para 0.

84
 fila::~fila()
{
    cout << “destrutor“ << endl;
    delete [] elemento;
    elemento = 0;
}

O método insere deve receber um caractere e colocá-lo na fila (caso a fila

ainda não esteja cheia e caso o elemento a ser inserido seja um elemento alfa-
numérico). Ele deve entrar na última posição vaga, caso a fila ainda não esteja
cheia. A verificação de fila cheia é feita na condição tam_atual < tammax. Se
tam_atual ainda não atingiu o tamanho máximo (tammax), então ainda é possível
inserir elementos no vetor. E caso seja possível inserir, deve-se sempre lembrar
que é preciso atualizar o tamanho atual do vetor.

bool fila::insere(char a)
{
if (isalpha(a) && tam_atual < tammax)
{
elemento[tam_atual++] = a;
return true;
}
else
return false;
}

O método retira deve retornar o valor que está sendo retirado da fila para quem
fez a chamada do método. Muitos confundem o conceito e acreditam que imprimir
o número retirado da fila já seja a solução. Não é! O valor deve ser devolvido e não
impresso. O valor impresso seria útil para o usuário que estivesse acompanhando
a execução do programa (caso a impressão fizesse algum sentido). Números sal-
tando na tela não fazem sentido. O valor retornado é útil para o programador, que
poderá utilizar o elemento retirado da fila para fazer testes, etc.

Outra questão importante na retirada de um elemento da fila é que todos os

elementos que permaneceram na fila devem mudar de posição. A retirada do ele-
mento implicará, ainda, na atualização do tamanho da fila.

char fila::retira()
{
int i; 85
 char letra;
if (tam_atual > 0)
{
letra = elemento[0];
for (i=0;i<tam_atual;i++)
elemento[i] = elemento[i+1];
tam_atual--;
return letra;
}
else
return ‘0’;
}

O método imprime é responsável por imprimir a fila. Se ela estiver vazia, não
imprime nada (só muda de linha).

void fila::imprime()
{
int i;
for (i=0;i<tam_atual;i++)
cout << elemento[i] << “ “;
cout << endl;
}

Falta demonstrar como a classe pode ser utilizada no programa principal.

Vamos criar uma fila de padaria com 15 elementos e oferecer ao usuário um
menu de opções para as tarefas a serem realizadas pela fila.

int main(int argc, char** argv) {

    int i;
char letra, vez, opção;
    fila padaria(15);
    { // abre novo escopo
        fila estadio_futebol;
    } // fecha escopo – aciona destrutor da fila
// exibir menu e ler opção do usuário
    cout << “i. inserir um elemento na fila“ << endl;
    cout << “r. retirar um elemento da fila“ << endl;
    cout << “p. imprimir a fila“ << endl;
86
     cout << “s. sair“ << endl;
    cout << “Entre com uma das opções do menu!“ << endl;
    cin >> opcao;
    while (opcao != ‘s’)
    {
        if (opcao == ‘i’)  {
            cout << “Entre com uma letra“;
            cin >> letra;
            if (padaria.insere(letra))
              cout << “inseriu !“ << endl;
            else
              cout << “falha na inserção! “ << endl;
        }
        if (opcao == ‘p‘)
          padaria.imprime();
        if (opcao == ‘r‘)  {
            vez = padaria.retira();
            if (vez != ‘0‘)
              cout << “agora é a vez do “ << vez << endl;
            else
              cout << “não tem ninguém na fila! “ << endl;
        }
// exibir menu e ler opção do usuário
...
}

O leitor atento observará logo no começo do código do programa principal

que há uma declaração de fila (estádio_futebol) que está entre parênteses. Na
verdade serve para provar que o destrutor é acionado automaticamente quando o
fim do escopo de um objeto é encontrado. O abrir chaves indica início de um novo
escopo e o fechar chaves indica o final de tal escopo. Assim, quando o programa
for executado, ele apresentará a mensagem “destrutor” no início do programa
e será referente à fila estádio_futebol. Uma confusão que os estudantes fazem
é com relação ao acionamento do destrutor. Muitos acham que ele é acionado
automaticamente quando o programa termina. O código apresentado é para
esclarecer tal dúvida.

Também é importante observar que as duas filas terão tamanhos diferentes.

Aquela declarada com parâmetro terá o tamanho informado (15), enquanto a
outra terá o tamanho padrão (10).

87
 5.8 Considerações finais

Gerenciamento dinâmico de memória é um assunto muito importante para

os programadores em C++. O gerenciamento dinâmico de memória permite que o
programador crie programas flexíveis e que satisfaçam as condições do ambiente
do usuário. Se houver a necessidade de uma matriz enorme, então o programa
tentará fazer a alocação. Caso seja bem-sucedida, seu programa poderá realizar
as tarefas pertinentes. Após ter sido utilizada, a área de memória relativa à ma-
triz poderá ser devolvida ao sistema operacional para que outro programa possa
utilizá-la. Ah, é preciso entender também o que faz o construtor de cópia e em quais
situações é preciso criar o próprio código do construtor de cópia para transformá-lo
em cópia profunda.

88
Unidade 6

Composição e herança
6.1 Primeiras palavras

Tanto composição como herança são conceitos muito importantes em

orientação a objetos e estão completamente associados aos conceitos de reuti-
lização de software.

Apesar de a operação “copy & paste” ser muito utilizada, ela traz incon-
venientes, do ponto de vista da engenharia de software. A replicação do código
sem um adequado gerenciamento provocará efeitos colaterais sempre que hou-
ver uma manutenção no sistema.

Nesta unidade os dois conceitos serão explorados de forma detalhada e

alguns exemplos ilustrarão o uso de ambos.

6.2 Problematizando o tema

A indústria de hardware conseguiu atender o aumento da demanda por pro-

dutos por meio da criação de componentes com funcionalidades bem definidas,
que podem ser aproveitados em outros projetos. Assim, um conjunto de compo-
nentes eletrônicos pode ser interligado e encapsulado de modo que forme um
circuito eletrônico. Circuitos eletrônicos podem ser combinados de maneira a for-
mar uma placa de circuito eletrônico. A combinação de placas pode produzir um
aparelho eletrônico como um monitor de vídeo.

A indústria do software, por outro lado, deparou-se com o aumento da

demanda de sistemas, o aumento da complexidade destes e a baixa qualidade
dos produtos por ela produzidos. Precisou reinventar-se. O paradigma de orien-
tação a objetos permitiu que algo similar ao encapsulamento de componentes
eletrônicos e seu reuso, praticado pela indústria do hardware, fosse replicado
para a indústria do software.

6.3 Composição

No mundo real, um objeto é composto por outros. Uma porta é composta por
maçaneta, fechadura, madeira (se for porta de madeira), etc. A própria fechadura
é composta por diversos outros componentes. Um monitor de vídeo é composto
por placas de circuito integrado, botões (de ligar/desligar, contraste, brilho, etc.),
tela, etc. Enfim, o mundo real contém objetos que são obtidos por meio da com-
binação com outros objetos. Quando dizemos que um carro tem uma direção,
estamos indicando que “direção” faz parte de “carro”; quando um empregado tem
uma data de admissão, estamos indicando que a data de admissão faz parte da
classe “empregado”. 91
 A relação tem-um é uma relação importante em orientação a objetos, pois
permite que o processo de criação de uma classe mais complexa seja feito de
forma similar a um jogo Lego.

6.4 Herança

Do ponto de vista biológico, herança é a transmissão de características co-

dificadas nos genes para outros indivíduos da mesma espécie, por meio de um
mecanismo chamado reprodução. Assim, a criação de um novo indivíduo é feita
segundo um modelo existente. O que ocorre é um reaproveitamento de um có-
digo genético já existente.

O paradigma de orientação a objetos inspirou-se também no conceito de

herança. Se há um código que define uma classe X e há outra classe Y que utiliza
a classe X como exemplo, então, segundo o conceito de herança, o código da
classe X pode ser reaproveitado. No exemplo, a classe X serve como base para
a criação da classe Y. A classe Y é derivada da classe X, assim como queijo,
requeijão e iogurte seriam derivados de leite. Alguns outros exemplos podem dei-
xar o conceito de herança mais claro. O primeiro exemplo seria a classe veículo.
A definição de veículo é “um meio de transporte qualquer”. Ou seja, tudo aquilo
capaz de mover algo de um lugar para outro é considerado veículo. O rádio, a TV
e o jornal são, então, veículos de comunicação. O skate, o patinete, o carro, a
lancha, o navio, o helicóptero e o foguete são veículos de transporte de pessoas.
Uma relação muito clara que emerge dessa relação é a relação é-um. Um carro
é um veículo. Portanto, veículo é uma classe mais geral, que permite diferenciar
objetos que transportam algo de outros objetos que servem para enfeitar ambien-
tes, por exemplo. Estamos falando de categorias. Quando vamos definir um carro
ou um skate podemos emprestar o conceito de veículo já consolidado, e a relação
é um é válida. Isso nos faz entender as vantagens da utilização de herança pela
indústria de software.

Figura 8 Algumas categorias que compartilham o conceito veículo.

Na verdade, podemos criar uma hierarquia de classes. Poderíamos subdividir

veículos em veículos de comunicação e veículos de transporte de pessoas e/ou
92 cargas. Veículos de transporte de pessoas e/ou cargas poderiam ser terrestres,
aquáticos e aéreos. Veículos terrestres poderiam ser sem rodas ou com rodas. Veí-
culos com rodas poderiam ser os de 4 rodas, 3 rodas, 2 rodas ou mesmo os de uma
roda. O fato é que a relação é-um se mantém. Um carro de 4 rodas é um veículo.
Um carro de 4 rodas é um veículo terrestre de rodas. É importante observar que
a relação é-um pode ser direta (como no caso filho-pai) ou indireta (como no caso
neto-avô ou bisneto-bisavô). Na herança direta não existe uma classe intermediá-
ria. Na indireta há pelo menos uma classe entre as duas relacionadas.
A herança pode ser simples ou múltipla. Na herança simples apenas uma
classe é considerada para efeitos de transmissão de características. Na herança
múltipla mais de uma classe é considerada. No exemplo do veículo, poderíamos
definir um veículo anfíbio, que tem características de veículo aquático e também de
veículo terrestre.

Figura 9 Hierarquia de classes.

Outro conceito importante associado com herança é o de sobreposição de

método. Sobreposição (ou anulação) é diferente de sobrecarga. Quando dois mé-
todos têm o mesmo nome, mas assinaturas diferentes, dizemos que há sobrecar-
ga de método. Quando um método com mesmo nome e mesma assinatura está
presente, tanto na classe base como na classe derivada, o método da classe
derivada esconde o método da classe base, ou seja, sobrepõe-se ao método da
classe base. A chamada do método por um objeto da classe derivada sempre
acionará o método presente na classe derivada.

A seguir serão apresentados exemplos práticos nas linguagens C++ e Java

para consolidar os conceitos e demonstrar suas utilizações práticas.

6.5 Exemplo em Java

Java trabalha apenas com herança simples. Assim, vamos apresentar um

exemplo em Java de herança simples em dois níveis. Vamos, primeiramente,
apresentar a classe PONTO, que deve ter como atributos as coordenadas x
e y. Também é importante que existam as funções de acesso aos atributos, 93
 chamadas de funções set e get. As funções set servem para alterar os valores,
enquanto as funções get servem para recuperar os valores armazenados.

public class PONTO {

private int x, y;
public PONTO(int a, int b) { x = a; y = b;}
public void setx(int a) { x = a;}
public void sety(int a) { y = a;}
public int getx(){return x;}
public int gety(){return y;}
public void imprimir(){
System.out.println(“ x = “+ x+ “ y = “+ y);
}
}

A criação da classe circulo pode ser feita levando-se em conta a existência

da classe ponto.

public class circulo extends PONTO {

private double raio;
public circulo (int a, int b, double c) {
super(a,b);
raio = c;
}
public double getRaio() {
return raio;
}
@Override public void imprimir(){
super.imprimir();
System.out.println(“raio = “+getRaio());
}
public double getArea() {
return 3.141592*getRaio()*getRaio();
}
public double getPerimetro() {
return 2*3.141592*getRaio();
}
}

94
 Podemos dizer que circulo é um ponto com um raio. A classe circulo indica
que está herdando características da classe ponto por meio da declaração extends.
Dessa forma, os atributos x e y também fazem parte da classe circulo, assim
como os métodos set e get daquela classe.

Os membros private da classe PONTO não podem ser acessados direta-

mente pela classe circulo. Dessa forma, x e y são obtidos ou alterados apenas
por meio das funções de acesso get e set, respectivamente.

O construtor da classe circulo recebe 3 parâmetros, sendo dois deles refe-

rentes a PONTO. Assim, o construtor da classe circulo deve acionar – por intermé-
dio da chamada de super – o construtor da classe PONTO. A classe PONTO é a
classe base, também chamada superclasse. Por isso o nome super. A classe base
deve ser acionada e finalizada antes da classe derivada. Em uma analogia com
a construção civil, a classe base seria equivalente ao alicerce de uma obra e a
classe derivada, as paredes. Não se pode construir as paredes sem o alicerce. A
chamada da classe base acontece, como informado, por meio do comando super.
Os parâmetros a e b recebidos pelo construtor de circulo são passados para o
construtor PONTO a partir da chamada super(a,b). Uma das funções de super
está, então, decifrada. Outra função de super é acessar um método da classe
base, o que é demonstrado no método imprimir. Lá, o método imprimir de PONTO
é acionado e em seguida o raio é impresso. Isso evita que tenhamos que reescrever
o código da impressão de ponto. Isso é especialmente importante se a impressão
de ponto obedecer a um formato preestabelecido.

Deve-se observar que em uma classe derivada o comando super deve ser
sempre o primeiro a ser executado. Se isso não acontecer, o construtor default da
classe base será acionado automaticamente. É importante que ele exista.

Em Java existe uma anotação (@Override) que permite que programadores

assinalem a intenção de sobrescrever em uma classe derivada um método da
classe base. Alguns compiladores utilizam tal anotação para alertar o programa-
dor quando uma alteração na assinatura de um método é efetuada e não repli-
cada nos métodos das classes relacionadas (base ou derivada). No código em
questão, o método imprimir da classe circulo está escondendo o método imprimir
da classe PONTO. Anotar no código que essa é a verdadeira intenção pode evi-
tar problemas futuros, no caso de uma mudança de nome, de tipo de retorno ou
mesmo de número de parâmetros em um dos métodos.

No programa principal, a classe circulo poderia ser utilizada da seguinte forma:

circulo c = new circulo(10,10,2);

c.imprimir(); 95
 Como mencionado, o método imprimir acionado é o da classe circulo. O mé-
todo imprimir da classe base está escondido. Na verdade, ele é acionado dentro
do método imprimir da classe circulo por meio da chamada super.imprimir().

Outra palavra-chave em Java que tem relação com herança é a palavra

FINAL. Ela pode ser usada tanto antes de nomes de métodos como antes de
nomes de classes. Se um método chamado X da classe base é precedido da pa-
lavra final, então tal método não poderá ser sobreposto na classe derivada.

Se uma classe é definida como final, então tal classe não poderá ser derivada.

6.6 Exemplo em C++

Outro exemplo interessante seria a classe pessoa e a classe professor.

Professor é uma pessoa. Assim, podemos criar a classe pessoa e depois criar
a classe professor utilizando a classe pessoa como base. A classe pessoa, na
verdade, poderá servir de base para a classe estudante também (pois estudan-
te é uma pessoa).

Uma pessoa tem nome, sobrenome e data de nascimento. Seria o conjunto

básico de informações, uma vez que uma criança pode não possuir RG e CPF.
Como vamos utilizar a data de nascimento, precisamos definir a classe data e
uma função para verificar o ano bissexto.

bool bissexto(int a) {
if (a % 4 == 0 && a % 100 != 0) return true;
else
if (a % 4 == 0 && a % 100 == 0 && a % 400 == 0)
return true;
else
return false;
}

class data {
private:
int dia, mes, ano;
public:
data();
data(int, int, int);
void setDia(int);
void setMes(int);

96
 void setAno(int);
int getDia();
int getMes();
int getAno();
void imprime();
};
data::data() {
dia = 1;
mes = 1;
ano = 2010;
}
data::data(int d, int m, int a) {
if (a > 1900 && a < 2011)
ano = a;
else
ano = 2010;
if (m >=1 && m <=12)
mes = m;
else
{
mes = 1;
if (d > 0 && d < 29)
dia = d;
else
if (d > 28 && d < 32)
{
dia = 30;
if (d == 29 && mes == 2 && bissexto(ano))
dia = d;
else
if (d == 31 && (mes == 1 || mes == 3 ||
mes == 5 || mes == 7 || mes == 8 ||
mes == 10 || mes == 12))
dia = d;
}
else
dia = 1;
}
}
void data::setAno(int a) {
if (a > 1900 && a < 2010) 97
 ano = a;
else
ano = 2010;
}
void data::setMes(int m) {
if (m < 13 && m > 0)
mes = m;
else
mes = 1;
}

void data::setDia(int d) {
int x;
if (d > 0 && d < 29)
dia = d;
else
if (d > 28 && d < 32)
{
dia = 30;
if (d == 29 && getMes() == 2 && bissexto(getAno()))
dia = d;
else
{
x = getMes();
if (d == 31 && (x == 1 || x == 3 || x == 5 || x == 7 ||
x == 8 || x == 10 || x == 12))
dia = d;
}
}
else
dia = 1;
}

int data::getAno() {
return ano;
}
int data::getMes() {
return mes;
}

98
 int data::getDia() {
return dia;
}
void data::imprime() {
cout << getDia() << “/“ << getMes() << “/“ << getAno() << endl;
}

Como informado, a classe pessoa utiliza a classe data (uma pessoa tem
uma data de nascimento), ou seja, uma composição.

class pessoa {
private:
char nome[20];
char sobrenome[20];
data nascimento;
public:
pessoa();
pessoa(char *, char*);
void setNome(char *);
void setSobrenome(char *);
char *getNome();
char *getSobrenome();
void imprime();
void setData(int, int, int);
};
pessoa::pessoa() {
strcpy(nome,“Ana“);
strcpy(sobrenome,“Silva“);
nascimento.setAno(2010);
nascimento.setDia(1);
nascimento.setMes(1);
}
pessoa::pessoa(char *n, char *s) {
strcpy(nome,n);
strcpy(sobrenome,s);
nascimento.setAno(2010);
nascimento.setDia(1);
nascimento.setMes(1);
}
void pessoa::setNome(char *x){
strcpy(nome,x); 99
}
 void pessoa::setSobrenome(char *x) {
strcpy(sobrenome,x);
}
char * pessoa::getNome() {
return nome;
}
char * pessoa::getSobrenome() {
return sobrenome;
}
void pessoa::imprime() {
cout << getNome() << “,“ << getSobrenome() << endl;
nascimento.imprime();
}
void pessoa::setData(int d, int m, int a) {
nascimento.setDia(d);
nascimento.setMes(m);
nascimento.setAno(a);
}

Algumas considerações interessantes:

1. O método imprime de pessoa chama o método imprime de data (nasci-

mento.imprime());

2. A classe pessoa necessita ter um método que permita modificar a data.

Com ele, podem-se acionar os métodos set de data a partir do atributo
nascimento;

3. Os atributos de data e de pessoa são privados e não podem ser acessa-

dos diretamente.

A classe estudante herda características de pessoa. Assim, espera-se que

não seja necessário reescrever o código de acesso às informações de pessoa. É
o que será apresentado no código a seguir. Note que a classe estudante indica
que está herdando as características (atributos e métodos) da classe pessoa por
meio do :public.

class estudante: public pessoa {

private:
char curso[20];
char RA[10];
char universidade[20];

100
 public:
estudante();
estudante(char *, char *, char *);
estudante(char *, char *, char *, char *, char *);
void setCurso(char *);
void setRA(char *);
void setUniversidade(char *);
char *getCurso();
char *getRA();
char *getUniversidade();
void imprime();
};
estudante::estudante() {
strcpy(curso,“Computacao“);
strcpy(RA,“123456“);
strcpy(universidade,“UFSCar“);
}
estudante::estudante(char *c, char *r, char *u) {
strcpy(curso,c);
strcpy(RA, r);
strcpy(universidade,u);
}
estudante::estudante(char *c, char *r, char *u, char *n, char
*s): pessoa(n,s)
{
strcpy(curso,c);
strcpy(RA, r);
strcpy(universidade,u);
}

O primeiro construtor inicializa o objeto com valores padrão e chama o cons-

trutor sem parâmetro da classe base. O segundo construtor inicializa com os
dados passados por parâmetro, mas os dados de pessoa são os criados pelo
construtor sem parâmetro da classe pessoa. O terceiro construtor recebe, tam-
bém, por meio da lista de parâmetros, os dados de nome e sobrenome e aciona
o construtor com parâmetros da classe base, conforme se pode observar a partir
do código apresentado anteriormente. O resto do código é bem simples, com
destaque para o método imprime, que aciona o método imprime de pessoa.

101
 void estudante::setCurso(char *c) {
strcpy(curso,c);
}
void estudante::setRA(char *r) {
strcpy(RA, r);
}
void estudante::setUniversidade(char *u) {
strcpy(universidade,u);
}
char * estudante::getCurso() {
return curso;
}
char *estudante::getRA() {
return RA;
}
char *estudante::getUniversidade() {
return universidade;
}
void estudante::imprime() {
cout << “ curso : “ << curso << endl;
cout << “ RA : “ << RA << endl;
cout << “ Univ. : “ << universidade << endl;
pessoa::imprime();
}

Tente criar o código do programa principal para utilizar a classe pessoa e a

classe estudante.

6.7 Considerações finais

A tarefa de copiar, colar e adaptar normalmente gera erros. Erros são mui-
to caros para as fábricas de software. Recriar do zero também é caro (afinal,
todo o esforço de planejar, implementar e testar já foi feito por alguém). A melhor
solução é poder reutilizar um código pronto. Algumas formas foram vistas nesta
unidade, como herança e composição. Herança está associada à relação é-um,
enquanto composição está associada à relação tem-um.

102
Unidade 7

Polimorfismo
7.1 Primeiras palavras

Você já viu algum tipo de polimorfismo neste livro, mas ele ainda não foi
formalmente definido. Nesta unidade você verá vários tipos de polimorfismo exis-
tentes em orientação a objetos com exemplos em C++ e em Java.

7.2 Problematizando o tema

O termo “polimorfismo” tem suas origens no idioma grego e significa várias

(poli) formas (morfos).

Há mais de 40 anos – mais precisamente em 1967 – Strachey (2000) iden-

tificou 2 tipos de polimorfismo: paramétrico e ad-hoc. Mais tarde, em 1985, Luca
Cardelli & Peter Wegner (1985) aprofundaram o estudo sobre o tema e propuse-
ram uma nova visão, em que 4 tipos são claramente definidos.

Figura 10 Formas de polimorfismo.

O polimorfismo universal pode ser considerado o polimorfismo verdadeiro,

enquanto o polimorfismo ad-hoc normalmente é considerado polimorfismo apa-
rente ou de aparência. O polimorfismo ad-hoc pode, ainda, ser subdividido em 2
outros tipos: de sobrecarga e de coerção. Sobrecarga foi um dos assuntos abor-
dados neste livro. Faz sentido entender sobrecarga como uma forma de poli-
morfismo, visto que um mesmo método pode assumir várias formas dependendo
da quantidade e do tipo de parâmetros passados. Coerção permite que um argu-
mento seja convertido para o tipo esperado por uma função, evitando assim um
erro de tipo. Um exemplo bem simples seria o do operador de adição, definido
para realizar a soma de 2 números reais. Se um dos operandos for inteiro, então
105
ele será forçado a se tornar real.
 O polimorfismo universal, como já mencionado, é considerado o verdadeiro
polimorfismo. Ele é subdividido em 2 outras categorias: paramétrico e de inclusão.
O polimorfismo paramétrico é aquele que a partir de uma única definição de um
método ou de atributo pode trabalhar de forma genérica com qualquer tipo. O
polimorfismo de inclusão está associado com herança. Toda classe derivada (ou
subclasse) pode ser usada no contexto da classe base (ou superclasse). Esses
tipos de polimorfismo serão abordados com mais detalhes nos itens a seguir.

7.3 Polimorfismo paramétrico

Um gabarito, na indústria de confecção, é um molde que pode ser aplicado

a qualquer tipo de tecido. Imagine a dificuldade que seria ter que criar moldes
semelhantes para tecidos diferentes. O gabarito é para isso mesmo. Serve como
molde. Está associado ao conceito de generalização. Em orientação a objetos tam-
bém é possível explorar esse conceito de forma que o produto (software) tenha
qualidade e possa ser produzido mais rapidamente. Imagine que você já tenha uma
classe vetor de inteiros. Agora aparece a necessidade de se criar uma classe vetor
de floats. Modificar a classe já existente não é uma boa solução, pois você pode
ter a necessidade de utilizá-la em um futuro próximo. Uma solução seria copiá-la
para outro arquivo, atribuir-lhe um novo nome e modificar-lhe o tipo de dado, mas
eventuais ajustes no código original implicarão em ajustes no novo código e nas
respectivas documentações. E se, além do tipo float, você tivesse que utilizar a
classe vetor para aceitar também doubles? Os riscos de o código ser modificado
em alguma das classes e não o ser em outra(s) aumenta. O desejável é que haja
uma espécie de molde, em que o tipo de dado é definido como genérico e pode
ser modificado conforme o interesse do programador. Assim, as manutenções
são feitas em um único código.

7.3.1 Templates em C++

Nada melhor que alguns exemplos para entender o conceito de templates

em C++.

void troca(int & a, int & b)

{
int temp(a);
a = b;
b = temp;
}
106
 No exemplo anterior, o procedimento troca recebe dois parâmetros inteiros e
faz com que os valores sejam trocados, ou seja, o que estava em a vai para b e o
que estava em b vai para a. Simples! E se desejarmos algo parecido para a troca de
valores de duas variáveis float? Uma solução seria criar outro procedimento, mas já
vimos que isso não é vantajoso.

Teríamos o mesmo código repetido apenas por necessitar modificar o tipo

de dados dos parâmetros? Isso não parece muito inteligente! Precisamos de algo
que generalize a utilização do código apresentado (e de outros também!).

template class<T>
void troca(T & a, T & b) {
T temp(a);
a = b;
b = temp;
}

Em C++, felizmente, temos os templates! Eles permitem que o código fique

geral para tipos diferentes de dados, como o apresentado no exemplo anterior.
Em todos os lugares onde encontrávamos int, fizemos uma substituição por T
e colocamos uma declaração antes da função, informando que o T será o tipo
genérico. O nome T foi escolhido aleatoriamente (na verdade é em homenagem
a template).

Assim, no código apresentado, a, b e temp são todas variáveis do tipo T. E

como utilizar isso? Veja o código exemplo a seguir.

int x1, x2;

x1 = 10;
x2 = 20;
troca(x1,x2); // ß primeira chamada
float y1, y2;
y1 = 10.2;
y2 = 33.3;
troca(y1,y2); // ß segunda chamada
…

O compilador sabe qual procedimento chamar pelo fato de saber os tipos

das variáveis. A primeira chamada é direcionada para o procedimento troca
cujos parâmetros são inteiros. Já na segunda chamada, o procedimento acionado
é o troca com floats. Tais procedimentos são criados automaticamente pelo com-
pilador. O programador não precisa fazer essa tarefa repetitiva (e mecânica)!
107
 Outro exemplo poderia ser o de acesso a uma posição específica de um
vetor. O método at, da classe meu_vetor, indica a posição em que está o valor
a ser utilizado. O importante aqui é que o p é um ponteiro para T, em que T é
genérico!

template <class T>

class meu_vetor
{
T *p;
…
T & at(unsigned int indice)
{
return p[indice];
}
…
};

No programa principal teríamos:

meu_vetor <int> v;

O tipo que está dentro dos limites < > é que será utilizado para fazer a aloca-
ção de memória. No construtor, por exemplo, você faria a alocação new T[x], em
que x seria o tamanho do vetor. Note que, no exemplo anterior, o método at está
dentro da classe. Se ele estivesse fora, você teria que especificar a qual classe
pertence. Bom, isso você já sabe! O que você provavelmente não sabe é que se
estivesse fora, e se você estivesse utilizando template, então deveria colocar a
declaração de template antes do método! Na verdade, o template deve ser decla-
rado antes de cada método.

Com o uso de templates passa a ser possível criar objetos da classe meu_vetor
do tipo inteiro, float, double, etc. Muito simples!

108
7.3.2 Generics em Java

Generics em Java tem o mesmo objetivo que template em C++. Vamos criar
uma classe simples que apenas armazena um valor.

public class Obj {

private Integer i;
public void add(Integer i){
this.i = i;
}
public Integer get(){
return this.i;
}
}

A classe em questão armazena um valor inteiro. Para utilizá-la podemos, no

programa principal, fazer chamadas para add e get, como no exemplo seguinte.

public class NewMain {

public static void main(String[] args) {
Obj integerObj = new Obj();
integerObj.add(10);
Integer OutroInteger = integerObj.get();
System.out.println(OutroInteger);
}
}

Mas é fácil notar que tal programa não conseguiria trabalhar com Strings.
Para trabalhar com Strings ou qualquer outro tipo precisaríamos que Obj armaze-
nasse um tipo de dado genérico, conforme o exemplo a seguir.

public class Obj<T>{

    private T t; // T é o tipo do atributo
    public void add(T t){
        this.t = t;
    }
    public T get(){
        return this.t;
    }
 } 109
 O trecho de código a seguir apresenta o uso da nova classe Obj. Agora ela
aceita tanto Strings como inteiros.

Obj<String>  ObjInt = new Obj<Integer>();

ObjInt.add(10);

String OutroObjInt = (Integer) ObjInt.get();

System.out.println(OutroObjInt);

Obj<String>  cadeiaCaracteres = new Obj<String>();

cadeiaCaracteres.add(“Teste“);

String outraCadeia = (String) cadeiaCaracteres.get();

System.out.println(outraCadeia);

7.4 Polimorfismo de inclusão

Como já mencionado, polimorfismo é a capacidade de assumir várias for-

mas. Ele permite que escrevamos programas mais genéricos. Uma das formas
vistas nesta unidade é o paramétrico, em que uma classe é projetada indepen-
dentemente do tipo que seus atributos irão ter. Outra forma é o polimorfismo de
inclusão, em que um objeto de uma classe mais genérica (base ou superclasse)
assume o papel de um objeto de uma classe mais específica (subclasse ou clas-
se derivada). Um exemplo é quando um objeto A de animal assume o papel de
cachorro (cachorro é um animal).

7.4.1 Polimorfismo de inclusão em C++

Vamos supor que você seja gerente de uma equipe em uma fábrica de
software. Você, junto com a equipe de projeto de software, estabeleceu as carac-
terísticas gerais da classe funcionário_empresa.

A classe deve ter a seguinte forma:

classe funcionario_empresa {
private:
char primeiro_nome[20];
char sobrenome[20];
int codigo_funcao;
110
 int codigo_departamento;
float salario_base;
public:
funcionario_empresa(char * , char *);
~funcionario_empresa();
void atribui_salario(float);
void promocao();
void imprime_dados();
void imprime_vencimentos();
};

Um gerente é um funcionário de empresa, assim como um funcionário do

departamento de compras ou do departamento de finanças. Mas tem, pelo me-
nos, uma coisa que o diferencia: um gerente tem subordinados. Assim, a classe
gerente é uma subclasse de funcionário_empresa, que tem uma particularidade:
tem subordinados. A relação é-um, como vista anteriormente, determina herança.
Também poderíamos ter uma classe de vendedores. Eles também são funcioná-
rios da empresa (novamente a relação é-um), mas normalmente os vendedores
têm um salário fixo e um salário variável (comissão). Os programadores que com-
põem sua equipe desejam criar um programa genérico que trabalhe com todos
os funcionários da empresa. Eles sabem que a forma de imprimir os dados do ge-
rente é diferente da forma de imprimir os dados do funcionário do departamento
de finanças. Mesmo assim entendem que ficaria mais fácil para alguém entender
o código se simplesmente colocassem o método imprimir_dados() disponível e o
programa se encarregasse de acionar o método correto de cada classe. Eles
também notaram que a forma de calcular e apresentar os dados sobre ven-
cimentos de um gerente e de um vendedor são diferentes. Mesmo assim, a
funcionalidade deveria ser a mesma: imprimir_vencimentos(). O programa se
encarregaria de acionar o método correto.

Bom, em C++ isso é feito utilizando-se a declaração virtual antes do método.

A classe funcionario_empresa ficaria:

classe funcionario_empresa {
private:
char primeiro_nome[20];
char sobrenome[20];
int codigo_funcao;
int codigo_departamento;
float salario_base;

111
 public:
funcionario_empresa(char * , char *);
~funcionario_empresa();
void atribui_salario(float);
void promocao();
virtual void imprime_dados();
virtual void imprime_vencimentos();
};

Cada classe derivada da classe funcionario_empresa teria seu método

imprime_dados() e imprime_vencimentos(). Poderia criar-se um funcionário ge-
nérico no programa principal que pudesse assumir o papel tanto de gerente como
de vendedor:

funcionario_empresa *genérico;

A declaração deve ser feita utilizando-se ponteiro. Nesse caso, tem-se um

funcionário genérico. Ainda não sabemos se ele assumirá o papel de gerente, fun-
cionário do departamento de compras ou mesmo o papel de um vendedor. Após
o usuário informar o papel que deseja assumir, é possível transformar o genérico
em específico. Suponha que o usuário tenha escolhido o papel de vendedor:

genérico = new vendedor();

Vendedor é uma classe derivada da classe funcionario_empresa e tem os

métodos imprime_dados() e imprime_vencimentos(). Agora sim, se o método
imprime_dados() for acionado (ver exemplo a seguir), o programa saberá que o
referido método pertence à classe vendedor:

genericoimprime_dados();

Fica claro, então, que a declaração de um objeto genérico pode implicar

em uma utilização específica posteriormente. O programador em questão não
deve se esquecer de que o comando new aloca memória do computador e ela
deverá ser liberada (por meio do comando delete) tão logo não seja mais utilizada.

Com polimorfismo é possível criar um vetor de elementos heterogêneos, por

exemplo, um vetor de animais mamíferos. Vamos supor que queiramos construir
tal vetor, mas que o usuário vai determinar qual será a posição do cachorro, do
gato, do cavalo, etc. Depois, o usuário vai escolher uma posição do vetor e vai
112
acionar o método emitir_som() do animal daquela posição. Veja um exemplo resu-
mido da classe mamífero e da classe gato (derivada de mamífero):

classe mamífero {
private:
...
public:
virtual emitir_som();
};

A classe mamífero foi simplificada. O que interessa é apenas a existência de

um método comum às classes derivadas (emitir_som).

classe gato::public mamífero // herança!

{
private:
...
public:
emitir_som();
};

O exemplo anterior apenas representa uma das possibilidades de classe

derivada (poderíamos ter cavalo, cachorro, leão, tigre, entre outros).

Um vetor de animais mamíferos poderia, então, ser criado da seguinte forma:

mamífero *animal[10];

Ou seja, teríamos dez animais mamíferos no vetor animal. Se o usuário

houvesse decidido que, na primeira posição, seria colocado um cachorro, então
teríamos:

animal[0] = new cachorro(“totó“,1, 5);

Os dados entre parênteses seriam: nome, meses de idade e peso. Poste-

riormente, o método emitir_som() do animal[0] poderia ser acionado da seguinte
forma:

animal[0]emitir_som();
113
 Não é difícil imaginar que o seguinte trecho de código do programa poderia
emitir sons distintos, como au au au, miau, ihhhhh, etc.:

for (i=0;i<10;i++)
animal[i]emitir_som();

É importante notar que no polimorfismo de inclusão não é possível saber a

qual classe pertence o método acionado antes que o programa seja executado.
Isso porque tudo ocorre dinamicamente (em tempo de execução).

7.4.2 Polimorfismo de inclusão em Java

E como seria o polimorfismo de inclusão em Java, já que ele acontece em

C++, principalmente pelo fato de existirem ponteiros nessa linguagem? Em Java o
processo é muito semelhante. Vamos utilizar como exemplo a classe animal e as
classes cachorro, gato e pato que são derivadas (subclasses) de animal. A classe
animal tem um construtor que inicializa o tipo de animal criado, um método exibir que
imprime o tipo do animal e o método som. Note que o método som é genérico.

public class Animal {

private String tipo;
public Animal(String tipo1){ tipo = new String(tipo1); }
public void exibir(){ System.out.println(“Eu sou um“ +
tipo);}
//Método a ser implementado nas subclasses.
public void som(){ System.out.println(“som de animal“); }
}
public class Cachorro extends Animal {
private String nome, raca;
public Cachorro(String nome1){
super(“cachorro“);
nome = nome1; raca = “Boxer”;
}
public Cachorro(String nome1, String raca1){
super(“cachorro“);
nome = nome1; raca = raca1;
}
public void som() { System.out.println(“Auau“);}
114 }
 O método som de Cachorro imprime Auau, enquanto o do Gato imprime
miau e o do Pato quaquá. As classes de Gato e Pato não serão repetidas aqui
por questões de espaço, mas são muito similares à Cachorro. É importante ob-
servar que a classe Cachorro (assim como a Gato e a Pato) são subclasses de
Animal e, por isso, utilizam a palavra extends em Java.

Para testar o polimorfismo, é preciso criar um programa principal, que

deve estar dentro da classe TestePolimorfismo. Tal classe deve estar no arqui-
vo TestePolimorfismo.java (isso você já sabe, não?!).

No programa principal criamos um vetor de animais e o chamamos de

bichos. O interessante dessa construção é que cada elemento do vetor pode as-
sumir o papel de um animal. Podemos, então, ter cachorro, gato e pato fazendo
parte de um mesmo vetor.

O código a seguir cria um vetor com os elementos cachorro, gato e pato e

faz com que um animal de estimação assuma o papel de um dos animais con-
forme sorteio (feito por Math.random()). O sorteio é feito 5 vezes. Não é possível,
a partir da inspeção do código, informar, por exemplo, a qual classe pertence o
método som executado por estimacao. Isso é resolvido em tempo de execução.

public class TestePolimorfismo {

public static void main(String[] args){
Animal[] bichos = { new Cachorro(“Rex“,“Labrador“),
new Gato(“Mimi“),
new Pato(“Gertrudes“) };
Animal estimacao;
for (int i=0; i<5; i++){
int indice = (int) (bichos.length * Math.random()
- 0.001);
estimacao = bichos[indice];
System.out.println(“\n Escolha: “);
estimacao.exibir();
estimacao.som();
}
}

115
 7.5 Considerações finais

Um código genérico gera menos erros. Copiar e colar um código sim-

plesmente para se alterar o tipo (por exemplo) com o qual ele trabalha não faz
muito sentido. Além disso, se houver a necessidade de se realizar uma alteração
no código, isso terá que ser feito em todas as versões (int, float, double, long int,
etc.). A orientação a objetos propõe soluções baseadas em polimorfismo.

Alguns poucos exemplos de polimorfismo foram apresentados. É importante

que o leitor aprofunde os conhecimentos sobre o assunto, fazendo uma leitura
mais detalhada sobre polimorfismo em Deitel & Deitel (2009a, 2009b).

116
Unidade 8

Classes abstratas
8.1 Primeiras palavras

Temos uma ideia do que seja abstrato. Uma forma simples de se definir seria
“algo intangível, que não pode ser pego”. Uma ideia, por exemplo, é algo intangí-
vel. Mas o que seria classe abstrata em programação? Nesta unidade tal conceito
será explorado e alguns exemplos em C++ e em Java serão apresentados.

8.2 Problematizando o tema

Pode acontecer que você, como gerente, queira forçar sua equipe a criar mé-
todos específicos para as classes derivadas. Você pode fazer isso de duas formas:

1. Inspeção em todos os códigos;

2. Deixar para o compilador a tarefa de verificar.

É claro que você vai preferir a segunda opção! É mais fácil, rápida e segura.

Assim, você pode criar uma classe abstrata, que não pode ser utilizada direta-
mente (daí vem a justificação do uso da palavra abstrato), mas que irá servir como
referência para a criação de outras classes. Imagine que você deseje que todas as
figuras geométricas em 2 dimensões tenham os métodos calcArea( ), calcPerime-
tro( ) e desenhar( ). É preciso sinalizar para o compilador que ele deverá controlar o
trabalho de seus programadores. O compilador, na verdade deverá:

1. Impedir que alguém crie um objeto da classe abstrata;

2. Acusar erro se algum dos métodos não tiver sido criado em uma classe
derivada que será utilizada.

Se uma classe derivada não implementar todos os métodos da classe base

(ou superclasse), ela também será considerada classe abstrata (por herança) e
não poderá, portanto, ser utilizada.

8.3 Definição de classes abstratas

Do ponto de vista de programação, uma classe que contenha funções virtuais

puras (C++) ou funções abstratas (Java) é chamada de classe abstrata. Essas
classes são chamadas assim porque não permitem instanciações (objetos). Na
verdade, existem apenas com o propósito de estabelecer parâmetros para outras
classes dela derivadas. Lembrando: as classes derivadas devem conter as imple-
mentações das funções virtuais puras ou abstratas para que se tornem classes 119
 concretas. Caso tais implementações não estejam presentes em tais classes,
elas também serão consideradas abstratas.

8.4 Classes abstratas em Java e em C++

Você deve estar achando que classes abstratas e interfaces (de Java) são
conceitos parecidos e que podem ser usados com objetivos semelhantes. Cuida-
do! Uma classe pode estender uma única classe (que pode ser abstrata ou não),
mas pode implementar várias interfaces. Além disso, interfaces Java não permi-
tem declaração de atributos, enquanto classes abstratas permitem.

8.4.1 Exemplos em Java

Em Java, utiliza-se a palavra chave abstract para definir uma classe

abstrata:

public abstract class Eletrodomestico {
private boolean ligado;
private int voltagem;
// métodos abstratos
public abstract void ligar();
public abstract void desligar();
// construtor
public Eletrodomestico(boolean l, int volt) {
this.ligado = l;
this.voltagem = volt;
}
 
// métodos concretos
public void setVoltagem(int voltagem) {
this.voltagem = voltagem;
}
public int getVoltagem() {
return this.voltagem;
}
public void setLigado(boolean ligado) {
this.ligado = ligado;
}
public boolean isLigado() {
return ligado;
120 }
}
 A classe eletrodoméstico, no exemplo anterior, cria um “modelo” que deve
ser compartilhado entre outras classes que herdam as características de eletro-
domésticos. Nota-se que ter uma voltagem e estar ligado ou não são caracterís-
ticas de aparelhos elétricos. Assim, pode-se criar uma classe televisão (televisão
é um eletrodoméstico) que implemente os métodos abstratos da superclasse. Por
questões de espaço serão apresentados apenas alguns dos principais métodos
da classe televisão:

public class TV extends Eletrodomestico {
private int tamanho;
private int canal;
private int volume;
 
public TV(int tam, int volt) {
super (false, volt); 
this.tamanho = tam;
this.canal = 0;
this.volume = 0;
}

// métodos abstratos implementados

public void desligar() {
super.setLigado(false);
setCanal(0);
setVolume(0);
}
public void ligar() {
super.setLigado(true);
setCanal(3);
setVolume(25);
}
// outros métodos da classe
...
}

121
 8.4.2 Exemplos em C++

Em C++ a sinalização de que a classe é abstrata ocorre quando igualamos

a zero um método virtual:

virtual nome_método() = 0;

Assim, quando alguém cria um método xxx() virtual e o iguala a zero, na ver-
dade o que está sendo desejado é que a implementação de tal método ocorra em
cada uma das classes derivadas daquela classe à qual xxx pertence. Um método
puramente virtual (são assim chamados os métodos igualados a zero) não pode
ser instanciado em qualquer parte do programa (você só poderá utilizar ponteiros
para a classe). Ou seja, se você criou um método virtual xxx() = 0; na classe Ani-
mal, não poderá fazer a seguinte declaração:

Animal x;

Toda classe derivada de Animal deverá implementar todos os métodos vir-

tuais puros dela, caso contrário, a classe derivada também será considerada abs-
trata pelo compilador e não autorizará a criação de um objeto daquela classe.

Como exemplo, podemos relembrar a classe Animal da unidade anterior. Se

a classe fosse reescrita para C++ e o método som( ) fosse declarado como virtual
puro, então em todas as classes derivadas de Animal (cachorro, gato, pato, cava-
lo, etc.) deveria haver uma implementação específica de som().

8.5 Considerações finais

Classes abstratas trazem segurança para quem planeja uma classe base e
deseja que todos a utilizem como referência. Como ela não pode ser instanciada,
o programador será obrigado a criar classes com implementações corretas de
todos os métodos virtuais puros (C++) ou abstratos.

Ou seja, com classes abstratas, o trabalho de verificar se os membros da

equipe de desenvolvimento implementaram os métodos planejados fica a cargo
do compilador. Caso alguma classe não tenha sido contemplada com todos os
métodos planejados, ela será automaticamente convertida para abstrata e o com-
pilador impedirá que um objeto daquela classe seja criado. O gerente do projeto
saberá (sem ter que investigar o código), então, que o programador responsável
pela tarefa não a realizou.
122
Apêndice A

Na internet existem vários tutoriais de como instalar os ambientes de desen-

volvimento (ou de programação). Aqui serão vistas maneiras simples de como uti-
lizá-los para construir programas em C++ e em Java. No apêndice B serão vistos
exemplos de programas voltados para jogos envolvendo conceitos de orientação
a objetos.

Um dos ambientes mais utilizados em desenvolvimento de programas é o

NetBeans (Figura 11). Ele permite construções de programas tanto em C++ como
em Java, o que é ideal para quem quer aprender orientação a objetos e testar
os conceitos nas duas linguagens. A tela inicial do NetBeans pode ser vista na
Figura 11.

Figura 11 Tela inicial do NetBeans.

Para iniciar um novo aplicativo, o programador deve clicar no menu Arquivo

e escolher a opção “Novo Projeto”. Então, uma janela de diálogo para solicitar a
informação sobre qual linguagem deseja utilizar se abrirá (Figura 12).

O programador poderá notar que as opções Java e C/C++ estão presentes.

A escolha de uma opção na parte esquerda do diálogo implica na apresentação
de tipos de projetos disponíveis na parte direita do diálogo.

123
 Figura 12 Caixa de diálogo do novo projeto.

Quando escolher a linguagem Java, escolha o tipo de projeto “Aplicação

Java”; quando escolher C/C++, escolha o tipo de projeto “Aplicativo de C/C++”.

Figura 13 Dados do projeto.

Em ambos os casos, clique no botão “Próximo” para prosseguir com as defi-

nições do programa. Uma nova caixa de diálogo aparecerá solicitando informações
124
específicas sobre o projeto, tais como nome e localização dos arquivos (Figura 13).
 Defina o nome que achar apropriado ou mantenha as sugestões do am-
biente. Não é necessário definir como projeto principal, caso seu programa tenha
vários arquivos.

Finalizada a etapa de preparação do ambiente, vem a parte de elaboração

dos códigos. Na parte esquerda do ambiente aparecerá uma lista de aplicativos,
entre os quais aquele que acabou de ser criado (em nosso exemplo, aplicativo_4).
Para criar um arquivo de cabeçalho em C++ ou um arquivo do programa principal
é preciso clicar com o botão direito do mouse sobre o tipo de arquivo desejado.
No exemplo da Figura 14, o programador está escolhendo a opção de criar um
programa principal em C++.

Figura 14 Criação de um programa em C++.

Uma nova caixa de diálogo aparecerá para que o programador defina o

nome do arquivo que está sendo criado. Em seguida, o NetBeans cria um esque-
leto do programa, inclusive com comentários sobre a autoria e a data do progra-
ma (Figura 15). Em ambientes como o NetBeans, existem recursos que são muito
importantes e que facilitam a vida do programador. Um deles é o aviso de que
algo não está correto. No exemplo da Figura 15 pode-se ver uma marca (x) na
linha 8 indicando que há um erro. Outro recurso interessante é o code completion
(Figura 17), que apresenta sugestões de complemento do código particularmente
interessantes para a escolha de um método de uma classe.

125
 Figura 15 Ambiente de desenvolvimento do NetBeans.

Uma vez escrito o código, basta compilar e executar. Procure as opções em

“construir” e “executar” do menu.

Para se construir uma aplicação Java, os passos são semelhantes. Deve-se

ter cuidado especial com a caixa de diálogo sobre os dados do projeto (Figura 16).

Figura 16 Dados do projeto Java.

126
 Normalmente ela vem com a opção “criar classe principal” ativada. Desative-a
se você estiver criando apenas a classe. Essa opção serve para quando se pre-
tende criar o programa principal.

Figura 17 Exemplo de Code Completion em Java.

127
Apêndice B

Existem alguns exemplos de problemas que permitem entender melhor os

conceitos de orientação a objetos de uma forma bem simples. Aqui serão aborda-
dos três exemplos em C++: dois de classes simples (rádio e jogo da forca) e um
terceiro de sobrecarga de operadores (valor_monetário).

Classe simples

Um exemplo de classe simples seria a classe rádio. Um rádio é um equi-

pamento eletrônico que permite receber conteúdos sonoros transmitidos a partir
de uma fonte (a estação de rádio). O aparelho permite que possamos escolher a
fonte por meio de um botão de sintonia. Além disso, o rádio, como qualquer outro
equipamento eletrônico, pode estar ligado ou desligado. Quando desligado não
é possível ouvir qualquer transmissão; quando ligado pode-se ouvir o que está
sendo transmitido na estação de rádio sintonizada. Também se pode escolher o
volume em que se deseja ouvir. O código em C++ a seguir apresenta uma forma
de se implementar a classe rádio.

A classe rádio, a seguir, tem os seguintes atributos:

• Volume;

• Memória (para armazenar as estações preferidas, tanto em AM como

em FM). É uma matriz com 2 linhas e 5 colunas. A primeira linha arma-
zena as estações AM e a segunda linha as estações FM. São 5 esta-
ções por linha;

• Indicador de modo AM ou FM;

• Indicador de ligado/desligado;

• Estações.

Para simplificar o problema, não se contemplou a questão da bateria (nível

de carga, troca de bateria, uso de energia elétrica, etc.).

Os atributos são private, ou seja, não podem ser acessados diretamente.

Assim, para alterar os atributos foram criados “botões” de rádio que realizam
as funções desejadas. Por exemplo, para o atributo volume existem dois botões
(aumenta e diminui); para o modo AM/FM existe o botão muda_tipo_estação e
assim por diante.

129
 class radio
{
 private:
    int volume; // volume (0 a 10)
int sintonia_AM; // estação AM atual da memória
int sintonia_FM; // estação FM atual da memória
    int memoria[2][5]; // memórias de estações preferidas
    bool estacao_FM; // indica se está no modo AM ou FM
    bool ligado; // indica se está ligado ou não
    float estacoes[2][20]; // total de estações AM e FM
 public:
    radio(); // construtor
    float busca_estacao(); // “botão“ de buscar estação
    void grava_memoria(int); // “botão“ de gravar memória
    void sintoniza_memoria(int); // “botão“ de sintonizar
// estação gravada em
// memória
    void muda_tipo_estacao(); // troca de AM para FM ou
// de FM para AM
    void liga_desliga(); // “botão“ de ligar e desligar
    void aumenta_volume(); // “botão“ de aumentar
// volume
    void diminui_volume(); // “botão“ de diminuir volume
    void display(); // display do rádio
};

O construtor é um método que deve inicializar os atributos de forma que eles

já tenham valores válidos. É conveniente inicializar o rádio desligado e já colocar
as estações possíveis.

radio::radio()
{
    estacao_FM = true;
sintonia_AM = 0;
sintonia_FM = 0;
    ligado = false;
    estacoes[0][0] = 650;
    estacoes[0][1] = 685;
    estacoes[0][2] = 710;
130
     estacoes[0][3] = 730;
    estacoes[0][4] = 745;
    estacoes[0][5] = 770;
    estacoes[0][6] = 810;
    estacoes[0][7] = 830;
    estacoes[0][8] = 850;
    estacoes[0][9] = 870;
    estacoes[1][0] = 88.1;
    estacoes[1][1] = 90.2;
    estacoes[1][2] = 91.6;
    estacoes[1][3] = 92.1;
    estacoes[1][4] = 94.0;
    estacoes[1][5] = 94.7;
    estacoes[1][6] = 95.1;
    estacoes[1][7] = 98.3;
    estacoes[1][8] = 99.1;
    estacoes[1][9] = 99.8;
    volume = 5;  
    for (int i=0;i<5;i++)
    {
       memoria[0][i] = 0;
       memoria[1][i] = 0;
    }
}
               
O botão de buscar estação é responsável por sintonizar uma nova estação.
Ou seja, se atualmente o rádio está sintonizado na estação 90.2 FM, então o
busca estação vai para a próxima estação, ou seja, 91.6.

float radio::busca_estacao() {
      if (ligado) {
        if (estacao_FM) {
         sintonia_FM++;
         if (sintonia_FM == 10)
             sintonia_FM = 0;
        }
        else {
          sintonia_AM++;
          if (sintonia_AM == 10)

131
              sintonia_AM = 0;
        }
      }                  
}

O botão de gravar na memória permite que algumas estações preferidas se-

jam armazenadas para facilitar a troca de estações. O usuário deve indicar qual
botão deseja associar à estação (são 5 botões para FM e 5 para AM). Se o botão já
armazenava uma estação preferida, então ela será substituída pela nova estação.

void radio::grava_memoria(int m) {
     if (ligado) {
       if (estacao_FM) {
        if (m >= 0 && m <= 4)
           memoria[1][m] = sintonia_FM;
       }  else
        if (m >= 0 && m <= 4)
           memoria[0][m] = sintonia_AM;
     }
}

Associado ao botão de gravar memória está o botão de sintonizar uma es-

tação preferida. O usuário indica o botão (pressionando) e o rádio faz a sintonia.
Claro que isso só acontece se o rádio estiver ligado!

void radio::sintoniza_memoria(int m) {
     if (ligado)  {
        if (estacao_FM) {
           if (m >= 0 && m <= 4)
              sintonia_FM = memoria[1][m];
        }  else
           if (m >= 0 && m <= 4)
              sintonia_AM = memoria[0][m];
     }
}   

Há também os botões de mudança de estação (que troca de AM para FM e

vice-versa), o botão de liga/desliga, e os de controle de volume, conforme mos-
tram os códigos apresentados a seguir.

132
 void radio::muda_tipo_estacao() {
     if (ligado)
        estacao_FM = !estacao_FM;
}
void radio::liga_desliga() {
     ligado = !ligado;
}
void radio::aumenta_volume() {
     if (ligado)
        volume++;
     if (volume > 25) volume = 25;
}
void radio::diminui_volume() {
     if (ligado)
        volume--;
     if (volume < 0) volume = 0;
}

O método display servirá para apresentar as informações correntes sobre

o rádio (se está ligado, em qual estação, qual volume, etc.); se estiver desligado
aparecerá uma informação indicando apenas que está desligado.

void radio::display() {
if (ligado)  {
cout << “volume  = “ << volume << endl;
if (estacao_FM)
cout << “FM = “ << estacoes[1][sintonia_FM] << endl;
else
cout << “AM = “ << estacoes[0][sintonia_AM] << endl;
}
else
cout << “radio desligado “ << endl;
}
   

O programa principal deverá contar com uma função menu que disponibi-
lizará as funcionalidades do rádio. Poderia ser parte da classe, como se fosse a
parte externa do rádio com seus botões.

int menu() {
    int opcao;
    opcao = 0; 133
     while (opcao <= 0 || opcao > 8) {
      cout << “ 1. Botao liga/desliga“ << endl;
      cout << “ 2. Botao AM/FM “ << endl;
      cout << “ 3. Botao busca estacao “ << endl;
      cout << “ 4. Botao grava estacao “ << endl;
      cout << “ 5. Botao memoria “ << endl;
      cout << “ 6. Botao aumenta volume “ << endl;
      cout << “ 7. Botao diminui volume “ << endl;
      cout << “ 8. finalizar “ << endl;
      cin >> opcao;
   }
   return opcao;       
}        

Por fim, o programa principal. Nele declaramos um objeto X e, por meio das
escolhas do usuário, fazemos o acionamento dos métodos de X.

int main(int argc, char *argv[]) {

    radio X;
    int opcao;
    opcao = menu();
    while (opcao != 8) {
       if (opcao == 1)  X.liga_desliga();
       if (opcao == 2)  X.muda_tipo_estacao();
       if (opcao == 3)  X.busca_estacao();
       if (opcao == 4) {
           int mem = 10;
           while (mem < 0 || mem > 4) {
                 cout << “ entre com o numero do botao “ ;
                 cin >> mem;
           }
           X.grava_memoria(mem);
       }     
       if (opcao == 5) {
           int mem = 10;
           while (mem < 0 || mem > 4) {
                 cout << “ entre com o numero do botao “ ;
                 cin >> mem;
           }
           X.sintoniza_memoria(mem);
134
        }       
       if (opcao == 6)   X.aumenta_volume();
       if (opcao == 7)   X.diminui_volume();
       X.display();
       opcao = menu();
    }
    system(“PAUSE“);
    return EXIT_SUCCESS;
}

Outro exemplo interessante é o jogo da forca. Esse jogo é um jogo de

adivinhação, em que o jogador joga contra o computador. Ao jogador são dadas
algumas chances de escolher letras que permitam formar a palavra escolhida
(sorteada) pelo computador. A palavra é sorteada no início do programa e o
computador deve exibir o número de letras da palavra e uma dica sobre a mesma.
O jogador vence se conseguir decifrar a palavra; perde se for enforcado. Cada
letra errada implica em uma parte do corpo acrescida. Ou seja, o jogador tem a
chance de cometer 6 erros (duas pernas, dois braços, corpo e cabeça). As letras
erradas são apresentadas em um espaço separado; as corretas são mostradas em
suas posições corretas sobre o tracejado (que indica o tamanho da palavra).

Figura 18 Jogo da forca.

O programador, assim como no exemplo anterior, deve se preocupar com as

funcionalidades do jogo, bem como seus atributos. O código a seguir (também em
C++) apresenta uma implementação do jogo da forca.3 Alguns comandos utilizados
no desenvolvimento do jogo podem não ser reconhecidos em algumas platafor-
mas de desenvolvimento. Exemplo: utilizando o CygWin como compilador do
NetBeans IDE 6.5.1 o comando “printf(“\033[2J”);” limpa a tela, e para exercer essa
mesma função no Dev-C++ o comando utilizado deve ser o “system(“CLS”);”.

3 O exemplo do jogo da forca foi elaborado por alunos de graduação da UFSCar. Os nomes 135
dos autores foram preservados no código.
 /*
* JOGO DA FORCA
* Autores:
Alan Cesar Laine
Bruno Fernando Rodrigues
Guilherme Cuppi Jerônimo
Guilherme Rigo Recio
*/

//Inclusão das bibliotecas

#include <stdlib.h>
#include <iostream.h>
//para atribuir e comparar strings
#include <string.h>
//para utlizar as funções srand() e rand()
#include <time.h>
//para utilizar a funcão isdigit()
#include <ctype.h>
using namespace std;

//Declaração da classe jogo_da_forca

class jogo_da_forca
{
private:
//Matriz das palavras possíveis do jogo
char matriz[90][40];
//Vetor para armazenar a dica do jogo
char dica[25];
//Vetor para armazenar as letras corretas
char letras_corretas[30];
//Vetor para armazenar as letras erradas
char letras_erradas[7];
//palavra digitada até o momento
char palavra_digitada[40];
int numero_erros, posicao_acertos,
posicao_erros, sorteio;
public:
//Construtor com parâmetro
jogo_da_forca(int);
136 //Método para imprimir o jogo
 void imprimir();
//Método para verificar se a letra digitada
//consta na palavra sorteada
void letra_correta(char);
//Método para verificar se a letra digitada
//não consta na palavra sorteada
void letra_errada(char);
//Método para montar a palavra digitada
//até o momento
void monta_palavra();
//Método para checar se o jogador acertou a
//palavra sorteada
bool ganhar();

//Método para checar se o jogador atingiu o

//limite de erros
bool perder();
//Método para verificar se a letra
//já foi digitada
bool verifica_letra(char);
//Método para controlar o jogo
int jogar();
};

//Construtor
jogo_da_forca::jogo_da_forca(int nivel)
{
int i; //Contador

//Variável para armazenar o número sorteado

//na função srand()
int sorteio_parcial;

/*Atribuição das 30 palavras do nível fácil, ordenadas de 6

em 6 nas respectivas categorias, “Animal“, “Novela ou Mini-Série“,
“Fruta“, “Filme“ e “País“ */
strcpy(matriz[0], “ARARA“);
strcpy(matriz[1], “MACACO“);
strcpy(matriz[2], “LEAO“);
strcpy(matriz[3], “ELEFANTE“); 137
 strcpy(matriz[4], “COBRA“);
strcpy(matriz[5], “GIRAFA“);
strcpy(matriz[6], “VIVER A VIDA“);
strcpy(matriz[7], “CARAS E BOCAS“);
strcpy(matriz[8], “CAMA DE GATO“);
strcpy(matriz[9], “CAMINHO DAS INDIAS“);
strcpy(matriz[10], “PARAISO“);
strcpy(matriz[11], “NEGOCIO DA CHINA“);
strcpy(matriz[12], “BANANA“);
strcpy(matriz[13], “ABACATE“);
strcpy(matriz[14], “MAMAO“);
strcpy(matriz[15], “ABACAXI“);
strcpy(matriz[16], “LARANJA“);
strcpy(matriz[17], “UVA“);
strcpy(matriz[18], “A ERA DO GELO TRES“);
strcpy(matriz[19], “BRUNO“);
strcpy(matriz[20], “HEROIS“);
strcpy(matriz[21], “JOGOS MORTAIS SEIS“);
strcpy(matriz[22], “NOIVAS EM GUERRA“);
strcpy(matriz[23], “SE EU FOSSE VOCE DOIS“);
strcpy(matriz[24], “BRASIL“);
strcpy(matriz[25], “MEXICO“);
strcpy(matriz[26], “ARGENTINA“);
strcpy(matriz[27], “CHILE“);
strcpy(matriz[28], “ESTADOS UNIDOS“);
strcpy(matriz[29], “URUGUAI“);

/*Atribuição das 30 palavras do nível intermediário, ordenadas

de 6 em 6 nas respectivas categorias, “Animal“, “Novela ou Mini-
Série“, “Fruta“, “Filme“ e “País“ */
strcpy(matriz[30], “BICHO-DA-SEDA“);
strcpy(matriz[31], “CARRAPATO“);
strcpy(matriz[32], “CAMALEAO“);
strcpy(matriz[33], “CROCODILO“);
strcpy(matriz[34], “CARPA“);
strcpy(matriz[35], “CHIMPANZE“);
strcpy(matriz[36], “A CASA DAS SETE MULHERES“);
strcpy(matriz[37], “MULHERES APAIXONADAS“);
strcpy(matriz[38], “AGORA E QUE SAO ELAS“);
strcpy(matriz[39], “KUBANACAN“);

138 strcpy(matriz[40], “CHOCOLATE COM PIMENTA“);

 strcpy(matriz[41], “CELEBRIDADE“);
strcpy(matriz[42], “DAMASCO“);
strcpy(matriz[43], “FRUTA-DO-CONDE“);
strcpy(matriz[44], “GUABIROBA“);
strcpy(matriz[45], “KIWI“);
strcpy(matriz[46], “MORANGO“);
strcpy(matriz[47], “PITANGA“);
strcpy(matriz[48], “MAIS VELOZES MAIS FURIOSOS“);
strcpy(matriz[49], “AMERICAN PIE TRES“);
strcpy(matriz[50], “AS PANTERAS“);
strcpy(matriz[51], “AS TARTARUGAS NINJAS“);
strcpy(matriz[52], “BAD BOYS DOIS“);
strcpy(matriz[53], “BEM-VINDO A SELVA“);
strcpy(matriz[54], “GUIANA FRANCESA“);
strcpy(matriz[55], “CISJORDANIA“);
strcpy(matriz[56], “AZERBAIJAO“);
strcpy(matriz[57], “NIGERIA“);
strcpy(matriz[58], “MARROCOS“);
strcpy(matriz[59], “PAQUISTAO“);

/*Atribuição das 30 palavras do nível difícil, ordenadas de 6

em 6 nas respectivas categorias, “Animal“, “Novela ou Mini-Série“,
“Fruta“, “Filme“ e “País“ */
strcpy(matriz[60], “AGUIA CINZENTA“);
strcpy(matriz[61], “ALBATROZ“);
strcpy(matriz[62], “BUGIO PRETO“);
strcpy(matriz[63], “GAROUPA“);
strcpy(matriz[64], “GAVIAO-QUIRIQUIQUI“);
strcpy(matriz[65], “QUERO-QUERO“);
strcpy(matriz[66], “SARAMANDAIA“);
strcpy(matriz[67], “ANJO MAU“);
strcpy(matriz[68], “VEJO A LUA NO CEU“);
strcpy(matriz[69], “O CASARAO“);
strcpy(matriz[70], “ESCRAVA ISAURA“);
strcpy(matriz[71], “O FEIJAO E O SONHO“);
strcpy(matriz[72], “SAPOTI“);
strcpy(matriz[73], “ARATICUM“);
strcpy(matriz[74], “FRAMBOESA“);
strcpy(matriz[75], “MANGABA“);
strcpy(matriz[76], “TAMARINDO“);
strcpy(matriz[77], “MARMELO“); 139
 strcpy(matriz[78], “HARRY POTTER E O ENIGMA DO PRINCIPE“);
strcpy(matriz[79], “A NOITE DOS MORTOS-BOBOS“);
strcpy(matriz[80], “A FANTASTICA FABRICA DE CHOCOLATE“);
strcpy(matriz[81], “O QUEBRA-NOZES E O REI DOS
CAMUNDONGOS“);
strcpy(matriz[82], “LADRAO QUE ROUBA LADRAO“);
strcpy(matriz[83], “CONTOS DE NOVA YORK“);
strcpy(matriz[84], “TRINIDAD E TOBAGO“);
strcpy(matriz[85], “INDONESIA“);
strcpy(matriz[86], “ESLOVENIA“);
strcpy(matriz[87], “LETONIA“);
strcpy(matriz[88], “GROENLANDIA“);
strcpy(matriz[89], “REPUBLICA DEMOCRATICA DO CONGO“);

/* Função utilizada para definir o ponto de partida para gerar

o número aleatório */
srand(time(NULL));

// Atribuição do número sorteado(0 até 29)

sorteio_parcial = rand() % 30;
/* Comando para selecionar a palavra sorteada correspondente
ao nível escolhido */
sorteio = sorteio_parcial + ((nivel - 1) * 30);

// Inicialização do vetor letras_corretas

for(i = 0; i < 30; i++)
letras_corretas[i] = ‘ ‘;

// Inicialização do vetor letras_erradas

for(i = 0; i < 7; i++)
letras_erradas[i] = ‘ ‘;

// Inicialização do vetor palavra_digitada

for (i = 0; i < 40; i++)
palavra_digitada[i] = ‘ ‘;

numero_erros = 0;

posicao_erros = 0;

140 posicao_acertos = 0;
// Atribuição da dica com relação a sorteio_parcial
if(sorteio_parcial >= 0 && sorteio_parcial <= 5)
strcpy(dica, “Animal“);
else
if(sorteio_parcial >= 6 && sorteio_parcial <= 11)
strcpy(dica, “Novela ou Mini-Serie“);
else
if(sorteio_parcial >= 12 && sorteio_parcial <= 17)
strcpy(dica, “Fruta“);
else
if(sorteio_parcial >= 18 && sorteio_parcial <= 23)
strcpy(dica, “Filme“);
else
strcpy(dica, “Pais“);
}

void jogo_da_forca::imprimir()
{
int i, j; //Contadores
// Comando condicional utilizado para imprimir
// o jogo sendo acionado pelo número de erros
// 0 indica que a forca está vazia
// 1 indica que a forca já tem a cabeça
// 2 indica cabeça e pescoço
// etc.
switch(numero_erros)
{
case 0:
cout << “ _____ “;
cout << “ “ << “Dica: “ << dica << endl;
cout << “| |“ << endl;
cout << “|“ << endl;
cout << “|“ << endl;
cout << “|“ << endl;
cout << “|“ << endl;
cout << “|“;
break;
case 1:
cout << “ _____ “;
cout << “ “ << “Dica: “ << dica << endl; 141
 cout << “| |“;
cout << “ Letras Erradas: “;
for(i = 0; i < 1; i++)
cout << letras_erradas[i] << ‘ ‘;
cout << endl;
cout << “| O“ << endl;
cout << “|“ << endl;
cout << “|“ << endl;
cout << “|“ << endl;
cout << “|“;
break;
// assim por diante…
}

//Impressão do formato do jogo

for(i = 0; i < strlen(palavra_digitada); i++)
if(palavra_digitada[i] == ‘ ‘)
cout << “ “;
else
if(palavra_digitada[i] == ‘-’)
cout << “- “;
else
if(palavra_digitada[i] == ‘_’)
cout << “__ “;
else
cout << palavra_digitada[i] << “ “;
cout << endl << endl;
}

void jogo_da_forca::letra_correta(char letra)

{
int j = 0; //Contador

// Percorre a palavra sorteada para verificar se a // letra

digitada é correta
while(matriz[sorteio][j] != letra)
j++;

// Caso a letra seja correta, ela será atribuida ao // vetor

letras_corretas
142
 if(j < strlen(matriz[sorteio]))
letras_corretas[posicao_acertos++] = letra;
}

void jogo_da_forca::letra_errada(char letra)

{
int j = 0;

// Percorre a palavra sorteada para verificar se a

// letra digitada é incorreta
while(matriz[sorteio][j] != letra)
j++;

// Caso a letra seja incorreta, ela será atribuida

// ao vetor letras_erradas
if(j > strlen(matriz[sorteio]))
{
letras_erradas[posicao_erros++] = letra;
numero_erros++;
}
}

void jogo_da_forca::monta_palavra()
{
int i, j; //Contadores

// Comando de repetição para atribuir os

// caracteres ao vetor palavra_digitada
for(i = 0; i < 40; i++)
if(matriz[sorteio][i] == ‘ ‘)
palavra_digitada[i] = ‘ ‘;
else
if(matriz[sorteio][i] == ‘-‘)
palavra_digitada[i] = ‘-‘;
else
{
j = 0;

while(matriz[sorteio][i] != letras_corretas[j]
&& j < strlen(letras_corretas))
j++; 143
 if(matriz[sorteio][i] == letras_corretas[j])
palavra_digitada[i] = letras_corretas[j];
else
palavra_digitada[i] = ‘_‘;
}
}

bool jogo_da_forca::ganhar()
{
// Faz a comparação entre a palavra_digitada
// e a palavra sorteada
if(strcmp(palavra_digitada, matriz[sorteio]) == 0)
return true;
else
return false;
}

bool jogo_da_forca::perder()
{
// Verifica se o jogador atingiu o
// limite de erros
if(numero_erros == 7)
return true;
else
return false;
}

bool jogo_da_forca::verifica_letra(char letra)

{
int i; //Contador

// Comandos de repetição para verificar se

// a letra já foi digitada
for(i = 0; i < strlen(letras_corretas); i++)
if (letras_corretas[i] == letra)
{
cout << endl << “Esta Letra Ja Foi Digitada!!!“ <<
endl << endl;
return true;
}

144
 for(i = 0; i < strlen(letras_erradas); i++)
if (letras_erradas[i] == letra)
{
cout << endl << “Esta Letra Ja Foi Digitada!!!“ <<
endl << endl;
return true;
}

return false;
}

int jogo_da_forca::jogar()
{
char letra; //Letra que o jogador insere

monta_palavra();

// Comando de repetição para verificar se o

// jogador não acertou a palavra e não atingiu
// o limite de erros
do
{
// Comando utilizado para limpar a
// tela no NetBeans
printf(“\033[2J“);
// Comando utilizado para limpar a
// tela no Dev C++
// system(“CLS“);

imprimir();

// Comando de repetição para verificar

// se a letra não foi digitada
do
{
cout << “Digite a letra: “;
cin >> letra;
letra = toupper(letra);
}
while(verifica_letra(letra));

145
 letra_correta(letra);
letra_errada(letra);
monta_palavra();
}
while(!ganhar() && !perder());

// Verifica se o jogador acertou a palavra

// sorteada ou atingiu o limite de erros
if(ganhar())
{
printf(“\033[2J“);
//system(“CLS“);
imprimir();
cout << “Voce acertou!!!“ << endl << endl;
return (EXIT_SUCCESS);
}
else
{
printf(“\033[2J“);
//system(“CLS“);
imprimir();
cout << “Voce errou!!!“ << endl << endl;
cout << “Resposta: “ << matriz[sorteio] << endl << endl;
return (EXIT_SUCCESS);
}
}

int main(int argc, char *argv[])

{

// Variável para armazenar o nível

// escolhido pelo jogador
int nivel;
char caracter[1];

// Comando de repetição para verificar

// se nível digitado é correto
do
{
// Comando de repetição para verificar

146
 // se é um inteiro
do
{
cout << “Escolha o nivel:“ << endl << endl;
cout << “ 1 - Facil“ << endl;
cout << “ 2 - Intermediario“ << endl;
cout << “ 3 - Dificil“ << endl << endl;
cout << “Nivel: “;
cin >> caracter;
cout << endl;
if(isdigit(caracter[0]) == 0)
cout<< “Nivel Invalido!!!“ << endl << endl;
}
while(isdigit(caracter[0]) == 0);

//Conversão do caracter para um inteiro

nivel = atoi(caracter);

if(nivel < 1 || nivel > 3)

cout<< “Nivel Invalido!!!“ << endl << endl;
}
while(nivel < 1 || nivel > 3);

//Declaração do objeto jogo_da_forca

jogo_da_forca jogo(nivel);

//Chamada do método jogar

jogo.jogar();
}

Sobrecarga de operadores (C++)

Um exemplo simples para entender os conceitos de orientação a objetos

seria o da classe DINHEIRO. A classe DINHEIRO deve conter dois atributos do
tipo inteiro: a) unidades e b) centavos. Ambos não podem ser negativos e os
centavos não podem ter valores superiores a 99. Assim, em todos os momentos
que os atributos possam sofrer alterações, seus possíveis novos valores devem
ser verificados. Também é interessante que valores sejam somados, subtraídos,
multiplicados e divididos. É possível, ainda, que se deseje somar valores inteiros
147
 ao dinheiro (pode-se assumir que seja soma de centavos), bem como fazer ope-
ração de pré e pós-incremento.

A implementação da classe VM a seguir não contemplou a criação de méto-

dos set e get que possibilitariam a alteração dos valores armazenados e a recu-
peração dos mesmos. O foco principal foi a sobrecarga de operadores. Os opera-
dores de entrada e saída, bem como a adição (com outro valor monetário ou com
inteiro), pré e pós-incremento e a atribuição foram as principais operações.

class VM {
friend ostream& operator<< (ostream &, VM);
friend istream& operator>> (istream &, VM);
friend VM operator+ (int, VM);
private:
int unidade, centavos;
char simbolo;
public:
VM( );
VM(char, int, int);
VM& operator++();
VM operator++(int);
VM& operator=(VM);
VM& operator=(int);
VM operator+(int);
VM operator+(VM);
};

// construtor sem parâmetros

// inicializa com o símbolo do real e os valores
// são zerados

VM::VM() {
unidade = 0;
centavos = 0;
simbolo = ‘R‘;
}

// construtor com parâmetros

// obs.: deve manter a integridade e consistência
// dos dados. Deve, portanto, verificar os valores
// atribuidos a unidade e centavos
148
VM::VM(char s, int unid, int cent){
unidade = 0;
centavos = 0;
if (cent < 0) cent = 0;
else
while (cent > 99) {
unidade++;
cent -= 100;
}
if (unid >= 0)
unidade += unid;
else
unidade = 0;
centavos = cent;
simbolo = s;
}

// operadores membros

// o pré-incremento retorna o valor já alterado

// pelo método
VM& VM::operator++() {
this->centavos++;
if (this->centavos == 100) {
this->centavos = 0;
this->unidade++;
}
return *this;
}

// o pós-incremento retorna o valor antes da

// alteração. Ou seja, retorna uma cópia do que
// era antes de ser modificado

VM VM::operator++ (int) {
VM temp(*this);

this->centavos++;
if (this->centavos == 100) {
this->centavos = 0;
this->unidade++; 149
 }
return temp; // retorna o valor anterior
// às modificações
}

// operador de atribuição recebe os valores

// armazenados em val
// deve retornar uma referência a VM

VM& VM::operator=(VM val) {

this->unidade = val.unidade;
this->centavos = val.centavos;

return *this;
}

// operador de atribuição recebe o valor

// inteiro armazenados em val
// deve retornar uma referência a VM

VM& VM::operator=(int val) {

this->unidade = val;
this->centavos = 0;
return *this;
}

// operador de adição
// realiza a operação se os símbolos forem iguais
// mantém o cuidado de não ferir a regra
// dos centavos

VM VM::operator+(VM val) {
VM temp;
if (simbolo == temp.simbolo){
temp.unidade = val.unidade + unidade;
temp.centavos = val.centavos + centavos;
if (temp.centavos > 99){
temp.centavos -= 100;
temp.unidade++;
}

150 }
 return temp;
}

// operador de adição
// realiza a operação se os símbolos forem iguais
// Não há a preocupação com os centavos, pois
// o valor alterado é apenas referente à unidade.

VM VM::operator+(int val) {
VM temp;

temp.unidade = val + unidade;

temp.centavos = centavos;

return temp;
}

// operadores não membros (friends)

ostream& operator<< (ostream &s, VM x) {

s << x.simbolo << “$“ << x.unidade << “,“ << x.centavos << endl;
return s;
}

istream& operator>> (istream &i, VM x) {

i >> x.unidade >> x.centavos;
return i;
}

// operador de adição para contemplar o caso de um

// inteiro ser adicionado a um valor monetário
// exemplo: z = 5 + y;
// para os casos onde o operando à esquerda for
// inteiro, o método a seguir será acionado

VM operator+ (int val, VM x) {

VM temp;

temp.unidade = val + x.unidade;

temp.centavos = x.centavos; 151
 return temp;
}

// o programa principal apenas cria alguns

// valores e realiza a operação z = x + y; que
// contempla dois operadores (+ e =)
// também imprime o valor calculado utilizando
// a sobrecarga do operador de saída.

int _tmain(int argc, _TCHAR* argv[])

{
VM x(‘R‘,5,50), y(‘R‘,10,80), z;

z = x + y;

cout << z;

return 0;
}

152
Referências

CARDELLI, L.; WEGNER, P. On understanding types, data abstraction, and polymorphism.

ACM Computing Surveys, New York, v. 17, n. 4, p. 471-523, Dec. 1985.
DEITEL, P. J.; DEITEL, H. M. C++: How to Program. 7. ed. Upper Saddle River: Pearson
Hall, 2009a.
______. Java: How to Program. 8. ed. Upper Saddle River: Pearson Hall, 2009b.
SEBESTA, R. W. Concepts of Programming Languages. Reading: Addison-Wesley, 2009.
STRACHEY, C. Fundamental concepts in programming languages. Higher-Order and
Symbolic Computation, v. 13, n. 1-2, p. 11-49, Apr. 2000.
TUCKER, A. B.; NOONAN, R. E. Programming Languages: Principles and Paradigms.
New York: McGraw-Hill, 2007.

153
Sobre O Autor

Ednaldo Brigante Pizzolato

Bacharel em Ciência da Computação (USP), mestre em Ciência da Computação

(UFSCar) e Doutor em Computação (University of Essex – UK), o professor
Ednaldo tem larga experiência em programação, com conhecimentos sólidos em C,
Pascal, Fortran, C++ e Java. Ministra as disciplinas de construção de algoritmos,
programação de computadores e organização e recuperação da informação para
os cursos de Ciência da Computação e Engenharia da Computação da UFSCar.
Também atua na modalidade a distância no curso de Bacharelado de Sistemas
de Informação também da UFSCar. Suas atividades de pesquisa estão associa-
das ao reconhecimento de fala por computador, visão computacional e interfaces
multimodais.
Este livro foi impresso em novembro de 2011 pelo Departamento de Produção Gráfica - UFSCar.