Mga Komento sa Java

Ang mga komento ay bahagi ng isang programa na hindi naisakatuparan. Binabalewala lang ng compiler ang mga komento dahil hindi nila inilaan para dito. Ang mga ito ay nakasulat sa "tao" na wika at nilayon upang ipaliwanag ang programa, bahagi ng programa, isang linya o pamamaraan para sa mga developer o mga taong kasangkot sa pagbuo. Kadalasan, ang mga komento ay nakasulat sa Ingles, ito ay uri ng isang tradisyon. Sa artikulong ito, pag-uusapan natin ang tungkol sa mga komento sa Java at kung paano gamitin ang mga ito nang tama upang gawing mas madali ang buhay para sa iyo at sa iyong mga kasamahan sa koponan.

Mga Komento sa Java: bakit sila mahalaga

Sinasabi nila na ang mga programmer ay labis na tamad pagdating sa pagkomento sa kanilang sariling code. Gayunpaman, ito ay isang napakahalagang kasanayan, kaya huwag maliitin ito, kahit na nagsisimula ka pa lamang matuto ng Java. Ang code na may mahusay na komento ay mas mahalaga kaysa sa code na walang mga komento dahil ang naturang programa ay mas madaling mapanatili. Dahil ang malalaking proyekto ay kadalasang nakasulat sa Java, ang karampatang pagkomento ay nagpapabilis din ng pag-unlad, dahil mas madali para sa isang programmer na harapin ang code ng ibang tao. Kinakailangan ang mga komento upang:

Intindihin ang code. Sa iyo o sa ibang tao. Kung sa tingin mo ay hindi mo kailangang tukuyin ang sarili mong code dahil sinulat mo ito, subukang magbukas ng medyo kumplikadong programa na isinulat mo noong nakaraang buwan o mas maaga pa at mabilis na maunawaan kung ano, saan at bakit ang nasa isip mo. Maaaring gamitin ang mga komento upang ipaliwanag ang lohika ng isang programa o block ng isang programa, pati na rin ang mga rekomendasyon para sa mga taong gagana sa iyong code sa ibang pagkakataon. Ang ganitong uri ng komento ay maaaring tawaging paliwanag.
Naglalaman ng impormasyon tungkol sa layunin ng mga bagay, input at output parameter (kung mayroon), data tungkol sa developer, at iba pang mahahalagang bagay na nauugnay sa fragment ng code. Ang mga nasabing komento ay matatagpuan sa mga header ng mga module, library, procedure, at function. Maaari silang tawaging mga komento sa dokumentasyon.
Kontrolin ang mga bug at pagbutihin ang code. Ang kaduda-dudang code o code na nangangailangan ng pagpapabuti ay maaaring palaging ikomento at muling bisitahin sa ibang pagkakataon. Kung nangyari sa iyo na ang isang tiyak na problema ay maaaring malutas sa ibang paraan, ngunit ngayon ay wala kang oras para dito, isulat ang ideyang ito sa komento. Kung hindi man, malamang, sa ilalim ng presyon ng bagong code, malilimutan mo ito.

Mga uri ng komento sa Java

Sa kabila ng katotohanan na maaari kang magsulat ng anuman at lahat sa mga komento, may ilang mga uri ng mga komento sa Java at mga panuntunan para sa paggamit ng mga ito. Sa mga komento ng Java malamig ay:

Mga komento sa isang linya
Mga komento sa maraming linya
Mga komento sa dokumentasyon

Mga komento sa isang linya

Ang pinakakaraniwang mga komento sa Java ay mga solong linyang komento. Upang ipahiwatig ang gayong komento, sapat na maglagay ng dobleng slash bago ang teksto // . Ang mga komento sa isang linya ay na-flag lamang sa simula ng komento. Patuloy ang komento hanggang sa dulo ng linya. Syntax:

//here is a single line comment.

Kumuha tayo ng isang halimbawa ng ganitong uri ng mga komento sa Java:

public class CommentsDemo1 {
   public static void main(String[] args) {
       System.out.println("This text is visible for Java compiler");
       //this text is single line comment
//This one is also single line comment
//they both (and me) are invisible for compiler
   }
}

Ang output ay:

Ang tekstong ito ay makikita para sa Java compiler

Karaniwan ang isang solong linya na komento ay matatagpuan sa itaas o sa ibaba ng nagkomento na lugar sa programa, paminsan-minsan sa parehong linya. Mahalagang malinaw sa paningin kung ano ang tinutukoy ng komento.

Mga Multi-line na Komento

Minsan walang sapat na isang linya para magsulat ng komento sa Java. Halimbawa, kailangan mong ilarawan kung paano gumagana ang isang pamamaraan o isang kumplikadong formula na iyong ipinapatupad. Sa kasong ito, maaari kang magsulat ng ilang single-line na komento, ngunit magiging mas makatwiran na magsulat ng tinatawag na multi-line na komento. Ang mga ito ay minarkahan sa magkabilang panig ng mga simbolo /* */ . Syntax ng mga multi-line na komento:

/*This comment
is
Multi line comment
we can describe here
what we need */

Magkaroon tayo ng isang halimbawa ng mga multi-line na komento sa code

public class RleTest {

