Il Nuovo Java - Claudio De Sio Cesari

Esercizi

Home
Esercizi del capitolo 11 e dell'appendice E

Capitolo 11 e dell'appendice E
`Tipi Annotazioni, Reflection e la variabile d'ambiente CLASSPATH`

Con questi esercizi cercheremo di capire cosa significa sfruttare le annotazioni. Creeremo un'annotazione da zero, la sfrutteremo con un'applicazione creata ad hoc. Creeremo un verificatore di codice, che in base a delle annotazioni deciderà se le nostre classi rispettano determinati requisiti. Poi seguiranno anche tanti altri esercizi che supportano la preparazione alla certificazione, con quiz a risposta multipla. Dedicheremo alcuni esercizi anche agli altri argomenti del capitolo come la reflection, e alla variabile classpath introdotta nell'appendice E (questi hanno una numerazione diversa che inizia con la lettera E).

Di seguito trovate gli esercizi del capitolo. Per ogni esercizio, cliccando sulla traccia potete vedere la relativa soluzione.
Gli esercizi caratterizzati dall'icona sono considerati i più complessi relativamente agli argomenti trattati.
Se preferite lavorare offline, è possibile scaricare tutti gli esercizi e le relative soluzioni in formato PDF nella sezione download.

Esercizio 11.a) Annotazioni, dichiarazioni ed uso, Vero o Falso:
1. Un'annotazione è un modificatore.
2. Un'annotazione è un'interfaccia.
3. Gli elementi di un'annotazione sembrano metodi astratti ma sottintendono un'implementazione implicita.
4. La seguente è una dichiarazione di annotazione valida:
```
public @interface MiaAnnotazione {
    void metodo();
}
```
5. La seguente è una dichiarazione di annotazione valida:
```
public @interface MiaAnnotazione {
    int metodo(int valore) default 5;
}
```
6. La seguente è una dichiarazione di annotazione valida:
```
public @interface MiaAnnotazione {
    int metodo() default -99;
    enum MiaEnum{VERO, FALSO};
    MiaEnum miaEnum();
}
```
7. Supponiamo che l'annotazione MiaAnnotazione definita nel punto 6 sia corretta. Con il seguente codice essa viene utilizzata correttamente:
```
public @MiaAnnotazione (
    MiaAnnotazione.MiaEnum.VERO
)
MiaAnnotazione.MiaEnum m() {
    return MiaAnnotazione.MiaEnum.VERO;
}
```
8. Supponiamo che l'annotazione MiaAnnotazione definita nel punto 6 sia corretta. Con il seguente codice essa viene utilizzata correttamente:
```
public @MiaAnnotazione (
    miaEnum=MiaAnnotazione.MiaEnum.VERO
)
MiaAnnotazione.MiaEnum m() {
    return @MiaAnnotazione.miaEnum;
}
```
9. Consideriamo la seguente annotazione:
```
public @interface MiaAnnotazione {
    int valore();
}
```
con il seguente codice essa viene utilizzata correttamente:
```
public @MiaAnnotazione (
    5
)
void m()
    //...
}
```
10. Consideriamo la seguente annotazione:
```
public @interface MiaAnnotazione {}
```
con il seguente codice essa viene utilizzata correttamente:
```
public @MiaAnnotazione void  m() {
    //...
}
```
Soluzione

1. Falso, è un tipo annotazione.
2. Falso, è un tipo annotazione.
3. Vero.
4. Falso, un elemento di un'annotazione non può avere come tipo void.
5. Falso, un metodo di un'annotazione non può avere parametri in input.
6. Vero.
7. Falso, infatti è legale sia il codice del metodo m(), sia dichiarare public prima dell'annotazione (ma ovviamente è un modificatore del metodo). Non è legale però passare in input all'annotazione il valore MiaAnnotazione.MiaEnum.VERO senza specificare una sintassi del tipo chiave = valore.
8. Falso, infatti la sintassi:
```
return @MiaAnnotazione.MyEnum;
```
non è valida. Non si può utilizzare un'annotazione come se fosse una classe con variabili statiche pubbliche.
9. Falso, infatti l'annotazione in questione non è a valore singolo, perché il suo unico elemento non si chiama value.
10. Vero.
Esercizio 11.b) Annotazioni e libreria, Vero o Falso:
1. La seguente annotazione è anche una meta-annotazione:
```
public @interface MiaAnnotazione ()
```
2. La seguente annotazione è anche una meta-annotazione:
```
@Target (ElementType.SOURCE)
public @interface MiaAnnotazione()
```
3. La seguente annotazione è anche una meta-annotazione:
```
@Target (ElementType.@INTERFACE)
public @interface MiaAnnotazione()
```
4. La seguente annotazione, se applicata ad un metodo, sarà documentata nella relativa documentazione Javadoc:
```
@Documented
@Target
(ElementType.ANNOTATION_TYPE)
public @interface MiaAnnotazione()
```
5. La seguente annotazione sarà ereditata se e solo se applicata ad una classe:
```
@Inherited
@Target (ElementType.METHOD)
public @interface MiaAnnotazione()
```
6. Per la seguente annotazione è anche possibile creare un processore di annotazioni che riconosca al runtime il tipo di annotazione, per implementare un particolare comportamento:
```
@Documented
@Target (ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MiaAnnotazione()
```
7. Override è un'annotazione standard per segnalare al runtime di Java che un metodo effettua l'override di un altro.
8. Deprecated può essere considerata anche una meta-annotazione perché applicabile ad altre annotazioni.
9. SuppressWarnings è una annotazione a valore singolo. Deprecated e Override invece sono entrambe annotazioni marcatrici.
10. Non è possibile utilizzare contemporaneamente le SuppressWarnings, Deprecated e Override su di un'unica classe.
Soluzione

1. Vero, infatti se non si specifica con la meta-annotazione Target quali sono gli elementi a cui è applicabile l'annotazione in questione, l'annotazione sarà di default applicabile a qualsiasi elemento tranne tipi parametro e uso dei tipi.
2. Falso, il valore ElementType.SOURCE non esiste.
3. Falso, il valore ElementType.@INTERFACE non esiste.
4. Falso, non è neanche applicabile a metodi per via del valore di Target, che è ElementType.ANNOTATION_TYPE.
5. Falso, infatti non può essere applicata ad una classe se è annotata con @Target(ElementType.METHOD).
6. Vero.
7. Falso, al compilatore, non al runtime.
8. Vero.
9. Vero.
10. Vero, Override non è applicabile a classi.

Esercizio 11.c)

Creare un'annotazione marcatrice per classi, di nome Breve, che deve essere usata per marcare classi che non hanno più di tre metodi. Questa annotazione deve appartenere ad un package metadati. Poi creare due classi ClasseBreve e ClasseLunga, la prima con un solo metodo, e l'altra con quattro metodi. Annotiamo entrambe le classi con Breve, e facciamole appartenere ad un package dati. Creiamo anche un'eccezione che chiameremo AnnotationException da far scattare quando una classe non rispetta la specifica dell'annotazione, che deve appartenere al package eccezioni.

