Exercícios de LPOO

Prévia do material em texto

Exercícios de LPOO (java) 
 
 
1) Crie uma classe de nome "Aluno" com os seguintes atributos: 
nome (público - texto) 
idade (público - inteiro) 
altura (público - real) 
 
 
2) Crie uma classe "Teste2" (com o método main) que instancia a classe 
"Aluno" (da questão i), coloca valores nos seus atributos, e mostra cada um, 
destes valores. 
 
1. public class Teste2() { 
2. public static void main(String[] args) { 
3. Aluno aluno = new Aluno(); 
4. 
5. aluno.nome = “Emerson Ferreira Gomes”; 
6. aluno.idade = 20; 
7. aluno.altura = 1.85; 
8. 
9. system.out.println(aluno.nome); 
10. system.out.println(aluno.idade); 
11. system.out.println(aluno.altura); 
12. } 
13. } 
 
 
 
3) Crie uma classe de nome "Carro" com os seguintes atributos: 
placa (público - texto) 
ano (público - inteiro) 
modelo (público - texto) 
1. public class Aluno() { 
2. public String nome; 
3. public int idade; 
4. public float altura; 
5. } 
 
 
 
4) Crie uma classe "Teste04" (com o método main) que instancia a classe 
"Carro" (da questão 3), colocava valores nos seus atributos, e mostra cada um 
destes valores. 
 
1. public class Teste04() { 
2. public static void main(String[] args) { 
3. Carro carro = new Carro(); 
4. 
5. carro.placa = “FDG-4545”; 
6. carro.ano = 2019; 
7. carro.modelo = “FIAT UNO”; 
8. 
9. system.out.println(carro.placa); 
10. system.out.println(carro.ano); 
11. system.out.println(carro.modelo); 
12. } 
13. } 
 
 
5) Crie uma classe de nome "Calculadora" com os seguintes atributos: 
Numero1 (público - inteiro) 
numero2 (público - inteiro) 
...e os seguintes métodos: 
retornaSomaAtributos - este método não deve receber parâmetros, mas 
deve retornar a soma dos valores atuais dos seus atributos (numero1 e 
numero2). 
retornaMultiplicacaoAtributos - este método não deve receber 
parâmetros, mas deve retornar a multiplicação dos valores atuais dos seus 
atributos. 
insereValoresAtributos - este método deve receber como parâmetros, 
dois valores inteiros que devem ser colocados em cada um dos atributos (Obs.: 
este método não deve retornar valor algum). 
 
 
 
1. public class Carro() { 
2. public String placa; 
3. public int ano; 
4. public String modelo; 
5. } 
 1. public class Calculadora { 
2. 
3. public int numero1; 
4. public int numero2; 
5. 
6. public retornaSomaAtributos(){ 
7. return numero1+numero2; 
8. } 
9. public retornaMultiplicacaoAtributos(){ 
10. return numero1*numero2; 
11. } 
12. public void insertValoresAtributo(int valor1, int valor2) { 
13. this.numero1 = valor1; 
14. this.numero2 = valor2; 
15. } 
16. } 
 
6) Crie uma classe "Teste06" (com o método main), que: 
- instancia a classe "Calculadora" (da questão 5) 
- coloca valores diretamente nos seus atributos. 
- mostra o valor retornado pelo Método "retomaSomaAtributos" 
- mostra o valor retornado pelo Método "retomaMultiplicaçãoAtributos'' 
- coloca outros valores nos atributos da Classe através do Método 
"insereValoresAtributos". 
- mostra o valor dos Atributos 
1. public class Teste06 { 
2. public static void main(String[] args) { 
3. Calculadora calc = new Calculadora(); 4. 
5. calc.numero1 = 5; 
6. calc.numero2 = 2; 7. 
8. system.out.println(calc.retornaSomaAtributos()); 
9. system.out.println(calc.retornaMultiplicacaoAtributos()); 
10. 
11. calc.insertValoresAtributos(8, 2); 
12. 
13. system.out.ptintln(calc.numero1); 
14. system.out.println(calc.numero2); 
15. } 
16. } 
 
 
7) Exercício sobre Encapsulamento - Crie uma classe de nome "Cilindro" com 
os seguintes atributos: 
raioBase (double) 
altura (double) 
... Faça o Encapsulamento desta Classe. 
 (obs.: crie os métodos "set" e "get", e não se esqueça de deixar os atributos 
como "privados") 
1. Public class Cilindro { 2. 
3. private double raioBase; 
4. private double altura; 5. 
6. public void setCilindo(double num1, double num2) { 
7. raioBase = num1; 
8. altura = num2; 9. } 
10. 
11. public getRaio() { 
12. return raioBase; 13. } 
14. 
15. public getAltura() { 
16. return altura; 17. } 
18. 
19. } 
 
