Mga anotasyon sa Java

Noong 2005, sa pagdating ng Java 5, nakilala namin ang mga bagong entity na tinatawag na anotasyon.

Ang mga anotasyon ay isang espesyal na anyo ng syntactic metadata na maaaring ideklara sa code. Ginagamit ang mga ito upang pag-aralan ang code sa compilation o sa runtime. Maaari mong isipin ang isang anotasyon bilang isang label, tag, o pahiwatig ng compiler.

Marahil ay nakatagpo ka na ng mga anotasyon dati. Halimbawa, kapag na-override ang isang paraan ng parent class, isinusulat namin ang @Override bago ang mismong paraan. Isinasaad ng anotasyong ito na ang paraan ng magulang ay ma-o-override sa klase ng bata.

Syntax:

@Override
public int hashCode() {
      return super.hashCode();
}

Gusto kong tandaan kaagad na ang mga anotasyon ay hindi lamang nalalapat sa mga pamamaraan. Ginagamit ang mga ito sa mga pakete, klase, pamamaraan, field at parameter.

Upang maunawaan kung paano gumagana ang mga anotasyon, kilalanin muna natin ang konsepto ng interface ng marker. Mula nang dumating ang Java, ang mga developer ay palaging nangangailangan ng isang paraan upang markahan ang mga klase upang maisagawa ang ilang mga aksyon sa kanila.

Bago ang Java 5, gumamit sila ng interface na hindi ginawa ang inaasahan naming gawin ng mga interface. Wala itong mga pamamaraan at walang kontrata. Minarkahan lang nito ang isang klase bilang espesyal sa ilang paraan.

Ang ganitong interface ay tinatawag na marker interface. Mula sa pangalan maaari mong hulaan na ang layunin nito ay markahan ang mga klase para sa JVM, compiler, o ilang library. Ang ilang mga interface ng marker, tulad ng Serializable , ay nananatili. Ang interface ng marker na ito ay nagbibigay-daan sa amin na ipahiwatig na ang mga pagkakataon ng isang klase ay maaaring i-serialize.

Gaya ng nakita natin, patuloy na nabubuhay ang mga interface ng marker kahit na pagkatapos ng pagpapakilala ng mga anotasyon.

Mga anotasyon kumpara sa mga interface ng marker:

@MyAnnotation
public class MyClass {}

public class MyClass implements MarkerInterface {}

Ang parehong mga diskarte ay may parehong layunin, ngunit may isang malinaw na pagkakaiba sa kanilang pagpapatupad. Halimbawa, isaalang-alang ang isang interface at isang anotasyon na nagpapahiwatig na ang isang klase ay kabilang sa isang partikular na uri.

Kung gumagamit kami ng interface, minarkahan namin ang klase. Kung ginamit namin ito nang hindi tama at may naganap na error, matutuklasan namin ang problema sa compilation at hindi tatakbo ang program.

Sa mga anotasyon, ang lahat ay hindi gaanong simple: dito ang error ay makikita sa runtime, na nangangahulugang magsisimula ang programa, ngunit, hindi nakakagulat, hindi ito matatapos.

Tandaan na kung kailangan nating markahan ang isang klase para magamit sa hinaharap, ang mga pagkakataon nito ay dapat na maipasa sa isang partikular na paraan:

public class MyInteger implements Sum {}
interface Sum {};

public static void main(String[] args) throws IOException {
        increase(new MyInteger());
}

public static void increase(Sum count) {
        // TODO
}

Ang isang marker interface ay pinakamahusay na gumagana dito.

Pinakamainam na gumamit ng mga anotasyon kapag kailangan namin ng higit pa, gaya ng mga parameter na sinusuportahan ng mga anotasyon.

Tingnan natin ang karaniwang mga anotasyon sa JDK:

@Override
public int hashCode() {
        return super.hashCode();
}

@Deprecated
public abstract void method();

public class DocumentsFolder {
   private List documents;

   @SuppressWarnings("unchecked")
public void addDocument(String document) {
            documents.add(document);
   }
}

@SuppressWarnings({"unchecked", "deprecated"})