Java-opmerkingen gebruiken

Java-opmerkingen zijn opmerkingen in een Java-codebestand die door de compiler en runtime-engine worden genegeerd. Ze worden gebruikt om de code te annoteren om het ontwerp en het doel te verduidelijken. U kunt een onbeperkt aantal opmerkingen toevoegen aan een Java-bestand, maar er zijn enkele "best practices" die u kunt volgen bij het gebruik van opmerkingen.

Over het algemeen zijn code-opmerkingen "implementatie" -reacties die de broncode verklaren, zoals beschrijvingen van klassen, interfaces, methoden en velden. Dit zijn meestal een paar regels die boven of naast Java-code zijn geschreven om te verduidelijken wat het doet.

Een ander type Java-opmerking is een Javadoc-opmerking. Javadoc-opmerkingen verschillen enigszins in syntaxis van implementatie-opmerkingen en worden door het programma javadoc.exe gebruikt om Java HTML-documentatie te genereren.

Waarom Java-opmerkingen gebruiken?

Het is een goede gewoonte om de gewoonte te maken om Java-opmerkingen in uw broncode te plaatsen om de leesbaarheid en duidelijkheid voor uzelf en andere programmeurs te verbeteren. Het is niet altijd meteen duidelijk wat een gedeelte van de Java-code uitvoert. Een paar verklarende regels kunnen de hoeveelheid tijd die nodig is om de code te begrijpen drastisch verminderen.

Hebben ze invloed op hoe het programma wordt uitgevoerd?

Opmerkingen over de implementatie in Java-code kunnen alleen door mensen worden gelezen. Java-compilers geven niet om hen en bij het compileren van het programma slaan ze ze gewoon over. De grootte en efficiëntie van uw gecompileerde programma worden niet beïnvloed door het aantal opmerkingen in uw broncode.

Opmerkingen over de implementatie

Opmerkingen over de implementatie zijn er in twee verschillende formaten:

Regel opmerkingen: Typ "//" voor een opmerking van één regel en volg de twee schuine strepen met uw opmerking. Bijvoorbeeld:
```
 // dit is een opmerking van één regel
int guessNumber = (int) (Math.random () * 10); 
```
Wanneer de compiler de twee schuine strepen tegenkomt, weet hij dat alles rechts ervan als een opmerking moet worden beschouwd. Dit is handig bij het debuggen van een stuk code. Voeg gewoon een opmerking toe uit een coderegel die u opspoort en de compiler ziet deze niet:
- ```
 // dit is een opmerking van één regel
// int guessNumber = (int) (Math.random () * 10); 
```
  U kunt ook de twee schuine strepen naar voren gebruiken om commentaar aan het einde van de regel te maken:
- ```
 // dit is een opmerking van één regel
int guessNumber = (int) (Math.random () * 10); // Een opmerking aan het einde van de regel 
```
Blok reacties: Typ "/ *" om een blokcommentaar te starten. Alles tussen de schuine streep en het sterretje, zelfs als het op een andere regel staat, wordt als een opmerking behandeld totdat de tekens "* /" de opmerking beëindigen. Bijvoorbeeld:
```
 /* deze
is
een
blok
commentaar
* /
/ * zo is dit * /
```

Javadoc-opmerkingen

Gebruik speciale Javadoc-opmerkingen om uw Java API te documenteren. Javadoc is een hulpmiddel bij de JDK dat HTML-documentatie genereert op basis van opmerkingen in broncode.

Een Javadoc-reactie in

.Java

bronbestanden zijn als volgt ingesloten in de syntaxis van begin en einde:

/ **

* /

. Elke opmerking hierin wordt voorafgegaan door een

Plaats deze opmerkingen direct boven de methode, klasse, constructor of elk ander Java-element dat u wilt documenteren. Bijvoorbeeld:

// myClass.java
/ **
* Maak hiervan een samenvattende zin die je klas beschrijft.
* Hier is nog een regel.
* /
openbaar klasse mijn klas

...

Javadoc bevat verschillende tags die bepalen hoe de documentatie wordt gegenereerd. Bijvoorbeeld de

@param

tag definieert parameters voor een methode:

 / ** hoofdmethode
* @param args String []
* /
openbaar statisch leegte main (String [] args)

System.out.println ("Hallo wereld!");

Veel andere tags zijn beschikbaar in Javadoc en het ondersteunt ook HTML-tags om de uitvoer te helpen controleren. Raadpleeg uw Java-documentatie voor meer informatie.

Tips voor het gebruik van opmerkingen

Geef geen commentaar. Elke regel van uw programma hoeft niet te worden uitgelegd. Als uw programma logisch stroomt en er niets onverwachts gebeurt, hoeft u geen commentaar toe te voegen.
Laat uw opmerkingen inspringen. Als de coderegel waarop u een opmerking plaatst, is ingesprongen, moet u ervoor zorgen dat uw opmerking overeenkomt met de inspringing.
Houd opmerkingen relevant. Sommige programmeurs zijn uitstekend in het aanpassen van code, maar vergeet om de een of andere reden de opmerkingen bij te werken. Als een opmerking niet meer van toepassing is, moet u deze wijzigen of verwijderen.

Geen nestreacties nesten. Het volgende resulteert in een compilerfout:

 /* deze
is
/ * Deze blokcommentaar voltooit de eerste reactie * /
een
blok
commentaar
* /

Wetenschap