Fout

Wees bang voor fouten, maar schrijf ze niet in Java! U weet waarschijnlijk al het een en ander over uitzonderingen in Java . Vandaag zal in ieder geval een oppervlakkige kennis u ten goede komen. We gaan de klasse Error analyseren en een speciaal uitzonderingstype dat veel mensen bang maakt wanneer het in hun stacktraces verschijnt.

Bovenaan de uitzonderingshiërarchie van Java staat de klasse Throwable , die twee afstammelingen heeft:

• Uitzondering , die verantwoordelijk is voor fouten in uw programma.
• En onze held voor vandaag — Error , die verantwoordelijk is voor fouten in de JVM.
  Het is vermeldenswaard dat dit waarschijnlijk niet eens codeerfouten zijn, maar eerder problemen die meestal niet afhankelijk zijn van de ontwikkelaar.

Wat te doen met een fout

Bij het afvangen van "errors" kunt u geen acties uitvoeren in het catch- blok, behalve logging , aangezien we het hebben over problemen in de JVM zelf.

Loggen is goed: wanneer u een runtime-fout krijgt, kunt u de logboeken bekijken, de oorzaak zien en weten wat u moet oplossen.

Aangezien u niet weet wat voor soort fout u kunt krijgen wanneer u uw code schrijft, heeft het geen zin om een ​​bepaald type in het catch- blok te schrijven. Het gebruik van de klasse Error zelf is ook niet de beste oplossing, aangezien u in dit geval alleen fouten zult opvangen.

Daarom is het beter om de klasse Throwable te gebruiken, die zowel Error als Exception kan opvangen . Hoe ziet dit er in de praktijk uit?

try {
    // Your code
} catch (OutOfMemoryError outOfMemoryError) {
    // Code to catch OutOfMemoryError
}

try {
    // Your code
} catch (Error error) {
    // Code to catch all Errors
}

try {
    // Your code
} catch (Throwable throwable) {
    // Code to catch all Throwables
}

De tweede optie voor het afhandelen van fouten is om ze hoger te gooien na het declareren van een throws- clausule in de methode. Deze techniek wordt gebruikt wanneer uw code theoretisch een fout zou kunnen veroorzaken en u iedereen die uw code zou kunnen gebruiken van tevoren wilt waarschuwen, zodat ze de fout correct kunnen afhandelen.

Veel voorkomende fouten

Enkele van de meest populaire fouten zijn de klassen OutOfMemoryError en StackOverflowError .

OutOfMemoryError verschijnt vaak wanneer het programma niet genoeg geheugen heeft om objecten te maken en de vuilnisman het niet bij kan houden. Het resultaat is een OutOfMemoryError .

Met Java kunt u objecten niet handmatig verwijderen om geheugenlekken te voorkomen, maar u kunt wel voorkomen dat er rommel wordt gemaakt om de vuilnisman niet te overbelasten en de hoop niet te vervuilen.

Code zoals deze zal bijvoorbeeld veel rotzooi in het geheugen creëren:

while (true) {
    new Object();
}

De tweede fout waarover ik je wil vertellen, is de StackOverflowError , die wordt gegenereerd wanneer de stapel overloopt. Aangezien de stack voornamelijk lokale variabelen, parameters en methodeaanroepen opslaat, is recursie (of een recursieve methodeaanroep) een veel voorkomende oorzaak van deze fout:

public void foo() {
    foo();
}

Om problemen tijdens de uitvoering van programma's te voorkomen, waarschuwen moderne IDE's vaak voor het recursief aanroepen van methoden.

U kunt een programma dat fouten genereert niet repareren , maar u kunt wel code schrijven die geen fout genereert en uw programma kapot maakt. Let op wat u met het geheugen doet, maak objecten zorgvuldig en roep methoden correct aan. Als je dat doet, heb je minder problemen in je code.

Verschil tussen de typen Fout en Uitzondering

Je kunt in Java niet aan uitzonderingen ontsnappen, maar je moet er ook niet bang voor zijn. U hoeft alleen maar te begrijpen wat elk type vertegenwoordigt en weet hoe u ermee om moet gaan. Dat is alles voor vandaag! Tot snel!