Java Exception Interviewvragen en Antwoorden

Handleidingen
Java

Java biedt een robuuste en objectgeoriënteerde benadering om uitzonderingsscenario’s te behandelen, bekend als Java Exception Handling. Enige tijd geleden schreef ik een lang bericht over Exception Handling in Java en vandaag som ik enkele belangrijke Java Exceptions-vragen met antwoorden op om je te helpen bij sollicitatiegesprekken.

  1. Wat is een Uitzondering in Java?
  2. Wat zijn de Uitzonderingsafhandelingszoekwoorden in Java?
  3. Leg de Java Exception-hiërarchie uit?
  4. Wat zijn de belangrijke methoden van de Java Exception Class?
  5. Leg Java 7 ARM-functie en multi-catch block uit?
  6. Wat is het verschil tussen Gecontroleerde en Ongewijzigde Uitzonderingen in Java?
  7. Wat is het verschil tussen het throw- en throws-zoekwoord in Java?
  8. Hoe schrijf je aangepaste uitzonderingen in Java?
  9. Wat is OutOfMemoryError in Java?
  10. Wat zijn de verschillende scenario’s die “Uitzondering in thread main” veroorzaken?
  11. Wat is het verschil tussen final, finally en finalize in Java?
  12. Wat gebeurt er wanneer een uitzondering wordt gegenereerd door de main-methode?
  13. Kunnen we een leeg catch-blok hebben?
  14. Geef enkele beste praktijken voor het afhandelen van Java-uitzonderingen?
  15. Wat is het probleem met de onderstaande programma’s en hoe lossen we het op?

1. Wat is een Uitzondering in Java?

Een uitzondering is een foutgebeurtenis die kan optreden tijdens de uitvoering van een programma en de normale doorstroming ervan verstoort. De uitzondering kan ontstaan uit verschillende soorten situaties zoals verkeerde gegevens ingevoerd door de gebruiker, hardwarestoring, netwerkverbindingstoring, enz. Telkens wanneer er een fout optreedt tijdens het uitvoeren van een java-instructie, wordt er een uitzonderingsobject gemaakt, en vervolgens probeert de JRE een uitzonderingshandler te vinden om de uitzondering af te handelen. Als er een geschikte uitzonderingshandler wordt gevonden, wordt het uitzonderingsobject doorgegeven aan de handlercode om de uitzondering te verwerken, bekend als het vangen van de uitzondering. Als er geen handler wordt gevonden, gooit de toepassing de uitzondering naar de runtime-omgeving en beëindigt de JRE het programma. Java Exception handling framework wordt alleen gebruikt om runtime-fouten af te handelen, compileerfouten worden niet afgehandeld door het uitzonderingsafhandelingsframework.

2. Wat zijn de uitzonderingsafhandelingskeywords in Java?

Er zijn vier keywords die worden gebruikt in de Java-uitzonderingsafhandeling.

  1. throw: Soms willen we expliciet een uitzonderingsobject maken en het vervolgens gooien om de normale verwerking van het programma te stoppen. Het throw-keyword wordt gebruikt om uitzonderingen naar de runtime te gooien om deze te laten behandelen.
  2. throws: Als we een gecontroleerde uitzondering gooien in een methode en deze niet afhandelen, moeten we het throws-keyword gebruiken in de methodehandtekening om het aanroepende programma op de hoogte te stellen van de uitzonderingen die door de methode kunnen worden veroorzaakt. De aanroepende methode kan deze uitzonderingen afhandelen of doorgeven aan zijn aanroepende methode met behulp van het throws-keyword. We kunnen meerdere uitzonderingen opgeven in de throws-clausule en het kan ook worden gebruikt met de main()-methode.
  3. try-catch: We gebruiken het try-catch-blok voor uitzonderingsafhandeling in onze code. try is het begin van het blok en catch staat aan het einde van het try-blok om de uitzonderingen af te handelen. We kunnen meerdere catch-blokken hebben met een try en try-catch-blokken kunnen ook genest zijn. Het catch-blok vereist een parameter die van het type Exception moet zijn.
  4. eindelijk: Het finally-blok is optioneel en kan alleen worden gebruikt met een try-catch-blok. Omdat een uitzondering het uitvoeringsproces onderbreekt, kunnen we enkele bronnen open hebben die niet worden gesloten. We kunnen dus het finally-blok gebruiken. Het finally-blok wordt altijd uitgevoerd, of er nu een uitzondering optreedt of niet.

