POO_Sem6_Ativ10

Prévia do material em texto

Ao se programar em Java, o uso de exceções permite separar a detecção de um erro e o seu respectivo tratamento. 
Assinale a alternativa correta: 
 
 A linguagem Java admite apenas exceções não verificadas (unchecked). 
 
 Para qualquer tipo de exceção o compilador não verifica se existe possibilidade de serem lançadas e não exige 
que os métodos em que possam ocorrer façam qualquer tratamento. 
 
 Uma exceção em Java é um objeto da classe java.lang.Exception ou de uma de suas subclasses. 
 
 A captura e o tratamento de exceções são feitos somente pelo bloco try/catch. 
 
 Quando um erro ou situação anormal é encontrado durante a execução de um método, uma classe exceção é 
construída. 
 
Considere o código a seguir que apresentará erro se for executado sem o tratamento de exceções. Analise o código 
e identifique quantas exceções podem ser geradas. 
 
import java.io.IOException; 
public class TesteException { 
 
public static void main(String[] args) { 
 
int[] numeros = {4, 8, 16, 32, 64, 128}; 
int[] denominador = {2, 0, 4, 8, 0}; 
 
for (int i = 0; i < numeros.length; i++) { 
System.out.println(numeros[i] + "/" + denominador[i] + " = " + (numeros[i]/denominador[i])); 
 
} 
} 
} 
 
 O número de exceções geradas será 2. 
 
 O número de exceções geradas será 3. 
 
 Não existirão exceções. 
 
 O número de exceções geradas será 4. 
 
 O número de exceções geradas será 1. 
 
Um analista foi convocado para analisar o código a seguir de modo a encontrar erros. É correto afirmar que: 
 
public class TestaException { 
 
 public static void testaException() { 
 String[] stringArray = { "Olá", "pessoal", "Saudações" }; 
 
 for (int i = 0; i < 4; i++) { 
 System.out.println(stringArray[i]); 
 } 
 } 
 
 public static void main(String[] args) { 
 testaException(); 
 } 
 } 
 
 
 trata-se de um erro de código que gera uma exceção de compilação. 
 
 é um tipo de exceção verificada. 
 
 não há erros e nenhuma exceção será gerada. 
 
 não temos uma exceção quando chamamos o método println() para uma posição inexistente do array (posição 
3). 
 
 é gerada uma exceção do tipo ArrayIndexOutOfBoundsException, pois ocorreu acesso a uma posição fora dos 
limites do array. 
Dois programadores estavam em uma discussão acerca das exceções em Java e algumas afirmações desta 
discussão são listadas a seguir. 
 
I. O programador A disse que uma exceção é uma classe de Java representada genericamente pela classe java.io. 
II. O programador B salientou que não podemos criar as nossas próprias exceções, pois o Java trata disso por meio 
de uma hierarquia de exceções. 
III. Ambos os programadores concordaram que as exceções que são subclasses de java.lang.Exception são divididas 
em dois tipos: Checked e Unchecked. 
IV. Ambos os programadores concordam que embora seja comum usar catch com a classe Exception por qualquer 
erro, é muito mais difícil identificar o erro. Assim, sugerem tratar as exceções de forma específica. 
 
Assinale a alternativa correta. 
 
 Apenas III está correta. 
 
 Apenas II está correta. 
 
 Apenas III e IV estão corretas. 
 
 Apenas I está correta. 
 
 Apenas II e III estão corretas. 
 
 
Em relação às exceções verificadas (checked), é correto afirmar que: 
 
 as exceções verificadas são subtipos da classe java.util. 
 
 é facultativo tratar esse tipo de exceção. 
 
 é um tipo de runtime exception. 
 
 ela precisa ser obrigatoriamente tratada, pois caso contrário o programa não compila corretamente. 
 
 ela ocorre em tempo de execução. 
 
 
Foi solicitado a um programador a análise de código a seguir e o seu parecer está listado corretamente na 
alternativa: 
 
import java.util.Scanner; 
 
