|
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();
}
}
} |
|