8) Crie uma classe "Teste08" (com o método mair) que: 
- instancia a classe "Cilindro" (da questão 7) . 
- inclui valores nos seus atributos através dos métodos "set". 
- mostra valores nos seus atributos através dos métodos "get". 
1. public class Teste08 { 
2. public static void main(String[] args) { 
3. Cilindro cili = new Cilindro(); 4. 
5. cili.setCilindro(5.2, 2.9); 6. 
7. system.out.ptintln(cili.getRaio()); 
8. system.out.println(cili.getAltura()); 
9. } 
10. } 
 
 
9) Exercício sobre Métodos Construtores - Crie urna classe que representará 
um Funcionário de uma 
Empresa. Esta classe deverá possuir atributos tais como: 
- o seu número de Matrícula (pode ser do tipo inteiro) 
- o seu nome 
- a sua idade 
- o seu cargo 
- o seu salário 
... Faça o Encapsulamento desta Classe (criar os métodos "set" e "get"). 
Para esta classe, gere três Métodos Construtores. 
- o 1º não deve receber parâmetros, mas deve iniciar o valor do salário 
com R$ 1.500,00 
- o 2º deve receber como parâmetro o nome e a idade (O funcionário, e 
preencher estes dois campos com os valores recebidos. 
- o 3º deve receber o número de matrícula, o nome, e o salário, e 
preencher estes três campos com os valores recebidos 
 
 
1. public class Funcionario 
{ 2. 
3. private int matricula; 
4. private String nome; 
5. private int idade; 
6. private String cargo; 
7. private double salario; 
8. public void setMatricula(int matricula) { 
9. this.matricula = matricula; 
10. } 
11. public getNome(String nome) 
12. this.nome = nome; 
13. } 
14. public void setIdade(int idade) 
15. this.idade = idade; 
16. } 
17. public void setCargo(String cargo) 
18. this.cargo = cargo; 
19. } 
20. public void setSalario(double salario) { 
21. this.salario = salario; 
22. } 
23. public void setMatricula(int matricula) { 
24. this.matricula = matricula; 
25. } 
26. public getNome() 
27. return nome; 
28. } 
29. public getIdade() 
30. return idade; 
38. 
39. Public static void main(String[] args) { 
40. Funcionario func1 = Funcionario(); 41. Funcionario func2 = 
Funcionario(); 
42. Funcionario func3 = Funcionario(); 
43. 
44. func1.setSalario = 1.500; 
45. func2.setNome = “Matheus Borges”; 
46. func2.setIdade = 25; 
47. func3.setNome = “Leticia Prada”; 
48. func3.setMatricula = 26552; 
49. func3.setSalario = 4.200; 
50. } 
51. } 
 
 
10) Crie uma classe "Teste10" (com o método main) que: 
- instancia a classe criada no exercício anterior (da questão 9), através 
do Método Construtor 
sem parâmetros. 
- imprime o valor dos atributos nome e salário (o 1º deve estar vazio, e o 
2º com o valor 1500.0) 
- instancia a classe criada no exercício anterior (da questão 9), através 
do Método Construtor 
com os parâmetros de nome e idade. 
- imprime o valor dos atributos nome, idade e salário (o 1º e o 2º devem 
estar com os valores 
enviados como parâmetros, e o 3º deve estar 0.0) 
- instancia a classe criada no exercício anterior (da questão 9), através 
do Método Construtor 
com os parâmetros de matrícula, nome e salário. 
- imprime o valor dos atributos matrícula, nome e salário. 
 
 
 
