Lista Exercicios 10 Orientacao a Objetos (OO) (Professor) (1)

Prévia do material em texto

1 
 
Lista de Exercícios 10 – Orientação a Objetos 
 
1. Defina uma classe chamada TIPO com os seguintes atributos: código e percentual. Os percentuais devem 
seguira tabela abaixo. 
TIPO % de imposto 
1. Alimentação 10 
2. Limpeza 20 
 
Defina uma classe chamada PRODUTO com os seguintes atributos: descricao, tipo (que deve existir na classe 
TIPO), preco e imposto. Também deve conter o método calcular o preço final, ou seja, preço mais imposto. Faça 
um programa que carregue os dados de um produto e mostre seu preço final. 
//Tipo.java 
package lista10; 
 
public class Tipo { 
 private int codigo; 
 private double percentual; 
 
 public void setCodigo(int c){ 
 codigo = c; 
 } 
 
 public int getCodigo(){ 
 return codigo; 
 } 
 
 public void setPercentual(double p){ 
 percentual = p; 
 } 
 
 public double getPercentual(){ 
 return percentual; 
 } 
 
} 
//Produto.java 
package lista10; 
 
public class Produto { 
 private String descricao; 
 private Tipo tipo; 
 private double preco; 
 private double imposto; 
 
 public Produto(){ 
 
 } 
 
 public void setDescricao(String n){ 
 descricao = n; 
 } 
 
 public String getDescricao(){ 
 return descricao; 
 } 
 
 public void setTipo(Tipo t){ 
 tipo = t; 
 setImposto(preco * tipo.getPercentual()/100); 
 } 
2 
 
 
 private void setImposto(double i){ 
 imposto = i; 
 } 
 
 public Tipo getTipo(){ 
 return tipo; 
 } 
 
 public void setPreco(double p){ 
 preco = p; 
 } 
 
 public double getPreco(){ 
 return preco; 
 } 
 
 public double getImposto(){ 
 return imposto; 
 } 
 
 public double calcularPrecoFinal(){ 
 return preco + imposto; 
 } 
} 
//Ex1.java 
package lista10; 
 
import java.util.*; 
 
public class Ex1 { 
 public static void main(String[] args){ 
 Scanner entrada = new Scanner(System.in); 
 Tipo tipos[] = new Tipo[2]; 
 tipos[0] = new Tipo(); 
 tipos[0].setCodigo(1); 
 tipos[0].setPercentual(10); 
 tipos[1] = new Tipo(); 
 tipos[1].setCodigo(2); 
 tipos[1].setPercentual(20); 
 
 String descAux; 
 double precoAux; 
 int tipoAux; 
 Produto p = new Produto(); 
 System.out.println("\nDigite a descrição do produto: "); 
 descAux = entrada.next(); 
 p.setDescricao(descAux); 
 System.out.println("\nDigite o preço do produto: "); 
 precoAux = entrada.nextDouble(); 
 p.setPreco(precoAux); 
 System.out.println("\nDigite o tipo do produto: "); 
 tipoAux = entrada.nextInt(); 
 while (tipoAux != 1 && tipoAux != 2) 
 { 
 System.out.println("\nTipo Inválido. Digite novamente: "); 
 tipoAux = entrada.nextInt(); 
 } 
 p.setTipo(tipos[tipoAux-1]); 
 System.out.println("\nPreço Final = " + p.calcularPrecoFinal()); 
3 
 
 } 
} 
 
2. Refazer o exercício anterior para cadastrar cinco produtos. Para cada produto, mostrar o preço final e, 
posteriormente, calcular e mostrar a média dos preços finais dos produtos e a quantidade de produtos com preço 
final superior a 40. 
//Ex2.java 
package lista10; 
 
import java.util.*; 
 