Soluzione

Il listato dell'annotazione Breve dovrebbe essere simile al seguente:

package metadati;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface Breve {
}

Si noti che per i nostri scopi abbiamo dovuto specificare il livello di Retention a RetentionPolicy.RUNTIME.
La classe ClasseBreve potrebbe invece essere modificata nel seguente modo:

package dati;

import metadati.Breve;

@Breve
public class ClasseBreve {
    public void metodo1() {
        System.out.println("metodo1");
    }
}

La classe ClasseLunga invece, potrebbe essere simile alla seguente:

package dati;

import metadati.Breve;

@Breve
public class ClasseLunga {
    public void metodo1() {
        System.out.println("metodo1");
    }
    public void metodo2() {
        System.out.println("metodo2");
    }
    public void metodo3() {
        System.out.println("metodo3");
    }
    public void metodo4() {
        System.out.println("metodo4");
    }
}

Infine ecco l'eccezione richiesta:

package eccezioni;

public class AnnotationException extends Exception {
    public AnnotationException(String msg) {
        super(msg);
    }

    @Override
    public String toString() {
        return "AnnotationException{" + getMessage() + "}";
    }
}

Esercizio 11.d)

Creare una classe VerificatoreInterattivo che contiene un metodo main che verifica se una classe specificata al runtime tramite l'utilizzo di una classe Scanner (già incontrata in precedenti esercizi) e annotata con Breve, soddisfa il requisito che abbiamo specificato nell'esercizio 11.c. Ovvero deve essere possibile specificare una classe, battere il tasto Invio e il programma deve stampare se la verifica è andata a buon fine o un eventuale messaggio di errore. Questa classe deve appartenere ad un package chiamato test.

Soluzione

Il listato del verificatore richiesto potrebbe essere il seguente:

package test;

import eccezioni.AnnotationException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.Scanner;
import metadati.Breve;

public class VerificatoreInterattivo {

    public static void main(String args[]) {
        Scanner scanner = new Scanner(System.in);
        String stringa = "";
        System.out.println("Digita il nome di un file java presente nella "
          + " cartella corrente e batti enter, oppure scrivi \"fine\" "
          + "per terminare il programma");
        while (!(stringa = scanner.next()).equals("fine")) {
            System.out.println("Hai digitato " + stringa.toUpperCase() + "!");
            try {
                verificaClasse(stringa);
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
        System.out.println("Fine programma!");
    }

    private static void verificaClasse(String stringa) throws Exception {
        Class objectClass = Class.forName(stringa);
        try {
            System.out.println("Inizio verifica annotazione @Breve per " +
              stringa);
            Annotation breve = objectClass.getAnnotation(Breve.class);
            if (breve != null) {
                Method[] methods = objectClass.getDeclaredMethods();
                final int numeroMetodi = methods.length;
                if (numeroMetodi > 3) {
                    throw new AnnotationException("Ci sono " + numeroMetodi
                      + " metodi nella classe " + stringa);
                }
                System.out.println("Classe " + stringa +
                  " corretta!\nlista metodi:");
                for (Method method : methods) {
                    System.out.println(method);
                }
            } else {
                System.out.println("Questa classe non è annotata con @Breve");
            }
        } finally {
            System.out.println("Fine verifica annotazione @Breve per " +
              stringa);
        }
    }
}

In pratica si tratta solo di concentrarsi sul metodo


                            verificaClasse

, il cui codice è comunque molto intuitivo.
Il seguente output viene prodotto specificando prima le due classi davvero annotate con @Breve, poi una che non è annotata (la classe AnnotationException) e infine una classe inesistente:

Digita il nome di un file java presente nella  cartella corrente e 
 batti enter, oppure scrivi "fine" per terminare il programma
dati.ClasseBreve
Hai digitato DATI.CLASSEBREVE!
Inizio verifica annotazione @Breve per dati.ClasseBreve
Classe dati.ClasseBreve corretta!
lista metodi:
public void dati.ClasseBreve.metodo1()
public void dati.ClasseBreve.setVariabile(java.lang.String)
public java.lang.String dati.ClasseBreve.getVariabile()
Fine verifica annotazione @Breve per dati.ClasseBreve
dati.ClasseLunga
Hai digitato DATI.CLASSELUNGA!
Inizio verifica annotazione @Breve per dati.ClasseLunga
Fine verifica annotazione @Breve per dati.ClasseLunga
AnnotationException{Ci sono 4 metodi nella classe dati.ClasseLunga}
	at
  test.VerificatoreInterattivo.verificaClasse(
  VerificatoreInterattivo.java:37)
	at
  test.VerificatoreInterattivo.main(VerificatoreInterattivo.java:20)

eccezioni.AnnotationException
Hai digitato ECCEZIONI.ANNOTATIONEXCEPTION!
Inizio verifica annotazione @Breve per eccezioni.AnnotationException
Questa classe non è annotata con @Breve
Fine verifica annotazione @Breve per eccezioni.AnnotationException

ClasseInesistente
Hai digitato CLASSEINESISTENTE!
java.lang.ClassNotFoundException: ClasseInesistente
	at java.net.URLClassLoader$1.run(URLClassLoader.java:372)
	at java.net.URLClassLoader$1.run(URLClassLoader.java:361)
	at java.security.AccessController.doPrivileged(Native Method)
	at java.net.URLClassLoader.findClass(URLClassLoader.java:360)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
	at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:308)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
	at java.lang.Class.forName0(Native Method)
	at java.lang.Class.forName(Class.java:259)
	at test.VerificatoreInterattivo.verificaClasse(
  VerificatoreInterattivo.java:29)
	at
  test.VerificatoreInterattivo.main(VerificatoreInterattivo.java:20)

Esercizio 11.e)

Creare un'annotazione a valore unico di nome Specifica, che deve essere usata per marcare le classi che hanno un numero preciso di variabili d'istanza. Inserire anche questa annotazione nel package metadati. Usare anche questa annotazione per le classi ClasseBreve e ClasseLunga, che per l'occasione dichiareranno delle variabili d'istanza. In particolare ClasseBreve dichiarerà una variabile d'istanza incapsulata, mentre ClasseLunga dichiarerà due variabili d'istanza non incapsulate.

Soluzione

Il listato dell'annotazione Specifica dovrebbe essere il seguente:

package metadati;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface Specifica {
    int value();
}

Il listato delle classi ClasseBreve e ClasseLunga potrebbe essere modificato come segue:

package dati;

import metadati.Breve;
import metadati.Specifica;

@Breve
@Specifica(1)
public class ClasseBreve {

