As 30 principais perguntas e respostas da entrevista sobre como lidar com exceções [para calouros e experientes]
Publicados: 2020-09-29O tratamento de exceções é um conceito implementado em algoritmos para lidar com possíveis erros de tempo de execução, que podem interromper o fluxo normal de um programa. Alguns dos erros que podem ser tratados usando este conceito são:
- ClassNotFoundException
- IOException
- SQLException
- RemoteException
- Exceção de tempo de execução:
- AritméticaException
- Null Pointer Exception
- NumberFormatException
- IndexOutOfBoundsException
- Índice de matriz fora dos limites de exceção
- StringIndexOutOfBoundsException
O mérito desta implementação é evitar uma falha do programa se houver uma exceção durante a execução do programa. Sem Manipulação de Exceções, o programa lançará um erro quando encontrar uma exceção e o restante do programa não será executado. No entanto, a implementação desse conceito fornecerá uma solução alternativa na qual o restante do programa será executado se eles forem independentes em relação à exceção ocorrida. Para saber mais, confira nossos cursos de ciência de dados.
Leia: Deve ler 30 perguntas e respostas da entrevista do Selenium: Guia definitivo
Perguntas e Respostas da Entrevista sobre Tratamento de Exceções
1. O que você quer dizer com exceção?
É uma condição anormal que às vezes é encontrada quando um programa é executado. Isso interrompe o fluxo normal do programa. É necessário tratar esta exceção; caso contrário, pode fazer com que o programa seja encerrado abruptamente.
2. Explique como as exceções podem ser tratadas em Java. Qual é o mecanismo de tratamento de exceção por trás do processo?
Existem três partes no mecanismo de tratamento de exceções. Estes são chamados:
- Bloco Try: A seção do código que primeiro tenta ser executada e monitorada para qualquer exceção que possa ocorrer.
- Bloco de captura: Se alguma exceção for lançada pelo bloco 'try', ela será capturada por esta seção de código.
- Bloco Finalmente: O código nesta seção é sempre executado independentemente das exceções capturadas no bloco 'try', se houver. Mesmo que não haja exceção, o código sob este bloco será executado.
3. É possível manter outras instruções entre os blocos 'try', 'catch' e 'finally'?
Não é recomendado incluir quaisquer declarações entre as seções de blocos 'try', 'catch' e 'finally', uma vez que eles formam uma unidade inteira do mecanismo de tratamento de exceções.
experimentar
{
//Código que é monitorado para exceções.
}
//Você não pode manter declarações aqui
catch(Exceção ex)
{
//Captura as exceções lançadas pelo bloco try, se houver.
}
//Você não pode manter declarações aqui
finalmente
{
//Este bloco é sempre executado independente de exceções.
}
4. Será possível incluir apenas um bloco 'try' sem os blocos 'catch' e 'finally'?
Isso daria um erro de compilação. É necessário que o bloco 'try' seja seguido por um bloco 'catch' ou um bloco 'finally', se não ambos. Qualquer um dos blocos 'catch' ou 'finally' é necessário para que o fluxo de tratamento de exceções seja ininterrupto.
5. Será possível manter as declarações após o bloco 'finally' se o controle estiver retornando do próprio bloco finally?
Isso resultará em um erro de bloco catch inacessível. Isso ocorre porque o controle retornará do próprio bloco 'finally'. O compilador falhará ao executar o código após a linha com a exceção. É por isso que a execução mostrará um erro de código inacessível.
Sonha em estudar no exterior? Aqui está o programa certo para você6. Explique um erro de bloco catch inacessível.
No caso de vários blocos catch, a ordem em que os blocos catch são colocados é do mais específico para o mais geral. Ou seja, as subclasses de uma exceção devem vir primeiro e, em seguida, as superclasses seguirão. Caso as superclasses sejam mantidas primeiro, seguidas pelas subclasses depois, o compilador mostrará um erro de bloco catch inacessível.
classe pública ExceptionHandling
{
public static void main(String[] args)
{
experimentar
{
int i = Integer.parseInt(“teste”);
//Esta instrução lançará um NumberFormatException //porque a entrada fornecida é string, enquanto o //formato especificado é inteiro.
}
catch(Exceção ex)
{
System.out.println(“Este bloco trata todos os tipos de exceção”);
//Todos os tipos de exceções podem ser tratados neste //bloco, pois é uma superclasse de exceções.
}
catch(NumberFormatException ex)
{
//Isto dará erro em tempo de compilação
//Este bloco ficará inacessível à medida que o
//exceção já seria capturada pelo bloco //catch acima
}
}
}
7. Considere três instruções em um bloco 'try': instrução1, instrução2 e instrução3. Ele é seguido por um bloco 'catch' para capturar as exceções que ocorreram durante a execução do bloco 'try'. Suponha que a exceção seja lançada na instrução2. Você acha que o comando3 será executado?
A instrução3 não será executada. Se uma exceção for lançada pelo bloco 'try' em qualquer ponto, o código restante após a exceção não será executado. Em vez disso, o controle de fluxo virá diretamente para o bloco 'catch'.
8. Diferencie erro e exceção em Java.
A principal diferença entre erro e exceção é que, embora o erro seja causado pelo ambiente no qual a JVM (Java Virtual Machine) está sendo executada, as exceções são causadas pelo próprio programa. Por exemplo, OutOfMemory é um erro que ocorre quando a JVM esgota sua memória.
Mas, NullPointerException é uma exceção encontrada quando o programa tenta acessar um objeto nulo. A recuperação de um erro não é possível. Portanto, a única solução para um erro é encerrar a execução. No entanto, é possível contornar exceções usando blocos try e catch ou lançando exceções de volta para a função do chamador.
Deve ler: Perguntas e respostas da entrevista Java
9. Quais são os tipos de exceções? Explique-os.
Existem dois tipos de exceções:
Exceções verificadas
O tipo de exceções que são conhecidas e reconhecidas pelo compilador. Essas exceções podem ser verificadas apenas em tempo de compilação. Portanto, eles também são chamados de exceções de tempo de compilação. Eles podem ser tratados usando blocos try e catch ou usando uma cláusula throw. Se essas exceções não forem tratadas adequadamente, elas produzirão erros de tempo de compilação. Os exemplos incluem as subclasses de java.lang.Exception, exceto RunTimeException.
Exceções não verificadas
O tipo de exceções que não são reconhecidas pelo compilador. Eles ocorrem apenas em tempo de execução. Portanto, eles também são chamados de exceções de tempo de execução. Eles não são verificados em tempo de compilação. Portanto, mesmo após uma compilação bem-sucedida, eles podem fazer com que o programa seja encerrado prematuramente se não forem tratados adequadamente. Os exemplos incluem as subclasses de java.lang.RunTimeException e java.lang.Error.
10. Qual é a hierarquia de exceções em Java?
O java.lang.Throwable é uma superclasse de todos os erros e exceções em Java. Essa classe estende a classe java.lang.Object. O argumento do bloco catch deve ser seu tipo ou apenas seu tipo de subclasse. A classe Throwable inclui duas subclasses:
- java.lang.Error : Esta é uma superclasse para todos os tipos de erro em Java. Erros comuns incluídos neste são –
- java.lang.VirtualMachineError: Sob este –
- Erro de StackOverFlow
- Erro de falta de memória
- java.lang.AssertionError
- java.lang.LinkageError: Sob este –
- NoClassDefFoundError
- IncompatívelClassChangeError
- java.lang.VirtualMachineError: Sob este –
- java.lang.Exception: Esta é uma superclasse de todos os tipos de exceção em Java. Exceções comuns sob isso são –
- Exceção de tempo de execução
- AritméticaException
- NumberFormatException
- Null Pointer Exception
- Índice de matriz fora dos limites de exceção
- ClassCastException
- java.lang.InterruptedException
- java.lang.IOException
- java.lang.SQLException
- java.lang.ParseException
- Exceção de tempo de execução
11. O que são exceções de tempo de execução em Java? Dê alguns exemplos.
As exceções que ocorrem em tempo de execução são chamadas de exceções de tempo de execução. O compilador não pode reconhecer essas exceções, como exceções não verificadas. Inclui todas as subclasses de java.lang.RunTimeException e java.lang.Error. Exemplos incluem, NumberFormatException, NullPointerException, ClassCastException, ArrayIndexOutOfBoundException, StackOverflowError etc.
12. Defina OutOfMemoryError em Java.
É a subclasse de java.lang.Error que é encontrada quando a JVM fica sem memória.
13. Diferencie entre NoClassDefFoundError e ClassNotFoundException em Java.
Tanto NoClassDefFoundError quanto ClassNotFoundException ocorrem quando uma determinada classe não é encontrada em tempo de execução. No entanto, eles ocorrem em diferentes cenários. NoClassDefFoundError é quando ocorre um erro porque uma determinada classe estava presente em tempo de compilação, mas estava ausente em tempo de execução. ClassNotFoundException ocorre quando uma exceção é encontrada para um aplicativo que tenta carregar uma classe em tempo de execução que não é atualizada no caminho de classe.
14. O bloco 'finally' é executado se um dos blocos 'try' ou 'catch' retornar o controle?
O bloco 'finally' é sempre executado independentemente de os blocos try ou catch estarem retornando o controle ou não.
15. É possível lançar uma exceção manualmente? Se sim, explique como.
É possível lançar uma exceção manualmente. Isso é feito usando a palavra-chave 'throw'. A sintaxe para lançar uma exceção manualmente é
jogue InstanceOfThrowableType;
Aqui está um exemplo de uso da palavra-chave 'throw' para lançar uma exceção manualmente.
experimentar
{
NumberFormatException ex = new NumberFormatException(); //Aqui criamos um objeto para NumberFormatException explicitamente
jogar ex; //jogando o objeto NumberFormatException explicitamente usando a palavra-chave throw
}
catch(NumberFormatException ex)
{
System.out.println(“Neste bloco, o objeto NumberFormatException lançado explicitamente pode ser capturado.”);
}
Leia: As 35 principais perguntas e respostas da entrevista de primavera: Guia definitivo
16. O que você quer dizer com relançar uma exceção em Java?
As exceções que são levantadas no bloco 'try' são tratadas no bloco 'catch'. Se o bloco 'catch' não puder lidar com essa exceção, é possível que ele possa relançar a mesma exceção usando a palavra-chave 'throw'. Esse mecanismo é chamado de relançamento de uma exceção. A implementação é a seguinte:
experimentar
{
Cadeia s = null;
System.out.println(s.length()); //Esta declaração lança um NullPointerException
}
catch(NullPointerException ex)
{
System.out.println(“Aqui o NullPointerException é capturado”);
jogar ex; //Relançamento do NullPointerException
}
17. Por que você usa a palavra-chave 'throws' em Java?
Se for possível para um método lançar uma exceção se ela não puder ser tratada, ele deve especificar essa exceção usando a palavra-chave 'throws'. Será útil para as funções do chamador desse método no tratamento dessa exceção. A sintaxe para usar a palavra-chave 'throws' é,
return_type method_name(parameter_list) lança exceção_list
{
//código
}
Aqui, exception_list é a lista de exceções que podem ser lançadas pelo método. Essas exceções devem ser separadas por vírgulas. Um exemplo do código:
classe pública ExceptionHandling
{
public static void main(String[] args)
{
experimentar
{
métodoWithThrows();
}
catch(NullPointerException ex)
{
System.out.println("NullPointerException lançada pelo método methodWithThrows() será capturada aqui");
}
}
static void methodWithThrows() lança NullPointerException
{
Cadeia s = null;
System.out.println(s.length()); //Esta declaração lança NullPointerException
}
}
18. Muitas vezes é recomendado manter as operações de limpeza como fechar os recursos do banco de dados dentro do bloco 'finally'. Por que é necessário?
O bloco 'finally' é sempre executado independentemente do fato se exceções são levantadas no bloco 'try' ou se as exceções levantadas são capturadas no bloco 'catch' ou não. Manter as operações de limpeza no bloco 'finalmente' garante o funcionamento dessas operações em qualquer caso, e não serão afetadas por exceções, que podem ou não surgir.
19. Como você diferenciaria entre final, finalmente e finalize em Java?
Primeiro, 'final' é uma palavra-chave que pode ser usada para tornar uma variável, um método ou uma classe imutável. Simplificando, se uma variável é declarada como final, uma vez inicializada, seu valor não pode ser alterado. Se um método for declarado como final, ele não poderá ser substituído ou modificado na subclasse. Se uma classe for declarada como final, ela não poderá ser estendida para outras classes.
Segundo, 'finally' é um bloco que é usado no tratamento de exceções junto com os blocos 'try' e 'catch'. Este bloco é sempre executado independentemente de uma exceção levantada ou se a exceção levantada for tratada. Normalmente, este bloco é usado para realizar operações de limpeza para fechar os recursos como conexão de banco de dados, recursos de E/S, etc.
Terceiro, o método finalize() é um método protegido. Pertence à classe java.lang.Object. Toda classe criada em Java herda esse método. O thread do coletor de lixo chama esse método antes que um objeto seja removido da memória. Antes de um objeto ser removido da memória, esse método é usado para realizar algumas das operações de limpeza.
protected void finalize() lança Throwable
{
//Operações de limpeza
}
20. O que são exceções personalizadas em java?
As classes de exceção podem ser lançadas em Java conforme os requisitos do fluxo do programa. Essas exceções são chamadas de exceções definidas pelo usuário. Eles também são chamados de exceções personalizadas. Essas exceções devem estender qualquer uma das classes na hierarquia de exceções.
21. Como você explicaria uma ClassCastException em Java?
Quando a JVM não consegue converter um objeto de um tipo para outro tipo, essa exceção é gerada. É um RunTimeException.
22. Diferencie entre throw, throws e throwable em Java.
Primeiro, a palavra-chave 'throw' é usada para lançar uma exceção manualmente em Java. Usando esta palavra-chave, é possível lançar uma exceção de qualquer método ou bloco. No entanto, é essencial que a exceção seja do tipo java.lang.Throwable class ou pertença a uma das subclasses da classe java.lang.Throwable.
Segundo, a palavra-chave 'throws' é usada na assinatura do método em Java. Se o método for capaz de lançar exceções, isso será indicado por este método. As exceções mencionadas são tratadas por suas respectivas funções de chamador. Isso é feito usando blocos try e catch ou usando a palavra-chave throws.
Terceiro, a superclasse para todos os tipos de erros e exceções em Java é chamada Throwable. É um membro do pacote java.lang. A JVM ou a instrução throw gera apenas instâncias dessa classe ou de suas subclasses. O bloco catch deve conter apenas um argumento e deve ser deste tipo ou de suas subclasses. Caso exceções personalizadas sejam criadas, elas devem estender essa classe também.
23. Explique o StackOverflowError em Java.
Este é um erro lançado pela JVM quando a pilha estoura no tempo de execução.
24. É possível substituir um método de superclasse que lança uma exceção não verificada com exceções verificadas na subclasse?
Não é possível porque se um método de superclasse lançar uma exceção não verificada, ela será substituída na subclasse com a mesma exceção ou qualquer outra exceção não verificada. Mas, não pode ser substituído com exceções verificadas.
25. Defina exceções encadeadas em Java.
Em um programa, uma exceção pode lançar muitas exceções induzindo um efeito dominó. Isso causa uma cadeia de exceções. É benéfico conhecer a localização da causa real da exceção. Isso é possível com o recurso de exceções encadeadas em Java. Isso foi introduzido desde o JDK 1.4. Para implementação de exceções encadeadas em Java, dois novos construtores e dois novos métodos são incluídos na classe Throwable. Estes são,
Construtores da classe Throwable:
- Throwable(Throwable cause): A causa é a exceção que gera a exceção atual.
- Throwable(String msg, Throwable cause): A string msg é a mensagem de exceção. A exceção que gera a exceção atual é a causa aqui.
Métodos de classe Throwable:
- método getCause() : A causa real de uma exceção levantada é retornada por este método.
- initCause(Throwable cause) method : A causa da exceção de chamada é definida por este método.
26. Qual classe é definida como superclasse para todos os tipos de erros e exceções em Java?
A superclasse para todos os tipos de erros e exceções é java.lang.Throwable em Java.
27. O que pode ser classificado como uma combinação correta de blocos try, catch e finally?
Uma combinação de bloco try and catch.
experimentar
{
//tenta o bloco
}
catch(Exceção ex)
{
//pega bloco
}
Uma combinação de tentar e finalmente bloquear.
experimentar
{
//tenta o bloco
}
finalmente
{
//finalmente bloqueia
}
Uma combinação de todos os três: tente, bloqueie, finalmente bloqueie.
experimentar
{
//tenta o bloco
}
catch(Exceção ex)
{
//pega bloco
}
finalmente
{
//finalmente bloqueia
}
28. Por que você usa o método printStackTrace()?
Este método é usado para imprimir informações detalhadas sobre a exceção que ocorreu.
29. Quais são alguns exemplos de exceções verificadas?
Alguns exemplos de exceções verificadas incluem ClassNotFoundException, SQLException e IOException.
30. Quais são alguns exemplos de exceções não verificadas?
Alguns exemplos de exceções não verificadas incluem NullPointerException, ArrayIndexOutOfBoundsException e NumberFormatException.
Leia também: Deve ler 47 perguntas e respostas da entrevista OOPS para calouros e experientes
Empacotando
Se você estiver interessado em aprender mais sobre big data, confira o PG Diploma in Full-stack Software Development da upGrad & IIIT-B, projetado para profissionais que trabalham e oferece mais de 500 horas de treinamento rigoroso, mais de 9 projetos e atribuições, IIIT -B Status de ex-aluno, projetos práticos práticos e assistência de trabalho com as principais empresas.
Se você estiver interessado em aprender Ciência de Dados e optar por uma carreira neste campo, confira o Programa PG Executivo em Ciência de Dados do IIIT-B & upGrad, criado para profissionais que trabalham e oferece mais de 10 estudos de caso e projetos, workshops práticos práticos , orientação com especialistas do setor, 1 a 1 com mentores do setor, mais de 400 horas de aprendizado e assistência de trabalho com as principais empresas.