public class ExemploRuntimeException { 
 public static void main(String[] args) { 
 Scanner s = new Scanner(System.in); 
 System.out.print("Entre com um número inteiro: "); 
 int numero = s.nextInt(); 
 System.out.println("Número lido: " + numero); 
 } 
} 
 
 Ocorrerá uma exceção em tempo de compilação. 
 
 A exceção gerada é IndexOutOfBoundException. 
 
 O código executa corretamente. 
 
 Ocorrerá uma exceção em tempo de execução. 
 
 A exceção gerada é NullPointerException. 
 
 
 
 
Considere o código a seguir que apresentará erro se for executado sem o tratamento de exceções. Assinale a 
alternativa correta que lista quais são os tipos de exceções geradas ao executar o código. 
 
import java.io.IOException; 
public class TesteException { 
 
public static void main(String[] args) { 
 
int[] numeros = {4, 8, 16, 32, 64, 128}; 
int[] denominador = {2, 0, 4, 8, 0}; 
 
for (int i = 0; i < numeros.length; i++) { 
System.out.println(numeros[i] + "/" + denominador[i] + " = " + (numeros[i]/denominador[i])); 
 
} 
} 
} 
 
 ArithmeticException e ArrayIndexOutOfBoundsException. 
 
 ArithmeticException e NullPointerException. 
 
 NullPointerException e ArrayIndexOutOfBoundsException. 
 
 ArrayIndexOutOfBoundsException. 
 
 NullPointerException. 
 
 
 
Uma exceção é uma indicação de algum problema na execução de um programa de computador. Analise as 
afirmações a seguir e escolha a alternativa correta. 
 
I. É mais vantajoso usar o tratamento de erros usando as condições (if). 
II. O tratamento de exceções deixa o código mais legível e eficiente. 
III. NullPointerException ocorre quando se tenta fazer coerção equivocada de um objeto. 
IV. O tratamento de exceções em Java é feito somente por try/cacth, de modo que todas as exceções lançadas por 
um programa necessitem obrigatoriamente ser capturadas e tratadas. 
 
 Apenas III está correta. 
 
 Apenas III e IV estão corretas. 
 
 Apenas II está correta. 
 
 Apenas I está correta. 
 
 Apenas I e II estão corretas. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Considere o código Java a seguir: 
 
import java.util.Scanner; 
 
public class ExemploRuntimeException { 
 public static void main(String[] args) { 
 Scanner s = new Scanner(System.in); 
 System.out.print("Entre com um número inteiro: "); 
 int numero = s.nextInt(); 
 System.out.println("Número lido: " + numero); 
 } 
} 
 
Em que posição do código devemos tratar a exceção com o bloco try/catch? 
 
 Depois de int numero = s.nextInt() 
 
 Depois de System.out.println("Número lido: " + numero) 
 
 Antes de public class ExemploRuntimeException { 
 
 Antes de public static void main(String[] args) { 
 
 Usar o try antes de Scanner s = new Scanner(System.in); e o catch depois de System.out.println("Número 
lido: " + numero) 
 
 
Um analista foi solicitado para verificar o código a seguir e emitir uma opinião sobre ele. Assinale a alternativa 
correta. 
 
public class A { 
 
public void f(int a){ 
 if (a < 10) throw new NumberFormatException(); 
 System.out.println("a = "+ a); 
} 
 
} 
 
import java.io.IOException; 
public class B{ 
 public void f(int a) throws IOException { 
 if (a < 10) throw 
 new IOException ("valor do argumento de f() é " + a + " (menor que 10)"); 
 System.out.println("a = "+ a); 
 } 
} 
 
import java.io.IOException; 
public class TestaException{ 
public static void main(String[] args) throws IOException{ 
 B x = new B(); 
 int a = 4; 
 x.f(a); 
 System.out.println("fim do metodo main em TestaException"); 
} 
} 
 
 A exceção que pode ser lançada por f() é não verificada, na Classe B. 
 
 O código da classe TestaExcecao não vai executar. 
 
 A exceção que pode ser lançada por f() é verificada, na Classe A. 
 
 Considerando a classe TestaException, a exceção que pode ser lançada por f() é verificada (IOException), e o 
método main() tem a cláusula "throws IOException", o que faz a compilação ocorrer corretamente. 
 
 O código da classe TestaExcecao não compila corretamente, pois não tem try/catch.