    public void metodo1() {
        System.out.println("metodo1");
    }
    private String variabile;

    public String getVariabile() {
        return variabile;
    }

    public void setVariabile(String variabile) {
        this.variabile = variabile;
    }
}

package dati;

import metadati.Specifica;

@Breve
@Specifica(3)
public class ClasseLunga {

    public String variabile1;
    public String variabile2;

    public void metodo1() {
        System.out.println("metodo1");
    }

    public void metodo2() {
        System.out.println("metodo2");
    }

    public void metodo3() {
        System.out.println("metodo3");
    }

    public void metodo4() {
        System.out.println("metodo4");
    }
}

Esercizio 11.f)

Modificare la classe VerificatoreInterattivo affinché verifichi la correttezza dell'utilizzo dell'annotazione Specifica come fatto per l'annotazione Breve.

Soluzione

Modifichiamo il codice del nostro verificatore, estraendo come metodo il codice di verifica dell'annotazione Breve, e commentandone la chiamata. Creiamo un equivalente metodo per verificare l'annotazione Specifica. Di seguito riportiamo solo il codice modificato:

    private static void verificaClasse(String stringa) throws Exception {
        Class objectClass = Class.forName(stringa);
        //verificaBreve(stringa, objectClass);
        verificaSpecifica(stringa, objectClass);
    }

    private static void verificaBreve(String stringa, Class objectClass) throws
      AnnotationException {
        try {
            System.out.println("Inizio verifica annotazione @Breve per " +
              stringa);
            Annotation breve = objectClass.getAnnotation(Breve.class);
            if (breve != null) {
                Method[] methods = objectClass.getDeclaredMethods();
                final int numeroMetodi = methods.length;
                if (numeroMetodi > 3) {
                    throw new AnnotationException("Ci sono " + numeroMetodi
                      + " metodi nella classe " + stringa);
                }
                System.out.println("Classe " + stringa +
                  " corretta!\nlista metodi:");
                for (Method method : methods) {
                    System.out.println(method);
                }
            } else {
                System.out.println("Questa classe non è annotata con @Breve");
            }
        } finally {
            System.out.println("Fine verifica annotazione @Breve per " +
              stringa);
        }
    }

    private static void verificaSpecifica(String stringa, Class objectClass)
      throws AnnotationException {
        try {
            System.out.println("Inizio verifica annotazione @Specifica per "
              + stringa);
            Specifica specifica = (Specifica)objectClass.getAnnotation(
              Specifica.class);
            if (specifica != null) {
                int numeroVariabiliDaSpecifica = specifica.value();
                Field[] fields = objectClass.getDeclaredFields();
                final int numeroVariabili = fields.length;
                if (numeroVariabili != numeroVariabiliDaSpecifica) {
                    throw new AnnotationException("Ci sono " + numeroVariabili
                      + " variabili nella classe " + stringa +
                      " ma dovrebbero essere " +
                      numeroVariabiliDaSpecifica);
                }
                System.out.println("Classe " + stringa +
                  " corretta!\nlista variabili:");
                for (Field field : fields) {
                    System.out.println(field);
                }
            } else {
                System.out.println(
                  "Questa classe non è annotata con @Specifica");
            }
        } finally {
            System.out.println("Fine verifica annotazione @Breve per " +
              stringa);
        }
    }

Ecco un esempio di output:

Digita il nome di un file java presente nella cartella corrente e 
  batti enter, oppure scrivi "fine" per terminare il programma
dati.ClasseBreve
Hai digitato DATI.CLASSEBREVE!
Inizio verifica annotazione @Specifica per dati.ClasseBreve
Classe dati.ClasseBreve corretta!
lista variabili:
private java.lang.String dati.ClasseBreve.variabile
Fine verifica annotazione @Breve per dati.ClasseBreve
dati.ClasseLunga
Hai digitato DATI.CLASSELUNGA!
Inizio verifica annotazione @Specifica per dati.ClasseLunga
Fine verifica annotazione @Breve per dati.ClasseLunga
AnnotationException{Ci sono 2 variabili nella classe dati.ClasseLunga 
  ma dovrebbero essere 3}
	at
  test.VerificatoreInterattivo.verificaSpecifica(
  VerificatoreInterattivo.java:69)
	at
  test.VerificatoreInterattivo.verificaClasse(
  VerificatoreInterattivo.java:33)
	at
  test.VerificatoreInterattivo.main(VerificatoreInterattivo.java:22)

Esercizio 11.g)

Creare un'annotazione completa di nome Bean, che deve essere usata per marcare le classi che hanno un costruttore senza parametri, le variabili incapsulate, un numero di metodi non superiore a un numero da specificare, e un numero di variabili non inferiore a un numero da specificare. Inserire anche questa annotazione nel package metadati. Usare anche questa annotazione per le classi ClasseBreve e ClasseLunga.

Soluzione

Il listato dell'annotazione Bean potrebbe essere il seguente:

package metadati;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface Bean {
    int numeroMassimoMetodi();
    int numeroMinimoVariabili();
}

Il listato delle classi ClasseBreve e ClasseLunga potrebbe essere modificato come segue:

package dati;

import metadati.Bean;
import metadati.Breve;
import metadati.Specifica;

@Breve
@Specifica(1)
@Bean(numeroMassimoMetodi = 10, numeroMinimoVariabili = 1)
public class ClasseBreve {

    public void metodo1() {
        System.out.println("metodo1");
    }

    private String variabile;

    public String getVariabile() {
        return variabile;
    }

    public void setVariabile(String variabile) {
        this.variabile = variabile;
    }
}

package dati;

import metadati.Bean;
import metadati.Breve;
import metadati.Specifica;

@Breve
@Specifica(3)
@Bean(numeroMassimoMetodi = 10, numeroMinimoVariabili = 1)
public class ClasseLunga {

    public String variabile1;
    public String variabile2;

    public void metodo1() {
        System.out.println("metodo1");
    }

    public void metodo2() {
        System.out.println("metodo2");
    }

    public void metodo3() {
        System.out.println("metodo3");
    }

    public void metodo4() {
        System.out.println("metodo4");
    }
}

Esercizio 11.h)

Modificare la classe VerificatoreInterattivo affinché verifichi la correttezza dell'utilizzo dell'annotazione Bean come fatto per l'annotazione Breve e l'annotazione Specifica.

Soluzione

