Come ottenere le parentesi graffe su una tastiera italiana

Le tastiere con un layout differente da quello americano non hanno dei tasti con le parentesi graffe. E' possibile ottenere tali parentesi in uno dei seguenti modi (alcuni potrebbero non funzionare a seconda del programma usato):

• codice ASCII:
  tenere premuto ALT e digitare 123 per la parentesi aperta, 125 per quella chiusa
• SHIFT+ALT grafico:
  premere contemporaneamente SHIFT e ALT grafico (ALT GR, il tasto posto a destra) e i tasti con le parentesi quadre per ottenere quelle graffe
• ALT grafico (Linux):
  premere l'ALT grafico (ALT GR, il tasto posto a destra) e il numero 7 per la parentesi aperta, 8 per quella chiusa.
• cambio layout tastiera (Windows):
  premendo ALT+SHIFT e' possibile cambiare il layout fra americano e italiano, e quindi utilizzare la tastiera come se fosse americana.

Principali errori nell'esecuzione di programmi Java

• Tendando di eseguire un programma compare
  Exception in thread "main" java.lang.NoSuchMethodError: main
  significa che si sta tentando di eseguire una classe che non dichiara il metodo main o che non lo dichiara con il prototipo corretto. Si ricordi che il prototipo del main e' il seguente: public static void main(String argv[])



• Tendando di eseguire un programma si ottiene
  Exception in thread "main" java.lang.NoClassDefFoundError:
  significa che si sta cercando di accedere ad una classe che non puo' essere trovata. Tipicamente questo avviene perché il nome della classe non e' corretto o la classe non e' presente nel classpath.



• Durante l'esecuzione del programma compare
  Exception in thread "main" java.lang.NullPointerException
  significa che si sta accedendo tramite un riferimento non inizializzato correttamente. Si ricordi che i riferimenti agli oggetti sono inizializzati a null, e quindi occorre fare una escplicita istanziazione. Ad esempio:
  
  ContoCorrente cc; // dichiara solo il riferimento => cc vale null
...
cc = new ContoCorrente(..); // ora posso usare cc senza problemi di NullPointerException

  
  Si ricordi inoltre che anche i vettori vanno istanziati con new:
  
  int vettore[]; ... vettore = new int[10];



• Durante l'esecuzione del programma compare
  Exception in thread "main" java.lang.ArrayIndexOutOfBounds
  significa che si sta accedendo ad un array oltre il suo ultimo valore. Si ricordi che un valore di n elementi ha un indice che puo' variare fra 0 e n-1.



• A tempo di compilazione compare l'errore
  cannot resolve symbol
  il compilatore non riesce a capire a quale variabile o metodo si sta facendo riferimento. Tipicamente questo accade quando si sbaglia a scrivere il nome di una variabile o di un metodo. Ad esempio:
  
  int laMiaVariabile;
...
laTuaVariabile=10; // variabile non dichiarata prima => errore di battitura,ecc.
  

Se il simbolo indicato è un'oggetto e non sono presenti errori di battitura, molto probabilmente non si è compilato l'oggetto stesso. Si ricompili il sorgente della variabile non trovata e si riprovi.


• A tempo di compilazione compare l'errore
  duplicated class
  questo errore puo' essere generato da diverse cause. In generale il compilatore trova due definizioni della stessa classe e quindi non sa quale utilizzare. Il primo tentativo da fare è quello di cancellare tutte le classi (file .class) e ricompilare il progetto. Se ancora si verificano dei problemi, si controlli di non avere alcun sorgente nelle directory in cui vengono inserite le classi compilati. Utilizzando il JCreator, questo errore potrebbe verificarsi quando una classe viene spostata da un package all'altro, ossia quando si è compilata una classe come appartenente al package X, cambiandone poi la clausola package e ricompilando da capo. In questo caso si suggerisce di eliminare il vecchio codice sorgente e, se necessario, creare un nuovo progetto importando i sorgenti con le definizioni di package corrette.
  Un'altra causa di errore puo' derivare da una impostazione del classpath errata: si verifichi che il classpath non punti a directory ove sono presenti classi omonime.

