INFORMAZIONI GENERALI
I commenti nella scrittura del codice sono utili per facilitare la comprensione in fase di debug.
Inoltre e' buona regola inserire all'inizio di ogni applet/applicazione alcune righe con la descrizione, l'autore, la versione e tutte quelle informazioni che si possono ritenere necessarie.
Possono essere di 3 tipi:
| 1) | /* riga1 riga2 riga3 */ |
per commenti su piu’linee |
| 2) | /** documentazione */ | per documenti di commento |
| 3) | // testo | Per commenti su singola linea: il compilatore ignora da "//" alla fine della linea |
Inserendo alcuni tags specifici si possono distribuire insieme ai nostri la documentazione in formato HTML sulle classi e i metodi "public" e "protected". La funzione javadoc del JDK estrae tale informazioni.
Tags per documentazione di classi:
Tags per documentazione di metodi:
Nota:
javadoc puo’generare anche tag HTML:
| Esempio: |
| /** * <PRE> * System.out.println(new Date()): * <PRE> */ |
| Esempio completo: |
|
javadoc "Commenti.java" –version –author
produce la documentazione (incluso i dati sull’autore e la versione) in formato HTML
La classe e’ la struttura base
Quando si instanzia (definisce) una classe si crea un oggetto.
In java ogni cosa e’un oggetto a cui si puo’ chiedere di eseguire operazioni su se stesso.
I comportamenti associati a una classe o oggetto sono implementati con metodi (funzioni).
Quindi quando scriviamo un programma in java definiamo un oggetto (classe), al quale associamo delle funzioni che specificano quali comportamenti potra' avere.
Il codice java deve sempre iniziare con la dichiarazione della classe, che deve avere lo stesso nome del file .java
| Esempio: |
| Il file TestSwitch.java deve iniziare con la dichiarazione della
classe TestSwitch: public class TestSwitch |
Per convenzione i nomi di classe iniziano con una lettera maiuscola.
Vai alla sezione: Classi e metodi
In java si possono creare sia applicazioni stand alone (devono implementare il metodo main()) sia applet da aggiungere a pagine HTML e quindi scaricabili attraverso internet e eseguite da browser che implementano la JVM (Java Virtual Machine).
Usato solo per le applicazioni, ed eseguito per primo quando si lancia l'applicazione.
| Caratteristiche: |
| Accetta un array di elementi di tipo stringa void = che non produce risultato. static = Usato per scrivere un pezzo di programma senza creare un oggetto o per scrivere un metodo che non sia associato ad un particolare oggetto. public static void main(String, args[]) |
| Esempio: |
| /** * Visualizza la scritta: Hello World! */ class HelloWorldApp {
} |
Per convenzione i nomi di variabile iniziano con una lettera minuscola.
Se un nome di variabile e’ comprensivo di piu’ parole (come isVisible) le parole vengono congiunte e la prima lettera di ogni parola congiunta e’ maiuscola.
Le variabili in java possono essere dei seguenti tipi:
boolean
byte
char
double
float
int
long
short
Aritmetici
| + | somma (es. op1 e op2) |
| - | Sottrazione |
| / | divisione |
| % | calcola il resto della divisione tra op1 e op2 |
| +op | indica un valore positivo |
| -op | indica un valore negativo |
| var++ | equivale a scrivere: var = var + 1 |
Di relazione
| > | maggiore |
| >= | maggiore o uguale |
| < | minore |
| <= | minore o uguale |
| == | uguale |
| != | diverso |
Condizionali
| && | AND (& = && per valori booleani) |
| || | OR | = || per valori booleani) |
| ! | false (es !op = op e’ falso) |
Operazioni tra i bit
| >> | es. op1>>op2, sposta i bit di op1 a destra di op2 posizioni |
| << | (>> e << , se op2="1," equivale a moltiplicare o dividere op1 per 2) |
| & | AND tra i bit |
| | | OR tra i bit |
| ^ | XOR tra i bit |
| ~ | Complemento |
Operatori di assegnazione
| var=x | assegna a var il valore x |
scorciatoie:
| += | op1 += op2 = equivale a scrivere: op1=op1+op2 |
| -= | |
| *= | |
| /= | |
| %= | |
| &= | op1&=op2 ( op1=op1&op2) |
| |= | |
| ^= | |
| >>= | |
| >>>= |
Si possono dividere in 2 famiglie:
1) Di decisione : Eseguono una certa parte di codice in base al verificarsi o meno di una condizione.
2) DI LOOP :
Ripetono una o piu' istruzioni fino al verificarsi di una condizione specificata.
| Di decisione |
if-else(/elseif)
L'istruzione "if-else" e' usata per verificare una condizione booleana e in base
al valure true (o false tramite else) eseguire un determinato pezzo di codice.
elseif e' usato per concatenare piu' espressioni if.
| if (espressione) statment (else) statment (elseif espressione) |
La notazione ? equivale a IF/ELSE
| Esempio: |
| delay=(fps>0) ? (1000/fps):100 equivale a: if(fps>0) / 1000/fps / else 100) |
| Esempio: |
| //:Args.java // Determina se passata una stinga // sulla riga di comando public class Args {
} |
Eseguendolo si avra’:
| java Args | Nessun argomento |
| java Args prova | Stringa digitata: prova |
switch-case
Usato per definire quale pezzo di codice (statment) eseguire in base al valore di una
variabile (utile per eviatare lunghe catene di if-elseif).
switch (variabile){
} |
break e’ usato per interrompere il controllo degli altri "case" se non interessano
| Esempio: |
| //:TestSwitch.java public class TestSwitch {
} |
| di Loop |
for
Ripete il ciclo fino a quando il controllo non produce un risultato "false".
| for (inizializzazione; condizione/termine;
incremento) { statment } |
while e do while
Eseguono tanti cicli finche' la condizione produce un risultato "true/vero", in caso contrario esce dal loop.
| while (espressione booleana) { statment } |
| do { statment (dichiarazioni) } while (espresione booleana) |
| Esempio: |
| //: TestLoop.java public class TestLoop {
} |
<5 ; i++) { System.out.println("i=" + i);
}
int y = 0;
System.out.println(" Ciclo WHILE..."); while(y<5) { System.out.println("y=" + y);
y++;
}
int x = 0;
System.out.println(" Ciclo DO_WHILE..."); do { System.out.println("x=" + x);
x++;
} while(x<5);
}
}</pre>
<p> <a href=" #INIZIO">
Per concatenare stringhe si usa il simbolo "+"
Es: System.out.println("Nome " + "Cognome")
(nel caso si voglia concatenare a una stringa un intero, viene automaticamente chiamato il metodo toString()
| Esempio: |
| //: Concatena.java public class Concatena { public static void main(String args[]) { int telefono = 123456; System.out.println("Nome " + "Cognome " + telefono); } } |
Passare argomenti all’applicazione dalla linea di comando
Per eseguire un applicazione java e passargli un argomento, basta far seguire al nome dell' applicazione il valore desiderato: verra’interpretato come una stringa e memorizzato nell’array di stringhe args[] definito in main
| Esempio: |
| //:Args.java // Determina se passata una stinga // sulla riga di comando public class Args {
} |
Convertire una stringa in un numero
Questa operazione viene eseguita dal metodo parseInt()
| Esempio: |
| //: StringaInItero public class StringaInIntero { public static void main(String args[]) { int i; String text = new String("1"); i = Integer.parseInt(text); int y=10; y = y+i; System.out.println("Valore di y = " + y); } } |
| Esempio: |
| //: Casuale.java public class Casuale { public static void main(String args[]) { int x; x = ((int) (Math.random() * 10)); System.out.println("Numero casuale da 0 a 9 = " + x); } } |
Un nuovo oggetto deve essere:
es.
Date today = new Date()
Rectangle rect = new rectangle(0,0,100,200)
Eliminare un oggetto
1) Viene eliminato automaticamente dal Garbage collector (collettore di immondizia) System.gc
2) Forzatamente con il metodo Finalize
Servono per associare un indice numerico ad un oggetto di tipo conosciuto o a primitive.
La dimensione e’ fissata al momento della creazione
(allocazione) e non puo’ essere variata.
| Gli array devono essere dichiarati: | int[] ArrayOfInt; |
| e instanziati per allocargli memoria: | ArrayOfInt = new int[10] |
| (Forma compatta: int[] ArrayOfInt = new int[10] ) | |
metodi:
ArrayOfInt.lenght = propieta’ degli array che fornisce la lunghezza (nell’esempio e’ 10)
Gli array di stringhe oltre a dover essere dichiarati e instanziati devono essere anche riempiti
| Esempio: |
| //: TestArray.java public class TestArray {
} |
Associa un indice numerico a soli oggetti (no primitive) e puo’ ridimensionarsi dinamicamente.
Metodi:
size() = restituisce il numero degli elementi
addElement() = aggiunge un elemento
elementAt() = restituisce il valore dell’elemento passato come argomento
L’oggetto Vector fa parte del package java.util , quindi bisogna importare tale pakage (all’inizio del programma) con il comando:
import java.util.*;
o import java.util.Vector;
Vettore di bit
(deriva da Vector) Contenitore LIFO (Last Input First Output)
(deriva da dictionary) Associa una serie di oggetto "chiave" a un'altra sequenza di oggetti
Metodi:
size()
isEmpty()
put(Object key, Object value)
get(Object key)
remove(Object key)
containsKey(Object key)
| Esempio: |
| //:TestHashtable import java.util.*; public class TestHashtable { public static void main(String args[]) { Hashtable h = new Hashtable(); h.put("uno", new Integer(1)); h.put("due", new Integer(2)); h.put("tre", new Integer(3)); Integer num1 = (Integer)h.get("uno"); Integer num2 = (Integer)h.get("due"); Integer num3 = (Integer)h.get("tre"); System.out.println("uno = "+num1); System.out.println("due = "+num2); System.out.println("tre = "+num3); } } |
Nei contenitori visti prima (Vector, BitSet, Stack e Hashtable) per gestire le informazioni/oggetti contenuti, oltre ai propri metodi di gestione come addElement(), elementAt(), etc. si puo’ usare Enumeration.
Enumeration trasforma in una lista il contenitore di oggetti
Metodi:
nextElement() = fornisce il prossimo elemento della lista
hasMoreElement() = restituisce TRUE se ha altri elementi
elements() = converte un vettore in Enumeration
| Es: Enumeration e = vector.elements() |
| Esempio: |
| //:TestEnumeration.java import java.util.*; class Oggetto { private int numero; Oggetto(int i) { numero = i; } void stampa() { System.out.println("Oggetto numero: " + numero); } } public class TestEnumeration { public static void main(String args[]) { Vector contenitore = new Vector(); for(int i=0 ; i<5 ; i++) { contenitore.addElement(new Oggetto(i)); } Enumeration e = contenitore.elements(); while(e.hasMoreElements()) { ((Oggetto)e.nextElement()).stampa(); } } } |