Modifichiamo il codice del nostro verificatore e, sul modello della soluzione dell'esercizio 11.f, creiamo un metodo per verificare l'annotazione Bean. Di seguito riportiamo solo il codice modificato:

    private static void verificaClasse(String stringa) throws Exception {
        Class<?> objectClass = Class.forName(stringa);
        //verificaBreve(stringa, objectClass);
        //verificaSpecifica(stringa, objectClass);
        verificaBean(stringa, objectClass);
    }

    private static void verificaBean(String stringa, Class<?> objectClass)
            throws AnnotationException {
        try {
            System.out.println("Inizio verifica annotazione @Bean per "
                    + stringa);
            Bean bean = objectClass.getAnnotation(Bean.class);
            if (bean != null) {
                controlloNumeroVariabili(bean, objectClass, stringa);
                controlloNumeroMetodi(bean, objectClass, stringa);
                controlloCostruttoreSenzaParametro(objectClass, stringa);
                controlloIncapsulamento(objectClass, stringa);
            } else {
                System.out.println("Questa classe non è annotata con @Bean");
            }
        } finally {
            System.out.println("Fine verifica annotazione Bean per " + stringa);
        }
    }

    private static void controlloNumeroVariabili(Bean bean, Class<?>
            objectClass, String stringa) throws AnnotationException {
        int numeroMinimoVariabili = bean.numeroMinimoVariabili();
        Field[] fields = objectClass.getDeclaredFields();
        final int numeroVariabili = fields.length;
        if (numeroVariabili < numeroMinimoVariabili) {
            throw new AnnotationException("Ci sono " + numeroVariabili
                    + " variabili nella classe " + stringa
                    + " ma dovrebbero essere almeno " + numeroMinimoVariabili);
        }
        System.out.println("Classe " + stringa +
            " numero variabili ok!\nlista variabili:");
        for (Field field : fields) {
            System.out.println(field);
        }
    }

    private static void controlloNumeroMetodi(Bean bean, Class<?> objectClass,
            String stringa) throws AnnotationException {
        int numeroMassimoMetodi = bean.numeroMassimoMetodi();
        Method[] methods = objectClass.getDeclaredMethods();
        final int numeroMetodi = methods.length;
        if (numeroMetodi > numeroMassimoMetodi) {
            throw new AnnotationException("Ci sono " + numeroMetodi
                    + " metodi nella classe " + stringa
                    + " ma dovrebbero essere al massimo "
                    + numeroMassimoMetodi);
        }
        System.out.println("Classe " + stringa +
            " numero metodi ok!\nlista metodi:");
        for (Method method : methods) {
            System.out.println(method);
        }
    }

    private static void controlloCostruttoreSenzaParametro(Class<?> objectClass,
            String stringa) throws AnnotationException {
        try {
            Constructor<?> constructor = objectClass.getConstructor();
            System.out.println("Classe " + stringa
                    + " costruttore senza parametri presente!:");
            System.out.println(constructor);
        } catch(NoSuchMethodException exc) {
            throw new AnnotationException(
                        "Niente costruttore senza parametri!");
        }
    }

    private static void controlloIncapsulamento(Class<?> objectClass, String
            stringa) throws AnnotationException {
        String nomeVariabile =  null;
        try {
            Field[] fields = objectClass.getDeclaredFields();
            for (Field field : fields) {
                nomeVariabile = field.getName();
                final Class<?> type = field.getType();
                final Method setMethod = objectClass.getDeclaredMethod("set" +
                        capitalize(nomeVariabile), type);
                final Method getMethod = objectClass.getDeclaredMethod("get" +
                        capitalize(nomeVariabile));
            }
            System.out.println("Classe " + stringa + " incapsulamento ok!");
        } catch (NoSuchMethodException exc) {
            throw new AnnotationException("Variabile " + nomeVariabile +
                " non incapsulata correttamente nella classe " + stringa);
        }
    }

    private static String capitalize(String string) {
        return string.substring(0, 1).toUpperCase() + string.substring(1);
    }
}

Ecco un esempio di output:

Digita il nome di un file java presente nella cartella corrente e 
  batti enter, oppure scrivi "fine" per terminare il programma
dati.ClasseBreve
Hai digitato DATI.CLASSEBREVE!
Inizio verifica annotazione @Bean per dati.ClasseBreve
Classe dati.ClasseBreve numero variabili ok!
lista variabili:
private java.lang.String dati.ClasseBreve.variabile
Classe dati.ClasseBreve numero metodi ok!
lista metodi:
public void dati.ClasseBreve.metodo1()
public java.lang.String dati.ClasseBreve.getVariabile()
public void dati.ClasseBreve.setVariabile(java.lang.String)
Classe dati.ClasseBreve costruttore senza parametri presente!:
public dati.ClasseBreve()
Classe dati.ClasseBreve incapsulamento ok!
Fine verifica annotazione @Breve per dati.ClasseBreve
dati.ClasseLunga
Hai digitato DATI.CLASSELUNGA!
Inizio verifica annotazione @Bean per dati.ClasseLunga
Classe dati.ClasseLunga numero variabili ok!
lista variabili:
public java.lang.String dati.ClasseLunga.variabile1
public java.lang.String dati.ClasseLunga.variabile2
Classe dati.ClasseLunga numero metodi ok!
lista metodi:
public void dati.ClasseLunga.metodo3()
public void dati.ClasseLunga.metodo2()
public void dati.ClasseLunga.metodo4()
java.lang.NoSuchMethodException: dati.ClasseLunga.setVariabile1(java.lang.String)
public void dati.ClasseLunga.metodo1()
	at java.lang.Class.getDeclaredMethod(Class.java:2117)
Classe dati.ClasseLunga costruttore senza parametri presente!:
public dati.ClasseLunga()
	at test.VerificatoreInterattivo.controlloIncapsulamento(
  VerificatoreInterattivo.java:152)
Fine verifica annotazione @Breve per dati.ClasseLunga
	at test.VerificatoreInterattivo.verificaBean(
  VerificatoreInterattivo.java:97)
	at test.VerificatoreInterattivo.verificaClasse(
  VerificatoreInterattivo.java:36)
	at test.VerificatoreInterattivo.main(
  VerificatoreInterattivo.java:24)

Esercizio 11.i)
Quali tra le seguenti affermazioni sono corrette?

1. L'annotazione Override è utile solo nella fase di compilazione. 2. Un'annotazione Override che annota un metodo precede sempre gli eventuali modificatori del metodo. 3. L'annotazione Override appartiene al package java.lang. 4. L'annotazione Override può annotare solo metodi. 5. L'annotazione Override è una annotazione marcatrice (marker).

Soluzione

Tutte le affermazioni sull'annotazione Override sono corrette.

Esercizio 11.j)

Creare una classe ReflectionInterattiva che contiene un metodo main il quale stampa i metodi di una classe specificata al runtime tramite l'utilizzo di una classe Scanner (già incontrata più volte in precedenza). Deve essere possibile specificare una classe, battere il tasto Invio e il programma deve stampare le firme di tutti i metodi della classe specificata.

Questo programma potrebbe non essere eseguito correttamente su EJE, si consiglia di lanciarlo da riga di comando.

Soluzione

Il listato della classe ReflectionInterattiva potrebbe essere il seguente:

import java.lang.reflect.Method;
import java.util.Scanner;