3. Leg de Java Exception-hiërarchie uit?

Java Exceptions zijn hiërarchisch en overerving wordt gebruikt om verschillende soorten uitzonderingen te categoriseren. Throwable is de bovenliggende klasse van de hiërarchie van Java-uitzonderingen en het heeft twee onderliggende objecten – Error en Exception. Uitzonderingen zijn verder onderverdeeld in gecontroleerde uitzonderingen en runtime-uitzonderingen. Fouten zijn uitzonderlijke scenario’s die buiten de reikwijdte van de toepassing vallen en het is niet mogelijk om ze te anticiperen en te herstellen, bijvoorbeeld hardwarestoring, JVM-crash of out-of-memory-fout. Gecontroleerde uitzonderingen zijn uitzonderlijke scenario’s die we kunnen anticiperen in een programma en proberen ervan te herstellen, bijvoorbeeld FileNotFoundException. We moeten deze uitzondering opvangen en een nuttige boodschap aan de gebruiker verstrekken en deze correct vastleggen voor debugdoeleinden. Exception is de bovenliggende klasse van alle Gecontroleerde Uitzonderingen. Runtime-uitzonderingen worden veroorzaakt door slechte programmering, bijvoorbeeld proberen een element uit de Array op te halen. We moeten eerst de lengte van de array controleren voordat we proberen het element op te halen, anders kan het ArrayIndexOutOfBoundException veroorzaken tijdens runtime. RuntimeException is de bovenliggende klasse van alle runtime-uitzonderingen.

4. Wat zijn de belangrijke methoden van de Java Exception Class?

Exception en al zijn subklassen bieden geen specifieke methoden en alle methoden zijn gedefinieerd in de basisklasse Throwable.

  1. String getMessage() – Deze methode retourneert de berichttekst van Throwable en het bericht kan worden opgegeven bij het creëren van de uitzondering via zijn constructor.
  2. String getLocalizedMessage() – Deze methode wordt geleverd zodat subklassen deze kunnen overschrijven om de op locatie gebaseerde berichten te leveren aan het aanroepende programma. De implementatie van de Throwable-klasse van deze methode gebruikt eenvoudig de getMessage()-methode om het uitzonderingsbericht terug te geven.
  3. gesynchroniseerd Throwable getCause() – Deze methode retourneert de oorzaak van de uitzondering of null als de oorzaak onbekend is.
  4. String toString() – Deze methode retourneert de informatie over Throwable in String-formaat, de geretourneerde String bevat de naam van de Throwable-klasse en het gelokaliseerde bericht.
  5. void printStackTrace() – Deze methode drukt de stacktrace-informatie af naar de standaardfoutstroom, deze methode is overbelast en we kunnen PrintStream of PrintWriter doorgeven als argument om de stacktrace-informatie naar het bestand of de stroom te schrijven.

Leg de Java 7 ARM-functie en de multi-catch block uit?

Als je veel uitzonderingen opvangt in een enkel try-blok, zul je merken dat de code van het catch-blok er erg lelijk uitziet en voornamelijk bestaat uit overbodige code om de fout te loggen. Met dit in gedachten was een van de functies van Java 7 het multi-catch-blok waarin we meerdere uitzonderingen in een enkel catch-blok kunnen opvangen. Het catch-blok met deze functie ziet er als volgt uit:

catch(IOException | SQLException | Exception ex){
     logger.error(ex);
     throw new MyException(ex.getMessage());
}

Meestal gebruiken we het finally-blok alleen om de resources te sluiten en soms vergeten we ze te sluiten en krijgen we runtime-uitzonderingen wanneer de resources zijn uitgeput. Deze uitzonderingen zijn moeilijk te debuggen en we moeten mogelijk op elke plaats kijken waar we dat type resource gebruiken om ervoor te zorgen dat we het sluiten. Dus een van de verbeteringen in Java 7 was try-with-resources waar we een resource kunnen maken in de try-statement zelf en het binnen het try-catch-blok kunnen gebruiken. Wanneer de uitvoering het try-catch-blok verlaat, sluit de runtime-omgeving deze resources automatisch. Voorbeeld van een try-catch-blok met deze verbetering is:

try (MyResource mr = new MyResource()) {
            System.out.println("MyResource created in try-with-resources");
        } catch (Exception e) {
            e.printStackTrace();
        }

Lees hier meer over op Java 7 ARM.

6. Wat is het verschil tussen Gecontroleerde en Ongecontroleerde Uitzonderingen in Java?

  1. Gecontroleerde Uitzonderingen moeten worden afgehandeld in de code met behulp van een try-catch-blok of anders moet de methode het throws-sleutelwoord gebruiken om de beller op de hoogte te stellen van de gecontroleerde uitzonderingen die mogelijk vanuit de methode worden gegenereerd. Ongecontroleerde Uitzonderingen hoeven niet te worden afgehandeld in het programma of te worden vermeld in de throws-clausule van de methode.
  2. Exception is de superklasse van alle gecontroleerde uitzonderingen, terwijl RuntimeException de superklasse is van alle ongecontroleerde uitzonderingen. Let op dat RuntimeException de subklasse is van Exception.
  3. Gecontroleerde uitzonderingen zijn foutscenario’s die moeten worden afgehandeld in de code, anders krijgt u een compileerfout. Bijvoorbeeld, als u FileReader gebruikt om een bestand te lezen, gooit het een FileNotFoundException en moeten we deze opvangen in de try-catch-blok of opnieuw doorgeven aan de beller. Ongecontroleerde uitzonderingen worden meestal veroorzaakt door slecht programmeren, bijvoorbeeld NullPointerException bij het aanroepen van een methode op een objectreferentie zonder ervoor te zorgen dat deze niet null is. Bijvoorbeeld, ik kan een methode schrijven om alle klinkers uit de string te verwijderen. Het is de verantwoordelijkheid van de beller om ervoor te zorgen dat er geen nulstring wordt doorgegeven. Ik kan de methode wijzigen om deze scenario’s af te handelen, maar idealiter moet de beller hiervoor zorgen.

7. Wat is het verschil tussen het throw- en throws-trefwoord in Java?

Het trefwoord throws wordt gebruikt bij de methodehandtekening om de uitzonderingen aan te geven die de methode zou kunnen veroorzaken, terwijl het trefwoord throw wordt gebruikt om de programmaflow te onderbreken en de uitzonderingsobject door te geven aan de runtime om deze af te handelen.

8. Hoe schrijf je aangepaste uitzonderingen in Java?

We kunnen de klasse Exception of een van zijn subklassen uitbreiden om onze aangepaste uitzonderingsklasse te maken. De aangepaste uitzonderingsklasse kan zijn eigen variabelen en methoden hebben die we kunnen gebruiken om foutcodes of andere informatie met betrekking tot uitzonderingen door te geven aan de uitzonderingsafhandelaar. Een eenvoudig voorbeeld van een aangepaste uitzondering wordt hieronder getoond.

package com.journaldev.exceptions;

import java.io.IOException;

public class MyException extends IOException {

	private static final long serialVersionUID = 4664456874499611218L;
	