public class Ex2 { 
 public static void main(String[] args){ 
 Scanner entrada = new Scanner(System.in); 
 Tipo tipos[] = new Tipo[2]; 
 tipos[0] = new Tipo(); 
 tipos[0].setCodigo(1); 
 tipos[0].setPercentual(10); 
 tipos[1] = new Tipo(); 
 tipos[1].setCodigo(2); 
 tipos[1].setPercentual(20); 
 
 String descAux; 
 double precoAux, m, soma = 0; 
 int tipoAux, i, qtd = 0; 
 Produto p[] = new Produto[5]; 
 for(i=0; i<5; i++) 
 { 
 p[i] = new Produto(); 
 System.out.println("\nDigite a descrição do Produto: "); 
 descAux = entrada.next(); 
 p[i].setDescricao(descAux); 
 System.out.println("\nDigite o preço do Produto: "); 
 precoAux = entrada.nextDouble(); 
 p[i].setPreco(precoAux); 
 System.out.println("\nDigitte o tipo do Produto: "); 
 tipoAux = entrada.nextInt(); 
 while(tipoAux != 1 && tipoAux != 2) 
 { 
 System.out.println("\nTipo Inválido. Digite Novamente: "); 
 tipoAux = entrada.nextInt(); 
 } 
 p[i].setTipo(tipos[tipoAux-1]); 
 System.out.println("\nPreço Final = " + p[i].calcularPrecoFinal()); 
 soma = soma + p[i].calcularPrecoFinal(); 
 if (p[i].calcularPrecoFinal() > 40) 
 qtd++; 
 } 
 m = soma/5; 
 System.out.println("Média = " + m); 
 System.out.println("Quantidade = " + qtd); 
 } 
} 
 
3. Defina uma classe denominada CARGO com os seguintes atributos: número do cargo e valor da hora 
trabalhada. Defina uma classe FUNCIONARIO com os seguintes atributos: código do cargo, sexo e quantidade 
de horas trabalhadas. Essa classe deve possuir ainda, um método para calcular o salário final, ou seja, o salário 
de acordo com o cargo (valor da hora trabalhada * número de horas trabalhadas) mais o adicional, ou seja, para 
o sexo feminino (F ou f), adicionar 20% sobre o salário calculado; e para o sexo masculino (M ou m), não tem 
direito ao adicional. Faça um programa que carregue os dados de três cargos e um funcionário, calcule e mostre 
seu salário final. 
4 
 
//Cargo.java 
package lista10; 
 
public class Cargo { 
 private int numero; 
 private double valorHora; 
 
 public Cargo(){ 
 } 
 
 public void setNumero(int n) 
 { 
 numero = n; 
 } 
 
 public int getNumero() 
 { 
 return numero; 
 } 
 
 public void setValorHora(double vh) 
 { 
 valorHora = vh; 
 } 
 
 public double getValorHora() 
 { 
 return valorHora; 
 } 
 
} 
//Funcionario.java 
package lista10; 
 
public class Funcionario{ 
 private Cargo cargoFuncionario; 
 private char sexo; 
 private double adicional; 
 private double quantidadeHoras; 
 private double salarioBruto; 
 
 public Funcionario(){ 
 System.out.println("Executando Construtor da Classe abstrata Funcionário"); 
 } 
 
 public void setCargoFuncionario(Cargo c){ 
 cargoFuncionario = c; 
 setSalarioBruto(quantidadeHoras * cargoFuncionario.getValorHora()); 
 } 
 
 public void setSalarioBruto(double sb){ 
 salarioBruto = sb; 
 } 
 
 public Cargo getCargoFuncionario(){ 
 return cargoFuncionario; 
 } 
 
 public void setSexo(char s) 
 { 
5 
 
 sexo = s; 
 } 
 
 public char getSexo() 
 { 
 return sexo; 
 } 
 
 public void setAdicional(double a) 
 { 
 adicional = a; 
 } 
 
 public double getAdicional() 
 { 
 return adicional; 
 } 
 
 public void setQuantidadeHoras(double qh) 
 { 
 quantidadeHoras = qh; 
 } 
 