Individuare gli errori mediante le eccezioni

Le eccezioni rappresentano errori di esecuzione. Il sistema di eccezioni di Java è molto completo e complesso, per una sua trattazione si rimanda alle lezioni del prof.Cabri. Tuttavia, anche senza conoscere i dettagli di funzionamento del meccanismo ad eccezioni, è possibile utilizzarle per scovare gli errori nei programmi e quindi correggerli.
Ecco come si presenta l'output di un programma che genera un'eccezione.

Exception in Thread "main": java.lang.ArrayIndexOutOfBoundsException: 10
at jaas.Untitled1.main(Untitled1.java:18)
Exception in thread "main"

La prima riga riporta la classe che identifica il tipo di eccezione/errore (in questo caso java.lang.ArrayIndexOutOfBoundsException). E' possibile cercare nella documentazione Javadoc il significato attribuito alla classe di eccezione, ossia le condizioni in cui tale errore si verifica.
La seconda riga indica il punto in cui l'eccezione si è verificata, in modo che il programmatore possa trovare corrispondenza nel codice sorgente. L'indicazione sull'errore è formattata nel seguente modo:

Come produrre la documentazione Javadoc

Confronto fra le prestazioni di versioni successive delle JVM SUN

Quelli che seguono sono alcuni semplici risultati di un confronto fatto su versioni differenti delle JVM prodotte da SUN. Tali risultati non sono da considerarsi definitivi e/o professionali, e sono forniti al solo scopo di dare un'idea dei tempi di esecuzione delle singole JVM.
Il frammento principale del codice Java utilizzato e' il seguente:
for(int i=0;i<500;i++)
for(int j=0;j<500;j++)
for(int k=0;k<500;k++)
Math.sqrt( (double) i+j+k );

ove si faceva variare l'indice comune ai cicli for per ottenere un numero complessivo di radici calcolate differente. I programmi sono stati compilati con il compilatore a corredo della JVM, al fine di usufruire di tutte le ottimizzazioni possibili. I test sono stati eseguiti su una workstation SUN Ultra Sparc con sistema operativo SUN Solaris 5.8

Visualizzazione in formato leggibile del bytecode di una classe

Fra gli strumenti del JDK è presente javap che consente di disassemblare una classe compilata in formato umanamente leggibile. Ecco un esempio di decompilazione:

Classi base per la creazione di programmi di rete

La creazione di programmi di rete, ossia di programmi capaci di comunicare con altri programmi per mezzo di connessioni di rete, richiede la conoscenza di alcuni concetti fondamentali riguardanti i Thread e le Socket. Tuttavia, ricordando che Java gestisce tutto l'input/output per mezzo di stream, e' possibile nascondere i dettagli relativi alle connessioni in classi di piu' alto livello, che possono essere utilizzate nei propri programmi.
Le classi presentate di seguito, appartenenti al package fluca.net servono appunto a facilitare la creazione di applicazioni di rete client/server nascondendo la gestione dei thread e delle socket al programmatore, che deve quindi preoccuparsi solo di gestire opportunamente gli stream dati.

La struttura del package e' mostrata nella seguente figura:

Il seguente esempio mostra l'utilizzo delle classi sopra descritte per implementare un semplice programma client/server dove client e server si scambiano un messaggio:

	


   // creo i connection manager relativi alla connessione
    ConnectionManager server = new MyConnectionManager("Messaggio dal server");
    ConnectionManager client = new MyConnectionManager("Messaggio dal client");

    // creo il server, che esegue su un thread proprio
    BaseServer bServer = new BaseServer(3663, server, true);

    // creo il client
    BaseClient bClient = new BaseClient(client);

    // dico al client di collegarsi alla porta del server sull'host locale
    bClient.connectTo("localhost",3663);
   
    // a questo punto la gestione delle connessioni e' automatica!

    // posso stampare i messaggi che il client e il server si sono scambiati
    System.out.println("IL SERVER HA RICEVUTO: "+((MyConnectionManager)client).getMessaggio());
    System.out.println("IL CLIENT HA RICEVUTO: "+((MyConnectionManager)server).getMessaggio());

    // dico al client di chiudere la connessione
    bClient.closeConnection();




	
	

	