	private String errorCode="Unknown_Exception";
	
	public MyException(String message, String errorCode){
		super(message);
		this.errorCode=errorCode;
	}
	
	public String getErrorCode(){
		return this.errorCode;
	}
	

}

9. Wat is OutOfMemoryError in Java?

OutOfMemoryError in Java is een subklasse van java.lang.VirtualMachineError en wordt gegenereerd door de JVM wanneer deze geen heapgeheugen meer heeft. We kunnen deze fout oplossen door meer geheugen toe te wijzen om de Java-toepassing uit te voeren via Java-opties. $>java MyProgram -Xms1024m -Xmx1024m -XX:PermSize=64M -XX:MaxPermSize=256m

10. Wat zijn de verschillende scenario’s die “Exception in thread main” veroorzaken?

Enkele van de veelvoorkomende scenario’s voor uitzonderingen in de hoofdthread zijn:

  • Exception in thread main java.lang.UnsupportedClassVersionError: Deze uitzondering treedt op wanneer uw Java-klasse is gecompileerd vanuit een andere JDK-versie en u probeert deze uit te voeren vanuit een andere Java-versie.
  • Exception in thread main java.lang.NoClassDefFoundError: Er zijn twee varianten van deze uitzondering. De eerste is wanneer u de volledige naam van de klasse opgeeft met de extensie .class. Het tweede scenario is wanneer de klasse niet wordt gevonden.
  • Exception in thread main java.lang.NoSuchMethodError: main: Deze uitzondering treedt op wanneer u probeert een klasse uit te voeren die de hoofdmethode niet heeft.
  • Uitzondering in thread “main” java.lang.ArithmeticException: Telkens wanneer er een uitzondering wordt gegenereerd vanuit de hoofdmethode, wordt de uitzondering afgedrukt in de console. Het eerste deel legt uit dat er een uitzondering wordt gegenereerd vanuit de hoofdmethode, het tweede deel drukt de naam van de uitzonderingsklasse af en daarna na een dubbele punt, drukt het de uitzonderingsboodschap af.

Lees hier meer over op Java Uitzondering in thread main.

11. Wat is het verschil tussen final, finally en finalize in Java?

final en finally zijn trefwoorden in Java, terwijl finalize een methode is. Het trefwoord final kan worden gebruikt met klassevariabelen zodat ze niet opnieuw kunnen worden toegewezen, met de klasse om uitbreiding door klassen te voorkomen en met methoden om overschrijven door subklassen te voorkomen, het trefwoord finally wordt gebruikt met een try-catch-blok om verklaringen te geven die altijd worden uitgevoerd, zelfs als er een uitzondering optreedt, meestal wordt finally gebruikt om bronnen te sluiten. De finalize() methode wordt uitgevoerd door de Garbage Collector voordat het object wordt vernietigd, het is een goede manier om ervoor te zorgen dat alle globale bronnen worden gesloten. Van de drie is alleen finally gerelateerd aan de afhandeling van uitzonderingen in Java.

12. Wat gebeurt er wanneer een uitzondering wordt gegenereerd door de main-methode?

Wanneer een uitzondering wordt gegenereerd door een main() methode, beëindigt Java Runtime het programma en worden het uitzonderingsbericht en de stacktrace afgedrukt in de systeemconsole.

13. Kunnen we een lege catch-blok hebben?

We kunnen een leeg catch-blok hebben, maar het is een voorbeeld van slecht programmeren. We zouden nooit een leeg catch-blok moeten hebben omdat als de uitzondering door dat blok wordt opgevangen, we geen informatie hebben over de uitzondering en het een nachtmerrie zal zijn om deze te debuggen. Er moet minstens een logboekverklaring zijn om de uitzonderingsdetails te registreren in de console of logbestanden.

14. Geef enkele beste werkwijzen voor het afhandelen van Java-uitzonderingen?