 public double getQuantidadeHoras() 
 { 
 return quantidadeHoras; 
 } 
 
 public double getSalarioBruto() 
 { 
 return salarioBruto; 
 } 
 
 public double calculaSalarioFinal() 
 { 
 return salarioBruto + salarioBruto * adicional/100; 
 } 
 
} 
//Ex3.java 
package lista10; 
 
import java.util.*; 
 
public class Ex3 { 
 public static void main(String[] args){ 
 Scanner dado = new Scanner(System.in);Cargo cargos[] = new Cargo[3]; 
 Funcionario f = new Funcionario(); 
 
 cargos[0] = new Cargo(); 
 cargos[0].setNumero(1); 
 cargos[0].setValorHora(15); 
 cargos[1] = new Cargo(); 
 cargos[1].setNumero(2); 
 cargos[1].setValorHora(20); 
 cargos[2] = new Cargo(); 
 cargos[2].setNumero(3); 
 cargos[2].setValorHora(32); 
 
6 
 
 int cargof; 
 double q; 
 char s; 
 System.out.println("\nDigite a quantidade de horas trabalhadas: "); 
 q = dado.nextDouble(); 
 f.setQuantidadeHoras(q); 
 System.out.println("\nDigite o cargo do funcionario: "); 
 cargof = dado.nextInt(); 
 f.setCargoFuncionario(cargos[cargof-1]); 
 System.out.println("\nDigite o sexo: "); 
 s = dado.next().charAt(0); 
 f.setSexo(s); 
 if (f.getSexo() == 'M') 
 f.setAdicional(0); 
 else 
 f.setAdicional(20); 
 System.out.println("\nSalário Final = " + f.calculaSalarioFinal()); 
 } 
} 
 
4. Uma imobiliária comercializa 2 tipos de imóveis (1 – terrenos e 2 – casas). Cada tipo de imóvel possui 
características diferentes. 
Todo e qualquer imóvel possui um proprietário, uma quadra, um lote, uma área, um valor de venda, situação (1- 
á venda; 2- vendido; 3- em negociação) e valor da comissão (não pode ultrapassar 10% do valor do imóvel). 
Casas possuem informação da área construída. 
Cada tipo de imóvel tem um cálculo de IPTU diferente. 
 Imóvel territorial: IPTU = 2% do valor do imóvel 
 Casas: IPTU = 1% do valor do imóvel 
Implemente classes que representem a realidade acima apresentada. 
Utilize modificadores de acesso nos atributos e métodos de tal forma que se garanta o máximo possível de 
encapsulamento dos objetos. 
Crie uma aplicação para: 
- Cadastrar, no máximo, 30 imóveis; 
- Alterar a situação de cada imóvel, lembrando que: 
 - se a nova situação for à venda ou, em negociação, o valor da comissão será zero. 
 - se a situação for alterada para vendido, deve ser solicitado o percentual para o calculo da comissão. 
- Mostrar o somatório dos valores de todos os imóveis. 
- Mostrar o somatório dos valores de todas as comissões. 
 
//Imovel.java 
package lista10; 
 
public class Imovel { 
 private String proprietario; 
 private String quadra; 
 private int lote; 
 private double area; 
 private double valorIptu; 
 private String situacao; 
 private double valorVenda; 
 private double valorComissaoPaga; 
 
 public Imovel(){ 
 super(); 
 situacao = new String("a venda"); 
 valorComissaoPaga = 0; 
 } 
 
 public String getProprietaria(){ 
 return proprietario; 
 } 
7 
 
 
 public void setProprietario(String proprietario){ 
 this.proprietario = proprietario; 
 } 
 
 public String getQuadra(){ 
 return quadra; 
 } 
 
 public void setQuadra(String quadra){ 
 this.quadra = quadra; 
 } 
 
 public int getLote(){ 
 return lote; 
 } 
 
 public void setLote(int lote){ 
 this.lote = lote; 
 } 
 
 public double getArea(){ 
 return area; 
 } 
 
