|
Commenti nel codice java
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: |
//:Commenti.java
/**
* Esempi Commento della classe
Commenti
* @author Gasparri Roberto
* @version 1.0
*/
public class Commenti {
/**commento del metodo f()
* @param parametri di ingresso
* @return i valori che ritorna
* @exception Eccezioni catturate/generate(trow)
*/
public void f() { }
public static void main(String
args[])
}
/* Esempio di commento
su piu'linee */
|
javadoc "Commenti.java" –version –author
produce la documentazione (incluso i dati
sull’autore e la versione) in formato HTML
Classi
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
Applicazioni e Applet
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).
vai alla sezione applet
Il metodo main()
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 {
public static void main(String[]
args) {
System.out.println("Hello
World!");
}
}
|
Variabili
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
Operatori
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) |
| |= |
|
| ^= |
|
| >>= |
|
| >>>= |
|
Controlli
di flusso
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.
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 {
public static void main(String args[]) {
if (args.length < 1) {
System.out.println("Nessun argomento");
}
else {
System.out.println("Stringa digitata: "
+ args[0]);
}
}
}
|
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){
case 1 : statment ; break;
case 2 : statment ; break;
……..
default : statment ; break;
}
|
break e’ usato per interrompere il controllo
degli altri "case" se non interessano
| Esempio: |
| //:TestSwitch.java
public class TestSwitch {
public static void main(String
args[]) {
String valore = new String();
for(int i=1 ; i<10 ; i++)
{
switch (i) {
case 1 : System.out.println("uno");break;
case 3 : System.out.println("tre");break;
case 5 : System.out.println("cinque");break;
case 7 : System.out.println("sette");break;
case 9 : System.out.println("nove");break;
default : System.out.println("numero pari");break;
} }
} }
<10 ; i++) {
case 1 : System.out.println("uno");
break;
case 3 : System.out.println("tre");
break;
case 7 : System.out.println("sette");
break;
case 10 : System.out.println("dieci");
break;
}
}
}
|
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 {
public static void main(String
args[]) {
int i;
System.out.println("Ciclo
FOR...");
for(i=0 ; i<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);
}
}
|
<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">
Concatenare stringhe
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 {
public static void main(String args[]) {
if (args.length < 1) {
System.out.println("Nessun argomento");
}
else {
System.out.println("Stringa digitata: "
+ args[0]);
}
}
}
|
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);
}
} |
Generare
dei numeri casuali
| 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);
}
} |
Oggetti
Un nuovo oggetto deve essere:
- dichiarato (type nome) [es. Date today]
- instanziato (con: new)
- inizializzato (costruttore) [es. date()
/ rectangle(0,0,100,100)]
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
Array
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 {
public static void main(String
args[]) {
String[] ArrayOfString =
new String[10];
for(int i=0 ; i<ArrayOfString.length ; i++) {
ArrayOfString.length[i]
= new String("Hello " + i);
System.out.println("ArrayOfString["+i+"]
= " + ArrayOfString[i]);
}
}
}
|
Vector
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;
BitSet
Vettore di bit
Stack
(deriva da Vector) Contenitore LIFO (Last
Input First Output)
Hashtable
(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);
}
} |
Enumeration
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();
}
}
} |
|