Enkele van de beste werkwijzen met betrekking tot het afhandelen van Java-uitzonderingen zijn:

  • Gebruik specifieke uitzonderingen voor gemakkelijker debuggen.
  • Werp uitzonderingen vroeg (Fail-Fast) in het programma.
  • Vang uitzonderingen laat in het programma op, laat de beller de uitzondering afhandelen.
  • Gebruik de Java 7 ARM-functie om ervoor te zorgen dat resources worden gesloten of gebruik de finally-blok om ze correct te sluiten.
  • Log altijd uitzonderingsberichten voor debugdoeleinden.
  • Gebruik een multi-catch-blok voor schonere afsluiting.
  • Gebruik aangepaste uitzonderingen om een enkel type uitzondering uit uw toepassings-API te gooien.
  • Volg de naamgevingsconventie, eindig altijd met Exception.
  • Documenteer de geworpen uitzonderingen door een methode te gebruiken @throws in javadoc.
  • Uitzonderingen zijn kostbaar, gooi ze dus alleen als het zinvol is. Anders kunt u ze opvangen en een null of leeg antwoord geven.

Lees er meer over in detail op Best Practices voor het omgaan met Java-uitzonderingen.

15. Wat is het probleem met de onderstaande programma’s en hoe lossen we het op?

In dit gedeelte zullen we enkele programmeervragen bekijken die verband houden met Java-uitzonderingen.

  1. Wat is het probleem met het onderstaande programma?

    package com.journaldev.exceptions;

import java.io.FileNotFoundException;
import java.io.IOException;

public class TestException {

	public static void main(String[] args) {
		try {
			testExceptions();
		} catch (FileNotFoundException | IOException e) {
			e.printStackTrace();
		}
	}
	
	
	
	public static void testExceptions() throws IOException, FileNotFoundException{
		
	}
}

    Het bovenstaande programma compileert niet en je krijgt een foutmelding als “Het uitzonderingsgeval FileNotFoundException wordt al afgehandeld door de alternatieve IOException”. Dit komt doordat FileNotFoundException een subklasse is van IOException, er zijn twee manieren om dit probleem op te lossen. De eerste manier is om een enkel catch-blok te gebruiken voor beide uitzonderingen.

    		try {
			testExceptions();
		}catch(FileNotFoundException e){
			e.printStackTrace();
		}catch (IOException  e) {
			e.printStackTrace();
		}

    Een andere manier is om FileNotFoundException uit het multi-catch-blok te verwijderen.

    		try {
			testExceptions();
		}catch (IOException  e) {
			e.printStackTrace();
		}

    Je kunt een van deze benaderingen kiezen op basis van je catch-blokcode.

  2. Wat is het probleem met het onderstaande programma?

    package com.journaldev.exceptions;

import java.io.FileNotFoundException;
import java.io.IOException;

import javax.xml.bind.JAXBException;

public class TestException1 {

	public static void main(String[] args) {
			try {
				go();
			} catch (IOException e) {
				e.printStackTrace();
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			} catch (JAXBException e) {
				e.printStackTrace();
			}
	}

	public static void go() throws IOException, JAXBException, FileNotFoundException{
		
	}
}

    Het programma zal niet compileren omdat FileNotFoundException een subklasse is van IOException, dus het catch-blok van FileNotFoundException is onbereikbaar en u krijgt een foutmelding als “Onbereikbaar catch-blok voor FileNotFoundException. Het wordt al afgehandeld door het catch-blok voor IOException”. U moet de volgorde van de catch-blokken aanpassen om dit probleem op te lossen.

    			try {
				go();
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			} catch (JAXBException e) {
				e.printStackTrace();
			}

    Merk op dat JAXBException niet gerelateerd is aan IOException of FileNotFoundException en overal in de bovenstaande catch-blokhiërarchie kan worden geplaatst.

  3. Wat is het probleem met het onderstaande programma?

    package com.journaldev.exceptions;