 public void setArea(double area){ 
 this.area = area; 
 } 
 
 public double getValorIptu(){ 
 return valorIptu; 
 } 
 
 public void setValorIptu(double valorIptu){ 
 this.valorIptu = valorIptu; 
 } 
 
 public String getSituacao(){ 
 return situacao; 
 } 
 
 public void setSituacao(String situacao){ 
 this.situacao = situacao; 
 } 
 
 public double getValorVenda(){ 
 return valorVenda; 
 } 
 
 public void setValorVenda(double valorVenda){ 
 this.valorVenda = valorVenda; 
 } 
 
 public double getValorComissaoPaga(){ 
 return valorComissaoPaga; 
 } 
 
 public void setValorComissaoPaga(double valor){ 
 if(valor > 10) 
 valor = 10; //limitado a comissao a 10% do valor do imóvel 
 this.valorComissaoPaga = valorVenda * valor /100; 
8 
 
 } 
} 
/* Casa.java 
 Esta é uma das subcasses do Imóvel. Na classe Casa ficam os atributos pertinentes 
 apenas ao objetos do tipo Casa, além de seu método para cálculo do IPTU. 
 */ 
package lista10; 
 
public class Casa extends Imovel { 
 private double areaConstruida; 
 
 public Casa(){ 
 /* Casa.java 
 Esta é uma das subcasses do Imóvel. Na classe Casa ficam os atributos pertinentes 
 apenas ao objetos do tipo Casa, além de seu método para cálculo do IPTU. 
 */ super(); 
 } 
 
 public double getAreaConstruida(){ 
 return areaConstruida; 
 } 
 
 public void setAreaConstruida(double areaConstruida){ 
 this.areaConstruida = areaConstruida; 
 } 
 
 public void calcularIptu() { 
 super.setValorIptu(super.getValorVenda()* 1/100); 
 } 
} 
/* Terreno.java 
 Esta é uma das subcasses do Imóvel. Na classe Terreno não há declaração de atributos, 
 pois todas as características necessárias aos objetos desse tipo foram herdadas da 
 superclasse Imóvel. Contudo, a classe Terreno contém sua implementação própria do 
 calculo do IPTU. 
 */ 
 
package lista10; 
 
public class Terreno extends Imovel { 
 
 public Terreno(){ 
 super(); 
 } 
 
 public void calcularIptu(){ 
 super.setValorIptu(super.getValorVenda() * 2/100); 
 } 
} 
//Imobiliaria.java 
package lista10; 
 
import javax.swing.JOptionPane; 
 