1. public class Teste10 { 
2. public static void main(String[] args) { 
3. Funcionario func1 = Funcionario(); 4. Funcionario func2 = 
Funcionario(); 
5. Funcionario func3 = Funcionario(); 
6. func1.setSalario(1.500); 
7. func2.setNome (“Matheus Borges”); 
8. func2.setIdade(25); 
9. func3.setNome(“Leticia Prada”); 
10. func3.setMatricula(26552); 
11. func3.setSalario(0.0); 
12. system.out.println(func1.getSalario()); 
13. system.out.println(func2.getSalario()); 
14. system.out.println(func1.getNome()); 
15. system.out.println(func1.getIdade());16. system.out.println(func2.getNome()); 
17. system.out.println(func2.getIdade()); 
18. system.out.println(func3.getSalario()); 
19. } 
20. } 
11) Exercício sobre Sobrecarga de Métodos (Overloadinq) - .Crie uma classe 
chamada "Calculo" que não terá atributos. Nesta classe, crie os seguintes 
métodos:" 
- Um método cujo nome deve ser "calculo" que recebe dois números 
inteiros como parâmetros, e ao final retorna a soma destes dois números. 
- Um método cujo nome deve ser "calculo" (o mesmo do item anterior), 
que recebe três números 
inteiros como parâmetros, e ao final retorna a multiplicação destes três 
números. 
- Um método cujo nome deve ser "calculo" (o mesmo dos itens 
anteriores), que recebe dois números de ponto flutuante como parâmetros, e 
ao final retorna a divisão destes dois números. 
1. public class Calculos { 
2. public int Calculos(int A, int B) { 
3. return (A+B); 
4. } 
5. public int Calculos(int A, int B, int C) { 
6. Return (A*B*C); 
7. } 
8. public double Calculos(double A, double B) { 
9. Return (A/B); 
10. } 
11. } 
12) Crie uma classe "Teste12" (com o método main) que: 
- instancia a classe criada no exercício anterior (da questão 11). 
- utilize os métodos da classe instanciada com variáveis devidamente 
"tipadas", e imprima o resultado de cada um dos seus retornos. 
12. public class Teste12 { 
13. public static void main(String[] args) { 
14. Calculos c = new Calculos(); 
15. system.out.ptintln(c.Calculos(10, 20)); 
16. system.out.println(c.Calculos(2, 3, 10)); 
17. system.out.println(c.Calculos(3, 5, 15, 5)); 
18. } 
19. } 
Exercícios Gerais com a classe Data: 
 
