UNIVERSIDADE FEDERAL DO SUL E SUDESTE DO PARÁ

INSTITUTO DE GEOCIÊNCIAS E ENGENHARIAS

FACULDADE DE ENGENHARIA DA COMPUTAÇÃO
CURSO DE BACHARELADO EM ENGENHARIA DA COMPUTAÇÃO
DISCIPLINA: PROGRAMAÇÃO ORIENTADA A OBJETOS
PROF: CLAUDIO COUTINHO

2ª Lista de exercícios

1. Escreva uma classe abstrata chamada CartaoWeb. Essa classe representa todos os
tipos de cartões web e conterá apenas um atributo: destinatario (tipo String).
Implemente o construtor inicializador.
• Nessa classe você deverá também declarar o método public abstract
void showMessage().
• Crie classes filhas da classe CartaoWeb: DiaDosNamorados, Natal,
Aniversario e Amizade.
• Cada uma dessas classes deve conter um método construtor que receba o
nome do destinatário do cartão.
• Crie uma interface Dupla, que representa cartões que indicam o
remetente, com o método mostraRemetente(), que exibe o nome de
quem mandou o cartão. Cartões com remetente são: DiaDosNamorados e
Amizade.
• Cada classe também deve implementar o método showMessage(),
mostrando uma mensagem ao usuário com seu nome e que seja específica
para a data de comemorativa do cartão. Nos cartões com remetente, o
método mostraRemetente() deve ser chamado de dentro de
showMessage().
• Escreva um programa e no método main crie um array de CartaoWeb.
Insira instâncias dos 4 tipos de cartões neste array.
• Após isso, use um laço especializado para exibir as mensagens deste cartão
chamando o método showMessage().

2. Crie uma classe Calculadora. Esta classe deve ser abstrata e assinar as operações
básicas não-estáticas, que recebem dois double’s e retornam double (soma,
subtracao, divisao e multiplicacao). Utilizando o conceito de herança crie uma classe
chamada CalculadoraCientifica que implementa os seguintes cálculos: raiz
quadrada e a potência (além dos métodos herdados que deve implementar). Utilize
a classe Math do pacote java.lang. Teste todas as operações em uma classe de
teste, exibindo seus resultados na saída.
3. Crie uma hierarquia de classes conforme a Figura 1, com os seguintes atributos e
comportamentos (observe a tabela), utilize os seus conhecimentos e distribua as
características de forma que tudo o que for comum a todos os animais fique na classe
Animal.

Figura 1 - Hierarquia de Animal

• Implemente um programa que crie os 3 tipos de animais definidos acima e

invoque o método que emite o som de cada um de forma polimórfica, isto é,
independentemente do tipo de Animal;
• Implemente encapsulamento e construtores em todas as classes (use super, se
necessário);
• Implemente uma classe Veterinario que contenha um método void
examinar() cujo parâmetro de entrada é um Animal, quando o Animal for
examinado ele deve emitir um som;
• Crie uma classe Zoologico, com 6 jaulas (utilize um array). Inicialize o array
através do construtor da classe. Crie um método enjaula() que recebe um
Animal como argumento e o coloca na próxima posição livre do array (use uma
variável de controle);
• Crie uma interface intermediária AnimalQueCorre, para fornecer o
método correr() para as classes Cachorro e Cavalo. O método deve
imprimir uma String “Cachorro|Cavalo correu X metros!”, onde X
é dado por Math.random()*20;
• Em uma classe de Teste, coloque em cada jaula um Animal diferente, percorra
cada jaula faça o Veterinario examinar cada Animal.
• DESAFIO EXTRA: Se o animal for AnimalQueCorre, faça-o correr (use o
comando instanceof – será preciso fazer casting).
4. Aplicando encapsulamento e construtor, codifique a hierarquia de classes abaixo.

5. Realizar cálculos de Folha de Pagamento (FP) baseados nos tipos de empregados da

empresa. Utilizar polimorfismo com classes abstratas e métodos abstratos.

Utilizar uma superclasse abstract Empregado. Esta classe possui dentre os seus
métodos um método abstrato chamado calcularGanho() e um atributo double
salario. As subclasses de Empregado são:

• Chefe: empregado pago com um salário fixo semanal independentemente

do número de horas trabalhadas. O retorno do método ganho desta classe é
o próprio valor atribuído ao atributo salario. Consultar diagrama;

• TrabalhadorComissionado: empregado pago com um salário fixo mais

uma porcentagem sobre as vendas. O retorno do método ganho desta classe
é o resultado da operação sobre os valores dos atributos desta classe da
seguinte forma: salario+(comissao*quantidade);

• TrabalhadorPecaProduzida: empregado pago pelo número de itens

produzidos. O retorno do método ganho desta classe é o resultado da
operação sobre os valores dos atributos desta classe da seguinte forma:
remuneracaoPorItem*quantidade; Obs: o salário desta classe é 0.0;

• TrabalhadorHora: empregado que é pago por hora e que recebe um

adicional por hora extra trabalhada além do salário. O retorno do método
ganho desta classe é o resultado da operação sobre os valores dos desta
 classe da seguinte forma: salario+(salarioHora*horas). O salário
por hora representa 10% do salário principal (valor atribuído
automaticamente no construtor).

A chamada de método ganho pode ser aplicado genericamente a todos os tipos de

empregados. Mas a maneira como os rendimentos de cada pessoa são calculados
depende da classe Empregado, da qual essas classes derivam. Então o método
calcularGanho() é declarado abstract na superclasse Empregado e as
implementações apropriadas deste método são preparadas para cada uma das
subclasses. Portanto, para calcular os rendimentos de qualquer empregado, o
programa pode utilizar uma referência de superclasse para o objeto desse
empregado e invocar o método calcularGanho().

a) Em uma classe de Teste, crie um Empregado de cada tipo e armazene em um

array. Após isto, com o auxílio de um laço especializado, exiba o ganho de cada
um.
b) Construa graficamente o Diagrama de Classes UML do problema acima.

Observação: A classe Empregado deve ter o seguinte construtor:

• public Empregado(double salario);

6. Crie a seguinte hierarquia de classes:

• uma interface para representar qualquer forma geométrica, definindo
métodos para cálculo do perímetro e cálculo da área da forma;
• uma classe abstrata para representar quadriláteros. Seu construtor deve
receber os tamanhos dos 4 lados e o método de cálculo do perímetro já pode
ser implementado; O cálculo da área não precisa ser implementado nessa
classe.
• classes para representar retângulos e quadrados. A primeira deve receber
o tamanho da base e da altura no construtor, enquanto a segunda deve
receber apenas o tamanho do lado.
• uma classe para representar um círculo. Seu construtor deve receber o
tamanho do raio.

No programa principal, pergunte ao usuário quantas formas ele deseja criar. Em

seguida, para cada forma, pergunte se deseja criar um quadrado, um retângulo ou
um círculo, solicitando os dados necessários para criar a forma. Todas as formas
criadas devem ser armazenadas em um vetor. Finalmente, imprima:
(a) os dados (lados ou raio);
(b) os perímetros; e
(c) as áreas de todas as formas.
Para (b) e (c), tire vantagem do polimorfismo, enquanto que para (a) utilize
instanceof.

7. Codifique a seguinte hierarquia de classes e interfaces.

 Em uma classe de Teste, crie dois objetos de cada classe, imprimindo suas
informações (dependendo da classe, você usará o método específico para essa ação
ou simplesmente os métodos de encapsulamento).

8. Identifique e explique o(s) erro(s), se existir, nas classes abaixo. Qual(is) o(s)
conceito(s) de Orientação a Objetos está(ão) presente(s) no código abaixo?
Explique.

9. Identifique e explique o(s) erro(s), se existir, nas classes abaixo. Qual(is) o(s)
conceito(s) de Orientação a Objetos está(ão) presente(s) no código abaixo?
Explique.
10. Identifique e explique o(s) erro(s) na classe abaixo.
11. Identifique e explique o(s) erro(s), se existir, nas classes abaixo. Qual(is) o(s)
conceito(s) de Orientação a Objetos está(ão) presente(s) no código abaixo?
Explique.