├── .gitignore ├── Lista - 64 Exercicios ├── 1 │ └── estoque_medio.java ├── 2 │ └── ConversorDolarReal.java ├── 3 │ └── Comissao.java ├── 4 │ └── Exercicio.java ├── 5 │ └── Exercicio.java ├── 6 │ └── Exercicio.java ├── 7 │ └── Exercicio.java ├── 8 │ └── Exercicio.java ├── 9 │ └── Exercicio.java ├── 10 │ └── Exercicio.java ├── 11 │ └── Exercicio.java ├── 12 │ └── Exercicio.java ├── 13 │ └── Exercicio.java ├── 14 │ └── Exercicio.java ├── 15 │ └── Exercicio.java ├── 16 │ └── Exercicio.java ├── 17 │ └── Exercicio.java ├── 18 │ └── Exercicio.java ├── 19 │ └── Exercicio.java ├── 20 │ └── Exercicio.java ├── 21 │ └── Exercicio.java ├── 22 │ └── Exercicio.java ├── 23 │ └── Exercicio.java ├── 24 │ └── Exercicio.java ├── 25 │ └── Exercicio.java ├── 26 │ └── Exercicio.java ├── 27 │ └── Exercicio.java ├── 28 │ └── Exercicio.java ├── 29 │ └── Exercicio.java ├── 30 │ └── Exercicio.java ├── 31 │ └── Exercicio.java ├── 32 │ └── Exercicio.java ├── 33 │ ├── Aluno.java │ └── Exercicio.java ├── 34 │ └── Exercicio.java ├── 35 │ └── Exercicio.java ├── 36 │ └── Exercicio.java ├── 37 │ └── Exercicio.java ├── 38 │ └── Exercicio.java ├── 39 │ └── Exercicio.java ├── 40 │ └── Exercicio.java ├── 41 │ └── Exercicio.java ├── 42 │ └── Exercicio.java ├── 43 │ └── Exercicio.java ├── 44 │ └── Exercicio.java ├── 45 │ └── Exercicio.java ├── 46 │ └── Exercicio.java ├── 47 │ └── Exercicio.java ├── 48 │ └── Exercicio.java ├── 49 │ └── Exercicio.java ├── 50 │ └── Exercicio.java ├── 51 │ └── Exercicio.java ├── 52 │ └── Exercicio.java ├── 53 │ └── Exercicio.java ├── 54 │ └── Exercicio.java ├── 55 │ └── Exercicio.java ├── 56 │ └── Exercicio.java ├── 57 │ └── Exercicio.java ├── 58 │ └── Exercicio.java ├── 59 │ └── Exercicio.java ├── 60 │ └── Exercicio.java ├── 61 │ └── Exercicio.java ├── 62 │ └── Exercicio.java ├── 63 │ └── Exercicio.java ├── 64 │ └── Exercicio.java └── Lista - 64 Exercicios.pdf ├── Lista 2 ├── 1 │ ├── Caneta.java │ └── CanetaTeste.java ├── 2 │ ├── Lampada.java │ └── LampadaTeste.java ├── 3 │ ├── Apolice.java │ └── ApoliceTeste.java └── Lista Exercícios 2 - 26_02_2015.pdf ├── Lista 3 ├── 1 │ ├── Caneta.java │ └── CanetaTesteVetor.java ├── 2 │ ├── Lampada.java │ └── LampadaTesteVetor.java ├── 3 │ ├── Data.java │ └── Exercicio.java └── Lista Exercícios 3 - 26_02_2015.pdf ├── Lista 4 ├── 1 │ ├── Aluno.java │ ├── Data.java │ ├── Funcionario.java │ ├── Pessoa.java │ └── Teste.java ├── 2 │ ├── Aluno.java │ ├── Pessoa.java │ ├── Professor.java │ └── exercicio.jpeg ├── 3 │ ├── Cliente.java │ ├── PessoaFisica.java │ ├── PessoaJuridica.java │ └── exercicio.jpeg └── Exercícios LPOO 12_03_2015.pdf ├── Lista 5 ├── 1 │ ├── ContaBancariaSimplificada.java │ └── exercicio.jpg ├── 2 │ ├── Data.java │ ├── RegistroAcademico.java │ └── exercicio.jpg ├── 3 │ ├── Aluno.java │ ├── Discente.java │ ├── Docente.java │ ├── Empregado.java │ ├── Pessoa.java │ └── Teste.java ├── 4 │ ├── Data.java │ ├── Exercicio.java │ ├── Livro.java │ ├── LivroBiblioteca.java │ └── LivroLivraria.java ├── 5 │ ├── AutomovelAVenda.java │ ├── Exercicio.java │ ├── MotocicletaAVenda.java │ └── VeiculoAVenda.java └── Exercícios LPOO 19_03_2015.pdf └── README.md /.gitignore: -------------------------------------------------------------------------------- 1 | *.class 2 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/1/estoque_medio.java: -------------------------------------------------------------------------------- 1 | /************************************************************************* 2 | * 1-)Faça um programa para calcular o estoque médio de uma peça, sendo que: 3 | * ESTOQUE MÉDIO = (QUANTIDADE_MÍNIMA + QUANTIDADE_MÁXIMA) / 2. 4 | * 5 | *************************************************************************/ 6 | import java.util.Scanner; 7 | 8 | public class estoque_medio { 9 | 10 | public static void main(String[] args) { 11 | Scanner entrada = new Scanner(System.in); 12 | double quantidade_minima, quantidade_maxima,estoque_medio; 13 | 14 | System.out.print("Calculadora de Estoque Médio\n\n"); 15 | 16 | System.out.print("Digite a quantidade mímima:"); 17 | quantidade_minima = entrada.nextDouble(); 18 | 19 | System.out.print("Digite a quantidade máxima:"); 20 | quantidade_maxima = entrada.nextDouble(); 21 | estoque_medio = (quantidade_minima + quantidade_maxima ) / 2; 22 | System.out.print("Estoque Médio = "+estoque_medio+"\n"); 23 | 24 | } 25 | 26 | } 27 | 28 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/10/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 10) Escrever um programa que leia dois números inteiros e mostre todos os 3 | * relacionamentos de ordem existentes entre eles. Os relacionamentos possíveis 4 | * são: Igual, Não igual, Maior, Menor, Maior ou igual, Menor ou igual. 5 | *******************************************************************************/ 6 | 7 | import java.util.Scanner; 8 | 9 | public class Exercicio { 10 | 11 | public static void main(String[] args) { 12 | Scanner entrada = new Scanner(System.in); 13 | int PrimeiroNumero, SegundoNumero; 14 | boolean Igual=false, NaoIgual=false, Maior=false, Menor=false, MaiorOuIgual=false, MenorOuIgual=false; 15 | 16 | System.out.print("Mostrador de relacionamentos\n\n"); //Mais um exercício away 17 | 18 | 19 | System.out.print("Digite o primeiro número: "); 20 | PrimeiroNumero = entrada.nextInt(); 21 | 22 | System.out.print("Digite o segundo número: "); 23 | SegundoNumero = entrada.nextInt(); 24 | 25 | if(PrimeiroNumero == SegundoNumero) Igual = true; 26 | if(PrimeiroNumero != SegundoNumero) NaoIgual = true; 27 | if(PrimeiroNumero > SegundoNumero) Maior = true; 28 | if(PrimeiroNumero < SegundoNumero) Menor = true; 29 | if(PrimeiroNumero >= SegundoNumero) MaiorOuIgual = true; 30 | if(PrimeiroNumero <= SegundoNumero) MenorOuIgual = true; 31 | 32 | System.out.println("\nIgual = "+Igual); 33 | System.out.println("Não Igual = "+NaoIgual); 34 | System.out.println("Maior = "+Maior); 35 | System.out.println("Menor = "+Menor); 36 | System.out.println("Maior ou igual = "+MaiorOuIgual); 37 | System.out.println("Menor ou igual = "+MenorOuIgual); 38 | 39 | } 40 | 41 | } 42 | 43 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/11/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 11) Ler dois valores inteiros para as variáveis A e B, efetuar a troca dos 3 | * valores de modo que a variável A passe a possuir o valor da variável B, e a 4 | * variável B passe a possuir o valor da variável A. Apresentar os valores 5 | * trocados. 6 | *******************************************************************************/ 7 | 8 | import java.util.Scanner; 9 | 10 | public class Exercicio { 11 | 12 | public static void main(String[] args) { 13 | Scanner entrada = new Scanner(System.in); 14 | int A,B,VariavelTemporaria; 15 | 16 | System.out.print("Efetuador de troca de valores entre variaveis\n\n"); //Isso é estrutura condicional, mesmo? 17 | 18 | 19 | System.out.print("Digite a variável A: "); 20 | A = entrada.nextInt(); 21 | 22 | System.out.print("Digite a variável B: "); 23 | B = entrada.nextInt(); 24 | 25 | 26 | 27 | VariavelTemporaria = A; 28 | A = B; 29 | B = VariavelTemporaria; 30 | 31 | System.out.print("A="+A+" | B="+B+"\n"); 32 | 33 | } 34 | 35 | } 36 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/12/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 12) Escreva um programa que leia um número inteiro e exiba o seu módulo. 3 | * O módulo de um número x é: 4 | * x se x é maior ou igual a zero 5 | * x * (-1) se x é menor que zero 6 | *******************************************************************************/ 7 | 8 | import java.util.Scanner; 9 | 10 | public class Exercicio { 11 | 12 | public static void main(String[] args) { 13 | Scanner entrada = new Scanner(System.in); 14 | int Numero,ModuloNumero; 15 | 16 | System.out.print("Módulo de Número\n\n"); //Finalmente... 17 | 18 | 19 | System.out.print("Digite um número inteiro: "); 20 | Numero = entrada.nextInt(); 21 | 22 | 23 | ModuloNumero = (Numero < 0)? ModuloNumero = Numero*(-1):Numero; 24 | 25 | System.out.print("O módulo do número é "+ModuloNumero+"\n"); 26 | 27 | } 28 | 29 | } 30 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/13/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 13) Escreva um programa que leia 3 números inteiros e imprima na tela os 3 | * valores em ordem decrescente. 4 | *******************************************************************************/ 5 | 6 | import java.util.Scanner; 7 | import java.util.Arrays; //usando o método de arrays da biblioteca java 8 | 9 | public class Exercicio { 10 | 11 | public static void main(String[] args) { 12 | Scanner entrada = new Scanner(System.in); 13 | int Quantidade = 3; //Este valor é igual a quantidade de números para adicionar ao array. 14 | int[] Numeros = new int[Quantidade]; //Inicia os valores com a mesma quantidade de valores da variável "Quantidade" 15 | 16 | System.out.print("Ordenador de números\n\n"); 17 | 18 | for (int x = 0; x < Quantidade; x++) { 19 | System.out.print("Digite o "+(x+1)+" número: "); 20 | Numeros[x] = entrada.nextInt(); 21 | } 22 | 23 | Arrays.sort(Numeros); //Usando o método de arrays para organizar automaticamente os arrays para mim 24 | 25 | System.out.println("\n\nOs números em ordem crescente são:"); 26 | for (int Numero : Numeros) { 27 | System.out.println(Numero); 28 | } 29 | } 30 | 31 | } 32 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/14/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 14) Escreva um programa que leia dois números e apresente a diferença do 3 | * maior para o menor. 4 | *******************************************************************************/ 5 | 6 | import java.util.Scanner; 7 | 8 | public class Exercicio { 9 | 10 | public static void main(String[] args) { 11 | Scanner entrada = new Scanner(System.in); 12 | int PrimeiroNumero, SegundoNumero, Diferenca; 13 | 14 | System.out.print("Verificador de números\n\n"); 15 | 16 | 17 | System.out.print("Digite o primeiro número: "); 18 | PrimeiroNumero = entrada.nextInt(); 19 | 20 | System.out.print("Digite o segundo número: "); 21 | SegundoNumero = entrada.nextInt(); 22 | 23 | 24 | if(PrimeiroNumero >= SegundoNumero){ 25 | Diferenca = PrimeiroNumero - SegundoNumero; 26 | }else{ 27 | Diferenca = SegundoNumero - PrimeiroNumero; 28 | } 29 | 30 | System.out.println("\nA diferença do menor para o menor é "+Diferenca); 31 | 32 | } 33 | 34 | } 35 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/15/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 15) Escreva um programa que leia quatro notas escolares de um aluno e 3 | * apresentar uma mensagem que o aluno foi aprovado se o valor da média escolar 4 | * for maior ou igual a 7. Se o valor da média for menor que 7, solicitar a nota 5 | * do recuperação, somar com o valor da média e obter a nova média. Se a nova 6 | * média for maior ou igual a 7, apresentar uma mensagem informando que o aluno 7 | * foi aprovado na recuperação. Se o aluno não foi aprovado, apresentar uma 8 | * mensagem informando esta condição. Apresentar junto com as mensagens o valor 9 | * da média do aluno. 10 | *******************************************************************************/ 11 | 12 | import java.util.Scanner; 13 | 14 | public class Exercicio { 15 | 16 | public static void main(String[] args) { 17 | Scanner entrada = new Scanner(System.in); 18 | double PrimeiraNota, SegundaNota, TerceiraNota, QuartaNota, RecuperacaoNota, Media; 19 | boolean Aprovacao = false; 20 | 21 | System.out.print("Verificador de notas\n\n"); 22 | 23 | 24 | System.out.print("Digite a primeira nota: "); 25 | PrimeiraNota = entrada.nextDouble(); 26 | 27 | System.out.print("Digite a segunda nota: "); 28 | SegundaNota = entrada.nextDouble(); 29 | 30 | System.out.print("Digite a terceira nota: "); 31 | TerceiraNota = entrada.nextDouble(); 32 | 33 | System.out.print("Digite a quarta nota: "); 34 | QuartaNota = entrada.nextDouble(); 35 | 36 | 37 | Media = (PrimeiraNota + SegundaNota + TerceiraNota + QuartaNota)/4; 38 | 39 | if(Media >= 7) Aprovacao = true; 40 | else{ 41 | System.out.print("O aluno ficou de recuperação, digite a nota: "); 42 | RecuperacaoNota = entrada.nextDouble(); 43 | Media = (Media + RecuperacaoNota)/2; 44 | if(Media >= 7) Aprovacao = true; 45 | } 46 | 47 | if(Aprovacao == true){ 48 | System.out.println("\n\nO Aluno foi aprovado com a média "+Media); 49 | }else{ 50 | System.out.println("\n\nO Aluno foi reprovado com a média "+Media); 51 | } 52 | 53 | } 54 | 55 | } 56 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/16/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 16) Escreva um programa que leia dois números e exiba mensagem informando o 3 | * valor do maior número e o valor do menor número. Se os dois números forem 4 | * iguais, o programa deve exibir mensagem informando este fato. 5 | *******************************************************************************/ 6 | 7 | import java.util.Scanner; 8 | 9 | public class Exercicio { 10 | 11 | public static void main(String[] args) { 12 | Scanner entrada = new Scanner(System.in); 13 | int PrimeiroNumero, SegundoNumero; 14 | 15 | System.out.print("Verificador de números\n\n"); 16 | 17 | 18 | System.out.print("Digite o primeiro número: "); 19 | PrimeiroNumero = entrada.nextInt(); 20 | 21 | System.out.print("Digite o segundo número: "); 22 | SegundoNumero = entrada.nextInt(); 23 | 24 | 25 | if(PrimeiroNumero > SegundoNumero){ 26 | System.out.println("O primeiro número é maior que o segundo número."); 27 | }else if(PrimeiroNumero = 0 && Numero <= 9){ 25 | System.out.println("Valor válido."); 26 | }else{ 27 | System.out.println("Valor inválido."); 28 | } 29 | 30 | } 31 | 32 | } 33 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/18/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 18) Escreva um programa que leia um número inteiro (variável CODIGO). Verificar se o código 3 | * é igual a 1, igual a 2 ou igual a 3. Caso não seja, apresentar a mensagem “Código inválido”. 4 | * Ao ser verificado o código e constatado que é um valor válido, o programa deve verificar cada 5 | * código em separado para determinar seu valor por extenso, ou seja, apresentar a mensagem 6 | * “um”, ”dois” ou “três”. (Utilizar o comando Switch). 7 | *******************************************************************************/ 8 | 9 | import java.util.Scanner; 10 | 11 | public class Exercicio { 12 | 13 | public static void main(String[] args) { 14 | Scanner entrada = new Scanner(System.in); 15 | int CODIGO; 16 | 17 | System.out.print("Verificador de Código\n\n"); 18 | 19 | 20 | System.out.print("Digite o Código: "); 21 | CODIGO = entrada.nextInt(); 22 | 23 | 24 | 25 | switch(CODIGO){ 26 | case 1: 27 | System.out.println("um"); 28 | break; 29 | case 2: 30 | System.out.println("dois"); 31 | break; 32 | case 3: 33 | System.out.println("três"); 34 | break; 35 | default: 36 | System.out.println("Código inválido"); 37 | } 38 | 39 | } 40 | 41 | } 42 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/19/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 19) Escreva um programa que leia três valores para os lados de um triângulo 3 | * (variáveis A, B e C). Verificar se cada lado é menor que a soma dos outros dois lados. Se sim, 4 | * saber de A==B e se B==C, sendo verdade o triângulo é eqüilátero; Se não, verificar de A==B 5 | * ou se A==C ou se B==C, sendo verdade o triângulo é isósceles; e caso contrário, o triângulo 6 | * será escaleno. Caso os lados fornecidos não caracterizarem um triângulo, avisar a ocorrência. 7 | *******************************************************************************/ 8 | 9 | import java.util.Scanner; 10 | 11 | public class Exercicio { 12 | 13 | public static void main(String[] args) { 14 | Scanner entrada = new Scanner(System.in); 15 | int A, B, C; //Escreva um programa que leia três valores para os lados de um triângulo 16 | 17 | System.out.print("Verificador de Triângulo\n\n"); 18 | 19 | 20 | System.out.print("Digite o lado A="); 21 | A = entrada.nextInt(); //Escreva um programa que leia três valores para os lados de um triângulo 22 | 23 | System.out.print("Digite o lado B="); 24 | B = entrada.nextInt(); //Escreva um programa que leia três valores para os lados de um triângulo 25 | 26 | System.out.print("Digite o lado C="); 27 | C = entrada.nextInt(); //Escreva um programa que leia três valores para os lados de um triângulo 28 | 29 | 30 | if( A < B + C && B < A + C && C < A + B ){ //Verificar se cada lado é menor que a soma dos outros dois lados. 31 | if(A==B && B == C){ //saber de A==B e se B==C, sendo verdade o triângulo é eqüilátero 32 | System.out.print("O triângulo é Eqüilátero."); 33 | }else if(A==B || A==C || B==C){ //Se não, verificar de A==B ou se A==C ou se B==C, sendo verdade o triângulo é isósceles 34 | System.out.print("O triângulo é Isósceles."); 35 | }else{ //e caso contrário, o triângulo será escaleno 36 | System.out.print("O triângulo é Escaleno."); 37 | } 38 | }else{ //Caso os lados fornecidos não caracterizarem um triângulo, avisar a ocorrência. 39 | System.out.print("Os lados fornecidos não caracterizam um triângulo"); 40 | } 41 | 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/2/ConversorDolarReal.java: -------------------------------------------------------------------------------- 1 | /************************************************************************* 2 | * 2) Faça um programa que: 3 | * - Leia a cotação do dólar 4 | * - Leia um valor em dólares 5 | * - Converta esse valor para Real 6 | * - Mostre o resultado 7 | * 8 | *************************************************************************/ 9 | import java.util.Scanner; 10 | 11 | public class ConversorDolarReal { 12 | 13 | public static void main(String[] args) { 14 | Scanner entrada = new Scanner(System.in); 15 | double cotacao_dolar, valor_dolar,valor_real; 16 | 17 | System.out.print("Conversor de dólar em real\n\n"); 18 | 19 | System.out.print("Digite a cotação do dolar: "); 20 | cotacao_dolar = entrada.nextDouble(); 21 | 22 | System.out.print("Digite o valor em dolar: "); 23 | valor_dolar = entrada.nextDouble(); 24 | 25 | valor_real = cotacao_dolar * valor_dolar; 26 | 27 | System.out.print("O Valor em reais é " + valor_real + "\n"); 28 | 29 | } 30 | 31 | } 32 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/20/Exercicio.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/victorperin/Exercicios-Java/46491825a47aa97b7636de591ee4ad4a51d1752a/Lista - 64 Exercicios/20/Exercicio.java -------------------------------------------------------------------------------- /Lista - 64 Exercicios/21/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 21) Faça um programa que leia um número inteiro e mostre uma mensagem na tela 3 | * indicando se este número é positivo ou negativo. Pare a execução do programa 4 | * quando o usuário requisitar. 5 | *******************************************************************************/ 6 | 7 | import java.util.Scanner; 8 | import java.util.Arrays; 9 | 10 | public class Exercicio { 11 | 12 | public static void main(String[] args) { 13 | Scanner entrada = new Scanner(System.in); 14 | int numero; 15 | 16 | System.out.print("Verificador de numeros positivos ou negativos\n\n"); 17 | 18 | do { 19 | System.out.print("Digite um número, digite 0 para sair: "); 20 | numero = entrada.nextInt(); 21 | if(numero>0){ 22 | System.out.print("O número é positivo\n"); 23 | }else if(numero < 0){ 24 | System.out.print("O número é negativo\n"); 25 | } 26 | }while(numero != 0); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/22/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 22) Faça um programa que leia um número. Se positivo armazene-o em A, se for 3 | * negativo, em B. No final mostrar o resultado. 4 | *******************************************************************************/ 5 | 6 | import java.util.Scanner; 7 | import java.util.Arrays; 8 | 9 | public class Exercicio { 10 | 11 | public static void main(String[] args) { 12 | Scanner entrada = new Scanner(System.in); 13 | double A=0, B=0, Numero; 14 | System.out.print("Organizador de números\n\n"); //O texto do exercício é muito vago, mas acho que é isso o que ele quis dizer: 15 | 16 | do { 17 | System.out.print("Digite um número, digite 0 para sair: "); 18 | Numero = entrada.nextDouble(); 19 | if(Numero>0){ 20 | A += Numero; 21 | System.out.print("Numero armazenado em A\n"); 22 | }else if(Numero < 0){ 23 | B += Numero; 24 | System.out.print("Numero armazenado em B\n"); 25 | } 26 | }while(Numero != 0); 27 | System.out.printf("A= %2f\nB= %2f\n",A,B); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/23/Exercicio.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/victorperin/Exercicios-Java/46491825a47aa97b7636de591ee4ad4a51d1752a/Lista - 64 Exercicios/23/Exercicio.java -------------------------------------------------------------------------------- /Lista - 64 Exercicios/24/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 24) Escreva um programa que leia dois números inteiros e apresente as opções para usuário escolher o que deseja 3 | * realizar: 4 | * 1 – Verificar se um dos números lidos é ou não múltiplo do outro 5 | * 2 – Verificar se os dois números lidos são pares 6 | * 3 – Verificar se a média dos dois números é maior ou igual a 7. 7 | * 4 – Sair 8 | *******************************************************************************/ 9 | 10 | import java.util.Scanner; 11 | import java.util.Arrays; 12 | 13 | public class Exercicio { 14 | 15 | public static void main(String[] args) { 16 | Scanner entrada = new Scanner(System.in); 17 | double PrimeiroNumero,SegundoNumero,Resultado; 18 | int Menu; 19 | boolean LoopMenu = true; 20 | 21 | 22 | System.out.print("Digite o primeiro número: "); 23 | PrimeiroNumero = entrada.nextDouble(); 24 | 25 | System.out.print("Digite o segundo número: "); 26 | SegundoNumero = entrada.nextDouble(); 27 | 28 | while(LoopMenu){ 29 | System.out.print("\nVocê deseja verificar se...\n\t1 - um dos números lidos é ou não múltiplo do outro\n\t2 - os dois números lidos são pares\n\t3 - a média dos dois números é maior ou igual a 7\n\t4 - Sair\n"); 30 | Menu = entrada.nextInt(); 31 | switch(Menu){ 32 | case 1: 33 | if(PrimeiroNumero%SegundoNumero==0||SegundoNumero%PrimeiroNumero==0){ 34 | System.out.println("Sim, um dos números é múltiplo do outro"); 35 | }else{ 36 | System.out.println("Não, nenhum dos números é múltiplos do outro"); 37 | } 38 | break; 39 | case 2: 40 | if(PrimeiroNumero%2==0&&SegundoNumero%2==0){ 41 | System.out.println("Sim, os dois números lidos são pares."); 42 | }else{ 43 | System.out.println("Não, os dois números lidos são ímpares."); 44 | } 45 | break; 46 | case 3: 47 | if((PrimeiroNumero+SegundoNumero)/2 >= 7){ 48 | System.out.println("Sim, a média dos dois números é maior ou igual a 7."); 49 | }else{ 50 | System.out.println("Não, a média dos dois números não é maior ou igual a 7."); 51 | } 52 | break; 53 | case 4: 54 | LoopMenu = false; 55 | System.out.print("Saindo...\n"); 56 | break; 57 | default: 58 | System.out.println("Opção inválida!"); 59 | } 60 | } 61 | 62 | 63 | } 64 | 65 | } 66 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/25/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 25) Tendo como dados de entrada a altura e o sexo de uma pessoa, faça um 3 | * programa que calcule seu peso ideal, utilizando as seguintes fórmulas: 4 | * (h = altura) 5 | * - Para homens: (72.7*h) - 58 6 | * - Para mulheres: (62.1 *h) - 44.7 7 | *******************************************************************************/ 8 | 9 | import java.util.Scanner; 10 | import java.io.BufferedReader; 11 | import java.io.IOException; 12 | import java.io.InputStreamReader; 13 | 14 | public class Exercicio { 15 | 16 | public static void main(String[] args) { 17 | Scanner entrada = new Scanner(System.in); 18 | double Altura,PesoIdeal; 19 | char Sexo='n'; 20 | 21 | System.out.print("Digite sua altura (em metros): "); 22 | Altura = entrada.nextDouble(); 23 | 24 | while(Sexo !='m' && Sexo !='M' && Sexo !='h' && Sexo !='H'){ 25 | 26 | System.out.print("Digite H ou M para especificar o sexo: "); // o/ 27 | Sexo = entrada.next(".").charAt(0); 28 | 29 | switch(Sexo){ 30 | case 'h': 31 | case 'H': 32 | PesoIdeal = ( 72.7* Altura ) - 58; 33 | System.out.println("Seu peso ideal é de: "+PesoIdeal+" kg."); 34 | break; 35 | case 'm': 36 | case 'M': 37 | PesoIdeal = ( 62.1 * Altura ) - 44.7; 38 | System.out.println("Seu peso ideal é de: "+PesoIdeal+" kg."); 39 | break; 40 | default: 41 | System.out.println("Não é M"); 42 | } 43 | 44 | } 45 | } 46 | 47 | } 48 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/26/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 26) Escreva um programa que exiba os números de 1 a 100 na tela em ordem 3 | * decrescente. 4 | *******************************************************************************/ 5 | 6 | import java.util.Scanner; 7 | 8 | public class Exercicio { 9 | 10 | public static void main(String[] args) { 11 | 12 | Scanner entrada = new Scanner(System.in); 13 | for(int x =100;x>0;x--){ 14 | System.out.println(x); 15 | } 16 | 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/27/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 27) Escreva um programa que leia: 3 | * - a quantidade de números que deverá processar; 4 | * - os números que deverá processar,e calcule e exiba, para cada número a ser 5 | * processado o seu fatorial. 6 | * Lembrete: O fatorial de um número N é dado pela fórmula: 7 | * N! = 1 * 2 * 3 * 4 * 5 * ... * N 8 | *******************************************************************************/ 9 | 10 | import java.util.Scanner; 11 | 12 | public class Exercicio { 13 | 14 | public static void main(String[] args) { 15 | 16 | Scanner entrada = new Scanner(System.in); 17 | int quantidade; 18 | System.out.print("Digite a quantidade de números: "); 19 | quantidade = entrada.nextInt(); 20 | 21 | long[] numeros = new long[quantidade]; 22 | for(int x=0;x < numeros.length;x++){ 23 | System.out.print("Digite um número: "); 24 | numeros[x]= entrada.nextInt(); 25 | } 26 | for(int x=0; x < numeros.length;x++){ 27 | long resultado=1; 28 | for(long y=numeros[x]; y>0;y--){ 29 | resultado = y*resultado; 30 | } 31 | System.out.println("O fatorial de "+numeros[x]+" é: "+resultado); 32 | } 33 | 34 | 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/28/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 28) Faça um programa que gera e escreve os números ímpares dos números lidos 3 | * entre 100 e 200. 4 | *******************************************************************************/ 5 | public class Exercicio { 6 | 7 | public static void main(String[] args) { 8 | 9 | for(int x=100; x <= 200;x++){ 10 | if(x%2==1){ 11 | System.out.println(x); 12 | } 13 | } 14 | 15 | 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/29/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 29) Faça um programa que exiba os números de 1 até 2000. 3 | *******************************************************************************/ 4 | public class Exercicio { 5 | 6 | public static void main(String[] args) { 7 | 8 | for(int x=1; x <= 2000;x++){ 9 | System.out.println(x); 10 | } 11 | 12 | 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/3/Comissao.java: -------------------------------------------------------------------------------- 1 | /************************************************************************* 2 | * 3) Faça um programa para pagamento de comissão de vendedores de peças, 3 | * levando-se em consideração que sua comissão será de 5% do total da venda 4 | * e que você tem os seguintes dados: 5 | * - Identificação do vendedor 6 | * - Código da peça 7 | * - Preço unitário da peça 8 | * - Quantidade vendida 9 | 10 | *************************************************************************/ 11 | import java.util.Scanner; 12 | 13 | public class Comissao { 14 | public static void main(String[] args) { 15 | Scanner entrada = new Scanner(System.in); 16 | System.out.print("Programa para pagamento de comissão de vendedores de peças.\n\n"); //Why so specific?! 17 | 18 | int IdVendedor,IdPeca; 19 | float PrecoPeca,Quantidade,ValorComissao,PorcentagemComissao=0.05f; 20 | 21 | System.out.print("Digite a identificação do vendedor: "); 22 | IdVendedor = entrada.nextInt(); 23 | 24 | System.out.print("Digite o ID da Peça: "); 25 | IdPeca = entrada.nextInt(); 26 | 27 | System.out.print("Digite o preço unitário da peça: "); 28 | PrecoPeca = entrada.nextFloat(); 29 | 30 | System.out.print("Digite a quantidade de peças vendidas: "); 31 | Quantidade = entrada.nextFloat(); 32 | 33 | ValorComissao = (PrecoPeca * Quantidade) * PorcentagemComissao; 34 | 35 | System.out.printf("O valor da comissão é de %.2f reais.\n", ValorComissao); 36 | 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/30/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 30) Faça um programa para imprimir uma tabuada. 3 | *******************************************************************************/ 4 | import java.util.Scanner; 5 | 6 | public class Exercicio { 7 | 8 | public static void main(String[] args) { 9 | Scanner entrada = new Scanner(System.in); 10 | double numero; 11 | System.out.print("Digite um número: "); 12 | numero = entrada.nextDouble(); 13 | System.out.println(); 14 | 15 | for(int x=0; x <= 10;x++){ 16 | 17 | System.out.printf("%f x %d = %g\n",numero,x,numero*x); 18 | } 19 | 20 | 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/31/Exercicio.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/victorperin/Exercicios-Java/46491825a47aa97b7636de591ee4ad4a51d1752a/Lista - 64 Exercicios/31/Exercicio.java -------------------------------------------------------------------------------- /Lista - 64 Exercicios/32/Exercicio.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/victorperin/Exercicios-Java/46491825a47aa97b7636de591ee4ad4a51d1752a/Lista - 64 Exercicios/32/Exercicio.java -------------------------------------------------------------------------------- /Lista - 64 Exercicios/33/Aluno.java: -------------------------------------------------------------------------------- 1 | public class Aluno { //usando um array de objetos para que não seja necessário especificar 2 arrays diferentes. 2 | private String NumeroMatricula; 3 | private double NotaProva; 4 | 5 | public void setAluno(String NumeroMatricula,double NotaProva){ 6 | this.NumeroMatricula = NumeroMatricula; 7 | this.NotaProva = NotaProva; 8 | } 9 | 10 | public double getNotaProva() { 11 | return NotaProva; 12 | } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/33/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 33) Escreva um programa que calcule e exiba a média da nota dos alunos de uma 3 | * turma em uma prova. O número de alunos é desconhecido. Os dados de um aluno 4 | * são: número de matrícula e a sua nota na prova em questão. 5 | *******************************************************************************/ 6 | import java.util.Scanner; 7 | 8 | public class Exercicio { 9 | 10 | public static void main(String[] args) { 11 | 12 | Scanner entrada = new Scanner(System.in); 13 | int QuantidadeAlunos; 14 | String matricula; 15 | double mediaAlunos=0; 16 | 17 | System.out.print("Digite um a quantidade de alunos: "); 18 | QuantidadeAlunos = entrada.nextInt(); 19 | 20 | Aluno[] alunos = new Aluno[QuantidadeAlunos]; 21 | 22 | for(int x = 0;x < QuantidadeAlunos;x++){ 23 | System.out.print("\nDigite o número da matrícula do aluno: "); 24 | matricula = entrada.next(); 25 | System.out.print("Digite a nota do aluno: "); 26 | double nota = entrada.nextDouble(); 27 | alunos[x] = new Aluno(); 28 | alunos[x].setAluno(matricula,nota); 29 | mediaAlunos += nota; 30 | } 31 | mediaAlunos = mediaAlunos/QuantidadeAlunos; 32 | System.out.println("\nA média da turma foi de "+mediaAlunos); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/34/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 34) Escreva um programa que leia um conjunto de números positivos e exiba o 3 | * menor e o maior. Suporemos que o número de elementos deste conjunto não é 4 | * conhecido, e que um número negativo será utilizado para sinalizar o fim dos 5 | * dados. 6 | *******************************************************************************/ 7 | //Obs: Nesse exercício seria um ótimo lugar para se colocar listas ligadas 8 | import java.util.Scanner; 9 | 10 | public class Exercicio { 11 | 12 | public static void main(String[] args) { 13 | 14 | Scanner entrada = new Scanner(System.in); 15 | int numeroAtual,maior,menor; 16 | boolean primeiro=true; 17 | 18 | System.out.print("Digite um número (negativo para sair): "); 19 | numeroAtual = entrada.nextInt(); 20 | 21 | if(numeroAtual>=0){ 22 | menor = numeroAtual; 23 | maior = numeroAtual; 24 | while(numeroAtual>=0){ 25 | System.out.print("Digite outro número: "); 26 | numeroAtual = entrada.nextInt(); 27 | if(numeroAtual > maior){ 28 | maior = numeroAtual; 29 | } 30 | if(numeroAtual < menor && numeroAtual >= 0){ 31 | menor = numeroAtual; 32 | } 33 | } 34 | System.out.println("\nO maior número foi "+maior+" e o menor foi "+menor); 35 | } 36 | 37 | 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/35/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 35) Faça um programa que conte de 1 até 100 e a cada múltiplo de 10 exiba uma 3 | * mensagem: "Múltiplo de 10". 4 | *******************************************************************************/ 5 | 6 | public class Exercicio { 7 | 8 | public static void main(String[] args) { 9 | 10 | int numero; 11 | 12 | for(numero = 1; numero <= 100; numero++){ 13 | if(numero%10==0) System.out.println(numero+" -- multiplo de 10"); 14 | else System.out.println(numero); 15 | } 16 | 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/36/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 36) Faça um programa que leia 10 valores inteiros e positivos e: 3 | * - Encontre o maior valor 4 | * - Encontre o menor valor 5 | * - Calcule a média dos números lidos 6 | *******************************************************************************/ 7 | import java.util.Scanner; 8 | import java.util.Arrays; //Importando ferramentas para array 9 | 10 | public class Exercicio { 11 | 12 | public static void main(String[] args) { 13 | Scanner entrada = new Scanner(System.in); 14 | int quantidade_numeros = 10; // configuração: mude esta quantidade para mudar quantos números o usuário vai escrever 15 | double media=0; 16 | int[] numeros = new int[quantidade_numeros]; 17 | 18 | for(int x = 0; x < quantidade_numeros; x++){ 19 | System.out.print("Digite o "+(x+1)+"° número: "); 20 | numeros[x]= entrada.nextInt(); 21 | media += numeros[x]; 22 | } 23 | media = media / quantidade_numeros; 24 | Arrays.sort(numeros);//organiza os arrays em ordem crescente 25 | 26 | System.out.println("\nO menor número é: "+numeros[0]); 27 | System.out.println("O maior número é: "+numeros[quantidade_numeros - 1]); 28 | System.out.println("A média dos números é: "+media); 29 | 30 | 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/37/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 37) Faça um programa de conversão de base numérica. O programa deverá 3 | * apresentar uma tela de entrada com as seguintes opções: 4 | * 1 – Adição 5 | * 2 – Subtração 6 | * 3 – Multiplicação 7 | * 4 – Divisão 8 | * Informe a opção: 9 | * A partir da opção escolhida, o programa deverá solicitar para que o usuário 10 | * digite dois números. Em seguida, o programa deve exibir o resultado da opção 11 | * indicada pelo usuário e perguntar ao usuário se ele deseja voltar ao menu 12 | * principal. Caso a resposta seja ́S ́ ou ́s ́, deverá voltar ao menu, caso 13 | * contrário deverá encerrar o programa. 14 | *******************************************************************************/ 15 | import java.util.Scanner; 16 | import java.util.Arrays; //Importando ferramentas para array 17 | 18 | public class Exercicio { 19 | private static double primeiro, segundo; 20 | 21 | public static void main(String[] args) { 22 | Scanner entrada = new Scanner(System.in); 23 | int opcao; 24 | String charOpcao; 25 | boolean encerrar=false; 26 | 27 | while(encerrar==false){ 28 | 29 | System.out.println("Digite uma das opções para as operações:\n1 – Adição\n2 – Subtração\n3 – Multiplicação\n4 – Divisão\nopção: "); 30 | opcao = entrada.nextInt(); 31 | 32 | switch(opcao){ 33 | case 1: 34 | pegar_numeros(); 35 | System.out.println("Resultado de "+primeiro+"+"+segundo+"="+(primeiro+segundo)); 36 | break; 37 | case 2: 38 | pegar_numeros(); 39 | System.out.println("Resultado de "+primeiro+"-"+segundo+"="+(primeiro-segundo)); 40 | break; 41 | case 3: 42 | pegar_numeros(); 43 | System.out.println("Resultado de "+primeiro+"*"+segundo+"="+(primeiro*segundo)); 44 | break; 45 | case 4: 46 | pegar_numeros(); 47 | System.out.println("Resultado de "+primeiro+"/"+segundo+"="+(primeiro/segundo)); 48 | break; 49 | default: 50 | System.out.println("Opção inválida, digite novamente a opção: "); 51 | opcao = entrada.nextInt(); 52 | } 53 | System.out.println("Deseja continuar?(s/n)"); 54 | charOpcao = entrada.next(); 55 | if(charOpcao=="N"||charOpcao=="n"){ 56 | encerrar = true; 57 | } 58 | } 59 | 60 | 61 | 62 | } 63 | 64 | public static void pegar_numeros(){ 65 | Scanner entrada = new Scanner(System.in); 66 | System.out.println("Digite o primeiro número: "); 67 | primeiro = entrada.nextDouble(); 68 | 69 | System.out.println("Digite o segundo número: "); 70 | segundo = entrada.nextDouble(); 71 | } 72 | 73 | 74 | 75 | 76 | } 77 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/38/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 38) Faça um programa que leia as variáveis C e N, respectivamente código e 3 | * número de horas trabalhadas de um operário. E calcule o salário sabendo-se que 4 | * ele ganha R$ 10,00 por hora. Quando o número de horas exceder a 50, calcule o 5 | * excesso de pagamento armazenando-o na variável E, caso contrário zerar tal 6 | * variável. A hora excedente de trabalho vale R$ 20,00. No final do processamento 7 | * imprimir o salário total e o salário excedente. O programa só deve parar de 8 | * rodar quando o usuário responder "S" na seguinte pergunta, "Deseja encerrar o 9 | * programa?". 10 | *******************************************************************************/ 11 | import java.util.Scanner; 12 | 13 | public class Exercicio { 14 | private static double primeiro, segundo; 15 | 16 | public static void main(String[] args) { 17 | Scanner entrada = new Scanner(System.in); 18 | int C; 19 | double N,E=0,PrecoHora,PrecoExcedente; 20 | boolean continuar = true; 21 | char texto; 22 | 23 | do{ 24 | E=0; 25 | PrecoHora=10; 26 | PrecoExcedente=PrecoHora*2; 27 | 28 | System.out.print("Digite o código do operário: "); 29 | C = entrada.nextInt(); 30 | 31 | System.out.print("Digite o número de horas trabalhadas: "); 32 | N = entrada.nextDouble(); 33 | 34 | if(N>50){ 35 | E = N-50; 36 | } 37 | 38 | System.out.println("\nID: "+C+"\nSalario: "+(N*PrecoHora)+"\nSalario excedente: "+(E*PrecoExcedente)+"\nSalario total: "+(E*PrecoExcedente+N*PrecoHora)+"\n\nDeseja encerrar o programa?(s/N) "); 39 | texto = entrada.next().charAt(0); 40 | if(texto == 's' || texto == 'S'){ 41 | continuar = false; 42 | } 43 | 44 | }while(continuar); 45 | 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/39/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 39) Faça um programa que leia um número inteiro e mostre uma mensagem 3 | * indicando se este número é par ou ímpar, e se é positivo ou negativo. O 4 | * programa só deve parar de rodar quando o usuário responder "S" na seguinte 5 | * pergunta, "Deseja encerrar o programa?" . 6 | *******************************************************************************/ 7 | import java.util.Scanner; 8 | 9 | public class Exercicio { 10 | private static double primeiro, segundo; 11 | 12 | public static void main(String[] args) { 13 | Scanner entrada = new Scanner(System.in); 14 | int numero; 15 | boolean parar = false; 16 | char letra; 17 | 18 | do{ 19 | System.out.print("Digite um número inteiro: "); 20 | numero = entrada.nextInt(); 21 | 22 | 23 | if(numero%2==0){ 24 | System.out.print("O número é par.\n"); 25 | }else{ 26 | System.out.print("O número não é par\n"); 27 | } 28 | if(numero<0){ 29 | System.out.print("O número é negativo\n"); 30 | }else{ 31 | System.out.print("O número é positivo\n"); 32 | } 33 | 34 | System.out.println("Deseja sair? (s/N)? "); 35 | letra = entrada.next().charAt(0); 36 | if(letra == 's' || letra == 'S'){ 37 | parar = true; 38 | } 39 | 40 | }while(parar==false); 41 | 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/4/Exercicio.java: -------------------------------------------------------------------------------- 1 | /************************************************************************* 2 | * 4) Ler quatro valores numéricos inteiros e apresentar o resultado dois a dois da adição e multiplicação entre os 3 | * valores lidos, baseando-se na utilização do conceito de propriedade distributiva. Dica: se forem lidas as variáveis 4 | * A, B, C e D, devem ser somados e multiplicados os valores de A com B, A com C e A com D; depois B com C, B 5 | * com D e por último C com D. Note que para cada operação serão utilizadas seis combinações. Assim sendo, 6 | * devem ser realizadas doze operações de processamento, sendo seis para as adições e seis para as 7 | * multiplicações. 8 | 9 | *************************************************************************/ 10 | 11 | import java.util.Scanner; 12 | 13 | public class Exercicio { 14 | 15 | public static void main(String[] args) { 16 | Scanner entrada = new Scanner(System.in); 17 | int[] valores = new int[4] ; 18 | 19 | System.out.print("Exercício 4, leia o enunciado.\n\n"); //Desisto! 20 | 21 | for(int i=0; i<4; i++){ 22 | System.out.print("Digite o valor "+(i+1)+": "); 23 | valores[i] = entrada.nextInt(); 24 | } 25 | 26 | System.out.print("\nResultados:\n\n"); 27 | 28 | System.out.print("Valor 1 e Valor 2:\n"); 29 | System.out.print(" "+valores[0]+" + "+valores[1]+" = "+(valores[0]+valores[1])+"\n"); 30 | System.out.print(" "+valores[0]+" * "+valores[1]+" = "+(valores[0]*valores[1])+"\n\n"); 31 | 32 | System.out.print("Valor 1 e Valor 3:\n"); 33 | System.out.print(" "+valores[0]+" + "+valores[2]+" = "+(valores[0]+valores[2])+"\n"); 34 | System.out.print(" "+valores[0]+" * "+valores[2]+" = "+(valores[0]*valores[2])+"\n\n"); 35 | 36 | System.out.print("Valor 1 e Valor 4:\n"); 37 | System.out.print(" "+valores[0]+" + "+valores[3]+" = "+(valores[0]+valores[3])+"\n"); 38 | System.out.print(" "+valores[0]+" * "+valores[3]+" = "+(valores[0]*valores[3])+"\n\n"); 39 | 40 | System.out.print("Valor 2 e Valor 3:\n"); 41 | System.out.print(" "+valores[1]+" + "+valores[2]+" = "+(valores[1]+valores[2])+"\n"); 42 | System.out.print(" "+valores[1]+" * "+valores[2]+" = "+(valores[1]*valores[2])+"\n\n"); 43 | 44 | System.out.print("Valor 2 e Valor 4:\n"); 45 | System.out.print(" "+valores[1]+" + "+valores[3]+" = "+(valores[1]+valores[3])+"\n"); 46 | System.out.print(" "+valores[1]+" * "+valores[3]+" = "+(valores[1]*valores[3])+"\n\n"); 47 | 48 | System.out.print("Valor 3 e Valor 4:\n"); 49 | System.out.print(" "+valores[2]+" + "+valores[3]+" = "+(valores[2]+valores[3])+"\n"); 50 | System.out.print(" "+valores[2]+" * "+valores[3]+" = "+(valores[2]*valores[3])+"\n\n"); 51 | } 52 | 53 | } 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/40/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 40) A Secretaria de Meio Ambiente que controla o índice de poluição mantém 03 3 | * grupos de indústrias que são altamente poluentes do meio ambiente. O índice 4 | * de poluição aceitável varia de 0,05 até 0,25. Se o índice sobe para 0,3 as 5 | * indústrias do 1o grupo são intimadas a suspenderem suas atividades, se o 6 | * índice crescer para 0,4 as industrias do 1o e 2o grupo são intimadas a 7 | * suspenderem suas atividades, se o índice atingir 0,5 todos os grupos devem ser 8 | * notificados a paralisarem suas atividades. Faça um programa que leia o índice 9 | * de poluição medido e emita a notificação adequada aos diferentes grupos de 10 | * empresas. O algoritmo só deve parar de rodar quando o usuário responder "S" na 11 | * seguinte pergunta, "Deseja encerrar o programa?". 12 | *******************************************************************************/ 13 | import java.util.Scanner; 14 | 15 | public class Exercicio { 16 | private static double primeiro, segundo; 17 | 18 | public static void main(String[] args) { 19 | Scanner entrada = new Scanner(System.in); 20 | double numero; 21 | boolean parar = false; 22 | char letra; 23 | 24 | do{ 25 | do{ 26 | System.out.print("Digite o índice de poluição: "); 27 | numero = entrada.nextDouble(); 28 | if(numero<0) System.out.print("Número inválido digite um número positivo."); 29 | }while(numero<0); 30 | 31 | System.out.println(); 32 | 33 | if(numero>=0&&numero<=0.25){ 34 | System.out.println("Índice de poluição aceitável."); 35 | } 36 | 37 | 38 | if(numero>=0.3){ 39 | System.out.println("Suspender atividades das indústrias do 1° Grupo!"); 40 | } 41 | 42 | if(numero>=0.4){ 43 | System.out.println("Suspender atividades das indústrias do 2° Grupo!"); 44 | } 45 | 46 | if(numero>=0.5){ 47 | System.out.println("Suspender atividades das indústrias do 3° grupo!"); 48 | } 49 | 50 | System.out.println("\nDeseja encerrar o programa? (s/N) "); 51 | letra = entrada.next().charAt(0); 52 | if(letra == 's' || letra == 'S'){ 53 | parar = true; 54 | } 55 | 56 | }while(parar==false); 57 | 58 | } 59 | } 60 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/41/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 41) Faça um programa que dada a idade de um nadador, classifique-o em uma das 3 | * seguintes categorias: 4 | * - Infantil A = 5 a 7 anos 5 | * - Infantil B = 8 a 11 anos 6 | * - Juvenil A = 12 a 13 anos 7 | * - Juvenil B = 14 a 17 anos 8 | * - Adultos = Maiores de 18 anos 9 | *******************************************************************************/ 10 | import java.util.Scanner; 11 | 12 | public class Exercicio { 13 | private static double primeiro, segundo; 14 | 15 | public static void main(String[] args) { 16 | Scanner entrada = new Scanner(System.in); 17 | double idade; 18 | boolean parar = false; 19 | char letra; 20 | String categoria; 21 | 22 | do{ 23 | do{ 24 | System.out.print("Digite a idade do nadador: "); 25 | idade = entrada.nextDouble(); 26 | if(idade<5) System.out.println("Idade inválida."); 27 | }while(idade<5); 28 | 29 | System.out.println(); 30 | 31 | if(idade>= 5 && idade< 8) categoria = "Infantil A"; 32 | else if(idade>=8 && idade<12) categoria = "Infantil B"; 33 | else if(idade>=12 && idade<14) categoria = "Juvenil A"; 34 | else if(idade>=14 && idade<18) categoria = "Juvenil B"; 35 | else categoria = "Adultos"; 36 | 37 | 38 | System.out.println("A categoria é: "+categoria); 39 | 40 | System.out.println("\nDeseja encerrar o programa? (s/N) "); 41 | letra = entrada.next().charAt(0); 42 | if(letra == 's' || letra == 'S'){ 43 | parar = true; 44 | } 45 | 46 | }while(parar==false); 47 | 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/42/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 42) Faça um programa que determine o maior e o menor entre N números lidos. 3 | * A condição de parada é a entrada de um valor 0, ou seja, o programa deve ficar 4 | * executando até que a entrada seja igual a 0 (ZERO). 5 | *******************************************************************************/ 6 | import java.util.Scanner; 7 | 8 | public class Exercicio { 9 | private static double primeiro, segundo; 10 | 11 | public static void main(String[] args) { 12 | Scanner entrada = new Scanner(System.in); 13 | int numero,maior,menor; 14 | 15 | System.out.print("Digite um número: "); 16 | numero = entrada.nextInt(); 17 | menor = numero; 18 | maior = numero; 19 | 20 | do{ 21 | System.out.print("Digite outro número: "); 22 | numero = entrada.nextInt(); 23 | 24 | if(numero>maior) maior = numero; 25 | if(numero4) System.out.print("Opção Errada.\n"); 26 | }while(opcao<1||opcao>4); 27 | double Celsius, Fahrenheit; 28 | double Altura,PesoIdeal; 29 | switch(opcao){ 30 | case 1: 31 | System.out.print("Digite a temperatura em °C: "); 32 | Celsius = entrada.nextDouble(); 33 | Fahrenheit = (Celsius * 1.8) + 32; 34 | System.out.print("A temperatura convertida é: "+Fahrenheit+"°F.\n"); 35 | break; 36 | case 2: 37 | System.out.print("Digite a temperatura em °F: "); 38 | Fahrenheit = entrada.nextDouble(); 39 | Celsius = (Fahrenheit - 32) / 1.8; 40 | System.out.print("A temperatura convertida é: "+Celsius+"°C.\n"); 41 | break; 42 | case 3: 43 | System.out.print("Digite a altura: "); 44 | Altura = entrada.nextDouble(); 45 | PesoIdeal=(72.7*Altura) - 58; 46 | System.out.print("Seu peso ideal é: "+PesoIdeal+"kg"); 47 | break; 48 | case 4: 49 | System.out.print("Digite a altura: "); 50 | Altura = entrada.nextDouble(); 51 | PesoIdeal=(62.1 *Altura) - 44.7; 52 | System.out.print("Seu peso ideal é: "+PesoIdeal+"kg"); 53 | break; 54 | default: 55 | System.out.print("Opção Errada.\n"); 56 | } 57 | 58 | System.out.println("\nDeseja encerrar o programa? (s/N) "); 59 | letra = entrada.next().charAt(0); 60 | if(letra == 's' || letra == 'S'){ 61 | continuar = false; 62 | } 63 | }while(continuar); 64 | 65 | } 66 | } 67 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/45/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 45) Dada uma seqüência de n números (vetor de inteiros), imprimi-la na ordem inversa que 3 | * foi realizada a leitura. 4 | *******************************************************************************/ 5 | import java.util.Scanner; 6 | 7 | public class Exercicio { 8 | 9 | public static void main(String[] args) { 10 | Scanner entrada = new Scanner(System.in); 11 | int quantidade; 12 | 13 | System.out.print("Digite a quantidade de números: "); 14 | quantidade = entrada.nextInt(); 15 | 16 | int[] Numeros = new int[quantidade]; 17 | 18 | for(int x=0;x=0;y--){ 24 | System.out.println(Numeros[y]); 25 | } 26 | 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/46/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 46) Dados dois vetores x e y, ambos com n elementos, determinar o produto escalar desses 3 | * vetores. Ou seja, realizar a soma de todos dos resultados da multiplicação de x[i] por y[i]. 4 | *******************************************************************************/ 5 | import java.util.Scanner; 6 | 7 | public class Exercicio { 8 | 9 | public static void main(String[] args) { 10 | Scanner entrada = new Scanner(System.in); 11 | int quantidade; 12 | 13 | System.out.print("Digite a quantidade de números: "); 14 | quantidade = entrada.nextInt(); 15 | 16 | int[] vetorX = new int[quantidade]; 17 | int[] vetorY = new int[quantidade]; 18 | 19 | for(int x=0;xnumeroX){ 31 | System.out.println(vetor[w]); 32 | maiores++; 33 | } 34 | else if(vetor[w]==numeroX){ 35 | iguais++; 36 | } 37 | else{ 38 | menores++; 39 | } 40 | } 41 | // c. dizer quantos números no vetor são maiores que X, menores que X e iguais a X. 42 | System.out.print("\nMaiores: "+maiores+"\nIguais: "+iguais+"\nMenores: "+menores+"\n"); 43 | 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/48/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 48) Uma agência de publicidade pediu à agência de modelos Luz & Beleza para 3 | * encontrar uma modelo que tenha idade entre 18 e 20 anos para participar de 4 | * uma campanha publicitária milionária de produtos de beleza. Foram inscritas 5 | * 20 candidatas e, ao se inscreverem, forneceram nome e idade. Tais informações 6 | * foram armazenadas em 2 vetores distintos. Faça um programa para imprima o 7 | * vetor que contém os nomes das candidatas aptas a concorrer a uma vaga para 8 | * a campanha milionária. 9 | *******************************************************************************/ 10 | import java.util.Scanner; 11 | 12 | public class Exercicio { 13 | 14 | public static void main(String[] args) { 15 | Scanner entrada = new Scanner(System.in); 16 | 17 | int numeroCandidatas = 5; 18 | int quantidade_aptas = 0; 19 | String[] nome = new String[numeroCandidatas]; 20 | int[] idade = new int[numeroCandidatas]; 21 | 22 | 23 | 24 | for(int x=0;x=18&&idade[x]<21){ 32 | quantidade_aptas++; 33 | } 34 | } 35 | 36 | 37 | String[] nome_aptas = new String[quantidade_aptas]; 38 | int[] idade_aptas = new int[quantidade_aptas]; 39 | 40 | int y=0; 41 | for(int x=0;x=18&&idade[x]<21){ 43 | nome_aptas[y] = nome[x]; 44 | idade_aptas[y] = idade[x]; 45 | y++; 46 | } 47 | } 48 | 49 | System.out.println(); 50 | 51 | for(int x=0;x numero){ 30 | System.out.println("O número é menor."); 31 | }else{ 32 | System.out.println("O número é maior."); 33 | } 34 | } 35 | 36 | 37 | 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/51/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 51) Fazer um programa para ler uma quantidade N de alunos. Ler a nota de cada 3 | * um dos N alunos e calcular a média aritmética das notas. Contar quantos alunos 4 | * estão com a nota acima de 7.0. Obs.: Se nenhum aluno tirou nota acima de 5.0, 5 | * imprimir mensagem: Não há nenhum aluno com nota acima de 5. 6 | *******************************************************************************/ 7 | import java.util.Scanner; 8 | 9 | public class Exercicio { 10 | 11 | public static void main(String[] args) { 12 | Scanner entrada = new Scanner(System.in); 13 | int QuantidadeAlunos,NotasBoas=0; //notas boas são consideradas quando a nota é maior que 7. 14 | boolean SalaFudida = true;//SalaFudida quando ninguém tirou nota maior que 5. 15 | System.out.print("Digite a quantidade de alunos: "); 16 | QuantidadeAlunos = entrada.nextInt(); 17 | 18 | int[] notas = new int[QuantidadeAlunos]; 19 | 20 | for(int x=0;x7){ 25 | NotasBoas++; 26 | } 27 | if(notas[x]>5){ 28 | SalaFudida = false; 29 | } 30 | } 31 | 32 | if(SalaFudida==false){ 33 | System.out.println("Existem "+NotasBoas+" notas maiores que 7."); 34 | }else{ 35 | System.out.println("Não há nenhum aluno com nota acima de 5."); 36 | } 37 | 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/52/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 52) Fazer um programa ler um vetor de inteiros e positivos e imprimir quantas 3 | * vezes aparece o número 1, 3 e 4, nesta ordem. O vetor terá no máximo 100 4 | * posições. Sair do programa quando for digitado -1. 5 | *******************************************************************************/ 6 | import java.util.Scanner; 7 | 8 | public class Exercicio { 9 | 10 | public static void main(String[] args) { 11 | Scanner entrada = new Scanner(System.in); 12 | 13 | int NumeroPosicoes = 100,x = 0; //máximo 100 posições 14 | int[] numero = new int[NumeroPosicoes]; 15 | int contar1=0,contar3=0,contar4=0; //existe um outro jeito, mas vou manter as coisas simples por enqunato 16 | do{ 17 | System.out.print("Digite o próximo número (Digite -1 para sair): "); 18 | numero[x] = entrada.nextInt(); 19 | if(numero[x]==1) contar1++; 20 | if(numero[x]==3) contar3++; 21 | if(numero[x]==4) contar4++; 22 | x++; 23 | }while(numero[x-1]!=-1&&x C = new ArrayList(); 20 | int w=0; 21 | for(int x=0;x<5;x++){ 22 | System.out.print("Digite um número para o vetor A: "); 23 | A[x] = entrada.nextInt(); 24 | } 25 | for(int x=0;x<8;x++){ 26 | System.out.print("Digite um número para o vetor B: "); 27 | B[x] = entrada.nextInt(); 28 | for(int y=0;y<5;y++){ 29 | if(B[x]==A[y]){ 30 | C.add(w, B[x]); 31 | w++; 32 | } 33 | } 34 | } 35 | System.out.print("Números comuns: "); 36 | for(int x=0; x50); 19 | 20 | char[] ArrayChars = frase.toCharArray(); 21 | 22 | for (int x=0;x=0){ 18 | if(NumerosInteiros[x]%5==0&&NumerosInteiros[x]%2==0){ 19 | QuantidadeParesMaioresDe5++; 20 | } 21 | x++; 22 | } 23 | } 24 | 25 | System.out.println("\nA quantidade de números pares e multiplos de 5 é: "+QuantidadeParesMaioresDe5); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/57/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 57) Fazer um programa que leia uma frase e imprima somente as vogais. 3 | *******************************************************************************/ 4 | import java.util.Scanner; 5 | import java.util.Arrays; 6 | 7 | public class Exercicio { 8 | 9 | public static void main(String[] args) { 10 | Scanner entrada = new Scanner(System.in); 11 | String frase,Vogais = "aeiouAEIOU",StringVogais = ""; 12 | 13 | System.out.print("Digite uma frase: "); 14 | frase = entrada.nextLine(); 15 | 16 | char[] ArrayChars = frase.toCharArray(); 17 | 18 | for(int x=0;x=0&&segundo_charactere>=0&&diferencas>=0){ 31 | System.out.println("O numero de caracteres entre eles é: "+diferencas); 32 | }else{ 33 | System.out.println("Erro!"); 34 | } 35 | 36 | } 37 | 38 | public static int ChecarCharactere(char ch,char[] alfabeto){ 39 | 40 | int numero=-1; 41 | for(int x=0;x Fahrenheit\n\n"); //Pronto, bem mais simples! 17 | 18 | 19 | System.out.print("Digite a temperatura em Celsius: "); 20 | Celsius = entrada.nextDouble(); 21 | 22 | Fahrenheit = ( 9 * Celsius + 160 ) / 5; 23 | 24 | System.out.print("\n A medida convertida é " + Fahrenheit + "ºF\n"); 25 | 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/60/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 60) Escreva um programa que retorne o número do quadrante (1,2,3 ou 4) através 3 | * de um método chamado VERIFICA_QUADRANTE, que deve receber um valor para x e um 4 | * valor para y. 5 | Quadrantes 6 | * x | 7 | * | 8 | * 2o | 1o 9 | * | 10 | *y ---------------------- 11 | * | 12 | * | 13 | * 3o | 4o 14 | * | 15 | *******************************************************************************/ 16 | import java.util.Scanner; 17 | import java.util.Arrays; 18 | 19 | public class Exercicio { 20 | 21 | public static void main(String[] args) { 22 | Scanner entrada = new Scanner(System.in); 23 | int x,y; 24 | x=entrada.nextInt(); 25 | y=entrada.nextInt(); 26 | System.out.print(VerificaQuadrante(x,y)); 27 | 28 | 29 | } 30 | public static int VerificaQuadrante(int x, int y){ 31 | boolean quadx,quady; 32 | if(x>=0){ 33 | quadx=true; 34 | }else{ 35 | quadx=false; 36 | } 37 | if(y>=0){ 38 | quady=true; 39 | }else{ 40 | quady=false; 41 | } 42 | if(x==0||y==0) return 0; 43 | else if(quadx&&quady) return 1; 44 | else if (!quadx&&quady) return 2; 45 | else if (!quadx&&!quady) return 3; 46 | else return 4; 47 | 48 | } 49 | 50 | 51 | } 52 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/61/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 61) Escreva um programa que calcule e retorne o salário atualizado através do 3 | * método REAJUSTE. O método deve receber o valor do salário e o índice de 4 | * reajuste. 5 | *******************************************************************************/ 6 | import java.util.Scanner; 7 | 8 | public class Exercicio { 9 | 10 | public static void main(String[] args) { 11 | Scanner entrada = new Scanner(System.in); 12 | System.out.print("Digite o salario atual: "); 13 | double SalarioAtual = entrada.nextDouble(); 14 | System.out.print("Digite o percentual de reajuste: "); 15 | double Reajuste = (entrada.nextDouble()/100); 16 | System.out.println("O novo salario é de R$"+String.format( "%.2f", Reajuste(SalarioAtual,Reajuste) )+"."); 17 | } 18 | public static double Reajuste(double Salario,double IndiceReajuste){ 19 | double NovoSalario = Salario + (Salario*IndiceReajuste); 20 | return NovoSalario; 21 | } 22 | 23 | 24 | 25 | } 26 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/62/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Escreva um programa que calcule e retorne o valor da hipotenusa através do 3 | * método HIPOTENUSA. O método recebe o valor da base e da altura de um triângulo 4 | * Fórmulas: hipotenusa² = base² + altura² 5 | * base x altura 6 | * área = ----------------- 7 | * 2 8 | *******************************************************************************/ 9 | import java.util.Scanner; 10 | 11 | public class Exercicio { 12 | 13 | public static void main(String[] args) { 14 | Scanner entrada = new Scanner(System.in); 15 | System.out.print("Digite o tamanho da base: "); 16 | double base = entrada.nextDouble(); 17 | System.out.print("Digite o tamanho da altura: "); 18 | double altura = entrada.nextDouble(); 19 | System.out.println("A hipotenusa é : "+Hipotenusa(base,altura)); 20 | } 21 | public static double Hipotenusa(double Base,double Altura){ 22 | double hipotenusa = (Base*Base) + (Altura*Altura); 23 | hipotenusa = Math.sqrt(hipotenusa); 24 | return hipotenusa; 25 | } 26 | 27 | 28 | 29 | } 30 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/63/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 63) Escreva um programa que verifique se um número é par ou ímpar através de 3 | * um método chamado VERIFICA. O método deverá receber um número inteiro (n) e 4 | * deverá retornar a mensagem “PAR” ou “ÍMPAR”. 5 | *******************************************************************************/ 6 | import java.util.Scanner; 7 | 8 | public class Exercicio { 9 | 10 | public static void main(String[] args) { 11 | Scanner entrada = new Scanner(System.in); 12 | System.out.print("Digite um número: "); 13 | int numero = entrada.nextInt(); 14 | System.out.println(Verifica(numero)); 15 | } 16 | public static String Verifica(int numero){ 17 | if(numero%2==0) return "PAR"; 18 | else return "ÍMPAR"; 19 | } 20 | 21 | 22 | 23 | } 24 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/64/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 64) Escreva um programa que deverá ter as seguintes opções: 3 | * 1 - Carregar Vetor 4 | * 2 - Listar Vetor 5 | * 3 - Exibir apenas os números pares do vetor 6 | * 4 - Exibir apenas os números ímpares do vetor 7 | * 5 - Exibir a quantidade de números pares existem nas posições ímpares do vetor 8 | * 6 - Exibir a quantidade de números ímpares existem nas posições pares do vetor 9 | * 7 - Sair 10 | * Deverá ser implementado um método para realizar cada uma das opções de 1 a 6. 11 | *******************************************************************************/ 12 | import java.util.Scanner; 13 | 14 | public class Exercicio { 15 | private static int[] Vetor = new int[10]; 16 | private static Scanner entrada = new Scanner(System.in); 17 | public static void main(String[] args) { 18 | 19 | boolean continuar = true; 20 | while(continuar){ 21 | System.out.print("Digite uma opção: "); 22 | int opcao = entrada.nextInt(); 23 | switch(opcao){ 24 | case 1: 25 | CarregarVetor(); 26 | break; 27 | case 2: 28 | System.out.print(ListarVetor()); 29 | break; 30 | case 3: 31 | System.out.print(ListarParesVetor()); 32 | break; 33 | case 4: 34 | System.out.print(ListarImparesVetor()); 35 | break; 36 | case 5: 37 | System.out.print(QuantidadeParesNosImparesVetor()); 38 | break; 39 | case 6: 40 | System.out.print(QuantidadeImparesNosParesVetor()); 41 | break; 42 | case 7: 43 | continuar = false; 44 | break; 45 | default: 46 | System.out.println("Número inválido."); 47 | } 48 | } 49 | } 50 | //1 - Carregar Vetor 51 | public static void CarregarVetor(){ 52 | for(int x=0;x<10;x++){ 53 | System.out.print("Digite o "+(x+1)+"° número do vetor: "); 54 | Vetor[x]= entrada.nextInt(); 55 | } 56 | System.out.println("\nVetor carregado com sucesso!\n"); 57 | } 58 | //2 - Listar Vetor 59 | public static String ListarVetor(){ 60 | String ListaVetor = "Valores do vetor:\n"; 61 | for(int x=0;x<10;x++){ 62 | ListaVetor += "\t"+Vetor[x]+"\n"; 63 | } 64 | return ListaVetor; 65 | } 66 | //3 - Exibir apenas os números pares do vetor 67 | public static String ListarParesVetor(){ 68 | String ListaVetor = "Valores do vetor:\n"; 69 | for(int x=0;x<10;x++){ 70 | if(Vetor[x]%2==0){ 71 | ListaVetor += "\t"+Vetor[x]+"\n"; 72 | } 73 | } 74 | return ListaVetor; 75 | } 76 | //4 - Exibir apenas os números ímpares do vetor 77 | public static String ListarImparesVetor(){ 78 | String ListaVetor = "Valores do vetor:\n"; 79 | for(int x=0;x<10;x++){ 80 | if(Vetor[x]%2==1){ 81 | ListaVetor += "\t"+Vetor[x]+"\n"; 82 | } 83 | } 84 | return ListaVetor; 85 | } 86 | //5 - Exibir a quantidade de números pares existem nas posições ímpares do vetor 87 | public static int QuantidadeParesNosImparesVetor(){ 88 | int quantidade = 0; 89 | for(int x=1;x<10;x=x+2){ 90 | if(Vetor[x]%2==0){ 91 | quantidade++; 92 | } 93 | } 94 | return quantidade; 95 | } 96 | //6 - Exibir a quantidade de números ímpares existem nas posições pares do vetor 97 | public static int QuantidadeImparesNosParesVetor(){ 98 | int quantidade = 0; 99 | for(int x=0;x<10;x=x+2){ 100 | if(Vetor[x]%2==1){ 101 | quantidade++; 102 | } 103 | } 104 | return quantidade; 105 | } 106 | } 107 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/7/Exercicio.java: -------------------------------------------------------------------------------- 1 | /***************************************************************************************************************** 2 | * 7) Ler uma temperatura em graus Fahrenheit e apresentá-Ia convertida em graus Celsius. A fórmula de conversão de 3 | * temperatura a ser utilizada é C = (F - 32) * 5 / 9, em que a variável F é a temperatura em graus Fahrenheit e a 4 | * variável C é a temperatura em graus Celsius. 5 | 6 | *****************************************************************************************************************/ 7 | 8 | import java.util.Scanner; 9 | 10 | public class Exercicio{ 11 | 12 | public static void main(String[] args) { 13 | 14 | Scanner entrada = new Scanner(System.in); 15 | double Celsius, Fahrenheit; //Consegui colocar o nome de variável mais difícil do mundo! o/ 16 | 17 | System.out.print("Conversor de temperatura: Graus Fahrenheit -> Graus Celsius\n\n"); //é basicamente uma cópia do exercício anterior 18 | 19 | 20 | System.out.print("Digite a temperatura em Fahrenheit: "); 21 | Fahrenheit = entrada.nextDouble(); 22 | 23 | Calsius = (Fahrenheit - 32 ) * 5 / 9; 24 | 25 | System.out.print("\n A medida convertida é " + Calsius + "ºC\n"); 26 | 27 | } 28 | 29 | } 30 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/8/Exercicio.java: -------------------------------------------------------------------------------- 1 | /***************************************************************************************************************** 2 | * 8) Calcular e apresentar o valor do volume de uma lata de óleo, utilizando a fórmula: 3 | * V = 3.14159 * R * R * A 4 | * Onde as variáveis: V, R e A representam respectivamente o volume, o raio e a altura. 5 | *****************************************************************************************************************/ 6 | 7 | import java.util.Scanner; 8 | 9 | public class Exercicio{ 10 | 11 | public static void main(String[] args) { 12 | 13 | Scanner entrada = new Scanner(System.in); 14 | double RaioLata, AlturaLata, VolumeLata; 15 | 16 | System.out.print("Cálculo de volume de lata de óleo\n\n"); //Porque lata de óleo é especial 17 | 18 | 19 | System.out.print("Digite diâmeto da lata (em cm): "); 20 | RaioLata = entrada.nextDouble()/2; 21 | 22 | System.out.print("Digite a altura da lata (em cm): "); 23 | AlturaLata = entrade.nextDouble(); 24 | 25 | 26 | VolumeLata = Math.PI * RaioLata * RaioLata * AlturaLata; 27 | 28 | System.out.print("\n O volume da lata é de " + VolumeLata + " cm³\n"); 29 | 30 | } 31 | 32 | } -------------------------------------------------------------------------------- /Lista - 64 Exercicios/9/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 9) Faça um algoritmo que leia a idade de uma pessoa expressa em anos, meses e 3 | * dias e escreva a idade dessa pessoa expressa apenas em dias. Considerar ano 4 | * com 365 dias e mês com 30 dias. 5 | *******************************************************************************/ 6 | 7 | import java.util.Scanner; 8 | 9 | public class Exercicio { 10 | 11 | public static void main(String[] args) { 12 | Scanner entrada = new Scanner(System.in); 13 | int IdadeAnos /* not anus! */, IdadeMeses, IdadeDias, IdadeTotalDias; 14 | 15 | System.out.print("Calculadora de idade em dias\n\n"); //Existe algum exercício mais aleatório do que esse?! 16 | 17 | 18 | System.out.print("Digite os anos: "); 19 | IdadeAnos = entrada.nextInt(); 20 | 21 | System.out.print("Digite os meses: "); 22 | IdadeMeses = entrada.nextInt(); 23 | 24 | System.out.print("Digite os dias: "); 25 | IdadeDias = entrada.nextInt(); 26 | 27 | 28 | IdadeTotalDias = IdadeAnos * 365 + IdadeMeses * 30 + IdadeDias; 29 | System.out.print("Idade total em dias = "+IdadeTotalDias+"\n"); 30 | 31 | } 32 | 33 | } 34 | 35 | -------------------------------------------------------------------------------- /Lista - 64 Exercicios/Lista - 64 Exercicios.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/victorperin/Exercicios-Java/46491825a47aa97b7636de591ee4ad4a51d1752a/Lista - 64 Exercicios/Lista - 64 Exercicios.pdf -------------------------------------------------------------------------------- /Lista 2/1/Caneta.java: -------------------------------------------------------------------------------- 1 | public class Caneta{ 2 | private String marca, cor, tamanho; 3 | 4 | public Caneta(){} 5 | public Caneta(String marca, String cor, String tamanho){ 6 | this.marca = marca; 7 | this.cor = cor; 8 | this.tamanho = tamanho; 9 | } 10 | public String getMarca(){ 11 | return marca; 12 | } 13 | public void setMarca(String marca){ 14 | this.marca = marca; 15 | } 16 | 17 | public String getCor(){ 18 | return cor; 19 | } 20 | public void setCor(String cor){ 21 | this.cor = cor; 22 | } 23 | 24 | public String getTamanho(){ 25 | return tamanho; 26 | } 27 | public void setTamanho(String tamanho){ 28 | this.tamanho = tamanho; 29 | } 30 | 31 | public String toString(){ 32 | return "Marca: "+getMarca()+"\nCor: "+getCor()+"\nTamanho: "+getTamanho(); 33 | } 34 | } -------------------------------------------------------------------------------- /Lista 2/1/CanetaTeste.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/victorperin/Exercicios-Java/46491825a47aa97b7636de591ee4ad4a51d1752a/Lista 2/1/CanetaTeste.java -------------------------------------------------------------------------------- /Lista 2/2/Lampada.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 2. Implementar uma classe Lampada que deve possuir como características tipo 3 | * (led, fluorescente,...), voltagem, cor, marca, preço, potência, 4 | * status(boolean). Nesta classe devem ser implementados os métodos construtores, 5 | * getters, setters, toString, ascender e apagar. Em uma outra classe chamada 6 | * LampadaTeste devem ser criados dois objetos do tipo Lampada, atribuir valores 7 | * e exibir os dados deste objeto. O programa deverá informar também qual das 8 | * duas lâmpadas possui maior potência e também qual das lâmpadas é a mais cara. 9 | *******************************************************************************/ 10 | 11 | import java.util.Scanner; 12 | 13 | public class Lampada { 14 | private String tipo,cor,marca; 15 | private int voltagem,potencia; 16 | private double preco; 17 | private boolean status; 18 | 19 | //Métodos construtores 20 | public Lampada() {} 21 | public Lampada(String tipo,int voltagem,String cor,String marca,double preco, int potencia,boolean status){ 22 | this.tipo = tipo; 23 | this.voltagem = voltagem; 24 | this.cor = cor; 25 | this.marca = marca; 26 | this.preco = preco; 27 | this.potencia = potencia; 28 | this.status = status; 29 | } 30 | 31 | //Métodos getters 32 | public String getTipo(){ 33 | return this.tipo; 34 | } 35 | public int getVoltagem(){ 36 | return this.voltagem; 37 | } 38 | public String getCor(){ 39 | return this.cor; 40 | } 41 | public String getMarca(){ 42 | return this.marca; 43 | } 44 | public double getPreco(){ 45 | return this.preco; 46 | } 47 | public int getPotencia(){ 48 | return this.potencia; 49 | } 50 | public boolean getStatus(){ 51 | return this.status; 52 | } 53 | 54 | //Métodos setters 55 | public void setTipo(String tipo){ 56 | this.tipo = tipo; 57 | } 58 | public void setVoltagem(int voltagem){ 59 | this.voltagem = voltagem; 60 | } 61 | public void setCor(String cor){ 62 | this.cor = cor; 63 | } 64 | public void setMarca(String marca){ 65 | this.marca = marca; 66 | } 67 | public void setPreco(double preco){ 68 | this.preco = preco; 69 | } 70 | public void setPotencia(int potencia){ 71 | this.potencia = potencia; 72 | } 73 | public void setStatus(boolean status){ 74 | this.status = status; 75 | } 76 | 77 | //Método toString 78 | public String toString(){ 79 | String retorno=""; 80 | 81 | retorno += "Objeto lâmpada:\n"; 82 | retorno += "\tTipo: "+this.tipo+"\n"; 83 | retorno += "\tVoltagem: "+this.voltagem+"\n"; 84 | retorno += "\tCor: "+this.cor+"\n"; 85 | retorno += "\tMarca: "+this.marca+"\n"; 86 | retorno += "\tPreço: "+this.preco+"\n"; 87 | retorno += "\tPotência: "+this.potencia+"\n"; 88 | if(this.status==true) retorno += "\tStatus: ligado\n"; 89 | else retorno+= "\tStatus: desligado\n"; 90 | 91 | return retorno; 92 | } 93 | 94 | //Método ascender 95 | public void Ascender(){ 96 | setStatus(true); 97 | } 98 | 99 | //Método apagar 100 | public void Apagar(){ 101 | setStatus(false); 102 | } 103 | } 104 | -------------------------------------------------------------------------------- /Lista 2/2/LampadaTeste.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * 2. Implementar uma classe Lampada que deve possuir como características tipo 3 | * (led, fluorescente,...), voltagem, cor, marca, preço, potência, 4 | * status(boolean). Nesta classe devem ser implementados os métodos construtores, 5 | * getters, setters, toString, ascender e apagar. Em uma outra classe chamada 6 | * LampadaTeste devem ser criados dois objetos do tipo Lampada, atribuir valores 7 | * e exibir os dados deste objeto. O programa deverá informar também qual das 8 | * duas lâmpadas possui maior potência e também qual das lâmpadas é a mais cara. 9 | *******************************************************************************/ 10 | 11 | import java.util.Scanner; 12 | 13 | public class LampadaTeste { 14 | 15 | public static void main(String[] args){ 16 | Scanner entrada = new Scanner(System.in); 17 | 18 | Lampada lampadaAzul = new Lampada("led",110,"Azul","Baconzitos",10.32, 200,false); 19 | Lampada lampadaVerde = new Lampada("led",220,"Verde","Bacon Supreme",11.15, 350,false); 20 | 21 | System.out.print(lampadaAzul.toString()); 22 | System.out.print(lampadaVerde.toString()); 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /Lista 2/3/Apolice.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | (Texto muito grande, melhor ver no PDF) 3 | 4 | 3. Implementar uma classe Apolice com os seguintes atributos nome do segurado, idade do segurado e valor do 5 | prêmio da apólice. Nesta classe Apolice devem ser implementados os métodos: 6 | *imprimir () - este método não retorna valor e deverá mostrar na tela todos os atributos da classe Apolice. Para 7 | imprimir em java usa-se o comando [System.out.println(nome do atributo);] 8 | *calcularPremioApolice() - este método não retorna valor e deverá calcular o valor do prêmio seguindo as 9 | seguintes regras: 10 | caso a idade seja maior ou igual a 18 e menor ou igual a 25 anos, use a formula 11 | valorPremio+=(valorPremio*20)/100. 12 | Quando a idade for superior a 25 e menor ou igual a 26, use a formula 13 | valorPremio+=(valorPremio*15)/100. 14 | Quando a idade for superior a 36 use a formula 15 | valorPremio+=(valorPremio*10)/100. 16 | *oferecerDesconto() - este método não retorna valor, mas recebe o parâmetro cidade, que irá conter o nome da 17 | cidade para o cálculo do desconto. Caso a cidade seja Curitiba, dê um desconto de no valor do premio de 20%, 18 | caso seja Rio de Janeiro, dê um desconto no valor do premio de 15%, caso seja São Paulo dê um desconto no 19 | valor do premio de 10% e se for Belo Horizonte dê um desconto no valor do premio de 5%. 20 | Logo após implementar a classe Apolice, implemente em uma classe chamada ApoliceTeste uma sequência de 21 | instruções para testar as funcionalidades da classe Apolice. 22 | Para entrada de dados em java, temos que instanciar um objeto da Classe Scanner, como no exemplo. 23 | import java.util.Scanner; 24 | public class ApoliceTeste{ 25 | public static void main(String args[]){ 26 | Scanner input = new Scanner(System.in); 27 | System.out.print("Para capturar uma string: "); 28 | String n = input.nextLine(); 29 | System.out.print("Para capturar um numero inteiro (int): "); 30 | int id = input.nextInt(); 31 | System.out.print("Para capturar um valor real (double): "); 32 | double vap = input.nextDouble(); 33 | } 34 | } 35 | *******************************************************************************/ 36 | 37 | public class Apolice { 38 | private String nome; 39 | private int idade; 40 | private double valorPremio; 41 | 42 | //Métodos construtores 43 | public Apolice(String nome,int idade,double valorPremio){ 44 | this.nome = nome; 45 | this.idade = idade; 46 | this.valorPremio = valorPremio; 47 | } 48 | public void imprimir(){ 49 | System.out.println("Apólice:\n\tNome do Segurado: "+this.nome+"\n\tIdade do Segurado: "+this.idade+"\n\tValor do Premio da Apólice: "+valorPremio); 50 | } 51 | public void calcularPremioApolice(){ 52 | if(idade>=18&&idade<=25) valorPremio+=(valorPremio*20)/100; 53 | else if(idade>25&&idade<=36) valorPremio+=(valorPremio*15)/100; //parti do principio de que o professor escreveu errado... 54 | else if(idade>36) valorPremio+=(valorPremio*10)/100; 55 | } 56 | public void oferecerDesconto(String cidade){ 57 | switch(cidade){ 58 | case "Rio de Janeiro": 59 | valorPremio-=valorPremio*0.15; 60 | break; 61 | case "São Paulo": 62 | valorPremio-=valorPremio*0.1; 63 | break; 64 | case "Belo Horizonte": 65 | valorPremio-=valorPremio*0.05; 66 | break; 67 | default: 68 | } 69 | } 70 | 71 | } 72 | -------------------------------------------------------------------------------- /Lista 2/3/ApoliceTeste.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | (Texto muito grande, melhor ver no PDF) 3 | 4 | 3. Implementar uma classe Apolice com os seguintes atributos nome do segurado, idade do segurado e valor do 5 | prêmio da apólice. Nesta classe Apolice devem ser implementados os métodos: 6 | *imprimir () - este método não retorna valor e deverá mostrar na tela todos os atributos da classe Apolice. Para 7 | imprimir em java usa-se o comando [System.out.println(nome do atributo);] 8 | *calcularPremioApolice() - este método não retorna valor e deverá calcular o valor do prêmio seguindo as 9 | seguintes regras: 10 | caso a idade seja maior ou igual a 18 e menor ou igual a 25 anos, use a formula 11 | valorPremio+=(valorPremio*20)/100. 12 | Quando a idade for superior a 25 e menor ou igual a 26, use a formula 13 | valorPremio+=(valorPremio*15)/100. 14 | Quando a idade for superior a 36 use a formula 15 | valorPremio+=(valorPremio*10)/100. 16 | *oferecerDesconto() - este método não retorna valor, mas recebe o parâmetro cidade, que irá conter o nome da 17 | cidade para o cálculo do desconto. Caso a cidade seja Curitiba, dê um desconto de no valor do premio de 20%, 18 | caso seja Rio de Janeiro, dê um desconto no valor do premio de 15%, caso seja São Paulo dê um desconto no 19 | valor do premio de 10% e se for Belo Horizonte dê um desconto no valor do premio de 5%. 20 | Logo após implementar a classe Apolice, implemente em uma classe chamada ApoliceTeste uma sequência de 21 | instruções para testar as funcionalidades da classe Apolice. 22 | Para entrada de dados em java, temos que instanciar um objeto da Classe Scanner, como no exemplo. 23 | import java.util.Scanner; 24 | public class ApoliceTeste{ 25 | public static void main(String args[]){ 26 | Scanner input = new Scanner(System.in); 27 | System.out.print("Para capturar uma string: "); 28 | String n = input.nextLine(); 29 | System.out.print("Para capturar um numero inteiro (int): "); 30 | int id = input.nextInt(); 31 | System.out.print("Para capturar um valor real (double): "); 32 | double vap = input.nextDouble(); 33 | } 34 | } 35 | *******************************************************************************/ 36 | 37 | import java.util.Scanner; 38 | public class ApoliceTeste{ 39 | public static void main(String args[]){ 40 | Scanner input = new Scanner(System.in); 41 | System.out.print("Digite o nome: "); 42 | String nome = input.nextLine(); 43 | System.out.print("Digite a idade: "); 44 | int idade = Integer.parseInt(input.nextLine()); 45 | System.out.print("Digite o Valor do Premio da Apólice: "); 46 | double valorPremio = Double.parseDouble(input.nextLine()); 47 | 48 | 49 | Apolice bacon = new Apolice(nome,idade,valorPremio); 50 | bacon.imprimir(); 51 | 52 | 53 | bacon.calcularPremioApolice(); 54 | 55 | System.out.print("Digite a cidade: "); 56 | String cidade = input.nextLine(); 57 | bacon.oferecerDesconto(cidade); 58 | 59 | bacon.imprimir(); 60 | } 61 | } 62 | -------------------------------------------------------------------------------- /Lista 2/Lista Exercícios 2 - 26_02_2015.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/victorperin/Exercicios-Java/46491825a47aa97b7636de591ee4ad4a51d1752a/Lista 2/Lista Exercícios 2 - 26_02_2015.pdf -------------------------------------------------------------------------------- /Lista 3/1/Caneta.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | 1. Implementar uma classe Caneta que deve possuir como características marca, 3 | cor e tamanho. Nesta classedevem ser implementados os métodos construtores, 4 | getters, setters e toString. Em uma outra classe chamada CanetaTesteVetor deverá 5 | ser criado um vetor para armazenar no máximo 50 objetos do tipo Caneta. 6 | O programa deverá exibir o seguinte menu para o usuário: 7 | 1–Cadastrar caneta 8 | 2–Exibir todas as canetas 9 | 3–Exibir quantidade de canetas cadastradas 10 | 4–Consultar quantidade de canetas de uma determinada cor (digitada pelo usuário) 11 | 0-Sair 12 | *******************************************************************************/ 13 | 14 | public class Caneta{ 15 | private String marca, cor; 16 | private int tamanho; 17 | 18 | public Caneta(){} 19 | public Caneta(String marca, String cor, int tamanho){ 20 | this.marca = marca; 21 | this.cor = cor; 22 | this.tamanho = tamanho; 23 | } 24 | 25 | //getters 26 | public String getMarca(){ 27 | return this.marca; 28 | } 29 | public String getCor(){ 30 | return this.cor; 31 | } 32 | public int getTamanho(){ 33 | return this.tamanho; 34 | } 35 | 36 | //setters 37 | public void setMarca(String marca){ 38 | this.marca = marca; 39 | } 40 | public void setCor(String cor){ 41 | this.cor = cor; 42 | } 43 | public void setTamanho(int tamanho){ 44 | this.tamanho = tamanho; 45 | } 46 | 47 | //toString 48 | public String toString(){ 49 | return "Caneta\n\tTamanho: "+this.tamanho+"\n\tCor: "+this.cor+"\n\tTamanho: "+this.tamanho+"\n"; 50 | } 51 | 52 | } 53 | -------------------------------------------------------------------------------- /Lista 3/1/CanetaTesteVetor.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | 1. Implementar uma classe Caneta que deve possuir como características marca, 3 | cor e tamanho. Nesta classedevem ser implementados os métodos construtores, 4 | getters, setters e toString. Em uma outra classe chamada CanetaTesteVetor deverá 5 | ser criado um vetor para armazenar no máximo 50 objetos do tipo Caneta. 6 | O programa deverá exibir o seguinte menu para o usuário: 7 | 1–Cadastrar caneta 8 | 2–Exibir todas as canetas 9 | 3–Exibir quantidade de canetas cadastradas 10 | 4–Consultar quantidade de canetas de uma determinada cor (digitada pelo usuário) 11 | 0-Sair 12 | *******************************************************************************/ 13 | import java.util.Scanner; 14 | public class CanetaTesteVetor{ 15 | public static void main(String[] args){ 16 | Scanner entrada = new Scanner(System.in); 17 | Caneta[] canetas = new Caneta[50]; 18 | int opcoes,quantidadeCanetas=0; 19 | do{ 20 | System.out.println("Digite uma das seguntes opções:\n\t1–Cadastrar caneta\n\t2–Exibir todas as canetas\n\t3–Exibir quantidade de canetas cadastradas\n\t4–Consultar quantidade de canetas de uma determinada cor (digitada pelo usuário)\n\t0-Sair"); 21 | opcoes = Integer.parseInt(entrada.nextLine()); 22 | switch(opcoes){ 23 | case 1: 24 | if(quantidadeCanetas>=50){ 25 | System.out.println("Já existem muitas canetas."); 26 | }else{ 27 | String marca, cor; 28 | int tamanho; 29 | System.out.print("Digite a marca: "); 30 | marca = entrada.nextLine(); 31 | System.out.print("Digite a cor: "); 32 | cor = entrada.nextLine(); 33 | System.out.print("Digite o tamanho (inteiros): "); 34 | tamanho = Integer.parseInt(entrada.nextLine()); 35 | canetas[quantidadeCanetas]= new Caneta(marca,cor,tamanho); 36 | quantidadeCanetas++; 37 | } 38 | break; 39 | case 2: 40 | for(int x=0;x=quantidade_vetor){ 30 | System.out.println("Já existem muitas lâmpadas."); 31 | }else{ 32 | String tipo, cor, marca; 33 | int voltagem; 34 | boolean status; 35 | double preco, potencia; 36 | 37 | System.out.print("Digite o tipo: "); 38 | tipo = entrada.nextLine(); 39 | System.out.print("Digite a cor: "); 40 | cor = entrada.nextLine(); 41 | System.out.print("Digite a marca: "); 42 | marca = entrada.nextLine(); 43 | System.out.print("Digite a voltagem: "); 44 | voltagem = Integer.parseInt(entrada.nextLine()); 45 | System.out.print("Digite o preco: "); 46 | preco = Double.parseDouble(entrada.nextLine()); 47 | System.out.print("Digite a potencia: "); 48 | potencia = Double.parseDouble(entrada.nextLine()); 49 | 50 | lampadas[quantidade_lampadas]= new Lampada(tipo,voltagem,cor,marca,preco,potencia,false); 51 | quantidade_lampadas++; 52 | } 53 | break; 54 | case 2: 55 | for(int x=0;x0){ 53 | switch(mes){ 54 | case 1: 55 | case 3: 56 | case 5: 57 | case 7: 58 | case 8: 59 | case 10: 60 | case 12: 61 | if(dia<=31) return true; 62 | break; 63 | case 2: 64 | if(ano%4==0){ 65 | if(dia<=29) return true; 66 | } 67 | else{if(dia<=28) return true;} 68 | break; 69 | case 4: 70 | case 6: 71 | case 9: 72 | case 11: 73 | if(dia<=30) return true; 74 | break; 75 | default: 76 | break; 77 | } 78 | } 79 | return false; 80 | } 81 | 82 | } 83 | -------------------------------------------------------------------------------- /Lista 3/3/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | 3. Implementar uma classe Data que deve possuir como características os atributos dia, mês e ano (todas do 3 | tipo inteiro). Nesta classe além dos métodos construtores, getters, setters e toString, deverá ser 4 | implementado o método validarData (int, int, int): boolean que deverá verificar se as informações passadas 5 | por parâmetros é verdadeira ou não. Este método deverá inclusive verificar se é ano bissexto. O método 6 | toString deverá retornar uma string no seguinte formato “dia/mês/ano”, como por exemplo 7 | “05/março/2015” 8 | 9 | *******************************************************************************/ 10 | //obs: um ano é bissexto quando o mesmo é divisível por 4 11 | import java.util.Scanner; 12 | 13 | public class Exercicio{ 14 | 15 | public static void main(String[] args) { 16 | Scanner entrada = new Scanner(System.in); 17 | int dia,mes,ano; 18 | System.out.print("Digite o dia: "); 19 | dia = entrada.nextInt(); 20 | System.out.print("Digite o mês: "); 21 | mes = entrada.nextInt(); 22 | System.out.print("Digite o ano: "); 23 | ano = entrada.nextInt(); 24 | 25 | 26 | 27 | Data calendario = new Data(dia,mes,ano); 28 | if(calendario.validarData(dia,mes,ano)){ 29 | System.out.print(calendario.getDia()); 30 | }else{ 31 | System.out.print("False"); 32 | } 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /Lista 3/Lista Exercícios 3 - 26_02_2015.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/victorperin/Exercicios-Java/46491825a47aa97b7636de591ee4ad4a51d1752a/Lista 3/Lista Exercícios 3 - 26_02_2015.pdf -------------------------------------------------------------------------------- /Lista 4/1/Aluno.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | Exercício 1) 3 | a) Criar uma classe data com os atributos dia, mes e ano, realizando os testes para saber se é uma data válida. 4 | b) Usando herança, criar as classes Pessoa, Aluno e Funcionário 5 | c) Usando Delegação, criar na classe Pessoa o atributo Data de Nascimento do tipo Data (classe do item a) 6 | d) Na classe Aluno deverá existir um atributo Data da Matricula que deverá ser do tipo Data (classe do item a) 7 | e) Na classe Funcionário deverá existir um atributo Data de Admissão que deverá ser do tipo Data (classe do item a) 8 | f) Criar uma classe Teste com um menu para cadastrar aluno e funcionario. 9 | 10 | *******************************************************************************/ 11 | import java.util.Scanner; 12 | 13 | public class Aluno extends Pessoa{ 14 | private String ra; 15 | private Data dataMatricula; 16 | 17 | //construtor 18 | public Aluno(String nome, String rg,String dataNascimento, String ra, String dataMatricula){ 19 | super(nome,rg,dataNascimento); 20 | this.ra = ra; 21 | this.dataMatricula = new Data(dataMatricula); 22 | } 23 | 24 | //gets 25 | public String getRa(){ 26 | return this.ra; 27 | } 28 | public String getDataMatricula(){ 29 | return this.dataMatricula.toString(); 30 | } 31 | 32 | //sets 33 | public void setRa(String ra){ 34 | this.ra = ra; 35 | } 36 | public void setDataMatricula(String dataMatricula){ 37 | this.dataMatricula.setData(dataMatricula); 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /Lista 4/1/Data.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | Exercício 1) 3 | a) Criar uma classe data com os atributos dia, mes e ano, realizando os testes para saber se é uma data válida. 4 | b) Usando herança, criar as classes Pessoa, Aluno e Funcionário 5 | c) Usando Delegação, criar na classe Pessoa o atributo Data de Nascimento do tipo Data (classe do item a) 6 | d) Na classe Aluno deverá existir um atributo Data da Matricula que deverá ser do tipo Data (classe do item a) 7 | e) Na classe Funcionário deverá existir um atributo Data de Admissão que deverá ser do tipo Data (classe do item a) 8 | f) Criar uma classe Teste com um menu para cadastrar aluno e funcionario. 9 | 10 | *******************************************************************************/ 11 | public class Data{ 12 | private int dia, mes, ano; 13 | 14 | public Data(){} 15 | public Data(String dataString){ 16 | int[] dataInt = converterToArray(dataString); 17 | if(validarData(dataString)){ 18 | this.dia=dataInt[0]; 19 | this.mes=dataInt[1]; 20 | this.ano=dataInt[2]; 21 | } 22 | } 23 | 24 | //getters 25 | public int getDia(){ 26 | return this.dia; 27 | } 28 | public int getMes(){ 29 | return this.mes; 30 | } 31 | public int getAno(){ 32 | return this.ano; 33 | } 34 | 35 | //setters 36 | public void setDia(int dia){ 37 | this.dia=dia; 38 | } 39 | public void setMes(int mes){ 40 | this.mes=mes; 41 | } 42 | public void setAno(int ano){ 43 | this.ano=ano; 44 | } 45 | public void setData(String dataString){ 46 | int[] data = converterToArray(dataString); 47 | this.dia=data[0]; 48 | this.mes=data[1]; 49 | this.ano=data[2]; 50 | } 51 | 52 | 53 | //toString 54 | public String toString(){ 55 | return this.dia+"/"+this.mes+"/"+this.ano; 56 | } 57 | 58 | //converter String para data array 59 | public int[] converterToArray(String dataString){ 60 | String partes[] = dataString.split("/"); 61 | int[] dataInt = new int[3]; 62 | for(int x=0;x 0 && data[2] <= Integer.parseInt(df.format(c))){//ano 74 | switch(data[1]){ //mes 75 | case 1: 76 | case 3: 77 | case 5: 78 | case 7: 79 | case 8: 80 | case 10: 81 | case 12: 82 | if(data[0]<=31) return true;//dia 83 | break; 84 | case 2: 85 | if(data[2]%4==0){//ano 86 | if(data[0]<=29) return true;//dia 87 | } 88 | else{if(data[0]<=28) return true;}//dia 89 | break; 90 | case 4: 91 | case 6: 92 | case 9: 93 | case 11: 94 | if(data[0]<=30) return true;//dia 95 | break; 96 | default: 97 | break; 98 | } 99 | } 100 | return false; 101 | } 102 | 103 | } 104 | -------------------------------------------------------------------------------- /Lista 4/1/Funcionario.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | Exercício 1) 3 | a) Criar uma classe data com os atributos dia, mes e ano, realizando os testes para saber se é uma data válida. 4 | b) Usando herança, criar as classes Pessoa, Aluno e Funcionário 5 | c) Usando Delegação, criar na classe Pessoa o atributo Data de Nascimento do tipo Data (classe do item a) 6 | d) Na classe Aluno deverá existir um atributo Data da Matricula que deverá ser do tipo Data (classe do item a) 7 | e) Na classe Funcionário deverá existir um atributo Data de Admissão que deverá ser do tipo Data (classe do item a) 8 | f) Criar uma classe Teste com um menu para cadastrar aluno e funcionario. 9 | 10 | *******************************************************************************/ 11 | import java.util.Scanner; 12 | 13 | public class Funcionario extends Pessoa{ 14 | private double salario; 15 | private String funcao; 16 | private Data dataAdmissao; 17 | 18 | //construtor 19 | public Funcionario(String nome, String rg,String dataNascimento, double salario,String funcao, String dataAdmissaoString){ 20 | super(nome,rg,dataNascimento); 21 | this.salario = salario; 22 | this.funcao = funcao; 23 | this.dataAdmissao = new Data(dataAdmissaoString); 24 | } 25 | 26 | //gets 27 | public double getSalario(){ 28 | return this.salario; 29 | } 30 | public String getFuncao(){ 31 | return this.funcao; 32 | } 33 | public String getDataAdmissao(){ 34 | return this.dataAdmissao.toString(); 35 | } 36 | 37 | //sets 38 | public void setSalario(double salario){ 39 | this.salario = salario; 40 | } 41 | public void setFuncao(String funcao){ 42 | this.funcao = funcao; 43 | } 44 | public void setDataAdimissao(String dataString){ 45 | this.dataAdmissao.setData(dataString); 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /Lista 4/1/Pessoa.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | Exercício 1) 3 | a) Criar uma classe data com os atributos dia, mes e ano, realizando os testes para saber se é uma data válida. 4 | b) Usando herança, criar as classes Pessoa, Aluno e Funcionário 5 | c) Usando Delegação, criar na classe Pessoa o atributo Data de Nascimento do tipo Data (classe do item a) 6 | d) Na classe Aluno deverá existir um atributo Data da Matricula que deverá ser do tipo Data (classe do item a) 7 | e) Na classe Funcionário deverá existir um atributo Data de Admissão que deverá ser do tipo Data (classe do item a) 8 | f) Criar uma classe Teste com um menu para cadastrar aluno e funcionario. 9 | 10 | *******************************************************************************/ 11 | import java.util.Scanner; 12 | 13 | public class Pessoa{ 14 | String nome, rg; 15 | Data dataNascimento; 16 | 17 | //construtor 18 | public Pessoa(String nome, String rg,String dataString){ 19 | this.nome = nome; 20 | this.rg = rg; 21 | this.dataNascimento = new Data(dataString); 22 | } 23 | 24 | //gets 25 | public String getNome(){ 26 | return this.nome; 27 | } 28 | public String getRg(){ 29 | return this.rg; 30 | } 31 | public String getData(){ 32 | return this.dataNascimento.toString(); 33 | } 34 | 35 | //sets 36 | public void setNome(String nome){ 37 | this.nome = nome; 38 | } 39 | public void setRg(String rg){ 40 | this.rg = rg; 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /Lista 4/1/Teste.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | Exercício 1) 3 | a) Criar uma classe data com os atributos dia, mes e ano, realizando os testes para saber se é uma data válida. 4 | b) Usando herança, criar as classes Pessoa, Aluno e Funcionário 5 | c) Usando Delegação, criar na classe Pessoa o atributo Data de Nascimento do tipo Data (classe do item a) 6 | d) Na classe Aluno deverá existir um atributo Data da Matricula que deverá ser do tipo Data (classe do item a) 7 | e) Na classe Funcionário deverá existir um atributo Data de Admissão que deverá ser do tipo Data (classe do item a) 8 | f) Criar uma classe Teste com um menu para cadastrar aluno e funcionario. 9 | 10 | *******************************************************************************/ 11 | import java.util.Scanner; 12 | import java.util.List; 13 | import java.util.ArrayList; 14 | 15 | public class Teste{ 16 | 17 | public static void main(String[] args) { 18 | Scanner entrada = new Scanner(System.in); 19 | int opcao; 20 | List alunos = new ArrayList(); //lista ordenada de aluno 21 | List funcionarios = new ArrayList(); //lista ordenada de funcionarios 22 | 23 | do{ 24 | System.out.print("Digite 1 para cadastrar um aluno e 2 para cadastrar um funcionário (3 para sair): "); 25 | opcao = Integer.parseInt(entrada.nextLine()); 26 | switch(opcao){ 27 | case 1: 28 | System.out.print("Digite o nome do Aluno: "); 29 | String nomeAluno = entrada.nextLine(); 30 | System.out.print("Digite o RG do Aluno: "); 31 | String rgAluno = entrada.nextLine(); 32 | System.out.print("Digite a data de nascimento do Aluno (string dia/mes/ano): "); 33 | String dataNascimentoAluno = entrada.nextLine(); 34 | System.out.print("Digite o RA do Aluno: "); 35 | String ra = entrada.nextLine(); 36 | System.out.print("Digite a data da matricula do Aluno: "); 37 | String dataMatricula = entrada.nextLine(); 38 | 39 | alunos.add(new Aluno(nomeAluno,rgAluno,dataNascimentoAluno,ra,dataMatricula)); 40 | 41 | break; 42 | 43 | case 2: 44 | System.out.print("Digite o nome do funcionario: "); 45 | String nomeFuncionario = entrada.nextLine(); 46 | System.out.print("Digite o RG do funcionario: "); 47 | String rgFuncionario = entrada.nextLine(); 48 | System.out.print("Digite a data de nascimento do Funcionario (string dia/mes/ano): "); 49 | String dataNascimentoFuncionario = entrada.nextLine(); 50 | System.out.print("Digite o salário do funcionário: "); 51 | double salario = Double.parseDouble(entrada.nextLine()); 52 | System.out.print("Digite a função do funcionário: "); 53 | String funcao = entrada.nextLine(); 54 | 55 | System.out.print("Digite a data de admissao do funcionário: "); 56 | String dataAdmissao = entrada.nextLine(); 57 | 58 | funcionarios.add(new Funcionario(nomeFuncionario,rgFuncionario,dataNascimentoFuncionario,salario,funcao,dataAdmissao)); 59 | 60 | break; 61 | case 3: 62 | System.out.print("Saindo..."); 63 | break; 64 | default: System.out.println("Opção inválida."); 65 | } 66 | }while(opcao!=3); 67 | } 68 | } 69 | -------------------------------------------------------------------------------- /Lista 4/2/Aluno.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | Exercicio no arquivo de imagem. 3 | *******************************************************************************/ 4 | import java.util.Scanner; 5 | 6 | public class Aluno extends Pessoa{ 7 | private int matricula; 8 | 9 | //construtor 10 | public Aluno(String nome, String sobrenome, int matricula){ 11 | super(nome,sobrenome); 12 | this.matricula=matricula; 13 | } 14 | 15 | //gets 16 | public int getMatricula(){ 17 | return this.matricula; 18 | } 19 | 20 | //sets 21 | public void setMatricula(int matricula){ 22 | this.matricula = matricula; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /Lista 4/2/Pessoa.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | Exercicio no arquivo de imagem. 3 | *******************************************************************************/ 4 | 5 | import java.util.Scanner; 6 | 7 | public class Pessoa{ 8 | String nome,sobrenome; 9 | 10 | //construtor 11 | public Pessoa(String nome, String sobrenome){ 12 | this.nome = nome; 13 | this.sobrenome = sobrenome; 14 | } 15 | 16 | //gets 17 | public String getNome(){ 18 | return this.nome; 19 | } 20 | public String getSobrenome(){ 21 | return this.sobrenome; 22 | } 23 | //sets 24 | public void setNome(String nome){ 25 | this.nome = nome; 26 | } 27 | public void setSobrenome(String sobrenome){ 28 | this.sobrenome = sobrenome; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /Lista 4/2/Professor.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | Exercicio no arquivo de imagem. 3 | *******************************************************************************/ 4 | import java.util.Scanner; 5 | 6 | public class Professor extends Pessoa{ 7 | private String disciplina; 8 | 9 | //construtor 10 | public Professor(String nome, String sobrenome,String disciplina){ 11 | super(nome,sobrenome); 12 | this.disciplina = disciplina; 13 | } 14 | 15 | //gets 16 | public String getDisciplina(){ 17 | return this.disciplina; 18 | } 19 | 20 | //sets 21 | public void setDisciplina(String disciplina){ 22 | this.disciplina = disciplina; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /Lista 4/2/exercicio.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/victorperin/Exercicios-Java/46491825a47aa97b7636de591ee4ad4a51d1752a/Lista 4/2/exercicio.jpeg -------------------------------------------------------------------------------- /Lista 4/3/Cliente.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | Exercicio no arquivo de imagem. 3 | *******************************************************************************/ 4 | 5 | import java.util.Scanner; 6 | 7 | public class Cliente{ 8 | String nome,endereco,telefone; 9 | 10 | //construtor 11 | public Cliente(String nome, String endereco,String telefone){ 12 | this.nome = nome; 13 | this.endereco = endereco; 14 | this.telefone = telefone; 15 | } 16 | 17 | //gets 18 | public String getNome(){ 19 | return this.nome; 20 | } 21 | public String getEndereco(){ 22 | return this.endereco; 23 | } 24 | public String getTelefone(){ 25 | return this.telefone; 26 | } 27 | //sets 28 | public void setNome(String nome){ 29 | this.nome = nome; 30 | } 31 | public void setEndereco(String endereco){ 32 | this.endereco = endereco; 33 | } 34 | public void setTelefone(String telefone){ 35 | this.telefone = telefone; 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /Lista 4/3/PessoaFisica.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | Exercicio no arquivo de imagem. 3 | *******************************************************************************/ 4 | import java.util.Scanner; 5 | 6 | public class PessoaFisica extends Cliente{ 7 | private String cpf; 8 | 9 | //construtor 10 | public PessoaFisica(String nome, String endereco,String telefone,String cpf){ 11 | super(nome,endereco,telefone); 12 | this.cpf=cpf; 13 | } 14 | 15 | //gets 16 | public String getCpf(){ 17 | return this.cpf; 18 | } 19 | 20 | //sets 21 | public void setCpf(String cpf){ 22 | this.cpf = cpf; 23 | } 24 | 25 | //toString 26 | public void ImprimirDados(){ 27 | System.out.println("Pessoa Física:\n\tNome: "+this.nome+"\n\tEndereço: "+this.endereco+"\n\tTelefone: "+this.telefone+"\n\tCPF: "+this.cpf); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /Lista 4/3/PessoaJuridica.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | Exercicio no arquivo de imagem. 3 | *******************************************************************************/ 4 | import java.util.Scanner; 5 | 6 | public class PessoaJuridica extends Cliente{ 7 | private String cnpj; 8 | private String nomeFantasia; 9 | 10 | //construtor 11 | public PessoaJuridica(String nome, String endereco,String telefone,String cnpj,String nomeFantasia){ 12 | super(nome,endereco,telefone); 13 | this.cnpj = cnpj; 14 | this.nomeFantasia = nomeFantasia; 15 | } 16 | 17 | //gets 18 | public String getCnpj(){ 19 | return this.cnpj; 20 | } 21 | public String getNomeFantasia(){ 22 | return this.nomeFantasia; 23 | } 24 | 25 | //sets 26 | public void setCnpj(String cnpj){ 27 | this.cnpj = cnpj; 28 | } 29 | public void setNomeFantasia(String nomeFantasia){ 30 | this.nomeFantasia = nomeFantasia; 31 | } 32 | 33 | //toString 34 | public void ImprimirDados(){ 35 | System.out.println("Pessoa Física:\n\tNome: "+this.nome+"\n\tEndereço: "+this.endereco+"\n\tTelefone: "+this.telefone+"\n\tCNPJ: "+this.cnpj+"\n\tNome Fantasia: "+this.nomeFantasia); 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /Lista 4/3/exercicio.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/victorperin/Exercicios-Java/46491825a47aa97b7636de591ee4ad4a51d1752a/Lista 4/3/exercicio.jpeg -------------------------------------------------------------------------------- /Lista 4/Exercícios LPOO 12_03_2015.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/victorperin/Exercicios-Java/46491825a47aa97b7636de591ee4ad4a51d1752a/Lista 4/Exercícios LPOO 12_03_2015.pdf -------------------------------------------------------------------------------- /Lista 5/1/ContaBancariaSimplificada.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | veja a imagem anexa na mesma pasta 3 | *******************************************************************************/ 4 | 5 | public class ContaBancariaSimplificada{ 6 | private String nomeDoCorretista; 7 | private double saldo; 8 | private boolean contaEspecial; 9 | 10 | public ContaBancariaSimplificada(){} 11 | public void AbreConta(String nome,double saldo,boolean especial){ 12 | this.nomeDoCorretista=nome; 13 | this.saldo=saldo; 14 | this.contaEspecial=especial; 15 | } 16 | public void AbreContaSimples(String nome){ 17 | this.nomeDoCorretista=nome; 18 | this.saldo= 0; 19 | this.contaEspecial=false; 20 | } 21 | public void Deposita(double valor){ 22 | this.saldo += valor; 23 | } 24 | public void Retira(double valor){ 25 | this.saldo -= valor; 26 | } 27 | 28 | public void MostraDados(){ 29 | String especial; 30 | if(contaEspecial==true){especial="sim";} 31 | else{especial="não";} 32 | System.out.println("Conta:\n\tNome do Corretista: "+this.nomeDoCorretista+"\n\tSaldo: "+this.saldo+"\n\tConta Especial? "+especial); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /Lista 5/1/exercicio.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/victorperin/Exercicios-Java/46491825a47aa97b7636de591ee4ad4a51d1752a/Lista 5/1/exercicio.jpg -------------------------------------------------------------------------------- /Lista 5/2/Data.java: -------------------------------------------------------------------------------- 1 | public class Data{ 2 | private int dia, mes, ano; 3 | 4 | public Data(){} 5 | public Data(String dataString){ 6 | int[] dataInt = converterToArray(dataString); 7 | if(validarData(dataString)){ 8 | this.dia=dataInt[0]; 9 | this.mes=dataInt[1]; 10 | this.ano=dataInt[2]; 11 | } 12 | } 13 | 14 | //getters 15 | public int getDia(){ 16 | return this.dia; 17 | } 18 | public int getMes(){ 19 | return this.mes; 20 | } 21 | public int getAno(){ 22 | return this.ano; 23 | } 24 | 25 | //setters 26 | public void setDia(int dia){ 27 | this.dia=dia; 28 | } 29 | public void setMes(int mes){ 30 | this.mes=mes; 31 | } 32 | public void setAno(int ano){ 33 | this.ano=ano; 34 | } 35 | public void setData(String dataString){ 36 | int[] data = converterToArray(dataString); 37 | this.dia=data[0]; 38 | this.mes=data[1]; 39 | this.ano=data[2]; 40 | } 41 | 42 | 43 | //toString 44 | public String toString(){ 45 | return this.dia+"/"+this.mes+"/"+this.ano; 46 | } 47 | 48 | //converter String para data array 49 | public int[] converterToArray(String dataString){ 50 | String partes[] = dataString.split("/"); 51 | int[] dataInt = new int[3]; 52 | for(int x=0;x0){//ano 62 | switch(data[1]){ //mes 63 | case 1: 64 | case 3: 65 | case 5: 66 | case 7: 67 | case 8: 68 | case 10: 69 | case 12: 70 | if(data[0]<=31) return true;//dia 71 | break; 72 | case 2: 73 | if(data[2]%4==0){//ano 74 | if(data[0]<=29) return true;//dia 75 | } 76 | else{if(data[0]<=28) return true;}//dia 77 | break; 78 | case 4: 79 | case 6: 80 | case 9: 81 | case 11: 82 | if(data[0]<=30) return true;//dia 83 | break; 84 | default: 85 | break; 86 | } 87 | } 88 | return false; 89 | } 90 | 91 | } 92 | -------------------------------------------------------------------------------- /Lista 5/2/RegistroAcademico.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | 2- Dado o diagrama, implemente: 3 | (imagem) 4 | Obs: O valor inicial da mensalidade deverá ser de R$ 400,00 e caso o aluno 5 | seja bolsista deverá ter desconto de 50%. 6 | Dica: O atributo dataDeNascimento deve ser do tipo Data (classe já criada em 7 | exercício anterior) 8 | *******************************************************************************/ 9 | 10 | public class RegistroAcademico{ 11 | private String nomeDoAluno; 12 | private int numeroDaMatricula,anoDeMatricula; 13 | private double mensalidade; 14 | private Data dataDeNascimento; 15 | private boolean eBolsista; 16 | 17 | public RegistroAcademico(){} 18 | public void IniciaRegistro(String nome,int matricula,String nascimento,boolean bolsista, int ano){ 19 | this.nomeDoAluno=nome; 20 | this.numeroDaMatricula=matricula; 21 | this.dataDeNascimento=new Data(nascimento); 22 | this.eBolsista=bolsista; 23 | this.anoDeMatricula=ano; 24 | CalculaMensalidade(); 25 | } 26 | public void CalculaMensalidade(){ 27 | double valorPadraoMensalidade = 400; 28 | if(this.eBolsista==false){this.mensalidade=valorPadraoMensalidade;} 29 | else{this.mensalidade=valorPadraoMensalidade*0.5;} 30 | } 31 | public void MostraRegistro(){ 32 | System.out.println("Registro Acadêmico:"); 33 | System.out.println("\tNome do Aluno: "+this.nomeDoAluno); 34 | System.out.println("\tNúmero da Matrícula: "+this.numeroDaMatricula); 35 | System.out.println("\tData de Nascimento: "+this.dataDeNascimento); 36 | System.out.println("\tAno de Matricula: "+this.anoDeMatricula); 37 | System.out.println("\tMensalidade: "+this.mensalidade); 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /Lista 5/2/exercicio.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/victorperin/Exercicios-Java/46491825a47aa97b7636de591ee4ad4a51d1752a/Lista 5/2/exercicio.jpg -------------------------------------------------------------------------------- /Lista 5/3/Aluno.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | Exercício 3) 3 | Uma universidade deseja modificar a estrutura de sua base de dados. Para isso, ela quer construir a 4 | hierarquia das pessoas que frequentam o estabelecimento com a ajuda de uma representação do tipo 5 | OO (orientado objeto). A universidade deseja conservar o nome de todas as pessoas e dispõe de 6 | uma função que lhe permite de inicializar e de modificar este membro dado. A universidade é 7 | frequentada por estudantes e empregados. As fichas dos estudantes devem conter seu nome, seu 8 | estatuto (aluno especial, tempo parcial, tempo integral) e sua média. Além do mais, é necessário 9 | prever funções que poderão modificar o estatuto e a média. Os empregados são divididos em duas 10 | categorias: o corpo docente (demonstrador, monitor, professor) e o discente (escritório e 11 | manutenção). Para todos os empregados, nós devemos prever um campo salário e uma função que 12 | permita fixar os salários. Escreva, em linguagem JAVA, as declarações das classes que permitem 13 | representar esta hierarquia. 14 | *******************************************************************************/ 15 | 16 | public class Aluno extends Pessoa{ 17 | private String estatuto; 18 | private double media; 19 | 20 | public Aluno(String nome,String estatuto,double media){ 21 | super(nome); 22 | this.estatuto=estatuto; 23 | this.media=media; 24 | } 25 | 26 | //getters 27 | public String getEstatuto(){ 28 | return this.estatuto; 29 | } 30 | public double getMedia(){ 31 | return this.media; 32 | } 33 | 34 | //setters 35 | public void setEstatuto(String estatuto){ 36 | this.estatuto=estatuto; 37 | } 38 | public void setMedia(double media){ 39 | this.media=media; 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /Lista 5/3/Discente.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | Exercício 3) 3 | Uma universidade deseja modificar a estrutura de sua base de dados. Para isso, ela quer construir a 4 | hierarquia das pessoas que frequentam o estabelecimento com a ajuda de uma representação do tipo 5 | OO (orientado objeto). A universidade deseja conservar o nome de todas as pessoas e dispõe de 6 | uma função que lhe permite de inicializar e de modificar este membro dado. A universidade é 7 | frequentada por estudantes e empregados. As fichas dos estudantes devem conter seu nome, seu 8 | estatuto (aluno especial, tempo parcial, tempo integral) e sua média. Além do mais, é necessário 9 | prever funções que poderão modificar o estatuto e a média. Os empregados são divididos em duas 10 | categorias: o corpo docente (demonstrador, monitor, professor) e o discente (escritório e 11 | manutenção). Para todos os empregados, nós devemos prever um campo salário e uma função que 12 | permita fixar os salários. Escreva, em linguagem JAVA, as declarações das classes que permitem 13 | representar esta hierarquia. 14 | *******************************************************************************/ 15 | 16 | public class Discente extends Empregado{ 17 | 18 | public Discente(String nome,double salario,String tipo){ 19 | super(nome,salario); 20 | setTipo(tipo); 21 | } 22 | 23 | //setters 24 | public void setTipoDiscente(String tipo){ 25 | switch(tipo){ 26 | case "escritorio": 27 | case "manutenção": 28 | setTipo(tipo); 29 | break; 30 | default: 31 | System.out.println("Atenção, tipo de discente errado."); 32 | } 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /Lista 5/3/Docente.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | Exercício 3) 3 | Uma universidade deseja modificar a estrutura de sua base de dados. Para isso, ela quer construir a 4 | hierarquia das pessoas que frequentam o estabelecimento com a ajuda de uma representação do tipo 5 | OO (orientado objeto). A universidade deseja conservar o nome de todas as pessoas e dispõe de 6 | uma função que lhe permite de inicializar e de modificar este membro dado. A universidade é 7 | frequentada por estudantes e empregados. As fichas dos estudantes devem conter seu nome, seu 8 | estatuto (aluno especial, tempo parcial, tempo integral) e sua média. Além do mais, é necessário 9 | prever funções que poderão modificar o estatuto e a média. Os empregados são divididos em duas 10 | categorias: o corpo docente (demonstrador, monitor, professor) e o discente (escritório e 11 | manutenção). Para todos os empregados, nós devemos prever um campo salário e uma função que 12 | permita fixar os salários. Escreva, em linguagem JAVA, as declarações das classes que permitem 13 | representar esta hierarquia. 14 | *******************************************************************************/ 15 | 16 | public class Docente extends Empregado{ 17 | 18 | public Docente(String nome,double salario,String tipo){ 19 | super(nome,salario); 20 | setTipo(tipo); 21 | } 22 | 23 | //setters 24 | public void setTipoDocente(String tipo){ 25 | switch(tipo){ 26 | case "demonstrador": 27 | case "monitor": 28 | case "professor": 29 | setTipo(tipo); 30 | break; 31 | default: 32 | System.out.println("Atenção, tipo de docente errado."); 33 | } 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /Lista 5/3/Empregado.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | Exercício 3) 3 | Uma universidade deseja modificar a estrutura de sua base de dados. Para isso, ela quer construir a 4 | hierarquia das pessoas que frequentam o estabelecimento com a ajuda de uma representação do tipo 5 | OO (orientado objeto). A universidade deseja conservar o nome de todas as pessoas e dispõe de 6 | uma função que lhe permite de inicializar e de modificar este membro dado. A universidade é 7 | frequentada por estudantes e empregados. As fichas dos estudantes devem conter seu nome, seu 8 | estatuto (aluno especial, tempo parcial, tempo integral) e sua média. Além do mais, é necessário 9 | prever funções que poderão modificar o estatuto e a média. Os empregados são divididos em duas 10 | categorias: o corpo docente (demonstrador, monitor, professor) e o discente (escritório e 11 | manutenção). Para todos os empregados, nós devemos prever um campo salário e uma função que 12 | permita fixar os salários. Escreva, em linguagem JAVA, as declarações das classes que permitem 13 | representar esta hierarquia. 14 | *******************************************************************************/ 15 | 16 | public class Empregado extends Pessoa{ 17 | protected double salario; 18 | protected String tipo; 19 | 20 | public Empregado(String nome,double salario){ 21 | super(nome); 22 | this.salario=salario; 23 | } 24 | 25 | //getters 26 | public double getSalario(){ 27 | return this.salario; 28 | } 29 | public String getTipo(){ 30 | return this.tipo; 31 | } 32 | 33 | //setters 34 | public void setSalario(double salario){ 35 | this.salario=salario; 36 | } 37 | protected void setTipo(String tipo){ 38 | this.tipo=tipo; 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /Lista 5/3/Pessoa.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | Exercício 3) 3 | Uma universidade deseja modificar a estrutura de sua base de dados. Para isso, ela quer construir a 4 | hierarquia das pessoas que frequentam o estabelecimento com a ajuda de uma representação do tipo 5 | OO (orientado objeto). A universidade deseja conservar o nome de todas as pessoas e dispõe de 6 | uma função que lhe permite de inicializar e de modificar este membro dado. A universidade é 7 | frequentada por estudantes e empregados. As fichas dos estudantes devem conter seu nome, seu 8 | estatuto (aluno especial, tempo parcial, tempo integral) e sua média. Além do mais, é necessário 9 | prever funções que poderão modificar o estatuto e a média. Os empregados são divididos em duas 10 | categorias: o corpo docente (demonstrador, monitor, professor) e o discente (escritório e 11 | manutenção). Para todos os empregados, nós devemos prever um campo salário e uma função que 12 | permita fixar os salários. Escreva, em linguagem JAVA, as declarações das classes que permitem 13 | representar esta hierarquia. 14 | *******************************************************************************/ 15 | 16 | public class Pessoa{ 17 | protected String nome; 18 | 19 | public Pessoa(String nome){ 20 | this.nome=nome; 21 | } 22 | 23 | public String getNome(){ 24 | return this.nome; 25 | } 26 | public void setNome(String nome){ 27 | this.nome=nome; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /Lista 5/3/Teste.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | Exercício 3) 3 | Uma universidade deseja modificar a estrutura de sua base de dados. Para isso, ela quer construir a 4 | hierarquia das pessoas que frequentam o estabelecimento com a ajuda de uma representação do tipo 5 | OO (orientado objeto). A universidade deseja conservar o nome de todas as pessoas e dispõe de 6 | uma função que lhe permite de inicializar e de modificar este membro dado. A universidade é 7 | frequentada por estudantes e empregados. As fichas dos estudantes devem conter seu nome, seu 8 | estatuto (aluno especial, tempo parcial, tempo integral) e sua média. Além do mais, é necessário 9 | prever funções que poderão modificar o estatuto e a média. Os empregados são divididos em duas 10 | categorias: o corpo docente (demonstrador, monitor, professor) e o discente (escritório e 11 | manutenção). Para todos os empregados, nós devemos prever um campo salário e uma função que 12 | permita fixar os salários. Escreva, em linguagem JAVA, as declarações das classes que permitem 13 | representar esta hierarquia. 14 | *******************************************************************************/ 15 | 16 | public class Teste{ 17 | public static void main(String[] args){ 18 | Pessoa jose = new Pessoa("josé"); 19 | System.out.println(jose.getNome()); 20 | 21 | Aluno marcos = new Aluno("marcos","especial",9.5); 22 | System.out.println(marcos.getNome()); 23 | System.out.println(marcos.getEstatuto()); 24 | System.out.println(marcos.getMedia()); 25 | 26 | Empregado joao = new Empregado("João",5000.32); 27 | System.out.println(joao.getNome()); 28 | System.out.println(joao.getSalario()); 29 | 30 | Empregado mario = new Docente("Mario",102312.23,"professor"); 31 | System.out.println(mario.getNome()); 32 | System.out.println(mario.getSalario()); 33 | System.out.println(mario.getTipo()); 34 | 35 | Empregado jackinsong = new Discente("jackinsong",300.23,"manutenção"); 36 | System.out.println(jackinsong.getNome()); 37 | System.out.println(jackinsong.getSalario()); 38 | System.out.println(jackinsong.getTipo()); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /Lista 5/4/Data.java: -------------------------------------------------------------------------------- 1 | import java.util.Calendar; 2 | 3 | public class Data{ 4 | private int dia, mes, ano; 5 | 6 | public Data(){ 7 | Calendar agora = Calendar.getInstance(); 8 | int dia = agora.get(Calendar.DAY_OF_MONTH); 9 | int mes = agora.get(Calendar.MONTH); 10 | int ano = agora.get(Calendar.YEAR); 11 | } 12 | public Data(String dataString){ 13 | int[] dataInt = converterToArray(dataString); 14 | if(validarData(dataString)){ 15 | this.dia=dataInt[0]; 16 | this.mes=dataInt[1]; 17 | this.ano=dataInt[2]; 18 | } 19 | } 20 | public Data(int dia,int mes,int ano){ 21 | String dataString = Integer.toString(dia)+"/"+Integer.toString(mes)+"/"+Integer.toString(ano); 22 | if(validarData(dataString)){ 23 | this.dia=dia; 24 | this.mes=mes; 25 | this.ano=ano; 26 | } 27 | } 28 | 29 | //getters 30 | public int getDia(){ 31 | return this.dia; 32 | } 33 | public int getMes(){ 34 | return this.mes; 35 | } 36 | public int getAno(){ 37 | return this.ano; 38 | } 39 | 40 | //setters 41 | public void setDia(int dia){ 42 | this.dia=dia; 43 | } 44 | public void setMes(int mes){ 45 | this.mes=mes; 46 | } 47 | public void setAno(int ano){ 48 | this.ano=ano; 49 | } 50 | public void setData(String dataString){ 51 | int[] data = converterToArray(dataString); 52 | this.dia=data[0]; 53 | this.mes=data[1]; 54 | this.ano=data[2]; 55 | } 56 | 57 | 58 | //toString 59 | public String toString(){ 60 | return this.dia+"/"+this.mes+"/"+this.ano; 61 | } 62 | 63 | //converter String para data array 64 | public int[] converterToArray(String dataString){ 65 | String partes[] = dataString.split("/"); 66 | int[] dataInt = new int[3]; 67 | for(int x=0;x0){//ano 77 | switch(data[1]){ //mes 78 | case 1: 79 | case 3: 80 | case 5: 81 | case 7: 82 | case 8: 83 | case 10: 84 | case 12: 85 | if(data[0]<=31) return true;//dia 86 | break; 87 | case 2: 88 | if(data[2]%4==0){//ano 89 | if(data[0]<=29) return true;//dia 90 | } 91 | else{if(data[0]<=28) return true;}//dia 92 | break; 93 | case 4: 94 | case 6: 95 | case 9: 96 | case 11: 97 | if(data[0]<=30) return true;//dia 98 | break; 99 | default: 100 | break; 101 | } 102 | } 103 | return false; 104 | } 105 | 106 | } 107 | -------------------------------------------------------------------------------- /Lista 5/4/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | Exercício 4) 3 | Escreva uma classe Livro que represente os dados básicos de um livro. 4 | • Crie uma classe LivroLivraria que represente os dados básicos de um livro que 5 | está venda em uma livraria. 6 | • Crie uma classe LivroBiblioteca que represente os dados básicos de um livro 7 | que pode ser emprestado a leitores. 8 | • Escreva também um programa que demonstre o uso destas classes. 9 | *******************************************************************************/ 10 | public class Exercicio{ 11 | public static void main(String[] args){ 12 | Livro eurobo = new Livro("Eu, robô", "Isaac Asimov", "02/12/1950"); 13 | LivroLivraria euroboLivraria = new LivroLivraria(eurobo,45.00f,300); 14 | LivroBiblioteca euroboBiblioteca = new LivroBiblioteca(eurobo); 15 | 16 | 17 | System.out.println("Livro: "+euroboLivraria.getNomeLivro()); 18 | System.out.println("Preço: "+euroboLivraria.getPreco()); 19 | System.out.println("Quantidade de livros em estoque: "+euroboLivraria.getQuantidade()); 20 | 21 | System.out.println("Livro: "+euroboBiblioteca.getNomeLivro()); 22 | System.out.println("leitor: "+euroboBiblioteca.getLeitor()); 23 | System.out.println("Data de devolução: "+euroboBiblioteca.getDataDevolucao()); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /Lista 5/4/Livro.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | Exercício 4) 3 | Escreva uma classe Livro que represente os dados básicos de um livro. 4 | • Crie uma classe LivroLivraria que represente os dados básicos de um livro que 5 | está venda em uma livraria. 6 | • Crie uma classe LivroBiblioteca que represente os dados básicos de um livro 7 | que pode ser emprestado a leitores. 8 | • Escreva também um programa que demonstre o uso destas classes. 9 | *******************************************************************************/ 10 | public class Livro{ 11 | private String nome,autor,resumo; 12 | private Data dataLancamento; 13 | 14 | //construtores 15 | public Livro(String nomeLivro, String nomeAutor, Data dataLancamento){ 16 | this.nome = nomeLivro; 17 | this.autor = nomeAutor; 18 | this.dataLancamento = dataLancamento; 19 | } 20 | public Livro(String nomeLivro, String nomeAutor, String dataLancamento){ 21 | this.nome = nomeLivro; 22 | this.autor = nomeAutor; 23 | this.dataLancamento = new Data(dataLancamento); 24 | } 25 | public Livro(String nomeLivro, String nomeAutor, Data dataLancamento, String resumo){ 26 | this.nome = nomeLivro; 27 | this.autor = nomeAutor; 28 | this.dataLancamento = dataLancamento; 29 | this.resumo = resumo; 30 | } 31 | //getters 32 | public String getNome(){ 33 | return this.nome; 34 | } 35 | public String getAutor(){ 36 | return this.autor; 37 | } 38 | public String getDataLancamento(){ 39 | return this.dataLancamento.toString(); 40 | } 41 | public String getResumo(){ 42 | return this.resumo; 43 | } 44 | 45 | //setters 46 | public void setResumo(String resumo){ 47 | this.resumo = resumo; 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /Lista 5/4/LivroBiblioteca.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | Exercício 4) 3 | Escreva uma classe Livro que represente os dados básicos de um livro. 4 | • Crie uma classe LivroLivraria que represente os dados básicos de um livro que 5 | está venda em uma livraria. 6 | • Crie uma classe LivroBiblioteca que represente os dados básicos de um livro 7 | que pode ser emprestado a leitores. 8 | • Escreva também um programa que demonstre o uso destas classes. 9 | *******************************************************************************/ 10 | public class LivroBiblioteca{ 11 | private Livro livro; 12 | private boolean emprestado; 13 | private String leitor; 14 | private Data dataDevolucao; 15 | 16 | public LivroBiblioteca(Livro livro){ 17 | this.livro = livro; 18 | this.emprestado = false; 19 | } 20 | public LivroBiblioteca(Livro livro, String leitor){ 21 | this.livro = livro; 22 | this.leitor = leitor; 23 | this.emprestado = true; 24 | Data dataAtual = new Data(); 25 | this.dataDevolucao = new Data((dataAtual.getDia()+7),dataAtual.getMes(),dataAtual.getAno()); 26 | } 27 | public LivroBiblioteca(Livro livro, String leitor,String dataDevolucao){ 28 | this.livro = livro; 29 | this.leitor = leitor; 30 | this.emprestado = true; 31 | this.dataDevolucao = new Data(dataDevolucao); 32 | } 33 | 34 | //getters 35 | public String getNomeLivro(){ 36 | return livro.getNome(); 37 | } 38 | public String getAutorLivro(){ 39 | return livro.getAutor(); 40 | } 41 | public String getDataLancamentoLivro(){ 42 | return livro.getDataLancamento(); 43 | } 44 | public String getResumoLivro(){ 45 | return livro.getResumo(); 46 | } 47 | public boolean getSeFoiEmprestado(){ 48 | return this.emprestado; 49 | } 50 | public String getLeitor(){ 51 | if(this.emprestado) return this.leitor; 52 | else return "O livro não foi emprestado"; 53 | } 54 | public String getDataDevolucao(){ 55 | if(this.emprestado) return dataDevolucao.toString(); 56 | else return "O livro não foi emprestado"; 57 | } 58 | 59 | //setters 60 | public void devolver(){ 61 | this.emprestado = false; 62 | this.leitor = ""; 63 | } 64 | public void alugar(String nome){ 65 | this.emprestado = true; 66 | this.leitor = nome; 67 | Data dataAtual = new Data(); 68 | this.dataDevolucao = new Data((dataAtual.getDia()+7),dataAtual.getMes(),dataAtual.getAno()); 69 | } 70 | public void trocarLeitor(String nome){ 71 | this.leitor = nome; 72 | } 73 | public void aumentarPrazoDevolucao(){ 74 | Data novaData = new Data((this.dataDevolucao.getDia()+7),this.dataDevolucao.getMes(),this.dataDevolucao.getAno()); 75 | this.dataDevolucao = novaData; 76 | } 77 | } 78 | -------------------------------------------------------------------------------- /Lista 5/4/LivroLivraria.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | Exercício 4) 3 | Escreva uma classe Livro que represente os dados básicos de um livro. 4 | • Crie uma classe LivroLivraria que represente os dados básicos de um livro que 5 | está venda em uma livraria. 6 | • Crie uma classe LivroBiblioteca que represente os dados básicos de um livro 7 | que pode ser emprestado a leitores. 8 | • Escreva também um programa que demonstre o uso destas classes. 9 | *******************************************************************************/ 10 | public class LivroLivraria{ 11 | private Livro livro; 12 | private int quantidade; 13 | private float preco; 14 | 15 | //construtores 16 | public LivroLivraria(Livro livro, float preco){ 17 | this.livro = livro; 18 | if(preco>=0.0f) this.preco = preco; 19 | } 20 | public LivroLivraria(Livro livro, float preco,int quantidade){ 21 | this.livro = livro; 22 | if(preco>=0.0f) this.preco = preco; 23 | this.quantidade = quantidade; 24 | } 25 | 26 | //getters 27 | public String getNomeLivro(){ 28 | return this.livro.getNome(); 29 | } 30 | public String getAutorLivro(){ 31 | return this.livro.getAutor(); 32 | } 33 | public String getDataLancamentoLivro(){ 34 | return this.livro.getDataLancamento(); 35 | } 36 | public float getPreco(){ 37 | return this.preco; 38 | } 39 | public int getQuantidade(){ 40 | return this.quantidade; 41 | } 42 | 43 | //setters 44 | public void setPreco(float novoPreco){ 45 | if(novoPreco>=0.0f) this.preco = novoPreco; 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /Lista 5/5/AutomovelAVenda.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | Exercício 5) 3 | Escreva uma classe VeiculoAVenda que represente informações básicas sobre um veículo genérico que esteja à venda, como tipo (podendo ser representado por uma String), ano e precoDeVenda. 4 | • Escreva uma classe AutomovelAVenda que herde de VeiculoAVenda e que inicialize o campo tipo com o valor constante "Automóvel", 5 | • Escreva uma classe MotocicletaAVenda que herde de VeiculoAVenda e que inicialize o campo tipo com o valor "Motocicleta". 6 | • Escreva também um programa que demonstre o uso destas classes usando Polimorfismo. 7 | *******************************************************************************/ 8 | public class AutomovelAVenda extends VeiculoAVenda{ 9 | 10 | public AutomovelAVenda(String tipo, int ano, float precoDeVenda){ 11 | super(); 12 | String automovelTipo = "Automóvel "+tipo; 13 | super.setTipo(automovelTipo); 14 | super.setAno(ano); 15 | super.setPercodeVenda(precoDeVenda); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /Lista 5/5/Exercicio.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | Exercício 5) 3 | Escreva uma classe VeiculoAVenda que represente informações básicas sobre um veículo genérico que esteja à venda, como tipo (podendo ser representado por uma String), ano e precoDeVenda. 4 | • Escreva uma classe AutomovelAVenda que herde de VeiculoAVenda e que inicialize o campo tipo com o valor constante "Automóvel", 5 | • Escreva uma classe MotocicletaAVenda que herde de VeiculoAVenda e que inicialize o campo tipo com o valor "Motocicleta". 6 | • Escreva também um programa que demonstre o uso destas classes usando Polimorfismo. 7 | *******************************************************************************/ 8 | import java.util.ArrayList; 9 | 10 | public class Exercicio{ 11 | public static void main(String[]args){ 12 | 13 | ArrayList veiculos = new ArrayList(); 14 | veiculos.add(new AutomovelAVenda("fusca",1970,10000.00f)); 15 | veiculos.add(new MotocicletaAVenda("Alguma moto conhecida, porque eu não conheço nenhuma...",2012,7023.05f)); 16 | 17 | for(int x=0; x