public class Imobiliaria { 
 public static void main(String[] args){ 
 Imovel imoveis[] = new Imovel[30]; 
 int opcao, tipo, contImovel = 0; 
 
 do{ 
9 
 
 opcao = menu(); 
 
 if (opcao == 1){ 
 tipo = Integer.parseInt(JOptionPane.showInputDialog("Escolha o tipo de imóvel: \n1- Casa; 2 - Terreno")); 
 
 
 if (tipo == 1){ 
 Casa auxCasa = geraNovaCasa(); 
 contImovel = cadastraNovoImovel(imoveis, contImovel, auxCasa); 
 } 
 else { 
 if (tipo == 2){ 
 Terreno auxTerreno = geraNovoTerreno(); 
 contImovel = cadastraNovoImovel(imoveis, contImovel, auxTerreno); 
 } 
 else{ 
 JOptionPane.showMessageDialog(null, "Escolha Errada. Observe os tipos de imóveis válidos!"); 
 } 
 } 
 } 
 
 if (opcao == 2){ 
 alterarSituacaoImovel(imoveis, contImovel); 
 } 
 
 if (opcao == 3){ 
 double valorTotalImoveis = gerarValorTotalDosImoveis(imoveis, contImovel); 
 JOptionPane.showMessageDialog(null, "O somatório do valor de venda dos imóveis é " + valorTotalImoveis); 
 } 
 
 if (opcao == 4){ 
 double valorTotalComissoes = gerarValorTotalComissaoImoveis(imoveis, contImovel); 
 JOptionPane.showMessageDialog(null, "O somatório do valor das comissões dos imóveis vendidos é " + 
valorTotalComissoes); 
 } 
 
 if (opcao == 5){ 
 JOptionPane.showMessageDialog(null, "Finalizando execução da aplicação."); 
 } 
 
 if (opcao < 1 || opcao > 5){ 
 JOptionPane.showMessageDialog(null, "Opção Inválida"); 
 } 
 }while(opcao != 5); 
} 
 
/* 
 O método menu é responsável por mostrar na tela todas as opções e permitir que o usuário 
 escolha uma delas. 
 */ 
 
public static int menu(){ 
 String msg = new String(); 
 msg += "1 - Cadastrar Imóvel \n"; 
 msg += "2 - Alterar situação deum Imóvel \n"; 
 msg += "3 - Somatório do valor dos Imóveis \n"; 
 msg += "4 - Somatório do valor das Comissões \n"; 
 msg += "5 - Finalizar execução \n"; 
 msg += "Digite a opção desejada: \n"; 
 return Integer.parseInt(JOptionPane.showInputDialog(msg)); 
} 
10 
 
 
/* 
 * O método gerarNovoTerreno cria uma nova instância da classe Terreno, atribui valores a todos 
 * os seus atributos e retorna esse novo objeto. 
 */ 
 
public static Terreno geraNovoTerreno(){ 
 Terreno novoTerreno = new Terreno(); 
 novoTerreno.setProprietario(JOptionPane.showInputDialog("Digite o nome do proprietário: ")); 
 novoTerreno.setQuadra(JOptionPane.showInputDialog("Digite a quadra: ")); 
 novoTerreno.setLote(Integer.parseInt(JOptionPane.showInputDialog("Digite o lote: "))); 
 novoTerreno.setArea(Double.parseDouble(JOptionPane.showInputDialog("Digite a área: "))); 
 novoTerreno.setValorVenda(Double.parseDouble(JOptionPane.showInputDialog("Digite o valor de venda: "))); 
 return novoTerreno; 
} 
 
/* 
 * O método geraNovaCasa cria uma nova instância da classe Casa, atribui valores a todos 
 * os seus atributos e retorna esse novo objeto. 
 */ 
public static Casa geraNovaCasa(){ 
 Casa novaCasa = new Casa(); 
 novaCasa.setProprietario(JOptionPane.showInputDialog("Digite o nome do proprietário: ")); 
 novaCasa.setQuadra(JOptionPane.showInputDialog("Digite a quadra: ")); 
 novaCasa.setLote(Integer.parseInt(JOptionPane.showInputDialog("Digite o lote: "))); 
 novaCasa.setArea(Double.parseDouble(JOptionPane.showInputDialog("Digite a área: "))); 
 novaCasa.setValorVenda(Double.parseDouble(JOptionPane.showInputDialog("Digite o valor de venda: "))); 
 novaCasa.setAreaConstruida(Double.parseDouble(JOptionPane.showInputDialog("Digite o área construída: "))); 
 return novaCasa; 
} 
 
/* O método cadastraNovoImovel é responsável por guardar a referência de um novo objeto 
 * dentro do vetor de imóveis. 
 * Importante observar que esse método pode ser utilizado para guardar referência para 
 * qualquer objeto considerado imóvel, quer seja Terreno, quer seja Casa (polomorfismo). 
 */ 
public static int cadastraNovoImovel(Imovel imoveis[], int contImovel, Imovel auxiliar){ 
 if (contImovel < imoveis.length){ 
 imoveis[contImovel] = auxiliar; 
 contImovel++; 
 } 
 else JOptionPane.showMessageDialog(null,"Vetor de imóveis já está totalmente preenchido. "); 
 return contImovel; 
} 
 
// O método gerarValorTotalDosImoveis soma o valor de todos os imóveis cadastrados. 
 
public static double gerarValorTotalDosImoveis(Imovel imoveis[], int contImovel){ 
 double total = 0; 
 for (int i=0; i<contImovel; i++) 
 total += imoveis[i].getValorVenda(); 
 return total; 
} 
 
/* O método gerarValorTotalComissaoImoveis soma a comissao obtida com todos os imóveis 
 * vendidos. 
 */ 
 
public static double gerarValorTotalComissaoImoveis(Imovel imoveis[], int contImovel){ 
 double total = 0; 
 for (int i=0; i<contImovel; i++) 
11 
 
 total += imoveis[i].getValorComissaoPaga(); 
 return total; 
} 
 
/* 
 * O método alterarSituaçãoImovel muda a situação de um imóvel. Caso o imóvel mude para 
 * vendido, a comissão é calculada. Caso o imóvel mude de vendido para qualquer outra 
 * situação, a comissão recebe zero. 
 */ 
 
public static void alterarSituacaoImovel(Imovel imoveis[], int contImovel){ 
 int indice; 
 String novaSituacao= "";;; 
 indice = Integer.parseInt(JOptionPane.showInputDialog("Digite o índice do imóvel desejado: ")); 
 if (indice >=0 && indice < imoveis.length){ 
 novaSituacao = JOptionPane.showInputDialog("A situação atual do imóvel é : " + imoveis[indice].getSituacao() + "\n 
Digite a nova situação (a venda, vendido ou em negociação)"); 
 while(novaSituacao.equalsIgnoreCase(imoveis[indice].getSituacao())) 
 { 
 novaSituacao = JOptionPane.showInputDialog("ERRO! A situação atual do imóvel é: " + 
imoveis[indice].getSituacao() + ". \n Digite a nova situação (a venda, vendido ou em negociação)"); 
 } //fim while 
 
 if (novaSituacao.equalsIgnoreCase("vendido")) { 
 imoveis[indice].setValorComissaoPaga(Double.parseDouble(JOptionPane.showInputDialog("Digite a % da 
comissão: "))); 
 } 
 if (novaSituacao.equalsIgnoreCase("a venda")){ 
 imoveis[indice].setValorComissaoPaga(0); 
 } 
 imoveis[indice].setSituacao(novaSituacao); 
 } 
 else 
 JOptionPane.showMessageDialog(null, "indice Inválido!"); 
} 
 
} 
 
5. Uma farmácia necessita controlar todos os produtos que comercializa. Sabe-se que nesse estabelecimento os 
produtos comercializados são medicamentos e artigos e higiene. Os medicamentos possuem código, descrição, 
preço de compra, percentual de lucro e data de vencimento. Os produtos de higiene possuem código, descrição 
e preço de compra. Sabe-se que todo produto de higiene gera como lucro 30% do preço de compra. 
Crie classes que representem o contexto descrito. 
Depois disso, você deverá: 
a) Criar um método que permita cadastrar um produto (cadastre um por vez): 
- no momento do cadastro deverá ser feita uma verificação para não aceitar códigos repetidos (crie um 
método especificamente para fazer essa verificação); 
- o usuário decidirá se deseja cadastrar um medicamento ou um produto de higiene; 
- ao final do cadastramento, utilize o método apropriado para calcular o lucro do produto; 
- poderão ser cadastrados no m 
b) Crie um método para mostrar todas as informações do produto mais caro (pode ser um medicamento ou um 
produto de higiene). 
c) Mostre todos os dados de todos os produtos vendidos na loja. 
d) Crie um método que permita alterar os dados de determinado produto cujo código é informado pelo usuário 
(se for informado código inválido, mostre a mensagem “Produto inexistente”). 
 