public class ReflectionInterattiva {

    public static void main(String args[]) {
        Scanner scanner = new Scanner(System.in);
        String stringa = "";
        System.out.println("Digita il nome di una classe presente nella"
          + " cartella corrente e batti enter, oppure scrivi \"fine\""
          + " per terminare il programma");
        while (!(stringa = scanner.next()).equals("fine")) {
            System.out.println("Hai digitato " + stringa.toUpperCase() + "!");
            try {
                stampaMetodi(stringa);
            } catch (ClassNotFoundException ex) {
                ex.printStackTrace();
            }
        }
        System.out.println("Fine programma!");
    }

    private static void stampaMetodi(String stringa) throws
      ClassNotFoundException {
        Class objectClass = Class.forName(stringa);
        Method[] methods = objectClass.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
    }
}

Si noti che abbiamo utilizzato il metodo getDeclaredMethods invece di getMethods, perché quest'ultimo avrebbe anche stampato i metodi ereditati dalle superclassi (nel caso si specifichi la classe Moneta i metodi di Object).
L'output del precedente listato è il seguente:

Digita il nome di una classe presente nella cartella corrente e batti
 enter, oppure scrivi "fine" per terminare il programma 
Moneta
Hai digitato MONETA!
Caricata la classe Moneta con valuta = EURO
public boolean Moneta.equals(java.lang.Object)
public int Moneta.hashCode()
public java.lang.String Moneta.getDescrizione()
public Valore Moneta.getValore()
fine
Fine programma!

Esercizio 11.k)

Creare una classe CompilatoreInterattivo che contiene un metodo main il quale compila i file specificati specificata al runtime tramite l'utilizzo di una classe Scanner (già incontrata in più esercizi precedentemente). Deve essere possibile specificare una classe, battere il tasto Invio e il programma deve compilare la classe specificata.

Questo programma dovrebbe essere eseguito su riga di comando o tramite EJE, ma non tramite Eclipse o Netbeans. Infatti questi IDE compilano automaticamente i file e quindi non si riuscirebbe a capire bene se il file viene compilato correttamente dal nostro programma o dall'IDE.

Soluzione

Il listato della classe CompilatoreInterattivo potrebbe essere il seguente:

import java.util.Scanner;

public class CompilatoreInterattivo {

    public static void main(String args[]) {
        Scanner scanner = new Scanner(System.in);
        String stringa = "";
        System.out.println("Digita il nome di un file java presente nella "
          + " cartella corrente e batti enter, oppure scrivi \"fine\" "
          + "per terminare il programma");
        while (!(stringa = scanner.next()).equals("fine")) {
            System.out.println("Hai digitato " + stringa.toUpperCase() + "!");
            try {
                compilaClasse(stringa);
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
        System.out.println("Fine programma!");
    }

    private static void compilaClasse(String stringa) throws Exception {
        Runtime runtime = Runtime.getRuntime();
        Process process = runtime.exec("javac " + stringa);
        final int exitValue = process.waitFor();
        System.out.println(exitValue == 0 ? stringa + " compilato!" :
          "Impossibile compilare " + stringa);
    }
}

Si noti che avremmo potuto anche utilizzare la Compiler API, con un codice semplice come il seguente:

JavaCompilerTool compiler = ToolProvider.defaultJavaCompiler();
compiler.run(new FileInputStream("MyClass.java"),null, null);

Si noti inoltre che abbiamo catturato con il metodo waitFor il codice di uscita del processo di compilazione. Se questo vale 0 allora il file è stato compilato correttamente.
L'output del nostro programma sarà:

D:\esercizi>dir *.class

D:\esercizi>javac CompilatoreInterattivo.java

D:\esercizi>dir *.class
Il volume nell'unità C è OS
 Numero di serie del volume: 48D1-FF51

 Directory di D:\esercizi>

08/06/2014  15.11             1.693 CompilatoreInterattivo.class
               1 File          1.693 byte
               0 Directory  98.803.150.848 byte disponibili

D:\esercizi>java CompilatoreInterattivo
Digita il nome di un file java presente nella cartella corrente e batti
 enter, oppure scrivi "fine"
Moneta
Hai digitato MONETA!
Impossibile compilare Moneta
Moneta.java
Hai digitato MONETA.JAVA!
Moneta.java compilato!
fine
Fine programma!

D:\esercizi>dir *.class
 Il volume nell'unità C è OS
 Numero di serie del volume: 48D1-FF51

 Directory di D:\esercizi>

08/06/2014  13.47             1.693 CompilatoreInterattivo.class
08/06/2014  13.47             1.345 Moneta.class
08/06/2014  13.33               627 Valore$1.class
08/06/2014  13.33               636 Valore$2.class
08/06/2014  13.33               636 Valore$3.class
08/06/2014  13.33             1.786 Valore.class
               6 File          6.723 byte
               0 Directory  98.804.051.968 byte disponibili

Da riga di comando abbiamo prima cercato di visualizzare tutti i file .class con il comando dir *.class (cfr. appendice C), ma non ce n'erano. Poi abbiamo compilato la classe CompilatoreInterattivo.java e abbiamo controllato che il file CompilatoreInterattivo.class fosse stato generato. Poi abbiamo eseguito il nostro programma e nella nostra sessione interattiva abbiamo prima cercato di compilare il file Moneta, ma questo non esiste. Poi abbiamo provato a compilare il file Moneta.java e abbiamo verificato che effettivamente la compilazione sia andata a buon fine. Naturalmente è stata compilata anche la classe Valore e le sue classi anonime.

Esercizio 11.l)
Considerata la seguente gerarchia:
```
public interface Giocatore {
    default void gioca() {}
}

public class Bambino implements Giocatore {
    /*INSERISCI CODICE QUI*/
}
```
Cosa è possibile inserire al posto del commento /*INSERISCI CODICE QUI*/ tra i seguenti statement?:
1.
```
@Override void gioca() {}
```
2.
```
@Override public void gioca() {}
```
3.
```
@Override public boolean equals(Object o) {return false;}
```
4.
```
@Override public int hashcode() {return 1;}
```
5.
```
@Override public String toString() {return "";}
```
Soluzione

Solo lo statement 1 non è corretto in quanto, non esplicitando il modificatore public, si sta rendendo il metodo che applica l'override, meno accessibile rispetto all'originale ereditato. Quest'ultimo infatti, essendo un metodo dichiarato in un'interfaccia, è implicitamente pubblico. Insomma è stata violata la regola di cui abbiamo parlato nel paragrafo 7.2.3.1 (terza regola "il metodo ridefinito nella sottoclasse non deve essere meno accessibile del metodo originale della superclasse").
Infatti l'eventuale output sarebbe il seguente:
```
Bambino.java:2: error: gioca() in Bambino cannot implement gioca() in
  Giocatore
@Override void gioca(){}    /*INSERISCI CODICE QUI*/
               ^
  attempting to assign weaker access privileges; was public
1 error
```
Esercizio 11.m)
Quali tra le seguenti affermazioni sono corrette?