   /*
   Run Length Encoding (RLE),  a data compression algorithm
   that replaces repeated characters (series)
   with one character and the number of its repetitions.

   this method is to decode a String using run-length encoding

    */
   private static String decodeRle(String encoded) {
       if (encoded.isBlank()) return "";
       StringBuilder result = new StringBuilder();
       int count = 0;
       char baseChar = encoded.charAt(0);
       for (int i = 1; i <= encoded.length(); i++) {
           char c = i == encoded.length() ? '$' : encoded.charAt(i);
           if (Character.isDigit(c)) {
               count = count * 10 + Character.digit(c, 10);
           } else {
               do {
                   result.append(baseChar);
                   count--;
               } while (count > 0);
               count = 0;
               baseChar = c;
           }
       }
       return result.toString();
   }
   public static void main(String[] args) {
       System.out.println(decodeRle("C3ecddf8"));
   }
}

Mga Komento sa Dokumentasyon ng Java

Ito ay isang espesyal na uri ng mga komento sa Java na ginagamit upang bumuo ng isang pahina ng dokumentasyon. Karaniwang nagsusulat ang mga developer ng mga komento sa dokumentasyon gamit ang Javadoc, isang generator ng dokumentasyon para sa pagbuo ng dokumentasyon ng API sa format na HTML mula sa source code ng Java. Ang format ng mga dokumentong ginagamit ng Javadoc ay ang pamantayan ng industriya para sa pagdodokumento ng mga klase ng Java at ang pinakasikat na mga IDE tulad ng IntelliJ IDEA at Eclipse, ay awtomatikong bumubuo ng Javadoc HTML. Ang mga komento sa dokumentasyon ng Java ay may syntax sa ibaba:

/**
Some important Javadoc comments here
You don’t know it yet, but Javadoc rulez

@author  Java Developer
*/

Narito ang isang halimbawa: ito ay isang fragment ng Java Short class. Sa pamamagitan ng paraan, maaari mong tingnan ang anumang Java class code mula sa iyong IDE (halimbawa sa IntelliJ IDEA mula sa Windows pindutin lamang ang ctrl+LBM o ctrl + b (sa Windows) sa anumang pangalan ng klase o pamamaraan).

package java.lang;

import jdk.internal.HotSpotIntrinsicCandidate;
import jdk.internal.misc.VM;

/**
* The {@code Short} class wraps a value of primitive type {@code
* short} in an object.  An object of type {@code Short} contains a
* single field whose type is {@code short}.
*
* <p>In addition, this class provides several methods for converting
* a {@code short} to a {@code String} and a {@code String} to a
* {@code short}, as well as other constants and methods useful when
* dealing with a {@code short}.
*
* @author  Nakul Saraiya
* @author  Joseph D. Darcy
* @see     java.lang.Number
* @since   1.1
*/
public final class Short extends Number implements Comparable<Short> {

   /**
    * A constant holding the minimum value a {@code short} can
    * have, -2<sup>15</sup>.
    */
   public static final short   MIN_VALUE = -32768;

   /**
    * A constant holding the maximum value a {@code short} can
    * have, 2<sup>15</sup>-1.
    */
   public static final short   MAX_VALUE = 32767;

   /**
    * The {@code Class} instance representing the primitive type
    * {@code short}.
    */
   @SuppressWarnings("unchecked")

Narito ang Java code ng kilalang-kilala at minamahal ng lahat ng mga newbies println() na pamamaraan na may ganitong komento:

/**
* Prints a String and then terminate the line.  This method behaves as
* though it invokes {@link #print(String)} and then
* {@link #println()}.
*
* @param x  The {@code String} to be printed.
*/
public void println(String x) {
   if (getClass() == PrintStream.class) {
       writeln(String.valueOf(x));
   } else {
       synchronized (this) {
           print(x);
           newLine();
       }
   }
}

May ilang espesyal na Javadoc tag ang Javadoc na may markang @ na makikita mo sa code sa itaas. Ang halimbawa ng naturang Javadoc tag ay @author na nagdaragdag ng pangalan ng may-akda ng klase. Ang isa pang Javadoc tag ay @dahil nagdagdag ito ng komentong nagsasaad na ang klase na ito ay ginagamit mula noong tinukoy na bersyon ng Java. Ang pagsulat ng magagandang dokumento ng Javadoc ay nangangailangan ng kaalaman at karanasan (at pasensya!). Makakahanap ka ng higit pang impormasyon sa Javadoc sa opisyal na dokumentasyong Paano Sumulat ng Mga Komento ng Doc para sa Javadoc Tool .

PS ilang nakakatawang mga halimbawa ng komento mula sa totoong buhay

/**
*Dear Maintainer
*
*Once you are done trying to 'optimize' this routine,
*and you have realized what a terrible mistake that was,
*please increment the following counter as a warning
*to the next guy.
*
*total_hours_wasted_here = 73
*/

Exception up = new Exception("Something is really wrong.");
throw up;  //ha ha

// When I wrote this, only God and I understood what I was doing
// Now, God only knows

// sometimes I believe compiler ignores all my comments

/**
Always returns true.
*/
public boolean isAvailable() {
return false;
}

Upang palakasin ang iyong natutunan, iminumungkahi naming manood ka ng isang video lesson mula sa aming Java Course