Newsgroup: it.comp.java
Titolo: elenco annotazioni @

Ciao a tutti e scusate per la domanda molto probabilmente idiota.
Visto che in questi giorni ho un pò di tempo libero mi volevo togliere
due sassiolini dalle scarpe e chiedervi:
- a che cosa servono le annotazioni (o almeno spero si chiamino così)
@ che netbeans mi aggiunge nel codice sopra ai metodi?
- ma c'entrano qualcosa con AOP?
- se il loro nome non è annotazioni sapreste dirmi come si chiamano?
Ciao
Marco

 - se il loro nome non č annotazioni sapreste dirmi come si chiamano?
Si chiamano annotazioni. Si chiamano cosě perché ti permettono di 
appiccicare una annotazione, una nota, un metadato, ad un elemento 
(metodo, classe, campo, o dichiarazione) definito con il linguaggio.
Esistono vari tipi di note. Quelle che rimangono appiccicate solo fino 
alla compilazione, quelle che rimangono appiccicate anche dopo la 
compilazione e vanno a finire nel class file, quelle che rimangono 
appiccicate fino a runtime.
Quelle usate dal compilatore credo che vengano scartate subito.
Quelle usate per esempio dalle librerie ORM come JPA rimangono 
appiccicate almeno fino al class file, non se rimangono appiccicate 
anche a runtime, forse sě.
-- 
Andrea Francia
http://www.andreafrancia.it/

 
Sono tag Javadoc che permettono attraverso commenti embedded nel codice 
dei sorgenti .java di produrre la documentazione delle tue classi nel 
formato standard della documentazione Java (analoga a quella ufficiale 
delle API e del linguaggio).
Qui trovi la documentazione su Javadoc:
http://java.sun.com/j2se/javadoc/index.jsp
-- 
Google Image Labeler cumulative score: 76770


vabbè questa domanda era un pò minchiona ma volevo essere sicuro che
si chiamassero in questo modo, così da poter cercare su google e non
trovare risultati fuffa...
Ciao grazie
Marco


Non č la stessa cosa di cui parlava l'OP le annotazioni sono un 
costrutto(si dice cosě?) aggiunto dal Java 1.5 in poi.
Per certi versi hanno ereditato qualcosa dai tag JavaDoc (ad esempio il 
carattere '@' e il compito di taggare i metodi deprecati) ma sono 
tutt'altra cosa.
Credo che cercando "java annotations" non dev'essere difficile 
imbattersi nella pagina sul sito della Sun che spiega tutte le cose 
nuove introdotte nella 1.5 tra cui le annotazioni.


Della seguente pagina di Sun 
http://java.sun.com/j2se/1.5.0/docs/guide/language/annotations.html
non mi è chiaro questo esempio...
    /**
     * Describes the Request-For-Enhancement(RFE) that led
     * to the presence of the annotated API element.
     */
    public @interface RequestForEnhancement {
        int    id();
        String synopsis();
        String engineer() default "[unassigned]";
        String date();    default "[unimplemented]";
    }
 ____________________________ FINE Interface
____________________________
// Metodo contenuto in una classe separata
    @RequestForEnhancement(
        id       = 2868724,
        synopsis = "Enable time-travel",
        engineer = "Mr. Peabody",
        date     = "4/1/3007"
    )
    public static void travelThroughTime(Date destination) { ... }
in questo caso @RequestForEnhancement è una particolare istanza
dell'interfaccia RequestForEnhancement che verrà ustilizzata
all'interno del metodo travelThroughTime(Date) ?
se si poi come potrei utilizzarla all'interno del metodo? Per usarla
devo lavorare via Reflection come nel programma di test presente come
ultimo esempio?
Riporto il programma di test per chi non riuscisse ad aprire la pagina
per un qualsiasi motivo
    public class Foo {
        @Test public static void m1() { }
        public static void m2() { }
        @Test public static void m3() {
            throw new RuntimeException("Boom");
        }
        public static void m4() { }
        @Test public static void m5() { }
        public static void m6() { }
        @Test public static void m7() {
            throw new RuntimeException("Crash");
        }
        public static void m8() { }
    }
 ____________________________ FINE Foo ____________________________
    import java.lang.reflect.*;
    public class RunTests {
       public static void main(String[] args) throws Exception {
          int passed = 0, failed = 0;
          for (Method m : Class.forName(args[0]).getMethods()) {
             if (m.isAnnotationPresent(Test.class)) {
                try {
                   m.invoke(null);
                   passed++;
                } catch (Throwable ex) {
                   System.out.printf("Test %s failed: %s %n", m,
ex.getCause());
                   failed++;
                }
             }
          }
          System.out.printf("Passed: %d, Failed %d%n", passed,
failed);
       }
    }
 ____________________________ FINE RunTest__________________________
Grazie 1000 ancora
Marco

Marco Capoferri ha scritto:
...per la serie...freghiamocene dei copyright!
-- 
Lucio Benfante
JUG Padova           
http://www.parancoe.org
 ...have a look at it!
www.jugpadova.it
 
http://www.jugevents.org

 ultimo esempio?