1. L'annotazione Deprecated va utilizzata al posto del tag javadoc @Deprecated.
2. Un'annotazione Deprecated è di tipo annotazione completa, e dichiara due elementi: since, e forRemoval.
3. L'annotazione Deprecated appartiene al package java.lang.annotation.
4. L'annotazione Deprecated è una meta-annotazione.

Soluzione

Solo la seconda affermazione è corretta. La prima non è corretta perché semmai l'annotazione e il tag javadoc vanno usati in contemporanea. La terza è anch'essa scorretta perché l'annotazione appartiene a java.lang. Infine la numero 4 è sbagliata perché tale annotazione può annotare diversi elementi della programmazione Java, ma non altre annotazioni.
Esercizio 11.n)
Quali tra le seguenti affermazioni sono corrette?

1. L'annotazione FunctionalInterface è utile solo nella fase di compilazione.
2. Un'annotazione FunctionalInterface dovrebbe annotare solo interfacce che hanno un unico metodo (che viene chiamato metodo SAM).
3. L'uso dell'annotazione FunctionalInterface è obbligatoria se l'interfaccia annotata ha un unico metodo.
4. L'annotazione FunctionalInterface è un'annotazione marcatrice (marker).
5. L'uso dell'annotazione FunctionalInterface implica sicuramente l'uso dell'annotazione @Override.

Soluzione

Le affermazioni corrette sono la 1, la 2 e la 4. La terza è errata visto che è possibile dichiarare un un'interfaccia funzionale senza obbligatoriamente annotarla.
La numero 5 è errata invece, perché come FunctionalInterface anche l'annotazione @Override è sempre facoltativa.

Esercizio 11.o)

Se compiliamo la seguente classe:

import java.util.*;

public class Esercizio11O {

    List objects;

    public Esercizio11O() {
        objects = new ArrayList();
    }

    @SuppressWarnings({"rawtypes"})
    public void rimuovi(Object object) {
        Iterator iterator = objects.iterator();
        if (iterator.hasNext()) {
            Object item = iterator.next();
            if (object.toString().equals(item.toString())) {
                iterator.remove();
            }
        }
    }
}

otterremo il seguente output che ci segnala tre warning:

Esercizio11O.java:4: warning: [rawtypes] found raw type: List
    List objects;
    ^
  missing type arguments for generic class List<E>
  where E is a type-variable:
    E extends Object declared in interface List
Esercizio11O.java:7: warning: [rawtypes] found raw type: ArrayList
        objects = new ArrayList();
                      ^
  missing type arguments for generic class ArrayList<E>
  where E is a type-variable:
    E extends Object declared in class ArrayList
Esercizio11O.java:12: warning: [rawtypes] found raw type: Iterator
        Iterator iterator = objects.iterator();
        ^
  missing type arguments for generic class Iterator<E>
  where E is a type-variable:
    E extends Object declared in interface Iterator
3 warnings

È possibile aggiungere un'annotazione per ottenere:

• Solo due warning
• Solo un warning
• Nessun warning

Scrivere le tre versioni della classe che realizzano quanto richiesto.

Soluzione

Per ottenere solo due warning vi sono più soluzioni: aggiungere un'annotazione per sopprimere le annotazioni o sul costruttore, o sulla variabile d'istanza objects, o sul metodo rimuovi. Per esempio scegliamo la variabile d'istanza objects:

import java.util.*;

public class Esercizio11O {

    @SuppressWarnings({"rawtypes"})
    List objects;

    public Esercizio11O() {
        objects = new ArrayList();
    }

    public void rimuovi(Object object) {
        Iterator iterator = objects.iterator();
        if (iterator.hasNext()) {
            Object item = iterator.next();
            if (object.toString().equals(item.toString())) {
                iterator.remove();
            }
        }
    }
}

che produce il seguente output:

Esercizio16O.java:8: warning: [rawtypes] found raw type: ArrayList
        objects = new ArrayList();
                      ^
  missing type arguments for generic class ArrayList<E>
  where E is a type-variable:
    E extends Object declared in class ArrayList
Esercizio11O.java:16: warning: [rawtypes] found raw type: Iterator
        Iterator iterator = objects.iterator();
        ^
  missing type arguments for generic class Iterator<E>
  where E is a type-variable:
    E extends Object declared in interface Iterator
2 warnings

È facile immaginare come ottenere un solo warning. Per esempio, annotiamo il costruttore e il metodo rimuovi:

import java.util.*;

public class Esercizio11O {

    List objects;

    @SuppressWarnings({"rawtypes"})
    public Esercizio11O() {
        objects = new ArrayList();
    }

    @SuppressWarnings({"rawtypes"})
    public void rimuovi(Object object) {
        Iterator iterator = objects.iterator();
        if (iterator.hasNext()) {
            Object item = iterator.next();
            if (object.toString().equals(item.toString())) {
                iterator.remove();
            }
        }
    }
}

In questo caso otterremo il seguente output:

Esercizio11O.java:5: warning: [rawtypes] found raw type: List
    List objects;
    ^
  missing type arguments for generic class List<E>
  where E is a type-variable:
    E extends Object declared in interface List
1 warning

Infine è ovvio che annotando anche la variabile d'istanza non otterremo nessun warning, ma è più comodo annotare l'intera classe:

import java.util.*;

@SuppressWarnings({"rawtypes"})
public class Esercizio11O {

    List objects;

    public Esercizio11O() {
        objects = new ArrayList();
    }

    public void rimuovi(Object object) {
        Iterator iterator = objects.iterator();
        if (iterator.hasNext()) {
            Object item = iterator.next();
            if (object.toString().equals(item.toString())) {
                iterator.remove();
            }
        }
    }
}

Che non produce warning in compilazione.

Esercizio 11.p)

Quali tra le seguenti affermazioni sono corrette?

1. L'annotazione Native può essere usata per interfacciare Java con altri linguaggi.
2. Il termine "linguaggio nativo" significa linguaggio Java.
3. L'annotazione Native appartiene al package java.lang.
4. L'annotazione Native può annotare solo costanti.
5. L'annotazione Native è una annotazione marcatrice (marker).

Soluzione

Le affermazioni corrette sono 1, 4 e 5. Con il termine "linguaggio nativo" ci si riferisce solitamente al linguaggio utilizzato dalla piattaforma su cui gira il programma, ovvero il sistema operativo, che solitamente coincide con C/C++, quindi l'affermazione numero 2 è errata.
L'annotazione Native appartiene al package java.lang.annotation, quindi anche l'affermazione numero 3 è scorretta.
Esercizio 11.q)
Quali tra le seguenti affermazioni sono corrette?

