Exercícios de Programação Orientada Objetos

Prévia do material em texto

UNIVERSIDADE FEDERAL DE PELOTAS
CENTRO DE DESENVOLVIMENTO TECNOLÓGICO
CURSOS DE CIÊNCIA E ENGENHARIA DE COMPUTAÇÃO
Disciplina de Programação Orientada a Objetos - 2021/2
Prof.: Felipe de Souza Marques (felipem@inf.ufpel.edu.br)
Gabarito dos Exercícios de Preparação para Prova
1. (2017/1) A Programação Orientada a Objeto (POO) não é apenas uma forma de
programar, é também um jeito de pensar em um problema utilizando conceitos do
mundo real e, não somente conceitos computacionais. Considerando os conceitos da
POO e seus pilares (abstração, encapsulamento, herança e polimorfismo), analise as
afirmações abaixo.
I. O objeto tem determinadas propriedades que o caracterizam e que são
armazenadas no próprio objeto. As propriedades de um objeto são chamadas de
instâncias.
II. As mensagens são informações enviadas ao objeto para que ele se comporte de
uma determinada maneira. Um programa orientado a objetos em execução
consiste em envios, interpretações e respostas às mensagens. São os métodos, os
procedimentos residentes nos objetos, que determinam como eles irão atuar ao
receber as mensagens.
III. A herança é um mecanismo para o compartilhamento de métodos e atributos
entre classes e subclasses, permitindo a criação de novas classes através da
programação das diferenças entre a nova classe e a classe base.
IV. O encapsulamento é um mecanismo que permite o acesso aos dados de um objeto
somente através dos métodos desse. Nenhuma outra parte do programa pode
operar sobre os dados do objeto. A comunicação entre os objetos é feita apenas
através de troca de mensagens.
V. Abstração é a capacidade de poder definir classes abstratas.
VI. Considerando polimorfismo, pode-se dizer que a mesma chamada de método
pode, em momentos diferentes, invocar diferentes métodos, dependendo do tipo
dinâmico da variável utilizada para fazer essa chamada.
São CORRETAS apenas as afirmativas:
a) I, II, III
b) I, II, III e IV
c) II, III e IV
d) III, IV e VI
e) II, III, IV e VI <<<<<< Alternativa correta
f) II, III, IV, V e VI
mailto:felipem@inf.ufpel.edu.br
(2017/1) Para responder às questões de 2 a 5, considere o código das classes Java
apresentado abaixo:
1. class Hora {
2. private byte hor, min, seg;
3. public Hora (byte h, byte m, byte s) {
4. hor = h; min = m; seg = s;
5. }
6. }
7. class Data {
8. private byte dia, mes;
9. private short ano;
10. public Data(byte d, byte m, short a) {
11. dia = d; mes = m; ano = a;
12. }
13. }
14. class DataHora extends Data {
15. private Hora hora;
16. public DataHora(byte d, byte m, short a,
byte hor, byte min, byte seg)
17. {
18. super(d,m,a);
19. hora = new Hora(hor,min,seg);
20. }
21. }
22. class EntradaNaAgenda extends DataHora {
23. private String evento;
24. public EntradaNaAgenda(byte d, byte m, short a,
byte hor, byte min, byte seg, String ev)
25. {
26. super.super(d,m,a);
27. super(d,m,a,hor,min,seg);
28. evento = ev;
29. }
30. }
2. Os procedimentos realizados no método construtor da classe EntradaNaAgenda estão
corretos? Se não estão, quais seriam as instruções corretas a serem executadas.
A linha 26 deve ser excluida. A linha 27 basta para fazer a chamada correta do
método construtor da superclasse.
3. Apresente o diagrama de classes para as classes Java descritas acima.
4. Apresente a definição de uma classe denominada Agenda, cuja finalidade é armazenar
uma lista de eventos do tipo EntradaNaAgenda. Apresente apenas o código Java
referente a definição da classe, seu(s) atributo(s) e o método construtor.
public class Agenda {
private EntradaNaAgenda[] listaDeEventos;
private int numeroDeEventos;
public Agenda(int tamanhoDaLista) {
listaDeEventos = new
EntradaNaAgenda[tamanhoDaLista];
numeroDeEventos = 0;
}
}
5. Considerando a classe Agenda da questão 7 e que existe um método de acesso
getEvento na classe EntradaNaAgenda. Este método retorna uma String referente a
descrição do evento. Apresente um método para realizar a busca de um objeto
EntradaNaAgenda armazenado na lista da classe Agenda. Presume-se que este
método faz parte da classe Agenda e sua assinatura é a seguinte:
public EntradaNaAgenda buscaPorEvento(String evento) {
int i;
for (i = 0; i < tamanhoDaLista; i++)
if (listaDeEventos[i].getEvento().equals(evento))
return listaDeEventos[i];
return null;
}
6. (2018/2) Observe o diagrama abaixo:
Considere as seguintes afirmações:
I. Os tipos Heroi, Vilão, Mercador ou VilãoChefe podem ser tipos dinâmicos de uma
variável p do tipo Personagem.
II. A classe Personagem depende das classes Heroi, Vilão e Mercador.
III. A classe VilãoChefe herda as características do Vilão e do Personagem.
IV. Sabendo que não serão instanciados objetos da classe Personagem, deve-se definir esta
classe como abstrata ou como uma interface.
V. Sabendo que não serão instanciados objetos da classe Personagem e que ela possui
atributos e métodos (não-abstratos), deve-se definir esta classe como abstrata.
Assinale a alternativa correta:
a) I, III, IV e V <<<<< alternativa correta
b) I, IV e V
c) II, III e V
d) III, IV, V
e) I, IV
7. (2018/2) Considere os diagramas de classe abaixo:
Assinale verdadeiro ou falso nas afirmativas abaixo (cada resposta errada diminui 0,2 da
pontuação máxima da questão que pode ser obtida na questão):
(V) No diagrama a), uma variável do tipo Pessoa pode armazenar tanto
instâncias de objetos do tipo Funcionário quanto Cliente.
(V) Considerando o diagrama b), pode-se dizer que todo objeto Funcionário
é um Cliente e, também, uma Pessoa.
(F) Considerando o diagrama b) e assumindo que Pessoa é uma classe
abstrata, podemos dizer que ao instanciar um objeto do tipo Cliente, ele
também pode ser visto como uma Pessoa ou como um Funcionário.
(V) No diagrama c), uma instancia de um objeto Funcionário pode ser vista
tanto como Pessoa quanto Cliente.
(F) Assumindo uma implementação Java, ao considerar o diagrama c), as
classes Pessoa e Cliente são necessariamente abstratas.
(V) No diagrama a), se Pessoa é uma classe abstrata, pode-se instanciar
apenas objetos das classes Funcionário e Cliente.
(F) Em qualquer um dos diagramas, uma instância de um objeto Cliente
também pode ser visto como uma Pessoa.
(V) Em qualquer um dos diagramas, uma instância de um objeto
Funcionário também pode ser visto como Pessoa.
(V) Considerando o diagrama b), uma variável p do tipo Pessoa pode
receber uma instância de um objeto Funcionário.
(V) Assumindo uma implementação Java, ao considerar o diagrama c), se
Pessoa é uma classe abstrata, necessariamente Cliente deve ser uma
interface e vice-versa.
8. (2018/2) A linguagem Java dispõe de um suporte nativo a vetores, que exige a
definição de seu tamanho no momento da instanciação. Depois de instanciado, o
tamanho do vetor não pode ser modificado. Escreva uma classe chamada Vetor
cujos objetos simulem vetores de tamanho variável. A classe define os seguintes
métodos:
Construtor Recebe como parâmetro o tamanho inicial do vetor.
Insert Recebe como parâmetro uma String e a coloca na próxima posição
disponível do vetor; note que o vetor cresce automaticamente,
portanto, se a inserção ultrapassar o tamanho inicial estabelecido na
criação, o vetor deve aumentar seu tamanho automaticamente.
Get Recebe como parâmetro uma posição do vetor e retorna a String que
estiver naquela posição; se a posição não estiver ocupada ou
ultrapassar o tamanho do vetor, este método retorna null.
Size Retorna o número de elementos inseridos no vetor (independente do
tamanho do mesmo).
public class Vetor {
private String[] lista;
private int numeroDeElementos;
public Vetor(int tamanho) {
lista = new String[tamanho];
numeroDeElementos = 0;
}
public void insert(String elemento) {
int i;
if (numeroDeElementos < lista.length)
lista[numeroDeElementos++] = elemento;
else {
String[] novaLista = new String[lista.length * 2];
for (i = 0; i < numeroDeElementos; i++) {
novaLista[i] = lista[i];
}
lista = novaLista; // o atributo da classe passa a
referenciar o novo vetor com o dobro do tamanho
lista[numeroDeElementos++] = elemento;}
}
public String get(int indice) {
if (indice >= 0 && indice < numeroDeElementos)
return lista[indice];
return null;
}
public int size() {
return numeroDeElementos;
}
}
9. (2018/2) Dada as seguintes classes:
Representa o total de despesas de um mês
public class DespesaMes {
private int mes; // mes da despesa
private float valor; // valor da despesa
public DespesaMes(int mes, float valor) {
this.mes = mes;
this.valor = valor;
}
public int getMes() {
return mes;
}
public float getValor() {
return valor;
}
}
Representa o total de despesas de um dia
public class DespesaDia extends DespesaMes {
private int dia; // dia da despesa
public DespesaDia(int dia, int mes, float valor) {
super(mes, valor);
this.dia = dia;
}
public int getDia() {
return dia;
}
}
Escreva uma classe que representa todas as despesas de um indivíduo. Ela mantém um
vetor (ou estrutura de lista) onde podem ser registradas tanto despesas de um dia
(DespesaDia), quanto despesas de um mês (DepesaMes). A classe implementa os seguintes
métodos:
Construtor Recebe como parâmetro o CPF e um vetor com as despesas de
um indivíduo e as guarda.
getCPF Retorna o CPF do indivíduo.
totalizaMes Recebe um parâmetro com um mês (int) e retorna um objeto
da classe DespesaMes onde estará registrada a soma de todas
as despesas que o indivíduo fez naquele mês.
public class DespesasIndividuo {
private DespesaMes[] despesas;
private String cpf;
public DespesasIndividuo(String cpf, DespesaMes[] despesas)
{
this.cpf = cpf;
this.despesas = despesas;
}
public DespesaMes totalizaMes(int mes) {
int i;
float valor = 0;
if (mes > 0 && mes < 13) {
for (i = 0; i < despesas.length; i++) {
if (despesas[i].getMes() == mes)
valor += despesas[i].getValor();
}
return new DespesaMes(mes, valor);
}
return null;
}
public String getCPF() {
return cpf;
}
}
10. (2019/2) Considere, abaixo, o código fonte da classe Colaborador.
public class Colaborador extends PessoaFisica {
private String nome;
private double salario;
public void setNome(String nome) {
this.nome = nome;
}
public void setSalario(double salario) {
this.salario = salario;
}
public double calcularSalario() {
return salario * 1.10;
}
public double calcularSalario(double percentual) {
return salario + salario * percentual/100;
}
}
Neste código
a) a classe está incorreta, pois não possui os métodos getter.
b) a classe não tem construtor, nem implícito, nem explícito.
c) a classe implementa a interface PessoaFisica.
d) há sobrescrita do método calcularSalario.
e) há sobrecarga do método calcularSalario. <<<< Alternativa correta
11. (2019/1) Dada uma classe Equipamento na qual cada objeto representa um conjunto de N
equipamentos de uma empresa com seus respectivos valores, cujo diagrama UML está
representado a seguir:
construtor recebe como parâmetro o número de equipamentos e cria um
vetor de valores do respectivo tamanho.
getNumeroEquipamentos retorna o número de equipamentos.
getValor recebe como parâmetro o número do equipamento (começando de
zero) e retorna seu valor.
setValor recebe como parâmetro o número do equipamento e seu valor e
o registra.
Cada equipamento possui um código numérico sequencial, começando de zero, que corresponde
a sua posição no vetor.
Escreva uma classe, herdeira da classe Equipamento, denominada EquipamentoCorrigido em que
cada objeto representa os mesmos equipamentos com valor corrigido, conforme diagrama UML
parcial representado anteriormente.
Todo equipamento só é corrigido anualmente no mês em que foi comprado, por este motivo a
classe deve acrescentar para cada equipamento um registro do seu mês de compra. Além disto, deve
possuir os métodos:
construtor recebe como parâmetros o número de equipamentos. O objeto deve
manter registrado em um atributo o mês corrente, que deve começar
sempre em janeiro (quando o objeto é construído).
getMesCompra recebe como parâmetro o número do equipamento (começando de zero) e
retorna seu mês de compra.
setMesCompra recebe como parâmetro o número do equipamento e seu mês de compra e o
registra.
corrige este método recebe como parâmetro apenas o percentual de correção e
corrige todos os equipamentos cujo mês de compra seja igual ao mês
corrente; Cada vez que este método é chamado, após a correção, o mês é
incrementado de um e, se estiver em dezembro, retorna para janeiro.
substitui recebe como parâmetro um outro objeto da classe
EquipamentoCorrigido e substitui o valor e o mês de compra de
todos os equipamentos do objeto corrente pelos do objeto recebido
como parâmetro; a operação só será realizada se ambos os objetos
possuírem o mesmo número de equipamentos.
Note que o atributo “valor” da classe Equipamento é privado, portanto, só poderá ser acessado
indiretamente, até mesmo pela classe herdeira.
public class EquipamentoCorrigido extends Equipamento {
private int[] mesDeCompra;
private int mesCorrente;
public EquipamentoCorrigido(int numeroDeEquipamentos) {
mesDeCompra = new int[numeroDeEquipamentos];
mesCorrente = 1;
}
public int getMesCompra(int indice) {
if (indice >= 0 && indice < mesDeCompra.length) {
return mesDeCompra[indice];
}
return 0;
}
public void setMesCompra(int indice, int mes) {
if (indice >= 0 && indice < mesDeCompra.length) {
mesDeCompra[indice] = mes;
}
}
public void corrige(int percentual) {
int i;
for(i = 0; i < mesDeCompra.length; i++) {
if (mesDeCompra[i] == mesCorrente)
setValor(i, getValor(i)*(1+(percentual/100)));
}
if (mesCorrente == 12)
mesCorrente = 1;
else
mesCorrente++;
}
public void substitui(EquipamentoCorrigido equipamento) {
int i;
if (mesDeCompra.length == equipamento.length)
for (i = 0; i < mesDeCompra.length; i++) {
mesDeCompra[i] = equipamento[i];
setValor(i, equipamento.getValor(i));
}
}
}
12. (2019/2) Considere as duas declarações de interfaces na linguagem Java:
interface A {
int converte(String x);
}
interface B {
String converte(int x);
}
O programador deseja que a classe C implemente simultaneamente as interfaces A e B,
declarando C da seguinte maneira:
class C implements A, B {
// corpo da classe C
}
Nessas condições, é correto afirmar que:
a) no corpo da classe C, o método converte deverá ser definido apenas uma vez e a assinatura
será uma escolha do programador, podendo ser a prevista na declaração da interface A ou a
prevista na declaração da interface B;
b) no corpo da classe C, o método converte deverá ser definido apenas uma vez, com a
assinatura prevista na declaração da interface A, mencionada em primeiro lugar na cláusula
implements da declaração da classe C;
c) no corpo da classe C, o método converte deverá ser definido apenas uma vez, com a
assinatura prevista na declaração da interface B, mencionada em último lugar na cláusula
implements da declaração da classe C;
d) no corpo da classe C, o método converte deverá ser definido pelo menos duas vezes, sendo
que uma definição corresponderá à assinatura prevista na declaração da interface A e a outra
definição corresponderá à assinatura prevista na declaração da interface B; <<< Alternativa
correta
e) haverá um erro em tempo de compilação, assinalando ao programador a impossibilidade de a
classe C implementar simultaneamente as duas interfaces.
13. (2019/2) Crie uma hierarquia de classes para uma loja que venda livros, CDs e DVDs.
Sobrescreva o método toString() para que imprima:
● Para livros: nome, preço e autor;
● Para CDs: nome, preço e número de faixas;
● Para DVDs: nome, preço e duração.
Todos os dados dos itens vendidos devem ser inicializados a partir do método construtor de
cada classe. Evite ao máximo duplicação de código utilizando! Em seguida, crie uma classe Loja
com o método main() que adiciona 6 produtos diferentes (a sua escolha) a um vetor e, por fim,
imprima o conteúdo do vetor. Lembre que para que isso seja possível, é necessário utilizar
polimorfismo, a partir de uma classe base na hierarquia proposta. Esta classe deve ser abstrata!
public abstract class Item {
private String nome;
private double valor;
public item(String nome, doublevalor) {
this.nome = nome;
this.valor = valor;
}
@Override
public String toString() {
return “Nome: ” + nome + “ - Valor: ” + valor;
}
}
public class Livro extends Item {
private String autor;
public Livro(String nome, double valor, String autor) {
super(nome, valor);
this.autor = autor;
}
@Override
public String toString() {
return super.toString() + “\nAutor: ” + autor;
}
}
public class CD extends Item {
private int numeroDeFaixas;
public CD(String nome, double valor, int numeroDeFaixas) {
super(nome, valor);
this.numeroDeFaixas = numeroDeFaixas;
}
@Override
public String toString() {
return super.toString() + “\nNúmero de Faixas: ”
+
numeroDeFaixas;
}
}
public class DVD extends Item {
private double duracao;
public CD(String nome, double valor, double duracao) {
super(nome, valor);
this.duracao = duracao;
}
@Override
public String toString() {
return super.toString() + “\nDuração: ” + duracao;
}
}
public class Loja {
private Item[] itens;
public Loja(int tamanho) {
itens = new Item[tamanho];
}
public vois imprimir() {
int i;
for (i = 0; i < itens.length; i++) {
System.out.println(itens[i]);
}
}
public static void main(String [] args) {
Loja loja = new Loja(6);
loja.itens[0] = new Livro(“Homo Deus: Uma Breve História
do
Amanhã”, 159.90, “Yuval
Harari”);
loja.itens[1] =
new CD(“AC/DC : Highway to Hell”, 49.90,
10);
loja.itens[2] =
new CD(“Metallica : Black Album”, 64.90,
12);
loja.itens[3] = new DVD(“Pink Flyod: Pulse”, 169.50,
145);
loja.itens[4] = new Livro(“Por que Fazemos o que
Fazemos?”,
21.49, “Mário Sergio
Cortella”);
loja.itens[5] = new DVD(“Back to the Future”, 79.90 ,
116);
loja.imprimir();
}
}
14. (2019/2) Modifique o código do programa anterior, da seguinte forma:
a. Adicione um atributo que represente o código de barras do produto (é um valor obrigatório e,
portanto, deve ser pedido no construtor);
b. Sobrescreva o método equals() (da classe Object) retornando true se dois produtos possuem o
mesmo código de barras;
c. Na classe Loja, implemente um simples procedimento de busca que, dado um produto e um
vetor de produtos, indique em que posição do vetor se encontra o produto especificado ou
imprima que o mesmo não foi encontrado (considere a sua implementação do método
equals()).
// O código abaixo é uma cópia da solução da questão
anterior, // incluindo as devidas inclusões na cor azul
public abstract class Item {
private String nome;
private double valor;
// inserção para contemplar a questão 14
private String codigo;
public item(String nome, double valor, String codigo) {
this.nome = nome;
this.valor = valor;
this.codigo = codigo;
}
@Override
public String toString() {
return “Nome: ” + nome + “(” + codigo + “) - Valor: ” +
valor;
}
// Sobrescrita do método equals() para comparar dois
objetos
// da classe Item
@Override
public boolean equals(Object o) {
// Se o objeto é ele mesmo (mesmo endereço de memória),
// retorna true
if (o == this) {
return true;
}
// Verifica se ‘o’ é uma instância de Item ou não.
if (!(o instanceof Complex)) {
return false;
}
// typecasting ‘o’ para Item para comparar os códigos
Item item = (Item) o;
// Compara os códigos
return this.codigo.equals(item.codigo);
}
}
public class Livro extends Item {
private String autor;
public Livro(String nome, double valor, String codigo,
String autor)
{
super(nome, valor, codigo);
this.autor = autor;
}
@Override
public String toString() {
return super.toString() + “\nAutor: ” + autor;
}
}
public class CD extends Item {
private int numeroDeFaixas;
public CD(String nome, double valor, String codigo,
int numeroDeFaixas)
{
super(nome, valor, codigo);
this.numeroDeFaixas = numeroDeFaixas;
}
@Override
public String toString() {
return super.toString() + “\nNúmero de Faixas: ”
+
numeroDeFaixas;
}
}
public class DVD extends Item {
private double duracao;
public CD(String nome, double valor, String codigo,
double duracao)
{
super(nome, valor, codigo);
this.duracao = duracao;
}
@Override
public String toString() {
return super.toString() + “\nDuração: ” + duracao;
}
}
public class Loja {
private Item[] itens;
public Loja(int tamanho) {
itens = new Item[tamanho];
}
public vois imprimir() {
int i;
for (i = 0; i < itens.length; i++) {
System.out.println(itens[i]);
}
}
public static void main(String [] args) {
Loja loja = new Loja(6);
loja.itens[0] = new Livro(“Homo Deus: Uma Breve História
do
Amanhã”, 159.90, “010001”, “Yuval
Harari”);
loja.itens[1] =
new CD(“AC/DC : Highway to Hell”, 49.90, “010002”,
10);
loja.itens[2] =
new CD(“Metallica : Black Album”, 64.90, “010003”,
12);
loja.itens[3] =
new DVD(“Pink Flyod: Pulse”, 169.50, “010004”,
145);
loja.itens[4] = new Livro(“Por que Fazemos o que
Fazemos?”,
21.49, “010005”, “Mário Sergio
Cortella”);
loja.itens[5] =
new DVD(“Back to the Future”, 79.90, “010006”,
116);
loja.imprimir();
}
}
15. (2019/1) Dadas as seguintes interfaces:
Representa um animal
public interface Animal {
public String getNomeEspecie();
public String getNomeAnimal();
}
getNomeEspecie Retorna o nome da espécie do animal.
getNomeAnimal Retorna o nome do animal.
Representa um conjunto de rotinas utilitárias
public interface Ferramentas {
public Animal[] filtraEspecie(Animal[] completo, String
especieFiltrar);
public String[] classificaEspecies(Animal[] completo);
}
filtraEspecie Recebe como parâmetro um vetor contendo animais, que podem ser de
várias espécies diferentes, e retorna um vetor que contém apenas os
animais cuja espécie é especificada no parâmetro “especieFiltrar”. Se
não houver nenhum animal da espécie especificada, retorna um vetor
com zero posições.
classificaEspecies Recebe como parâmetro um vetor contendo animais e retorna um
vetor de String contendo o nome de todas as espécies que foram
encontradas no vetor recebido como parâmetro. Cada nome de espécie
só aparece uma vez no vetor de saída.
Escreva um método chamado contabilizaAnimaisPorEspecie que receba dois parâmetros:
● um vetor A de objetos que implementam a interface Animal representando diversos
animais;
● um objeto que implementa a interface Ferramentas.
Se preferir, utilize estruturas de dados para armazenar as coleções de dados. Por
exemplo, ArrayList pode ser utilizado no lugar de vetores (Animal[], String[], etc).
O método deve contabilizar o número de animais disponíveis em cada uma das espécies
e retornar os resultados como um mapa (Map) onde a chave deve ser uma String que
corresponde ao nome da espécie, associada a um valor inteiro que corresponde ao número de
animais daquela espécie. Devem ser consideradas apenas as espécies cujos animais estão
presentes no vetor A.
/*
Observação: ainda não vimos o uso de estruturas de dados e
coleções disponíveis em Java, como um mapa (Map), mas
apresento a solução para que vocês observem a utilização das
interfaces. Em outro momento, discutiremos este tipo de
estrutura. (Certamente, isso NÂO será cobrado na prova!)
*/
public void contabilizaAnimaisPorEspecie(Animal[] A,
Ferramentas F)
{
int i;
Animal[] animais;
Map<String, int> animaisPorEspecie = new TreeMap<>();
String[] especies = F.classificaEspecies(A);
for (i = 0; i < especies.length; i++) {
animais = F.filtraEspecie(A, especies[i]);
animaisPorEspecie.put(especies[i], animais.length);
}
return animaisPorEspecie;
}
16. (2019/1) Dada a classe ItemOrcamento que representa um item de um orçamento:
public class ItemOrcamento {
private String historico; // historico do item
private float valor; // valor do item
public ItemOrcamento(String historico, float valor) {
this.historico = historico;
this.valor = valor;
}
public String getHistorico() { return historico; }
public float getValor() { return valor; }
}
Escreva uma classe herdeira de ItemOrcamento denominada ItemOrcamentoComplexo
que mantenha um vetor com subitens de orçamento que podem ser da classe
ItemOrcamento ou da classe ItemOrcamentoComplexo. A classe implementa os seguintes
métodos:
Construtor Além dos parâmetros da superclasse, recebe como parâmetroo vetor
com os subitens de orçamento.
getValor Sobrescreve o método da superclasse, retornando a soma de valores de
todos os subitens de orçamento.
encontraItem Recebe como parâmetro o histórico de um subitem (String) e retorna o
objeto correspondente ao subitem que possui este histórico, se existir.
Se não existir retorna null.
public class ItemOrcamentoComplexo extends ItemOrcamento {
private ItemOrcamento [] itens;
public ItemOrcamentoComplexo(ItemOrcamento[] itens) {
this.itens = itens;
}
public float getValor() {
int i;
float valor = 0;
for(i = 0; i < itens.length; i++)
valor += itens[i].getValor();
return valor;
}
public ItemOrcamento encontraItem(String historico) {
int i;
for (i = 0; i < itens.length; i++)
if (itens[i].getHistorico().equals(historico))
return itens[i];
return null;
}
}
17. (2019/1) Um jardim zoológico definiu a seguinte interface que estende a interface
Animal:
public interface AnimalOrcamento extends Animal {
public ItemOrcamentoComplexo orcamentoGastosAnimal();
}
O método orcamentoGastosAnimal retorna o orçamento para gastos de um animal no
zoológico. O zoológico deseja saber quais de seus animais têm a “vacina W” prevista no
seu orçamento.
Escreva um método chamado animaisVacinados, que receba como parâmetro um vetor
de objetos que implementam a interface AnimalOrcamento representando todos os
animais do zoológico e seus respectivos orçamentos. O método deve retornar um outro
vetor de objetos que implementam a interface AnimalOrcamento apenas com aqueles
animais que possuem um subitem com histórico “vacina W” prevista no seu orçamento.
public AnimalOrcamento[] animaisVacinados(
AnimalOrcamento[] animais) {
int i, j = 0;
AnimalOrcamento[] vacinados =
new AnimalOrcamento[animais.length];
for (i = 0; i < animais.length; i++)
if (animais[i].ocamentoGastosAnimal().encontraItem(
“vacina W”) !=
null)
vacinados[j++] = animais[i];
return vacinados;
}