Boh? Io le annotazioni le uso da user, cioé le scrivo per spiegare cosa 
fare ai vari framework.
Per esempio li uso per definire un'entità, scrivo le mie brave 
annotazioni @Entity, @Id, @Column, etc.. e so che il mio motore JPA le 
capisce.
Il modo in cui hanno implementato il codice che legge le annotazioni mi 
importa relativamente.
A questo livello dovrebbe interessarti di piu' come utilizzare le 
annotazioni definite dalle varie librerie e lasciare la parte di capire 
come si leggono a quelli che scrivono librerie.
Comunque immagino proprio che sia necessario usare la reflection.
Ti consiglierei di partire a usare le annotazioni da utente dal punto 
pratico e passare solo successivamente alla teoria di come si dichiarano 
e come si leggono.
Le pagine sul sito della Sun spiegano della teoria che non è necessaria 
per utilizzare le annotazioni da utente e che in piu' è digeribile 
meglio quando le hai usate da utente.
Alcune tecnologie librerie in cui si usano le annotazioni e dove puoi 
imparare ad usarle da utente sono JPA, EJB-3.0, e junit 4.
-- 
Andrea Francia
http://andreafrancia.blogspot.com/2008/06/relazioni-molti-molti-con-jpa.html

 ultimo esempio?
Innanzitutto le annotation non vanno solitamente scritte da te, ma
dagli sviluppatori di framework. Solitamente eh.
Anzi qualche libreria, come Spring, puo' suggerire come pratica di
programmazione la creazione di proprie annotazioni, ma rientrano in un
contesto ben preciso e soprattutto la lettura delle stesse avviene per
mezzo delle utility fornite da Spring stesso.
Leggere le annotation presenti nelle classi non e' affatto banale, a
meno che tu non stia configurando da qualche parte quali sono le
classi annotate. Altrimenti ti devi passare tutto il classpath, e
questa non e' un'operazione semplice.
Concludendo se non stai sviluppando qualche libreria o framework puoi
tranquillamente tralasciare questi aspetti, e usarle. Usarle e'
semplice (anzi di piu') quando configurare un XML, non c'e' niente da
imparare.


Per la serie non mi sembra proprio di essermene fregato del
copyright... visto che ho semplicemente riportato degli esempi
riportati su una pagina internet pubblica.
e che pagina visto che è della guida Sun sul JDK 1.5......
Le mie sono solo delle domande per capire come funziona un costrutto,
se così si possono definire le annotazioni,
Dimmi dove secondo te avrei violato dei copyright che contatto
l'autore e gli pago le royalties! :D
Ciao Marco


La mia idea è capire a cosa servono e come si usano, magari + avanti
potrebbero servirmi. La mia è solo una curiosità, voglia di conoscere.
Nulla di più.
Nel breve periodo non ho intenzione di mettermi a scrivere dei
framework, oltre al fatto che non avrei il tempo ma poi ce ne sono in
giro talemtne tanti e molti veramente ben fatti per cui perchè usare
energie per reinventare la ruota???
Ciao Marco


Credo che sia perché dato che la pagina in fondo riporta una nota di 
copyright che dice che tutti i diritti sono riservati vuol dire che non 
puoi riprodurla in tutto o in parte.


Marco Capoferri ha scritto:

In fondo alla pagina c'è scritto:
Copyright © 2004 Sun Microsystems, Inc.  All Rights Reserved.
All significa...All!
Sempre rimanendo in tema di "all" :), tu hai praticamente riportato 
TUTTO (e sottolineo tutto, non si è trattato di una semplice citazione) 
il codice da una pagina pubblica coperta da copyright ad una altra 
"pagina" pubblica...se non è violazione questa. E' come mettersi a 
distribuire fotocopie di un libro per strada.
"pubblico" non significa che chiunque può prenderselo e usarlo come gli 
pare...anche se guardando per strada si potrebbe avere questa 
impressione per le cose pubbliche. :)
...comunque siamo OT e la smetterei qui, tanto ormai quel che è fatto è 
fatto.



Ha pero' detto all'inizio del post che quel codice proviene dal link
tal dei tali.
Se si puo' mettere il link perche' non si puo' mettere il contenuto?
La cosa mi sembra strana e colma di contraddizioni.

chiedo venia, non avevo letto l'ultimissima riga.


Perché il diritto di autore è così.


 chiedo venia, non avevo letto l'ultimissima riga.
Che ti frega l'unica parte "lesa" e la Sun e sicuramente non gliene 
frega niente.



Non si sa mai chi legge :D

 
Ti sbagli, di solito le ditte statunitensi (e Sun in particolare) sono 
molto attente alle violazioni di copyright, dato che la legge 
statunitense prevede che se il detentore di un copyright non fa valere i 
suoi diritti, automaticamente quei diritti li perde.
Comunque non credo che a qualcuno in Sun interessi molto dei diritti su 
quella singola pagina....ma in generale non č cosě: vedi conferenze che 
cambiano nome perché non possono usare il nome Java, o altro.


 cambiano nome perché non possono usare il nome Java, o altro.
Come quelle che fa il JUG?


 Come quelle che fa il JUG?
Ad esempio JavaPolis, che da quest'anno si chiamerà Javoxx 
(
www.javoxx.com
)...e JavaPolis/Javoxx è organizzata da un JUG.