1. L'annotazione Target è una meta-annotazione che annota sé stessa.
2. L'annotazione Target è di tipo annotazione ordinaria. Infatti può specificare vari parametri.
3. ElementType è un'interfaccia che definisce i vari elementi di programmazione Java a cui si possono applicare le annotazioni.
4. L'annotazione Target annota l'annotazione Target.

Soluzione

Le affermazioni corrette sono 1 e 4. La numero 2 non è corretta perché Target è un'annotazione a valore singolo di tipo array di ElementType.
La numero 3 non è corretta perché ElementType non è un'interfaccia ma un'enumerazione.
Esercizio 11.r)
Quali tra le seguenti affermazioni sono corrette?

1. L'annotazione Retention è annotata a sua volta da Target.
2. L'annotazione Target è annotata a sua volta da Retention.
3. L'annotazione Documented è annotata a sua volta da Target.
4. L'annotazione Target è annotata a sua volta da Documented.
5. L'annotazione Retention è annotata a sua volta da Documented.
6. L'annotazione Documented è annotata a sua volta da Retention.

Soluzione

Tutte le affermazioni sono vere.
Esercizio 11.s)
Quali tra le seguenti affermazioni sono corrette?

1. Con l'annotazione Retention decidiamo se l'annotazione annotata deve o meno essere conservata all'interno della classe compilata.
2. RetentionPolicy è un'enumerazione che dichiara solo due elementi: SOURCE e CLASS.
3. L'annotazione Retention e l'enumerazione RetentionPolicy appartengono al package java.lang.annotation.
4. L'annotazione Retention può annotare solo annotazioni.
5. L'annotazione Retention è di tipo annotazione ordinaria.

Soluzione

Le affermazioni corrette sono 1, 3 e 4.
La numero 2 non è corretta perché RetentionPolicy dichiara anche un terzo elemento (RUNTIME).
La numero 5 non è corretta perché Target è un'annotazione a valore singolo di tipo RetentionPolicy.
Esercizio 11.t)
Quali tra le seguenti affermazioni sono corrette?

1. L'annotazione Documented permette di includere all'interno della documentazione javadoc l'annotazione Documented stessa.
2. Un'annotazione Documented è annotata da sé stessa.
3. L'annotazione Documented è ereditata di default nelle sottoclassi.
4. L'annotazione Documented può annotare solo annotazioni che annotano classi.
5. L'annotazione Documented è una annotazione marcatrice (marker).

Soluzione Le affermazioni corrette sono la 2 e la 5.
La numero 1 non è corretta perché l'annotazione Documented è un'annotazione che annota annotazioni riportate all'interno della documentazione javadoc generata.
Le numero 3 e 4 sono semplicemente inventate.

Esercizio 11.u)

Considerato il seguente codice:

import java.util.*;

@SuppressWarnings({"rawtypes"})
public class Esercizio11O {

    List objects;

    public Esercizio11O() {
        objects = new ArrayList();
    }

    public void rimuovi(Object object) {
        Iterator iterator = objects.iterator();
        if (iterator.hasNext()) {
            Object item = iterator.next();
            if (object.toString().equals(item.toString())) {
                iterator.remove();
            }
        }
    }
}

Qual è l'output del seguente programma?

import java.lang.reflect.*;
import java.util.*;
import java.lang.annotation.*;
public class AnnotationsReflection {
    public static void main(String[] args) throws Exception {
        Annotation[] dcs=Esercizio11U.class.getAnnotations();
        for (Annotation dc : dcs) {
            System.out.println(dc);
        }
    }
}

Soluzione

Il programma che legge le annotazioni di Esercizio11U stamperà solo l'annotazione che è stata dichiarata per la classe stessa, ma non erediterà quella dall'interfaccia Interface16U. Infatti l'annotazione Inherited funziona solo sulle classi e non sulle interfacce.
Ecco l'output:

@DifferentAnnotation()

Esercizio 11.v)

Creare un inizializzatore statico (cfr. paragrafo 5.4.3) all'interno della classe Moneta, che abbiamo utilizzato l'ultima volta nella soluzione dell'esercizio 10.b, e facciamogli stampare una frase qualsiasi. Come è possibile usare la reflection per far eseguire il blocco?

Soluzione

La reflection in teoria non è necessaria. Infatti, supponiamo di aver definito il blocco statico seguente nella classe Moneta:

    static {
        System.out.println("Caricata la classe Moneta con valuta = " + VALUTA);
    }

Basterebbe semplicemente definire una variabile della classe Moneta come segue:

public class TestReflection {
    public static void main(String args[]) {
        Moneta moneta = new Moneta(Valore.CINQUANTA_CENTESIMI);
    }
}

Il codice precedente produrrebbe il seguente output:

Caricata la classe Moneta con valuta = EURO
Creata una moneta da 50 centesimi di EURO

Tuttavia, se volessimo usare la reflection non sarà sufficiente il seguente codice:

        Class<Moneta> classMoneta = Moneta.class;
        try {
            classMoneta.newInstance();
        } catch (InstantiationException | IllegalAccessException ex) {
            ex.printStackTrace();
        }

Che infatti produrrà il seguente output:

java.lang.InstantiationException: Moneta
	at java.lang.Class.newInstance(Class.java:418)
	at TestReflection.main(TestReflection.java:10)
Caused by: java.lang.NoSuchMethodException: Moneta.<init>()
	at java.lang.Class.getConstructor0(Class.java:2971)
	at java.lang.Class.newInstance(Class.java:403)
	... 1 more

Questo succede in quanto con il metodo newInstance viene chiamato il costruttore senza parametri, che però non esiste.
La soluzione è chiamare il costruttore corretto con il seguente codice:

try {
    Constructor<Moneta> costruttore = classMoneta.getConstructor(Valore.class);
    costruttore.newInstance(Valore.CINQUANTA_CENTESIMI);
} catch (NoSuchMethodException | SecurityException | InstantiationException |
         IllegalAccessException | IllegalArgumentException |
         InvocationTargetException ex) {
    ex.printStackTrace();
}

Esercizio 11.x)
L'utilizzo di un IDE implica (scegliere tutte le risposte che si ritiene siano corrette):

1. Iniziale rallentamento dell'apprendimento dello sviluppo, perché richiede lo studio dello stesso IDE.
2. La possibilità di utilizzare un debugger. Fondamentale strumento per sviluppare.
3. La possibilità di integrarsi con altri strumenti di sviluppo con un database o un application server.
4. La possibilità di utilizzare un editor evoluto che ci permette di automatizzare la creazione di costrutti di programmazione ed utilizzare tecniche di refactoring del codice.
5. L'impossibilità di utilizzare i package, che devono comunque essere gestiti da riga di comando.

Soluzione