13) Crie uma classe de nome "Data" com os seguintes atributos: 
dia (inteiro) 
mes (inteiro) 
ano (inteiro) 1 
...e faça o Encapsulamento desta Classe (criar os métodos "set" e "get"). 
1. public class Data { 
2. private int dia; 3. private int 
mes; 
4. private int ano; 
5. } 
14) Crie uma classe "Teste14" (com o método main) que: 
- instancia a classe "Data" (da questão 13) 
- inclui valores nos seus atributos através dos métodos "set". 
(obs.: ao incluir valores, o sistema não deve verificar os dados, mas 
apenas incluir. Ou seja, para este momento, pode-se incluir o dia 247) 
- mostra os valores dos seus atributos através.dos métodos "get". 
1. public class Data 
{ 2. 
3. private int 
dia,mes,ano,bissexto; 4. 
5. public int getDia() { return dia; 
} 6. 
7. public void setDia(int dia) { 
8. if (dia < 1 | dia > 31) { 
9. system.out.ptintln(“Valor do dia invalido!”); 
10. } else if (mes == 4 | mes == 6 | mes == 9 | mes == 11 ) { 
11. if (dia > 30) { 
12. system.out.println(“Valor do dia invalido”); 
13. } else { this.dia = dia; } 
14. } else if (mês == 2) { 
15. if (bissexto==1){ 
16. if (dia > 29) { 
17. System.out.println(“Valor do dia invalido”); 
18. } else { 
19. this.dia = dia; 
20. } else { 
21. this.dia = dia; 22. } 
23. 
24. public int getMes(){return mes;} 
25. 
26. public void setMes(int mes) { 
27. If (mes < 1 | mes > 12){ 
28. System.out.println(“Valor do mês invalido”); 
29. } else { 
30. this.ano = ano; 
31. if (ano % 4 == 0) { 
32. system.out.println(“Bissexto!”); 
33. bissexto = 1; 
34. } else { bissexto = 0;} 
35. } 
36. } 
37. 
38. public int getBissexto() {return bissexto;} 
39. public void setBissexto(int bissexto) {this.bissexto = bissexto;} 
 
15) Na classe "Data" do exercício 13: 
- alterar o método que inclui valor no atributo "mes", para não aceitar 
valores menores do que 1(um), e nem maiores do que 12(doze). Caso se tente 
incluir um valor não permitido, deve-se imprimir o seguinte texto: "Valor de mês 
inválido..." 
 
 
1. public class Data 
{ 2. 
3. private int 
dia,mes,ano,bissexto; 4. 
5. public int getDia() { return dia; 
} 6. 
22. public void setDia(int dia) { 
23. if (dia < 1 | dia > 31) { 
24. system.out.ptintln(“Valor do dia invalido!”); 
25. } else if (mes == 4 | mes == 6 | mes == 9 | mes == 11 ) { 
26. if (dia > 30) { 
27. system.out.println(“Valor do dia invalido”); 
28. } else { this.dia = dia; } 
29. } else if (mês == 2) { 
30. if (bissexto==1){ 
31. if (dia > 29) { 
32. System.out.println(“Valor do dia invalido”); 
33. } else { 
34. this.dia = dia; 
35. } else { 
36. this.dia = dia; 22. } 
23. 
24. public int getMes(){return mes;} 
25. 
37. public void setMes(int mes) { 
38. If (mes < 1 | mes > 12){ 
39. System.out.println(“Valor do mês invalido”); 
40. } else { 
41. this.ano = ano; 
42. if (ano % 4 == 0) { 
43. system.out.println(“Bissexto!”); 
44. bissexto = 1; 
45. } else { bissexto = 0;} 
46. } 
47. } 
37. 
40. public int getBissexto() {return bissexto;} 
41. public void setBissexto(int bissexto) {this.bissexto = 
bissexto;} 
 
 
16) Crie uma classe "Teste16" (com o método main) que 
- instancia a classe "Data" (da questão 15) 
- tente incluir o valor (25) ao atributo "mes". 
- tente incluir o valor (-9) ao atributo "mes". 
- tente incluir o valor (12) ao atributo "mes". 
 
1. public class Teste16 { 
2. Data dt = new Data(); 
3. dt.setMes(25); // ERRO Mês 
invalido 
4. dt.setMes(-9); // ERRO Mês 
invalido 
5. dt.setMes(12); // OK 
6. } 
 
 
17) Na classe "Data" do exercício 15: 
- alterar o método que inclui valor no atributo "ano", para não aceitar valores 
menores do que1 (um). Caso se tente incluir um valor não permitido, deve-se 
imprimir o seguinte texto: "Valor de 
ano inválido..." 
1. public setAno(int Ano) { 
2. if (ano <= 0) { 
3. system.out.println(“Valor do ano invalido”); 
4. } 
5. } 
 
18) Na mesma classe "Teste16" (da questão 16): 
- tente incluir o valor (-110) ao atributo ano. 
18. public class Teste16 { 
19. Data dt = new Data(); 
20. dt.setAno(-110); // ERRO Ano 
invalido 
21. } 
19) Na classe "Data" do exercício 17: 
- alterar o método que inclui valor no atributo "aia", para não aceitar valores 
menores do que1(um). Caso se tente incluir um valor não permitido, deve-se 
imprimir o seguinte texto: "Valor de dia inválido..." 
1. public class Data 
{ 2. 
3. private int 
dia,mes,ano,bissexto; 4. 
5. public int getDia() { return dia; 
} 6. 
37. public void setDia(int dia) { 
38. if (dia < 1 | dia > 31) { 
39. system.out.ptintln(“Valor do dia invalido!”); 
40. } else if (mes == 4 | mes == 6 | mes == 9 | mes == 11 ) { 
41. if (dia > 30) { 
42. system.out.println(“Valor do dia invalido”); 
43. } else { this.dia = dia; } 
44. } else if (mês == 2) { 
45. if (bissexto==1){ 
46. if (dia > 29) { 
47. System.out.println(“Valor do dia invalido”); 
48. } else { 
49. this.dia = dia; 
50. } else { 
51. this.dia = dia; 22. } 
23. 
24. public int getMes(){return mes;} 
25. 
48. public void setMes(int mes) { 
49. If (mes < 1 | mes > 12){ 
50. System.out.println(“Valor do mês invalido”); 
51. } else { 
52. this.ano = ano; 
53. if (ano % 4 == 0) { 
54. system.out.println(“Bissexto!”); 
55. bissexto = 1; 
56. } else { bissexto = 0;} 
57. } 
58. } 
37. 
42. public int getBissexto() {return bissexto;} 
43. public void setBissexto(int bissexto) {this.bissexto = 
bissexto;} 
 
 
20) Na classe "Teste16" (da questão 16): 
- tente incluir o valor (-3) ao atributo dia. 
1. public class Teste16 { 
2. Data dt = new Data(); 
3. dt.setDia(-3); // ERRO Dia 
invalido 
24. } 
 
 
Lista de Exercícios 2 de LPOO 
 
1) Assinale a alternativa correta. Quanto as Classes e Finais e Abstratas 
podemos afirmar que: 
 
a) As Classes Finais podem ser instanciadas, bem como, podem passar 
herança. 
b) As Classes Finais não podem ser instanciadas, mas podem passar 
herança. 
c) As Classes Finais são as mais específicas dentro de um modelo e só 
podem ser instanciadas. 
d) Classes Abstratas só possuem métodos abstratos. 
e)Classes Abstratas só podem ser instanciadas. 
 
