Java - Fouten

Bij het maken van programma's die steeds complexer worden, zullen we onvermijdelijk fouten tegenkomen, misschien sommige moeilijker op te lossen dan andere, maar dit mag ons niet ontmoedigen, omdat we soms fouten moeten maken voordat we iets corrects in onze applicatie bereiken. .
In Java we hebben er meerdere fout categorieën dat kan ons overkomen bij het maken van een programma, het herkennen ervan en het kennen van hun oorzaken zijn de eerste twee manieren om fouten te bestrijden.
Syntaxisfouten
Deze fouten treden op bij het compileren van de code, dus ze kunnen ook worden aangeroepen als compilatie fouten, ze komen voor wanneer we de code verkeerd spellen en de compiler kan onze instructies niet interpreteren.
Het is heel gebruikelijk om een ​​instructie verkeerd te schrijven, een blok verkeerd te sluiten en een van de meest verschrikkelijke is om een ​​puntkomma niet te halen, dit laatste is heel gebruikelijk omdat we vaak in verschillende talen werken en we kunnen oplopen in het mengen van de elementen die de lijnen beëindigen.
Dit soort fouten zijn gemakkelijk te debuggen omdat: Java Bij het compileren vertelt het ons waar het probleem is en geeft het ons een beschrijving ervan, laten we de volgende code met fouten bekijken:

 public class ShowSyntaxErrors {public static void main (String [] args) {i = 30; Systeem.uit.println (i + 4); }} 

Als we deze fout proberen te compileren, krijgen we het volgende in de opdrachtconsole:

VERGROTEN

We zien dan dat alles wordt geactiveerd door de variabele niet correct te hebben gedeclareerd. Om dit soort fouten te corrigeren, is het raadzaam om met de eerste regel te beginnen, zodat het corrigeren van de eerste fout misschien het aantal daaropvolgende fouten zal verminderen.
Uitvoeringsfouten
Dit type fout treedt op wanneer we in een programma een element hebben dat ervoor zorgt dat het programma abrupt wordt beëindigd, dit gebeurt bijvoorbeeld wanneer we een gebruikersinvoerveld hebben en de gebruiker iets invoert dat het programma niet had verwacht en dat niet is vastgelegd correct is of wanneer bijvoorbeeld een deling door 0 optreedt, iets dat niet kan worden afgehandeld.
Laten we hieronder een code bekijken waarmee we dit soort fouten kunnen illustreren:

 public class ShowRuntimeErrors {public static void main (String [] args) {int i = 1/0; }} 

Als we het resultaat in de compiler zien, geeft het ons het volgende:

BelangrijkHier zien we dat de compiler correct is geslaagd, maar bij het uitvoeren van het programma heeft het de fout gegenereerd. De meest gebruikelijke manier om deze fouten te voorkomen is door de probeer / vang blok om uitzonderingen te vermijden en om dergelijke uitzonderingen te kunnen afhandelen zonder het programma op een ongewenste manier te beëindigen.
Logische fouten
Dit is het type fout dat door elke programmeur het meest wordt gevreesd, omdat het niet wordt opgemerkt door de compiler of de uitvoering en dit komt omdat het niet is omdat het programma slecht is geschreven of dat er redenen zijn waarom het programma verkeerd eindigt, zo niet dat de logische implementatie van wat je wilt doen is verkeerdOm dit soort fouten op te lossen, moeten we koude runs toepassen en waarden hebben waarmee we kunnen weten of ons programma correct werkt.
Zoals we konden zien hebben we 3 grote groepen fouten in onze programma's en door ze te kennen, kunnen we manieren vinden om dergelijke fouten te vermijden of op zijn minst proberen ze te corrigeren wanneer ze zich voordoen.Vond je deze Tutorial leuk en heb je eraan geholpen?Je kunt de auteur belonen door op deze knop te drukken om hem een ​​positief punt te geven