//Produto.java 
package lista10; 
 
public abstract class Produto { 
 private int codigo; 
12 
 
 private String descricao; 
 private float precoDeCompra; 
 private float percentualDeLucro; 
 
 public int getCodigo(){ 
 return codigo; 
 } 
 
 public void setCodigo(int codigo){ 
 this.codigo = codigo; 
 } 
 
 public void setDescricao(String descricao){ 
 this.descricao = descricao; 
 } 
 
 public String getDescricao(){ 
 return descricao; 
 } 
 
 public void setPrecoDeCompra(float precoDeCompra){ 
 this.precoDeCompra = precoDeCompra; 
 } 
 
 public float getPrecoDeCompra(){ 
 return precoDeCompra; 
 } 
 
 public float getPercentualDeLucro(){ 
 return percentualDeLucro; 
 } 
 
 public void setPercentualDeLucro(float percentualDeLucro){ 
 this.percentualDeLucro = percentualDeLucro; 
 } 
 
 public abstract float gerarPrecoDeVenda(); 
 
 public abstract void definirPercentualDeLucro(); 
 
} 
//Remedio.java 
package lista10; 
 
import javax.swing.JOptionPane; 
 
public class Remedio extends Produto { 
 public float gerarPrecoDeVenda(){ 
 return (super.getPrecoDeCompra() + super.getPrecoDeCompra() * super.getPercentualDeLucro()/100); 
 } 
 public void definirPercentualDeLucro(){ 
 super.setPercentualDeLucro(Float.parseFloat(JOptionPane.showInputDialog("Digite o percentual de lucro do 
produto: "))); 
 } 
} 
//Higiene.java 
package lista10; 
 
public class Higiene extends Produto { 
 public float gerarPrecoDeVenda(){ 
13 
 
 return (super.getPrecoDeCompra() + super.getPrecoDeCompra() * 30/100); 
 } 
 public void definirPercentualDeLucro(){ 
 super.setPercentualDeLucro(30); 
 } 
} 
//ContoleDaFarmacia.java 
package lista10; 
 
import javax.swing.JOptionPane;public class ControleDaFarmacia { 
 public static void main(String[] args){ 
 Produto produto[] = new Produto[15]; 
 int opcao, contador = 0; 
 
 do{ 
 opcao = menu(); 
 switch(opcao) 
 { 
 case 1: if (contador == produto.length) 
 JOptionPane.showMessageDialog(null, "Vetor completamente preenchido!"); 
 else contador = cadastrarProduto(produto, contador); 
 break; 
 case 2: if (contador == 0) 
 JOptionPane.showMessageDialog(null, "Nenhum produto cadastrado!"); 
 else mostrarMaisCaro(produto, contador); 
 break; 
 case 3: if(contador == 0) 
 JOptionPane.showMessageDialog(null, "Nenhum produto cadastrad!o"); 
 else mostrarProdutoEmEstoque(produto, contador); 
 break; 
 case 4: if (contador == 0) 
 JOptionPane.showMessageDialog(null, "Nenhum produto cadastrado!"); 
 else alterarDadosDeUmProduto(produto, contador); 
 
 } // fim switch 
 } while(opcao != 5); 
 }//fim main 
 
 public static int menu(){ 
 int opcao; 
 String mensagem; 
 mensagem = "1 - Cadastrar Produto \n"; 
 mensagem += "2 - Mostrar detalhes do Produto mais caro \n"; 
 mensagem += "3 - Mostrar Produtos em estoque \n"; 
 mensagem += "4 - Alterar dados de um Produto \n"; 
 mensagem += "5 - Finalizar Programa \n"; 
 opcao = Integer.parseInt(JOptionPane.showInputDialog(mensagem)); 
 return opcao; 
 } 
 
 public static int cadastrarProduto(Produto p[], int c){ 
 int tipo; 
 do { 
 tipo = Integer.parseInt(JOptionPane.showInputDialog("1 - para cadastrar Remedio ou 2 - para cadastrar produto 
de Higiene: ")); 
 }while (tipo != 1 && tipo != 2); 
 
 if (tipo == 1){ 
14 
 
 Remedio auxiliar = new Remedio(); 
 auxiliar.setCodigo(c+1); 
 auxiliar.setDescricao(JOptionPane.showInputDialog("Digite a descrição do produto: ")); 
 auxiliar.setPrecoDeCompra(Float.parseFloat(JOptionPane.showInputDialog("Digite o preço de compra do 
produto: "))); 
 auxiliar.definirPercentualDeLucro(); 
 JOptionPane.showMessageDialog(null, "Preço de Venda = " + auxiliar.gerarPrecoDeVenda()); 
 p[c] = auxiliar; 
 } 
 else{ 
 Higiene auxiliar = new Higiene(); 
 auxiliar.setCodigo(c+1); 
 auxiliar.setDescricao(JOptionPane.showInputDialog("Digite a descrição do produto: ")); 
 auxiliar.setPrecoDeCompra(Float.parseFloat(JOptionPane.showInputDialog("Digite o preço de compra do 
produto: "))); 
 auxiliar.setPercentualDeLucro(30); 
 JOptionPane.showMessageDialog(null, "Preço de venda = " + auxiliar.gerarPrecoDeVenda()); 
 p[c] = auxiliar; 
 } 
 c++; 
 return c; 
 } //fim cadastrar produto 
 
 public static void alterarDadosDeUmProduto(Produto p[], int c){ 
 int codigo; 
 codigo = Integer.parseInt(JOptionPane.showInputDialog("Digite o código do produto a ser alterado: ")); 
 if (codigo < 1 || codigo >= c) 
 JOptionPane.showMessageDialog(null, "Produto Inexistente!"); 
 else{ 
 p[codigo-1].setDescricao(JOptionPane.showInputDialog("Digite a nova descrição: ")); 
 p[codigo-1].setPrecoDeCompra(Float.parseFloat(JOptionPane.showInputDialog("Digite o novo preço de compra: 
"))); 
 p[codigo-1].definirPercentualDeLucro(); 
 JOptionPane.showMessageDialog(null, "Novo Lucro = " + p[codigo-1].gerarPrecoDeVenda()); 
 } 
 }// fim alterarDadosDeUmProduto 
 
 public static void mostrarProdutoEmEstoque(Produto p[], int c){ 
 int cont; 
 String msg = ""; 
 for (cont = 0; cont < c; cont++){ 
 msg = msg + "\nCodigo: " + p[cont].getCodigo(); 
 msg = msg + "\nDescrição: " + p[cont].getDescricao(); 
 msg = msg + "\nPreço de Compra: " + p[cont].getPrecoDeCompra(); 
 msg = msg + "\n% de Lucro: " + p[cont].getPercentualDeLucro(); 
 msg = msg + "\nPreço de Venda: " + p[cont].gerarPrecoDeVenda(); 
 JOptionPane.showMessageDialog(null, msg); 
 msg = ""; 
 } 
 }//fim mostrarProdutosEmEstoque 
 
 public static void mostrarMaisCaro(Produto p[], int c){ 
 float maiorPreco; 
 int indiceDoMaior, cont; 
 String msg = ""; 
 maiorPreco = p[0].getPrecoDeCompra(); 
 indiceDoMaior = 0; 
 for (cont = 1; cont < c; cont ++){ 
 if (p[cont].getPrecoDeCompra() > maiorPreco){ 
 maiorPreco = p[cont].getPrecoDeCompra(); 
 indiceDoMaior = cont; 
15 
 
 } 
 } 
 msg += "Codigo: " + p[indiceDoMaior].getCodigo(); 
 msg += "\nDescrição: " + p[indiceDoMaior].getDescricao(); 
 msg += "\nPreço de Compra: " + p[indiceDoMaior].getPrecoDeCompra(); 
 msg += "\n% lucro: " + p[indiceDoMaior].getPercentualDeLucro(); 
 msg += "\nPreço de Venda: " + p[indiceDoMaior].gerarPrecoDeVenda(); 
 JOptionPane.showMessageDialog(null, msg); 
 }//fim do mostrarMaisCaro 
}//fim ControleDaFarmacia