import java.io.IOException;

import javax.xml.bind.JAXBException;

public class TestException2 {

	public static void main(String[] args) {
		try {
			foo();
		} catch (IOException e) {
			e.printStackTrace();
		}catch(JAXBException e){
			e.printStackTrace();
		}catch(NullPointerException e){
			e.printStackTrace();
		}catch(Exception e){
			e.printStackTrace();
		}
	}

	public static void foo() throws IOException{
		
	}
}

    Het programma compileert niet omdat JAXBException een gecontroleerde uitzondering is en de foo() methode deze uitzondering moet gooien om deze in de aanroepende methode op te vangen. Je krijgt een foutmelding als “Onbereikbaar catch-blok voor JAXBException. Deze uitzondering wordt nooit gegenereerd door het try-statementblok”. Om dit probleem op te lossen, moet je het catch-blok van JAXBException verwijderen. Merk op dat het opvangen van NullPointerException geldig is omdat het een niet-gecontroleerde uitzondering is.

  4. Wat is het probleem met het onderstaande programma?

    package com.journaldev.exceptions;

public class TestException3 {

	public static void main(String[] args) {
		try{
		bar();
		}catch(NullPointerException e){
			e.printStackTrace();
		}catch(Exception e){
			e.printStackTrace();
		}
		
		foo();
	}

	public static void bar(){
		
	}
	
	public static void foo() throws NullPointerException{
		
	}
}

    Dit is een strikvraag, er is geen probleem met de code en het zal succesvol compileren. We kunnen altijd een Exception of een willekeurige niet-gecontroleerde uitzondering opvangen, zelfs als deze niet in de throws-clausule van de methode staat. Op dezelfde manier is het niet verplicht om een ongecontroleerde uitzondering die in de throws-clausule van een methode (foo) wordt verklaard, in het programma te behandelen.

  5. Wat is het probleem met het onderstaande programma?

    package com.journaldev.exceptions;

import java.io.IOException;

public class TestException4 {

	public void start() throws IOException{		
	}
	
	public void foo() throws NullPointerException{
		
	}
}

class TestException5 extends TestException4{
	
	public void start() throws Exception{
	}
	
	public void foo() throws RuntimeException{
		
	}
}

    Het bovenstaande programma compileert niet omdat de handtekening van de start() methode niet hetzelfde is in de subklasse. Om dit probleem op te lossen, kunnen we ofwel de methodehandtekening in de subklasse precies hetzelfde maken als die van de superklasse, of we kunnen de throws-clausule uit de methode van de subklasse verwijderen zoals hieronder wordt getoond.

    @Override
	public void start(){
	}

  6. Wat is het probleem met het onderstaande programma?

    package com.journaldev.exceptions;

import java.io.IOException;

import javax.xml.bind.JAXBException;

public class TestException6 {

	public static void main(String[] args) {
		try {
			foo();
		} catch (IOException | JAXBException e) {
			e = new Exception("");
			e.printStackTrace();
		}catch(Exception e){
			e = new Exception("");
			e.printStackTrace();
		}
	}

	public static void foo() throws IOException, JAXBException{
		
	}
}

    Het bovenstaande programma compileert niet omdat het exceptie-object in het multi-catch blok final is en we de waarde niet kunnen wijzigen. Je krijgt een compileerfout als “De parameter e van een multi-catch blok kan niet worden toegewezen”. We moeten de toewijzing van “e” aan een nieuw exceptie-object verwijderen om deze fout op te lossen. Lees meer op Java 7 multi-catch block.

Dat is alles voor de vragen over Java-uitzonderingen tijdens interviews, ik hoop dat je ze leuk vindt. Ik zal er in de toekomst meer toevoegen, zorg ervoor dat je ze bookmarkt voor toekomstig gebruik.

Source:
https://www.digitalocean.com/community/tutorials/java-exception-interview-questions-and-answers