Solo la quinta risposta è falsa. Un IDE invece esonera il programmatore dalla complessa gestione dei package.
Esercizio 11.y)
L'architettura si occupa (scegliere tutte le risposte che si ritiene siano corrette):

1. Di definire diagrammi di attività UML che modellano le funzionalità del sistema.
2. Di migliorare le prestazioni del software.
3. Di ottimizzare l'utilizzo delle risorse da parte del software.
4. Di ottimizzare il partizionamento del software in modo tale da semplificare la procedura di installazione.

Soluzione

Solo la prima risposta è falsa. Un architetto infatti si dedica essenzialmente ai requisiti non funzionali dell'applicazione.
Esercizio 11.z)
Un deployment diagram (scegliere tutte le affermazioni che si ritiene siano corrette):

1. È un diagramma statico.
2. Mostra i flussi di esecuzione dell'applicazione.
3. Mostra come i nodi hardware ospitino i componenti software.
4. Evidenziano le dipendenze tra componenti software.
5. Il principale elemento del diagramma è un nodo, che è rappresentato da un rettangolo con due piccoli rettangoli che fuoriescono dall'angolo superiore sinistro.

Soluzione

Sono errate le affermazioni:

• numero 2: perché non sono evidenziati flussi di esecuzione.
• la numero 5: è vero che il nodo è il principale elemento del diagramma, ma viene rappresentato come un cubo tridimensionale. La descrizione riportata invece si riferisce all'elemento componente.
Esercizio 11.aa)
Abbiamo asserito che la conoscenza di base di argomenti quali XML e l'interazione con database è essenziale per lavorare in un'azienda informatica. Questo perché la quasi totalità delle applicazioni utilizza in qualche modo queste due tecnologie. Se si lavora ad un'applicazione web, quali sono le conoscenze di base che bisogna avere?

Soluzione

Se si lavora nel campo web, avere delle conoscenze basiche sul protocollo HTTP, i linguaggi HTML, Javascript e CSS, librerie come Bootstrap, e framework come Spring, o Angular JS e così via.
Esercizio 11.bb)
Definire brevemente i concetti di:

1. client
2. server
3. applicazione standalone
4. applicazione mobile
5. applicazione web
6. client web
7. server web
8. applicazione enterprise.

Soluzione

1. Per definizione un client è un programma che richiede servizi ad un altro programma che si chiama server.
2. Per definizione un server, è un programma sempre in esecuzione, che mette a disposizione dei servizi. Un client e un server comunicano solitamente tramite rete, con un protocollo ben definito.
3. Le applicazioni standalone, (dette anche applicazioni desktop). Questo tipo di applicazioni vengono eseguite su computer desktop e portatili, e solitamente hanno un'interfaccia grafica.
4. Un' applicazione mobile (spesso chiamata semplicemente app), sono applicazioni che vengono eseguite su client mobili, come smartphone e tablet, e possono anche avere una controparte server.
5. Le applicazioni web per esempio sono applicazioni che hanno un'architettura suddivisa in una parte client e una parte server.
6. Un client web richiede pagine web, e coincide con i programmi che chiamiamo comunemente browser (Mozilla Firefox, Google Chrome e così via).
7. Un server web, è invece un'applicazione che mette a disposizione servizi disponibili in rete.
8. Le applicazioni enterprise (potremmo tradurre come applicazioni aziendali), sono un'evoluzione delle applicazioni web, e solitamente mettono a disposizione servizi più complessi come scaricamento di risorse, web services (ovvero applicazioni di comunicazione tra sistemi eterogenei che usano il protocollo HTTP), servizi di reportistica, eccetera, e che quindi come client enterprise possono avere anche programmi appositamente creati per interagire con lo strato server enterprise. Quest'ultimo è costituito a sua volte da vari strati che utilizzano tecnologie diverse per adempiere a vari scopi.
Esercizio 11.cc)
Definire i compiti dei seguenti ruoli aziendali:

1. Capo progetto
2. Business analyst
3. IT manager
4. Release manager
5. DBA
6. Grafico

Soluzione

1. Il capo progetto (in inglese project manager) dovrebbe pianificare il lavoro a livello temporale, assegnare il lavoro alle risorse, interagire con tutti i principali membri del gruppo di sviluppo, con il management e con il cliente.
2. Il business analyst ha il compito di raccogliere requisiti dal cliente, formarlo e risolvere dubbi funzionali.
3. L'IT manager (in italiano meglio noto come sistemista) si occupa di preparare gli ambienti, di installare i software, di configurare la rete, le macchine, i permessi etc.
4. Il deployer o release manager, ha la responsabilità di creare e installare le versioni del software per i vari ambienti in cui deve essere utilizzato.
5. Il database administrator (o DBA) è l'esperto del database e si occupa di tutto ciò che concerne l'interazione e la configurazione del database.
6. Il grafico è il responsabile dell'aspetto della grafica dell'applicazione.
Esercizio 11.dd)
Definire cos'è una metodologia object oriented.

Soluzione

Una metodologia object oriented, nella sua definizione più generale, potrebbe intendersi come una coppia costituita da un processo e da un linguaggio di modellazione.
A sua volta un processo potrebbe essere definito come la serie di indicazioni riguardanti i passi da intraprendere per portare a termine con successo un progetto.
Un linguaggio di modellazione è invece lo strumento che le metodologie utilizzano per descrivere (possibilmente in maniera grafica) tutte le caratteristiche statiche e dinamiche di un progetto. Il linguaggio di modellazione considerato standard de facto è l'UML.
Esercizio E.a)
Impacchettare in un file JAR, il package di autenticazione progettato e realizzato negli esercizi 5.w.
Soluzione

Come soluzione creiamo un file JAR eseguibile, aggiungendo un file manifest.txt che specifica il nome della classe con il main. Il file manifest conterrà il seguente testo:
```
Main-Class: com.claudiodesio.autenticazione.Autenticazione
```
Notare che si deve andare da capo dopo la riga, altrimenti il comando non verrà considerato.

Il comando per impacchettare i file è:
```
jar -cvfm autenticazione.jar manifest.txt   
    com/claudiodesio/autenticazione/*.class
```
Il file manifest.txt deve essere presente nella cartella da dove si sta lanciando il comando.
Infine, per lanciare l'applicazione utilizzare il seguente comando:
```
java -jar autenticazione.jar
```

Email

Potete usare questo form per mandare all'autore richieste, suggerimenti, segnalazioni di errori, refusi, pareri, critiche, complimenti o altro.

Potete anche mandare una email direttamente all'indirizzo claudio@claudiodesio.com.

Il tuo messaggio è stato inviato correttamente. Grazie!

Esercizi

Capitolo 11 e dell'appendice ETipi Annotazioni, Reflection e la variabile d'ambiente CLASSPATH

Email

Capitolo 11 e dell'appendice E
`Tipi Annotazioni, Reflection e la variabile d'ambiente CLASSPATH`