RESPOSTA: C 
 
 
2) Em uma classe chamada "Calculos" existem os seguintes métodos: 
- Um método cujo nome é "calculo". Este método recebe 2(dois) números 
inteiros como parâmetros, e ao final retorna a soma destes dois números. 
- Um outro método cujo nome também é "calculo". Este método recebe 
3(três) números inteiros como parâmetros, e ao final retorna a multiplicação 
destes três números. 
No processo de criação de métodos em Classes Java, podem-se observar 
alguns processos tais como: Sobrecarga, Sobrescrita, e Polimorfismo. De 
acordo com os métodos descritos acima nesta questão, responda: 
a) É possível gerar a classe acima descrita? 
sim 
b) Se sim, qual daqueles três processos está ocorrendo? Por quê? 
Explique-o. 
Java permite sobrecarregar classes utilizando métodos que 
possuem o mesmo nome mas porem com resultados diferentes 
 
 
3) Todo erro ou exceção que ocorre em um programa Java gera uma 
"exception". O nome desta exceção aparece na mensagem de erro que é 
mostrada na console ("java.lang.<nome_da_exceção>"). Sendo assim, é 
possível tratar esta exceção incluindo seu nome num bloco catch. Considere o 
código do método "main" abaixo: 
1. public static void main(String[] args) { 
2. int a = 2, b = 0; 
3. System.out.println(a/b); 4. } 
Ao ser executado na IDE do eclipse, este código 
apresentou a seguinte mensagem: "...Exception in 
thread "main" java.lang.ArithmeticException: / by zero 
 at src.Principal.main(Principal.java:14)..." 
 
 Faça as alterações necessárias no programa apresentado, para que este 
possa "capturar o arremesso", ou seja, possa tratar o erro através da captura 
da exceção que aparece na mensagem acima. 
5. public static void main(String[] args) { 
6. int a = 2, b = 0; 
7. try { 
8. System.out.println(a/b); 
9. Catch { 
10. System.out.println(“Os valores informados são invalidos”); 
11. } 
12. } 
 
 4) [1.0 pto] Crie uma Classe Abstrata de nome "Eletrodomestico" 
com os seguintes atributos: 
 - ligado (público – inteiro) 
- voltagem (público – inteiro) Nesta classe crie os métodos 
abstratos "ligar" e "desligar". 
Estes métodos devem estar descritos de forma que não deverão receber 
parâmetro algum, e também não deverão retornar valor algum. 
 
1. public abstract class Eletrodomesticos { 
2. public int ligado; 
3. public int voltagem; 
4. public abstract void ligar(); 
5. public abstract void desligar(); 6. } 
 
 
5)Crie uma Classe Final de nome "Radio" com os seguintes atributos: 
- ligado (público – inteiro) 
- voltagem (público – inteiro) 
 Obs.: esta classe deverá herdar a classe "Eletrodomestico" do exercício 
anterior. 
a) [1.0 pto] Implemente as classes necessárias (de acordo com a classe 
herdada), de forma que: 
 >> rádio ligado –> atributo "ligado" = 1, e 
atributo "voltagem" = 110 >> rádio desligado –> 
atributo "ligado" = 0, e atributo "voltagem" = 0 
b) [1.0 pto] Crie nesta classe "Radio" um Método Construtor sem 
parâmetros que automaticamente 
"liga o rádio". 
1. public final class Radio extends Radio { 
2. public int ligado; 
3. public int voltage; 
4. public void ligar() { this.ligado = 1; 
5. this.voltagem = 110; 
6. } 
7. public void desligar() { this.ligado = 0; 
8. this.voltagem = 0; 
9. } 
10. public Radio() { ligar(); 
11. } 
12. } 
13. Crie uma Classe Final de nome "Radio" com os seguintes 
atributos: 
 
 
6) Assinale a alternativa incorreta. Quanto a captura de erros e exceções 
podemos afirmar que: 
a) Na captura de exceções temos a estrutura try-catch-finally. 
b) O bloco de captura de exceções possui um try e um ou mais 
catch. 
c) Um bloco de captura de exceções possui o finally como opcional. 
d) O bloco catch sempre será executado mesmo não havendo 
arremesso. 
 
RESPOSTA: D