Sei sulla pagina 1di 20

Introduzione

Programmare vuol dire saper scrivere un programma che riesce a fare ci che vuole il
programmatore. Per poter programmare abbiamo bisogno di:
un algoritmo = sequenza di azioni che trasformano i dati iniziali in un numero finito di passi
elementari e non ambigui; deve essere generale (funziona con tutti dati d'ingresso) non
ambiguo (d! luogo a un interpretazione univoca) eseguibile ( passi fatti in tempo finito).
"n linguaggio = esistono due tipi di linguaggio: quello di basso livello e quello di alto
livello. #uello di basso permette di comunicare direttamente con la macchina; si divide in
linguaggio macchina (istruzioni sono costituite da codici operativi valori indirizzi espressi
in binario) direttamente interpretabile dal computer; e linguaggio assemblativo (usati
simboli per codici operativo e variabili) necessita di un traduttore. #uello di alto pu essere
tradotto in vari modi a seconda del linguaggio trattato; esistono vari modi di tradurre
programmi di alto livello: compilazione interpretazione e una combinazione delle due. $l
compilatore traduce programmi espressi linguaggio alto livello in programmi equivalenti
espressi in linguaggio macchina o assemblativo. %' interprete invece si occupa di prelevare
nel giusto ordine le istruzioni di un programma di simulare loro esecuzione e di restituirne
risultati
macchina
%a disciplina che dice come definire algoritmi in modo che possano essere eseguiti da calcolatore si
chiama programmazione; il programma & la definizione di un algoritmo secondo regole sintattiche.
%e caratteristiche di un programma sono: efficienza (problema risolto nel minor tempo possibile)
leggibilit! (programma scritto in modo chiaro e documentato) modificabilit! (programma facile da
modificare).
'ava & un linguaggio che combina compilazione e interpretazione: il compilatore produce un codice
a b(te (b(tecode) per compilare si usa il comando )avac *)avac nomefile.)ava+; l'interprete esegue il
b(tecode *)ava nomeprogramma+
Correttezza Programma
,i sono due tipi di correttezza: sintattica e semantica. %a sintassi riguarda la grammatica del
linguaggio ed & costituita da insieme di regole che stabiliscono se frasi del programma sono
corrette. %a semantica riguarda il significato del linguaggio ed & costituita da insieme di regole che
stabiliscono come calcolatore esegue i programmi corretti. "n programma sintatticamente corretto
non necessariamente & semanticamente corretto.
PROGRAMMAZIONE IN JAVA
public class -elloPrinter .
public static void main (/tring*+ args) .
00 1ispla( a greeting in the console 2indo2
s(stem.out.println(3-ello 4ord56);
7
7
%e prime due righe sono l'intestazione; la terza riga il commento; la quarta riga & l'istruzione stampa
a video. -elloPrinter rappresenta il nome del programma; 3-ello 4ord56 rappresenta invece
l'argomento dell'istruzione. Le istruzioni terminano sempre con ;
public class nomeprogramma .
public static void main(/tring*+ args) .
8
8
8
8
8
.
.
Identiicatori
/ono sequenze di lettere cifre decimali e sottotratti che non iniziano con una cifra decimale;
denotano costanti simboliche tipi variabili funzioni e istruzioni. /i dividono in riservati (parole
chiavi il cui significato & stato fissato da chi ha realizzato )ava; non possono essere modificati) e
introdotti dal programmatore (utilizzati e definiti nel contesto del programma )
Rego!e per identiicatori introdotti da! programmatore"
no parole chiave
carattere iniziale: 98: a8z ; <
caratteri seguenti: idem in pi= >8?
niente spazi
@aiuscole divere da minuscole (area e 9rea)
Con#enzioni identiicatori"
costanti tutte maiuscole separate con ; : P$;ABC,D :CBD;9//D%"ED
variabili con iniziale maiuscole a parte la prima: a b baseBettangolo altezzaEriangolo
3Programmi6 (classi) in maiuscolo: ,iao9Eutti
Varia$i!i
/ono aree di memoria che vengono nominate con il nome dato dal programmatore; contengono dei
valori che possono essere di vario tipo (intero reale ecc..) Dltre al valore c'& anche il nome
(identificatore). $l tipo stabilisce l'insieme dei valori che l'identificatore pu assumere e l'insieme di
operazioni nelle quali l'identificatore pu essere coinvolto. $l tipo di una variabile & decisa dal
programmatore.
$n generale per dichiarare una variabile si scrive:
Nome%ipo NomeVaria$i!e;
esempio:
int base; variabile base & intera
double area; variabile area pu contenere valori con virgola
int base= F; variabile base vale F (variabile inizializzata)
possono essere create in una unica dichiarazione pi= variabile
esempio:
double base = G.G altezza = H.I area; (variabile inizializzata)
le costanti sono variabili il cui valore non cambia; per dichiarare le costanti si scrive:
ina! Nome%ipo NomeVaria$i!e;
esempio:
final double P$;ABC,D = H.JG;
%ipo
,orpo del programma
insieme di valori pi= operazioni eseguibili su quei valori; si dividono in predefiniti dal linguaggio o
primitivi e definiti dal programmatore
i primitivi sono:
b(te (K bit) short (JL bit) int (HI bit) long (LG bit) valori numerici interi
float (HI bit) double (LG bit) valori numerici con la virgola
char (JL bit) caratteri
boolean valori logici
la variabile char memorizza un singolo carattere; i letterali sono delimitati dagli apici singoli:
'a' 'M' 'N' '<' '' 'On'
esempio:
char topArade = '9'
char terminator = ';' separator = ' ';
boolean rappresenta un valore tra vero e falso; pu assumere i valori true e false
esempio:
boolean done = false
Operatori
possono essere:
aritmetici" P 8 & 0 Q ecc.. /i dividono in unari prefissi (8J PG) e binari infissi additivi
(JPJ H8N) e binari infissi moltiplicativi (GRN S GQI * fa la divisone e vede il resto+)
re!aziona!i" T U == 5= U= T= ecc. /i dividono in infissi d'uguaglianza (J==J J5=I
*diverso vuol dire+) e binari infissi d'ordine (JTI HT=M LUG M=UF)
!ogici" V VV 5 W X X X . /i dividono in unari prefissati (5MTG *negazione del valore+) e
binari infissa ( M=G VV MTK *congiunzione logica dei valori delle espressioni ( espressione
finale vera se entrambe le espressioni iniziali vere)+ MT? XX M=UG * disgiunzione logica valori
espressione (espressione finale vera se almeno una di quelle iniziali vera)+
condiziona!i" TcondUY TvalJU : TvalIU
,i sono poi quelli di assegnamento che assegnano un valore a un variabile:
variabile = espressione
esempio:
contatore = >
area = base R altezza 0I
contatore = contatore P J
operatore esempio equivalente
P= M P= ( M = M P (
8= M 8= ( M = M 8 (
R= M R= ( M = M R (
0= M 0= ( M = M 0 (
Q= M Q= ( M = M Q (
l'assegnamento deve rispettare i tipi cio& tipo espressione compatibile con tipo variabile
esistono poi gli operatori di incremento (PP) e decremento (Z)
esempio:
countPP & equivalente a count = count P J
Con#ersioni di %ipo
pu avvenire in due versi: Promozioni ( da un tipo pi= piccolo a uno pi= grande) e ,ast (da un tipo
pi= grande a uno pi= piccolo)

esempi di promozione:
J)
b(te b;
int i;
b = J>;
i = b;
I)
int i;
long l;
float f;
double d;
i = J>;
l = i
f = l
d = f
nel cast si scrive il nome del tipo fra parentesi tonde prima dell'espressione. [ un operazione
delicata che pu portare a perdita di informazioni; il programmatore dovr! quindi assumersi le sue
responsabilit!
esempi di cast:
J)
b(te b;
int i;
i = J>
b = (b(te)i;
I)
int i );
double e = J;
i = e;
) = i P e;
i = e pu portare ad una perdita di dati poich\ si cerca di assegnare un double in un int. ]ella
somma ) = i P e il valore di i viene convertito in double e il risultato aggiunto in e; questa
operazione & valida ma l'assegnamento a un int pu causare perdita di informazioni.
'tring(e
[ un sequenza di > o pi= caratteri la cui lunghezza & data dal numero dei caratteri stessi. Dgni
carattere ha una posizione all'interno della stringa. ^engono delimitate da apici
esempio:
3-ello6
stringa vuota : 36
possono essere concatenate e i valori numerici possono essere automaticamente convertiti in
stringhe. $l segno P & usato o per denotare una addizione ma anche un concatenamento di stringhe.
Csempio:
J)
/tring first = 34illiam6;
/tring middle = 3'ames6;
/tring last = 31uncan6;
/tring full]ame = first P 3 6 P middle P 3 6 P last;
full]ame assume valore 34illiam 'ames 1uncan6
I)
3Ehe sum of 6 P M P 3 and 6 P ( P 3 is 6 P M P (;
se M = H e ( = G si avr! 3Ehe sum of H and G is HG6
9ttraverso il metodo length ( ) & possibile vedere la lunghezza della stringa e quindi il numero dei
caratteri che la compongono:
int length
esempio:
/tring name = 3-arr(6;
int len = name.length ( );
la variabile len assumer! il valore F
troviamo poi il metodo char9t ( int i ) che riceve un indice i come argomento e restituisce il
carattere che occupa la i8esima posizione sulla stringa:
char char9t (int i)
esempio:
/tring s = 3-ello6;
char c = s.char9t (J);
il valore di c & e (- corrisponde all'indice >)
attraverso il metodo trim ( ) & possibile fare una copia della stringa dove vengono tolti gli eventuali
spazi
esempio:
/tring s = 3 -ello 6;
s = s.trim( );
il risultato di s = s.trim( ) sar! 3-ello6
C!asse Mat("
%a classe math mette a disposizione molte funzioni matematiche tra cui:
@ath.sqrt(M) *radice quadrata M+
@ath.round(M) *arrotonda M al valore intero pi= vicino+
@ath.po2(M() *M elevato alla (+
@ath.sin(M) *seno di M in radianti+
@ath.cos(M) *coseno di M in radianti+
@ath.tan(M) *tangente di M+
@ath.log(M) *logaritmo di M+
@ath.eMp(M) *eWM+
@ath.random( )
Input"
Per leggere dati in input esiste /(stem.in.read( ); ma non & il massimo poich\ legge un carattere
solo e restituisce il codice 9/,$$0"nicode. Per risolvere questa limitazione utilizziamo /canner che
& una classe che permettere di leggere dati in input da varie sorgenti. Per farlo funzionare bisogna
aggiungere la seguente stringa ad inizio programma:
import )ava.util./canner;
bisogna poi creare un oggetto che legga da tastiera:
/canner scan = ne2 /canner(/(stem.in);
una volta creato permette di leggere diverse tipologie di dati in input. _atto ci utilizzeremo poi il
metodo neMt per leggere questi dati:
ans2er = scan.neMt%ine( );
il metodo neMt%ine permette di leggere una stringa fino a fine linea. Csistono anche:
neMt$nt( ) dato di tipo int
neMt1ouble( ) dato di tipo 1ouble
neMt`oolean( ) 3 3 `oolean
neMt`(te( ) 3 3 `(te
neMt_loat( ) 3 3 _loat
neMt%ong( ) 3 3 %ong
neMt/hort( ) 3 3 /hort
Metodi di contro!!o
Permettono di controllare se c'& un flusso di dati nel file preso in considerazione:
has]eMt( )
restituisce true se c'& un altro dato in input
esempio:
has]eMt$nt( )
C!assi
"n programma )ava & la definizione di un insieme di classi. "na classe & un modello che definisce
attributi (dati) e comportamenti (metodi) per realizzare un oggetto; & la definizione di un nuovo tipo
*Dgni oggetto della classe & diverso dagli altri oggetti della stessa classe ma hanno tutti la stessa
struttura+. ^iene dichiarata con la parola riservata class seguita dal nome della classe e da un blocco
che viene delimitato dalle parentesi graffe. %a parola public che viene inserita prima della parola
class indica che questa & utilizzabile da tutti.
Csempio:
@ettiamo che io voglia creare una classe Bectangle. Per fare questo dovremmo definire i suoi
parametri (asse M asse ( altezza larghezza). /i potranno avere tanti rettangoli ognuno con
coordinate e dimensioni diverse. Per creare l'oggetto si dovr! usare l'operatore ne2:
ne2 Bectangle(FJ>I>H>)
dopo ne2 va specificato il costruttore ( metodo speciale che ha lo stesso nome della classe e diversi
parametri di costruzione).
Csempio:
public Point(double M double ()
public ,ircle(Point p double radius)
Point p = ne2 Point(H.> G.>);
,ircle c = ne2 ,ircle(ne2 Point(H.> G.>) F);
,ostruire un oggetto include tre passi:
spazio di memoria allocato per oggetto e suoi campi d'istanza
un riferimento all'oggetto (variabile) utile per localizzazione in memoria e suo utilizzo; il
riferimento & assegnato come valore della variabile di riferimento
%ipi primiti#i e di rierimento
Biprendiamo adesso in considerazione le variabili per aggiungere un'ulteriore concetto sui tipi
primitivi e di riferimento: nei tipi primitivi troviamo il valore assunto dalla variabile mentre nei tipi
di riferimento un collegamento all'oggetto a cui ci si riferisce e non l'oggetto vero e proprio.
Assegnamento
Eipi primitivi: l'assegnamento a = b significa che in a viene messo il contenuto di b.
Eipi di riferimento: l'assegnamento a = b significa che il riferimento di b viene messo in a;
risulta cosa che a e b puntano allo stesso oggetto.
'pazio di memoria de! !inguaggio )a#a
%a memoria & divisa in due sezioni:
heap: spazio di memoria gestito in modo autonomo dalla '^, ()ava virtual machine)
contiene gli oggetti creati dal programma. Dgni oggetto ha un indirizzo o riferimento che lo
identifica *gli oggetti che non vengono pi= utilizzati vengono cancellati+
stacb: zona apposita di memoria dove vengono conservate le variabili dichiarate nel
programma (tipi primitivi e di riferimento); a differenza dello heap questa zona & strutturata
in una pila di 3attivazioni6 (il metodo main & l'attivazione principale e si torva in fondo alla
pila) formate da un particolare contesto di esecuzione.
Csempio:
Bectangle boM = ne2 Bectangle(F J> I> H>);
int z = 8J> P I;
int 2 = JH;
Import
serve per importare una certa classe o un pacchetto intero (insieme di classi)
Csempio:
import )ava.a2t.Bectangle; *classe+
import )ava.a2t.R *pacchetto+
qualunque classe non definita pubblica nella stessa cartella in cui si trova il file sorgente che stiamo
scrivendo risulter! sconosciuta al compilatore se non:
viene importata
faccia parte del pacchetto )ava.lang o )ava.io (queste vengono importate automaticamente)
Programmazione strutturata
%e strutture di controllo della programmazione strutturata sono:
sequenza ; .7
selezione if if0else s2itch0casezione 3atomica6 termina con ;
iterazione 2hile do02hile for (breab continue)
'e*uenza
ogni istruzione 3atomica6 termina con punto e virgola. Per raggruppare pi= istruzioni in modo da
3farne diventare una sola6 si usano le parentesi graffe. 9ttraverso le parentesi graffe & possibile
costituire un blocco
.
8
8
8
8
7
i blocchi possono essere annidati; in poche parole un blocco pu contenere un altro blocco che a sua
volta pu contenerne un altro e cosa via
.
8
.
8
8
7
7
'e!ezione $inaria
,ome enunciato in precedenza ne fanno parte if if0else
esempio:
if (a Ub)
/(stem.out.println(3 il massimo & il primo6);
else
/(stem.out.println(3 il massimo & il secondo6)
1iagrammi di flusso:
if
if0else

blocco
blocchi
annidati
dove , & una condizione e $J e $I le istruzioni.
"no degli errori pi= comuni che si commette & quello di dimenticare di mettere le parentesi graffe
quando si ha a che fare con le istruzioni complesse.
Csempio:
if (M =U () .
maM = M;
min = (;
7
else
maM = (;
min = M;
in questo caso dopo l'else verr! eseguita solo l'istruzione maM = (.
Conronto"
numeri in virgola mobile *confrontando numeri in virgola si controlla se i numeri sono
sufficientemente approssimati+
esempio:
double r = @ath.sqrt(I);
double d = r R r Z I;
if (d == >)
/(stem.out.println(3 sqrt(I) squared minus I is > 3);
else
/(stem.out.println( 3 sqrt(I) squared minus I is not > but 3 P d);
stringhe *si utilizza il metodo equals il quale verifica il contenuto mentre == se si riferiscono
al medesimo oggetto+
esempio:
if (stringJ.equals(sringI) )
esiste anche il metodo compareEo
s.compareEo(t) U >
in questo caso restituisce un numero se s precede t in ordine alfabetico
oggetti * per gli oggetti si usa sempre equal poich\ == verifica se si riferiscono al medesimo
oggetto+
esempio:
Bectangle boMJ = ne2 Bectangle (F J> I> H>);
Bectangle boMI = boMJ;
Bectangle boMH = ne2 Bectangle (F J> I> H>);
in questo caso boMJ 5= boMH (non si riferiscono ad uno stesso oggetto) ma boMJ.equals(boMH)
(contenuto uguale)
con null *non fa riferimento a nessun oggetto+
esempio:
string middle$nitial = null;
per verificar se un riferimento & null si usa operatore ==
esempio:
if (middle$nitial == null)
/(stem.out.println( first]ame P 3 3 P last]ame);
else
/(stem.out.println( first]ame P 3 3 P middle$nitial P 3 3 P last]ame);
un riferimento null & diverso da una stringa vuota poich\ la stringa vuota & una stringa valida di
lunghezza > mentre il valore null indica che una variabile di tipo stringa non si riferisce ad alcuna
stringa.
'+itc(
,ostrutto speciale che serve per un caso particolare di if a cascata; si usa quando le condizioni da
verificare sono confronti di una variabile intera con delle costanti.
Csempio:
s2itch ( digit ) . *digit variabile di tipo intera+
case J :
/(stem.out.println(3one6);
breab;
case I:
/(stem.out.println(3t2o6);
breab;
default:
/(stem.out.println(3errore6);
breab;
7
la condizione di uno s2itch deve essere di tipo int o char. %a sintassi generale di uno statement
s2itch & sotto illustrata. 1entro al blocco si possono mettere quante righe 3case6 si vogliono; il
numero che segue case viene confrontato con la variabile e se sono uguali viene allora eseguito il
codice fino al prossimo 3case6 o al 3default6. $l caso default & vero se tutti i casi precedenti sono
risultati falsi (questa variabile ha valore diverso da tutti i casi).
]ell'esempio all'inizio citato & stato inserito breab poich\ se un 3case6 risulta vero viene eseguito il
codice ad esso associato ma anche il codice dei casi restanti.
,rea-
c un comando che serve ad uscire dal blocco di codice corrente. $l suo effetto & quello di buttare via
il frame del blocco preso in considerazione e far proseguire l'esecuzione del comando che segue il
blocco. Pu essere usato all'interno di un blocco s2itch e di un ciclo.
Iterazioni
2hile
il ciclo viene ripetuto mentre la condizione & vera
esempio:
2hile (i T= J>) .
/(stem.out.println(i);
i = i P J;
7
/(stem.out.println(3fine stampa6);
1iagramma di flusso:
1o04hile
Bispetto al ciclo 2hile si differenzia per il fatto che:
con do02hile il ciclo viene eseguito almeno una volta mentre nel 2hile pu accadere che il
ciclo non viene eseguito nemmeno una volta
il controllo della condizione viene effettuato alla fine dell'iterazione
1iagramma di flusso:

esempio:
i = J;
do .
/(stem.out.println(i);
i = i P J;
7 2hile (i T= J>);
le parentesi graffe anche se sono superflue (do e 2hile fanno gi! da parentesi) sono utili per la
leggibilit!. 3 7 2hile (c) 6 non rappresenta l'inizio di un ciclo 2hile.
_or
I rappresenta l'istruzione che viene iterata; l'istruzione di inizializzazione serve ad inizializzare la
variabile di controllo; se la condizione di iterazione & vera il corpo del ciclo viene eseguito;
l'istruzione di iterazione e quell di incremento riguardano la variabile di controllo.
esempio:
for (i = >; i T= J>; i = i P J) .
/(stem.out.print(i P 3 3);
/(stem.out.println(i R i);
7
/i pu dichiarare la variabile di controllo del ciclo nell'intestazione del for facendo attenzione al
fatto che ad esempio la variabile i esiste solo nel corpo del for:
for (int i = >; i T= J>; i = i P I)
/(stem.out.println(i);
l'incremento o il decremento nel ciclo for non per forza & unitario; si pu infatti avere che i = i P I
oppure i = i Z I ecc.. Per eseguire un decremento o un incremento esistono I 3 istruzioni 6 pi=
comode:
PPi o 8 8 i *pre8incremento o pre8decremento+
iPP o i88 *post8incremento o post8decremento+
,rea- e continue
,ome detto in precedenza breab consente di uscire dal ciclo mentre continue serve a passare
all'interazione successiva *entrambe sono parole riservate+
esempio:
J)
for (int i = >; i T= J>; iPP) .
if (i == F)
breab;
/(stem.out.println(i);
7
/(stem.out.println(3 _uori dal ciclo 3);
I)
for (i = J; i T= J>; iPP) .
if (i == F)
continue;
/(stem.out.println(i);
7
/(stem.out.println(3 _uori dal ciclo6);
esempio" Massimo Comun .i#isore
for (i = J; i T= ((M T ()Y M:( ); iPP) .
if ((M Q i == >) VV (( Q i == >))
mcd = i;
7
/(stem.out.println(mcd);
M e ( rappresentano due numeri. %a parte (M T ()Y verifica se ( U M se questa condizione & vera
viene presa la M in caso contrario la (.
Esempio" /attorizzazione di un intero
int q = n;
int t = I;
/tring factors = 3T6;
2hile (t T= q 0 t) .
if (q Q t == >) .
factors = factors P t P 3 6;
q = q 0 t;
7
else
.
t = (t == I) Y H : t P I;
7
7
factors = factors P q P 3 U 3;
nel seguente programma se t = I si passer! a H altrimenti t = t P I poich\ da H in poi i fattori
saranno dispari.
Arra0
"n arra( & una struttura dati che contiene un numero fisso di elementi. $n generale & classificato
come un costruttore di tipo poich\ consente di definire nuovi tipi di dati a partire da quelli
preesistenti (devono essere tutti dello stesso tipo). %a lunghezza dell'arra( viene specificata quando
viene creato. "n arra( viene dichiarato scrivendo:
tipo* + nome;
esempio:
double* + temperature
Per creare un arra( e allocarlo si scrive:
nome = ne2 tipo*lunghezza+;
esempio:
temperature = ne2 double*J>+;
c possibile accedere ai singoli elementi e inserire valori nel seguente modo:
nome*posizione+
esempio:
temperature*F+ = IJ.L;
come si pu vedere dalla rappresentazione sopra illustrata l'indice degli arra( parte da zero e non da
uno. Per azzerare gli elementi di un arra( basta fare:
for (int i = >; i T= ?; iPP)
temperature*i+ = >;
Esempio" Ca!co!o media
double* + temperature;
temperature = ne2 double*J>+;
double media = >;
for (int i = > ; i T= ?; iPP)
media = media P temperature*i+;
/(stem.out.println(media0J>);
per sapere la lunghezza di un arra( si utilizza length:
nomearra(.length
esempio:
char* + a = ne2 char*JI+;
char* + b = .'a' 's' 'd'7;
/(stem.out.println(a.length);
/(stem.out.println(b.length);
/(stem.out.println(b*b.lenght Z I+);
/(stem.out.println(b*a.lenght0L+);
Matrici
%e matrici sono arra( multidimensionali. Per dichiarare una arra( bidimensionale si scrive:
tipo* + * + nomematrice = ne2 tipo*n. righe + *n. colonne +
esempio:
double* + * + t = ne2 double*JH+ *HI+;
esempio di inizializzazione matrice:
int* + * + board = ne2 int* + * + ..J>>7 .>J>7.JIJ77;
Bappresentazione matrice:
per dichiarare ogni dimensione si usa una coppia di * + .
esempio:
double* + * + * + a;
a = ne2 double*J>+ *J>>+ *J>>>+;
per individuare la lunghezza di una matrice si usa length per il numero di righe e length*indice+ per
il numero di colonne.
Csempio:
for (int i = >; i T m.length; iPP)
for (int ) = >; ) T m*i+.length; )PP)
m*i+ *)+ = J;
come prima accennato quindi m.length denota il numero di righe della matrice m*i+.length denota il
numero di colonne della riga della matrice.
Csempio:
double* + * + v;
v = ne2 double*JF+ *I>+;
/(stem.out.println(v.length);
/(stem.out.println(v*>+.length);
Esempio" Ricerca de! Massimo in un Arra0"
int maM = v*>+;
for (int i = >; i T v.length; iPP)
if (v*i+ U maM)
maM = v*i+;
/(stem.out.println(3 il massimo & 3 P maM);
Esempio" In#ersione Arra0
for (int i = >; i T= (a.length Z J) 0 I; iPP) .
temp = a*i+;
a*i+ = a*a.length Z J Z i +;
a *a.length 8 J Z i+ = temp;
7
Esempio" Ordinamento Arra0
for (int i = >; i T a.length 8 J; iPP)
for (int ) = i ; ) T a.length; )PP)
if (a*i+ U a*)+)
temp = a*i+;
a*i+ = a*)+;
a*)+ = temp;
Metodi
"n metodo & un blocco di codice che svolge un certo compito; finisce la sua attivit! restituendo al
chiamante un valore il cui tipo & specificato prima del nome. %a parola chiave per terminare un
metodo & return seguita da un espressione il cui valore & del tipo da restituire.
Csempio:
static double tangente (double alfa) .
return (@ath.sin(alfa) 0 @ath.cos(alfa) );
7
public static void main(/tring* +args) .
double M ( ;
M = tangente(();
7
nel seguente esempio si possono notare due tipi di parametri:
formali *usati alla definizione per specificare cosa fa un metodo+ (alfa)
attuali *usati all'invocazione per dire al metodo su quali dato deve lavorare+ (()
Per definire un metodo si scrive:
/pecificatore1i9ccesso EipoBestituito nome@etodo (lista;parametri)
esistono tre tipi di specificatore di accesso:
public: pu essere richiamato da tutti
private: pu essere richiamato solo dall'interno della classe
protected: pu essere richiamato sola dall'interno di classisottoclassi stesso pacbage
il EipoBestituito pu essere o il tipo base o il nome della classe.
$n alcuni casi una funzione pu compiere alcune operazioni senza restituire un valore di un certo
tipo; in questi casi utilizzeremo il tipo void. Per ritornare baster! inserire return.
%'esecuzione di un programma con metodi inizia con il main. $l main & un metodo speciale che
costituisce il cuore del programma (ogni applicazione )ava deve contenere una classe pubblica con
un metodo). $l main & un metodo pubblico e statico che ha come parametro un arra( di stringhe; il
contenuto del main rappresenta la sequenza principale di istruzioni che il programma deve eseguire.
Csempio:
class /tampatore@atrici .
static void stampa@atrice(int* + * + m) .
for (int i = >; i T m.length; iPP)
for (int ) = >; ) T m*i+.length; )PP)
/(stem.out.println(m*i+ *)+ P 3Ot6);
/(stem.out.println( );
7
7
public static void main(/tring*+args) .
int *+ *+ matrice = ..>JI7 .HGF7 .LNK77;
stampa@atrice(matrice);
7
7
Arra0List
"n oggetto 9rra(%ist rappresenta una lista sequenziale di oggetti generici; come per gli arra( gli
elementi della sequenza sono numerati. /i pu accedere in maniera indipendente ad ogni elemento
tramite indice intero come per gli arra(. /i pu aggiungere un nuovo elemento in fondo
all'9rra(%ist tramite metodo add. ]on c'& limite alla sua lunghezza (il tutto legato alla memoria
della macchina). Per creare un oggetto della classe 9rra(%ist si scrive:
9rra(%ist nomecostruttore = ne2 9rra(%ist( );
esempio:
9rra(%ist coins = ne2 9rra(list( );
coins.add(ne2 coins(>.J 31ime6));
coins.add(ne2 coins(>.IF 3#uarter6));
Per accedere agli elementi si usa a.get(i) passando come parametro la posizione i dell'oggetto
richiesto. Ali elementi sono del tipo Db)ect. c necessario fare un cast esplicito per poter utilizzare
tutte le funzionalit! di un oggetto recuperato dall'9rra(%ist
esempio:
,oin a,oin = (,oin) coins.get(>);
coins.get(>) restituisce un riferimento ad un Db)ect che sarebbe il primo elemento di coins.
Csempio di accesso agli elementi:
double total = >;
for (int i = >; i T coins.size( ); iPP) .
,oin a,oin = (,oin) coins.get(i);
total = total P a,oin.get^alue( );
7
(il metodo size & l'analogo del campo length degli arra()
,ome detto prima il metodo void add(Db)ect) aggiunge un elemento in fondo all'9rr(%ist. ,on il
metodo void add(int Db)ect) si aggiunge un elemento nella posizione specificata dal primo
parametro facendo scorrere gli altri elementi che erano presenti di una posizione.
Csempio:
coins.add(Jm(1ime);
c possibile rimuovere un elemento in una data posizone con il metodo:
Db)ect remove(int)
/e ci sono altri elementi questi vengono spostati di una posizione; questo metodo restituisce un
riferimento all'oggetto rimosso.
Csempio:
Db)ect rimosso = coins.remove(>);
c inoltre possibile cambiare un elemento in una certa posizione con un altro usando il metodo:
void set(int Db)ect)
esempio:
coins.set(>m(#uarter);
%a classe 9rra(%ist mette a disposizione due metodi per la ricerca dell'oggetto:
int indeMDf (Db)ect)
int last$ndeMDf (Db)ect)
$l primo metodo ricerca il primo elemento dell'9rra(%ist su cui & stato chiamato che risulta uguale
all'Db)ect passato come parametro tramite il metodo equals. $l secondo si comporta come indeMDf
ma riporta l'ultima posizione dell'oggetto nell'9rra(%ist. /fortunatamente questi presentano degli
inconvenienti. Potremo per cui fare la ricerca lineare.
Csempio:
int i = >;
boolean trovato = false;
2hile (i T coins.size( ) VV 5trovato) .
,oin c = (,oin) coins.get(i);
if (c.get^alue( ) == v)
trovato = true;
else iPP;
7
]egli 9rra(%ist non si possono inserire tipi primitivi direttamente. Per poter manipolare valori id
tipo primitivo si utilizzano le classi involucro.
9rra(%ist T1oubleU data = ne2 9rra(%ist T1oubleU( );
data.add(I?.?F);
double M = data.get(>);
9 partire da )ava F.> la conversione tra tipi primitivi e le loro classi involucro sono automatiche:
1ouble d = I?.?F; (come se fosse 1ouble d = ne2 1ouble(I?.?F))
double M = d; (come se fosse double M = d.double^alue( );)
%a conversione automatica & valida anche nelle espressioni aritmetiche:
1ouble e = d P J;
(converte d in un valore double e aggiunge J; impacchetta il risultato in un nuovo oggetto di tipo
1ouble).