public class MyConnectionManager implements ConnectionManager{

  private String messaggio;

  public MyConnectionManager(String messaggio){
    this.messaggio = messaggio;
  }

  public void manageConnection(SocketAddress remoteAddress,
                              ObjectInputStream input,
                              ObjectOutputStream output,
                              boolean canRead,
                              boolean canWrite){

   try{
     // scrivo il messaggio verso l'altro capo della connessione
     if( canRead )
       output.writeObject(messaggio);

     // leggo il messaggio: faccio un ciclo per una read non bloccante
     do{
       this.messaggio = (String) input.readObject();
     }while( this.messaggio == null && canWrite);

   }catch(IOException e){
     System.err.println("Errore in scrittura/lettura");
     e.printStackTrace();
   }
   catch(ClassNotFoundException e){
     System.err.println("Errore in ricerca classe letta");
     e.printStackTrace();

   }
 }

 public String getMessaggio(){
   return this.messaggio;
 }

}

	
	

	
	[note.net.BaseServer - main] Devo creare un nuovo thread demone per questo server 
[note.net.BaseServer - main] Avvio il thread del server 
[note.net.BaseServer - main] thread del server avviato 
[note.net.BaseClient - main] Tentativo di connessione a localhost/127.0.0.1:3663 
[note.net.BaseClient - main] Gestisco la connessione attraverso il connection manager net.test.MyConnectionManager 
[note.net.BaseClient - main] Stream di output pronto 
[note.net.BaseClient - main] Stream di input pronto 
[note.net.BaseServer - BaseServerThread] Socket server creata, entro nel ciclo di attesa 
[note.net.BaseServer - BaseServerThread] Attendo una nuova connessione... 
[note.net.BaseServer - BaseServerThread] connessione ricevuta! 
[note.net.BaseServer - BaseServerThread] Client:/127.0.0.1:1932 
[note.net.BaseServer - BaseServerThread] Gestisco la connessione attraverso il connection manager net.test.MyConnectionManager 
[note.net.BaseServer - BaseServerThread] Stream di output pronto 
[note.net.BaseServer - BaseServerThread] Stream di input pronto 
[note.net.BaseClient - main] Gestione connessione terminata 
[note.net.BaseServer - BaseServerThread] Gestione connessione terminata 

IL SERVER HA RICEVUTO: Messaggio dal client
IL CLIENT HA RICEVUTO: Messaggio dal server

[note.net.BaseServer - BaseServerThread] Risveglio di eventuali thread sospesi su richiesta di stream 
[note.net.BaseServer - BaseServerThread] Attendo una nuova connessione... 
	
	

1. creare una implementazione di ConnectionManager per il client e una per il server; utilizzare gli stream forniti per scrivere e leggere oggetti;
2. avviare il server: creare un oggetto BaseServer legato ad una porta e fornire il relativo ConnectionManager;
3. connettere il client, tramite il metodo connectTo;
4. una volta terminata la connessione (ossia alla fine di invio/ricezione di dati), chiudere la connessione client ed eventualmente stoppare il server.

E' presente anche un sottopackage, fluca.net.secure che fornisce una implementazione di server e client con concetti di sicurezza basati su Grant. Un grant e' un oggetto che descrive alcune proprieta' che occorre avere per accedere ad una connessione (ad esempio uno username e una password). Il client invia il grant al server che lo controllo con il proprio, se i dati contenuti nel grant coincidono la connessione viene concessa, altrimenti rifiutata. Si veda la documentazione javadoc per maggiori dettagli.