Sei sulla pagina 1di 70

Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2

1
Logica Object Oriented e linguaggio Java
Indice:
1) Introduzione tecnica
1.1) Tipi semplici
1.2) Operatori
1.3) Array
1.4) Istruzioni di controllo e iterazione
2) La logica dellobject oriented
3) La Classe di Java
3.1) Definizione di Classe
3.2) Creazione di una Classe:
3.3) Metodi della classe
4) Overload
4.1) Overload dei metodi
4.2) Overload dei costruttori
5) Passaggio e ritorno di oggetti
5.1)Passaggio di oggetti come parametri
5.2) Restituzione degli oggetti
5.3) La ricorsione attraverso il metodo che chiama se stesso
6) Il controllo dellaccesso
6.1) Specificatori dellaccesso
7) Ereditariet e polimorfismo
7.1) Ereditariet e gerarchia delle classi
7.2) Utilizzo di super
7.3) Utilizzo di Final
7.4) Gerarchie di pi livelli
7.5) Smistamento dinamico dei metodi e Classi Atratte
7.6) Classe Object
7.7) Interfaccia
7.8) Sulla differenza tra Interfaccia e Classe Astratta
7.9) Esempio
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
2
1) Introduzione tecnica
1.1) Tipi semplici
Come in ogni linguaggio anche i java sono presenti i tipi di variabili semplici o predefinite.
Essi rappresentano:
Interi = byte (-128 127), short (-32.768 32.767), int (-2.147.483.648 - 2.147.483.647), long (-
9*10^18 9*10^18)
Numeri a virgola mobile = float, double
Caratteri = char
Java esegue la conversione di tipo automaticamente per tipi compatibili ed inoltre il tipo
destinazione deve essere pi grande di quello sorgente.
Il tipo char si presenta come un sottinsieme di int.
Associazione di tipi
Numeri tra stringhe diventano caratteri
Numeri sommati prima di una stringa, dopo la stringa diventano caratteri
Se il tipo di destinazione pi piccolo di quello di origine va fatta una conversione esplicita,
chiamata casting ad esempio:
int a;
byte b;
b = (byte) a;
Viene indicata tra parentesi il tipo a cui viene convertita la variabile in origine, in questo caso a ed
un int. Nel caso che si passi da una variabile a virgola mobile ad un intero, la parte decimale verr
troncata e se il numero troppo grande verr ridotta anche la parte intera.
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
3
Un altro tipo di conversione la promozione automatica del tipo si ha quando gli operandi di una
operazione sono di tipo inferiore a quello del risultato essi saranno automaticamente portati al tipo
del risultato.
Ad esempio se abbiamo 3 variabili byte a = 40; b = 50; c = 100; e una operazione il cui risultato
un int d = a * b / c; avremo automaticamente la conversione da byte a int degli operandi.
Esempi:
class Es1_Java
{
public static void main(String [] args)
{
Es1_Java s = new Es1_Java();
s.conve1();
s.conve2();
s.conve3();
}
void conve1()
{
int a = 3;
int b = 4;
System.out.print(" " + 7 + 2 + " ");
System.out.print(a + b);
System.out.print(" " + a + b + " ");
System.out.print( 2+ 7 + " ");
System.out.println(a + 1 + foo() + a + 1 );
}
void conve2()
{
int a = 32345, f = 0;
double b = 2345.89234;
short c = 123;
byte d = 23;
System.out.println(" " + a + " " + b + " " + c + " " + d + " " + f);
a = a + d;
f = (int) b;
b = b - a;
c = d;
System.out.println(" " + a + " " + b + " " + c + " " + d + " " + f);
System.out.println( a + b - c + " " + d + " " + f);
}
void conve3()
{
int a = 42;
char b = 'a';
short c = 1024;
int d = 50000;
float f = 5.67f;
double g = .1234;
double result = (a * f) + (d / b) - (g * c);
System.out.println((a * f) + " + " + (d / b)+ " - " + (g * c));
System.out.println("Risultato :" + result);
}
String foo()
{
return "foo";
}
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
4
}
72 7 34 9 4foo31
32345 2345.89234 123 23 0
32368 -30022.10766 23 23 2345
2322.8923399999985 23 2345
238.14 + 515 - 126.3616
Risultato :626.7784146484375
1.2) Operatori
Operatori aritmetici di base:
Addizione (+) , sottrazione (-) , moltiplicazione (*) e divisione (/)
Modulo (%).
Esempi:
class Es_operatori
{
public static void main(String [] args)
{
Es_operatori s = new Es_operatori();
s.ope1();
s.ope2();
s.ope3();
}
void ope1()
{
int a = 3 + 4;
int b = a * 11;
int c = b / 3;
int d = c - 27;
int f = -d;
char w = ' ';
System.out.println(" " + a + w + b + w + c + w + d + w + f);
}
void ope2()
{
double a = 3 + 4;
double b = a * 11;
double c = b / 3;
double d = c - 27;
double f = -d;
char w = ' ';
System.out.println(" " + a + w + b + w + c + w + d + w + f);
}
void ope3()
{
int a = 45;
double b = 45.378;
int a1 = 45 % 10;
double b1 = b % 10;
char w = ' ';
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
5
System.out.println(" " + a + w + a1 + w + b + w + b1);
}
}
7 77 25 -2 2
7.0 77.0 25.666666666666668 -1.3333333333333321 1.3333333333333321
45 5 45.378 5.378
Operatori di assegnazionearitmetici
Quando abbiamo una variabile w su cui viene fatta una operazione aritmetica ed il risultato viene
rimesso nella variabile, allora possibile scrivere il tutto attraverso una formula abbreviata, che
permette di passare da:
variabile = variabile ope. espressione
a
variabile ope= espressione
ad esempio:
w = w + 3 in w += 3
w = w 7 in w -= 7
w = w * 8 in w *= 8
w = w / 3 in w /= 3
w = w % 10 in w %= 10
Operatoredi incrementoedecremento
Operatore per esprimere in modo conciso lincremento di una unit del valore presente in una
variabile (e cos per il decremento).
w++ significa prendere il valore di w , incrementarlo di 1 e porre il valore in w
w-- cos anche per tale espressione, solo che in questo caso viene decrementato di 1;
possibile anche scrivere:
++w
--w
nelle due rappresentazioni il valore di w sempre lo stesso, incrementato o decrementato di 1.
Mentre quello che cambia la variabile y nel caso in cui:
w = 5;
y1 = w++;
y2 = ++w;
w = 6 ma y1 = 5 mentre y2 = 6;
class Es_assegnazione
{
public static void main(String [] args)
{
Es_assegnazione s = new Es_assegnazione();
s.asse1();
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
6
s.asse2();
}
void asse1()
{
int a = 3;
int b = 23;
int c = 36;
int d = 11;
a += (7 + 4);
b -= 3;
c /= (2 * 3);
d *= b - 7;
char w = ' ';
System.out.println(" " + a + w + b + w + c + w + d);
}
void asse2()
{
int a = 3, ya, xa;
int b = 7, yb, xb;
ya = ++a;
xa = a++;
yb = --b;
xb = b--;
char w = ' ';
System.out.println(" " + ya + w + xa + w + a + w + yb + w + xb + w +
b);
}
}
14 20 6 143
4 4 5 6 6 5
Operatori logici booliani
And = &
Or = |
Or esclusivo = ^
Not = !
A B A & B A | B A ^ B !B
FALSO FALSO FALSO FALSO FALSO VERO
VERO FALSO FALSO VERO VERO VERO
FALSO VERO FALSO VERO VERO FALSO
VERO VERO VERO VERO FALSO FALSO
Operatori logici short circuit
Sono operatori and e or indicate con && e || ed operano in maniera tale da condizionare la validit
delland o dellor alla validit del primo termine.
A && B restituisce FALSE quando A FALSE a prescindere del valori di B, in definitiva in tal
caso il valore B non viene proprio checkato. Questo esempio mostra il vantaggio:
if ( demon != 0 && val / demon > 10)
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
7
come si vede se demon = 0 laltro termine non viene provato, se invece fosse stato un & allora il
programma sarebbe andato in errore run-time.
Quindi nel caso && al primo FALSE si esce dal controllo, mentre nel caso || al primo VERO si esce
dal controllo.
Operatoredi assegnazioneeoperatoredi uguaglianza
In java loperatore di assegnazione, come abbiamo gi visto =, dire int x = 10; vuol dire assegnare
il valore 10 alla variabile intera x.
Loperatore di uguaglianza invece dato da ==, per cui in una condizione if viene usato:
if (x == 10) che vuol dire se x uguale a 10.
Operatore?
EspressioneA ? EspressioneB : EspressioneC
Questo operatore funziona cos: Se lespressioneA vera allora viene valutata lespressioneB
altrimenti viene valutata lespressioneC.
demon == 0 ? 0 : val / demon:
Se demon = 0 allora 0 altrimenti val/demon
Qui manca per il valore del risultato che va caricato su una variabile che chiameremo risul per cui
avremo:
risul = demon == 0 ? 0 : val / demon:
Come si vede dallesempio il confronto con loperatore ? deve essere tra booleani.
void asse1()
{
int n = 5;
int i = 0;
while (++i < n){
String risu = (byte) i == 1 ? "trovato" : "non trovato";
System.out.println(" " + i + " " + risu);
}
}
1 trovato
2 non trovato
3 non trovato
4 non trovato
package Blocco2;
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
8
public class tassert
{
public static int y;
public static int foo(int x)
{
System.out.print("foo ");
return y = x;
}
public static int bar(int z)
{
System.out.print("bar ");
return y = z;
}
public static void main(String [] args )
{
int t = 0;
assert t > 0 : bar(7);
assert t > 1 : foo(8); /* Line 18 */
System.out.println("done ");
}
}
void asse2()
{
int x = 0;
String st = (x > 0) ? "assertion failed" : "assertion passed" ;
System.out.println(st);
}
assertion passed
void asse3()
{
int x=20;
String sup = (x < 15) ? "small" : (x < 22)? "tiny" : "huge";
System.out.println(sup);
}
tiny
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
9
1.3) Array
Arraymonodimensionali
Un array monodimensionale un elenco di variabili dello stesso tipo. La dichiarazione di un array
si compone di una definizione del tipo, il nome dellarray e i simboli [].
int nome-array[]
a questo punto abbiamo solo una definizione di array con valori a null. Per creare un array fisico e
relativa allocazione di memoria occorre :
nome-array = new int[20]
con new va specificato il tipo e il numero di elementi che verranno creati con valore iniziale a zero.
Quindi la creazione di un array si compone di 2 parti:
1) dichiarazione di un array del tipo dati desiderato
2) con new viene creata un area di memoria con gli elementi definito
per accedere ad ogni elemento occorre indicarne lindice, in java il primo elemento sempre 0, per
cui un array di 20 elementi inizia con lelemento 0 e finisce con 19.
E possibile anche definire un array nel seguente modo:
int[] nome-array
int[] nome-array = new int[20]
Arraymultidimensionali
Gli array multidimensionali permette la rappresentazione di un vettore multidimensionali, il numero
di dimensioni viene specificato dal numero di parentesi [], il numero di elementi per ogni
dimensione dal numero indicato nella parentesi.
int[][] nome2 = new int[3][4]
E possibile definire la dimensione in modo dinamico e non costante in tale modo:
int nome2[][] = new int[3][];
nome2[0] = new int[1];
nome2[1] = new int[2];
nome2[2] = new int[3];
class Es_array
{
public static void main(String [] args)
{
Es_array s = new Es_array();
s.array1();
s.array2();
}
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
10
void array1()
{
int mesi_g[];
mesi_g = new int[12];
mesi_g[0] = 31;
mesi_g[1] = 28;
mesi_g[2] = 31;
mesi_g[3] = 30;
mesi_g[4] = 31;
mesi_g[5] = 30;
mesi_g[6] = 31;
mesi_g[7] = 31;
mesi_g[8] = 30;
mesi_g[9] = 31;
mesi_g[10] = 30;
mesi_g[11] = 31;
System.out.println(" Gennaio " + mesi_g[0] + " giorni");
}
void array2()
{
int tre[][][] = new int[3][4][5];
int i, j, k;
for(i=0; i<3; i++){
for(j=0; j<4; j++){
for(k=0; k<5; k++){
tre[i][j][k] = i*j*k; }
}
}
for(i=0; i<3; i++){
for(j=0; j<4; j++){
for(k=0; k<5; k++)
System.out.print(tre[i][j][k] + " ");
System.out.println();
}
System.out.println();
}
}
}
Gennaio 31 giorni
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 1 2 3 4
0 2 4 6 8
0 3 6 9 12
0 0 0 0 0
0 2 4 6 8
0 4 8 12 16
0 6 12 18 24
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
11
Esempio con array e operatori di assegnazione e incremento, e logici
class Demo_logici
{
boolean [] b = new boolean[3];
int count = 0;
void set(boolean [] x, int i)
{
x[i] = true;
count++;
}
void lettura(boolean b1, boolean b2,int y)
{
if ( b1 ) /* b1 */
{
if ( !b2 ) /* not b2 */
{
b1 = true;
y++;
if ( y > 1 )
y++;
if ( !b1 )
y = y + 10;
else if ( b2 = true )
y = y + 100;
else if ( b1 | b2 )
y = y + 1000;
}
}
System.out.println(" Lettura = " + b1 + " " + b2 + " " + y);
}
void scelta(boolean b1, boolean b2,int y)
{
if ( b1 && b2 )
y += 31;
else
y += 47;
int risu = b2 == true ? y % 10 : y % 11;
System.out.println(" Risultato = " + y + " " + b1 + " " + b2 + " " +
risu);
}
public static void main(String [] args)
{
Demo_logici ba = new Demo_logici();
ba.set(ba.b, 0);
ba.set(ba.b, 2);
ba.test();
ba.lettura(ba.b[0], ba.b[1], 0);
ba.scelta(ba.b[0], ba.b[1], 0);
}
void test()
{
if ( b[0] && b[1] | b[2] )
count++;
if ( b[1] && b[(++count - 2)] )
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
12
count += 7;
System.out.println("count = " +b[0]+ " " +b[1]+ " "+ b[2]+ " "+ count);
}
}
count = true false true 3
Lettura = true true 101
Risultato = 47 true false 3
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
13
1.4) Istruzioni di controllo e iterazione
Condizioneif
if (condizione)
(Istruzioni);
else if(condizione)
Istruzione;
else if(condizione)
istruzione;
..
else
istruzione;
Condizioneswitch
Switch(espressione) {
Case valore1:
istruzioni;
breack;
Case valore2:
istruzioni;
breack;
default:
Istruzioni;
}
Listruzione switch confronta il valore presente in espressione che deve essere sempre un intero o
valor letterario con i valore1, valore2 presenti in case se corrispondono esegue le istruzioni
presenti sotto case e poi col comando breack esce dal blocco di switch.
NOTA: Se non c uscita con break, tutti i valore successivi al primo case uguagliato sono
presi come validi.
class Es_controlli
{
public static void main(String [] args)
{
Es_controlli s = new Es_controlli();
s.contro1();
s.contro2();
}
void contro1()
{
int mese = 4;
String stagione;
if(mese == 12 || mese == 1 || mese ==2)
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
14
stagione = "Inverno";
else if(mese == 3 || mese == 4 || mese == 5)
stagione = "Primavera";
else if(mese == 6 || mese == 7 || mese == 8)
stagione = "Estate";
else
stagione = "Autunno";
System.out.println("Mese " + mese + " in " + stagione);
}
void contro2()
{
int mese = 7;
String stagione;
switch(mese){
case 12:
case 1:
case 2:
stagione = "Inverno";
break;
case 3:
case 4:
case 5:
stagione = "Primavera";
break;
case 6:
case 7:
case 8:
stagione = "Estate";
break;
case 9:
case 10:
case 11:
stagione = "Autunno";
break;
default:
stagione = "Mese errato";
}
System.out.println("Mese " + mese + " in " + stagione);
}
}
Mese 4 in Primavera
Mese 7 in Estate
Questo esempio a ricordare che senza un break dopo il case intercettato, vengono reperiti anche
quelli seccussivi.
public class switch0
{
public static void main(String args[])
{
int i = 1, j = 0;
switch(i)
{
case 2: j += 6;
case 4: j += 1;
default: j += 2;
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
15
case 0: j += 4;
}
System.out.println("j = " + j);
}
}
j = 6
NOTA : il valore in case deve essere sempre una costante.
public class switch2
{
final static short x = 2;
public static void main(String [] args)
{
for (int z=0; z < 3; z++)
{
switch (z)
{
case x-2: System.out.print("0 "); /* Line 11 */
default : System.out.print("Def ");
case x-1: System.out.print("1 "); /* Line 12 */
case x: System.out.print("2 "); /* Line 13 */
}
}
}
}
0 Def 1 2 1 2 2
public class switch2
{
final static short x = 2;
public static void main(String [] args)
{
for (int z=0; z < 3; z++)
{
switch (z)
{
case x-2: System.out.print("0 "); /* Line 11 */
default : System.out.print("Def ");
break;
case x-1: System.out.print("1 "); /* Line 12 */
break;
case x: System.out.print("2 "); /* Line 13 */
}
}
}
}
0 Def 1 2
Per comprendere questo esempio va detto che la variabile definita come final static short x =
2; una costante visibile a tutti gli oggetti in modo unico. Se x fosse solo
pubblic o static la procedura segnalerebbe un errore in quanto la variabile in
case deve essere sempre una costante.
public class switch1
{
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
16
final static short x = 2;
public static void main(String [] args)
{
for (int z=0; z < 3; z++)
{
switch (z)
{
case x-2: System.out.print("0 "); /* Line 11 */
case x-1: System.out.print("1 "); /* Line 12 */
case x: System.out.print("2 "); /* Line 13 */
}
}
}
}
0 1 2 1 2 2
I struzionewhile
While (condizione) {
Istruzioni;
}
Per entrare nel ciclo delle istruzioni while viene dallinizio controllata la verit della condizione , se
essa vera entra e viene fatto il ciclo a fine ciclo viene ricontrollata di nuovo se ancora vera viene
fatto un altro ciclo altrimenti esce dal blocco.
I struzionedo-while
Do {
Istruzioni;
} while(condizione);
A differenza del ciclo precedente in questo ciclo si entra sempre almeno una volta, e il controllo
della condizione viene fatto a fine ciclo.
I struzionefor
For(inizializzazione variabile ; condizione ; incremento) {
Istruzioni;
}
la variabile utilizzata deve essere intero e pu essere definita anche al momento
dellinizializzazione, la condizione confronta il valore della variabile iterativa con una espressione,
lincremento (o decremento) della variabile iterativa.
class Es_cicli
{
public static void main(String [] args)
{
Es_cicli s = new Es_cicli();
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
17
s.ciclo1();
s.ciclo2();
s.ciclo3();
s.ciclo4();
}
void ciclo1()
{
int n = 10;
int i = 0;
while (++i < n){
System.out.print(" " + i + " ");
}
System.out.println(" ");
}
void ciclo2()
{
int n = 10;
int i = 0;
do{
System.out.print(" " + i + " ");
}while(i++ < n);
System.out.println(" ");
}
void ciclo3()
{
int n = 10;
for( int i = 0 ; i < n ; i++){
System.out.print(" " + i + " ");
}
System.out.println(" ");
}
void ciclo4()
{
int n = 0;
for( int i = 10 ; i > n ; i--){
System.out.print(" " + i + " ");
}
System.out.println(" ");
}
}
1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9 10
0 1 2 3 4 5 6 7 8 9
10 9 8 7 6 5 4 3 2 1
Controllo e incremento allo stesso tempo
void ciclo6()
{
int x= 0;
int y= 0;
for (int z = 0; z < 5; z++)
{
if (( ++x > 2 ) || (++y > 2))
{
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
18
x++;
}
System.out.println(x + " " + y);
}
System.out.println(x + " " + y);
}
1 1
2 2
4 2
6 2
8 2
8 2
I struzioni break, continueereturn
Break e continue si possono usare solo in una istruzione ciclica.
Uscita dal ciclo infinito con break
void ciclo5()
{
int i = 0, j = 5;
tp: for (;;)
{
i++;
for (;;)
{
if(i > --j)
{
break tp;
}
}
}
System.out.println("i = " + i + ", j = " + j);
}
i = 1 , j = 0
Attenzione in questo esempio while che decide luscita, non il break !!!!
void ciclo7()
{
int i = 1, j = 10;
do
{
if(i > j)
{
break;
}
j--;
} while (++i < 5);
System.out.println("i = " + i + " and j = " + j);
}
i = 5 and j = 6
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
19
void ciclo8()
{
int i = 1, j = 10;
do
{
if(i++ > --j) /* Line 4 */
{
continue;
}
} while (i < 5);
System.out.println("i = " + i + " and j = " + j); /* Line 9 */
}
i = 5 and j = 6
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
20
2) La logica dellobject oriented
La logica di java lapplicazione nel campo di un linguaggio di programmazione delle
caratteristiche intensive ed estensive della logica dei concetti.
Ogni concetto rappresenta degli individui.
Ogni concetto ha delle caratteristiche che lo definiscono e che definiranno tutti gli individui che
rappresentano del concetto, ad esempio:
Animale = caratteri generali presenti in tutti gli animali che sono: et, sesso, peso, ecc.
Mammiferi = periodo di fertilit, numero di figli, periodo di gestazione, ecc.
Anche questi sono i caratteri che specificano gli individui che sono mammiferi
La definizione di mammifero specificher una sottoclasse della classe dei mammiferi, quella che
feconda luovo internamente e allatta la propria prole. Che sar differente dalla classe dei rettili che
deposita uova e non regolano la temperatura del proprio corpo.
Nellambito della classe dei mammiferi possiamo distinguere i felini dai canini, anche loro con una
definizione specifica e con delle caratteristiche specifiche.
Quindi ogni classe (o specie) ha una definizione specifica e delle caratteristiche specifiche.
Specie = genere + differenza specifica (con caratteristiche specifiche)
Tra specie e genere esiste una gerarchia tale che gli individui contenuti nel genere sono sempre
maggiori di quelli contenuti nella specie. Inoltre per il rapporto gerarchico che lega una classe con
la sua supeclasse, le propriet della superclasse sono anche le propriet degli elementi della classe
sottostante. Per cui le propriet comuni ai mammiferi saranno anche propriet dei canini e dei felini.
animali
mammiferi
canini
domestico
rettili
felini
lupo
Riproduzione
Gestazione
Sesso. Et.
Peso medio
Colore
Dimensioni
Branco
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
21
Se vogliamo allora definire la sottoclasse dei lupi dobbiamo percorrere il percorso verso lalto
prendendo di ogno concetto le sue caratteristiche specifiche, per cui:
Lupo = Animale, mammifero, canino
Come si vede laggiunta di concetti vuol dire procedere in intensione e specificher sempre di pi
le caratteristiche dellindividuo, e quindi diminuir la portata estensionale del concetto. Per ogni
concetto possibile definire un insieme di individui con tutte le propriet di quel concetto insieme a
tutte le propriet delle classi sovrastanti quella definita da quel concetto. Ovvero dai concetti che
definisco quel concetto dato.
Concetto di Lupo = Classe dei lupi con sue caratteristiche specifiche (D)
La classe dei lupi comprende anche le caratteristiche specifiche della classe dei canini (C1, C2), dei
mammiferi (B1, B2) e degli animali (A1, A2, A3).
Individui lupi = A1, A2, A3, B1, B2, C1, C2, D
Le propriet A1, A2, A3, B1, B2, C1, C2 sono ereditate dalle classi sovrastanti.
Tutti gli animali hanno la propriet BX che ad esempio sentire gli odori, per i cani domestici essa
avr una sua specificit ma questa specificit che chiameremo DX (odorato dei cani) ma questa
funzione specifica sar fatta allo stesso modo per tutti i cani, e per tutti i canini. Il modo in cui
questa funzione si attiva sempre lo stesso, quello che pu cambiare il tipo di reazione rispetto
allodore avvertito. Il modo in cui questa propriet strutturata e si rapporta con lesterno sempre
lo stesso quello che cambia il suo meccanismo interno, che cambia rispetto alla specie , ma anche
allindividuo. .
Concetto = Classe
Individuo = Istanza o Oggetto della Classe
Propriet specifiche del Concetto = Variabili e Metodi della Classe
Valori iniziali delle propriet specifiche del Concetto = Costruttori della Classe
Quindi ogni concetto contiene degli elementi, questi elementi hanno una serie di propriet definite e
delle variabili iniziali che definiscono ogni elemento del concetto. Alcune di queste propriet
possono avere lo stesso nome, quindi essere la stessa propriet differente solo dal numero di
variabili coinvolte. Ad esempio gli individui animali hanno una stessa funzione che chiamiamo
odorato, ma essa cambia sulla base del tipo di individuo animale. Se un cane o se serpente.
Nel nostro esempio AM1(1) e AM1(2) sono metodi con lo stesso nome ma con variabili differenti.
Una sottoclasse estensivamente riduce gli elementi in essa definiti, ma umenta il numero di metodi
ovvero di propriet che la definiscono, aggiungendo a quelle ereditate da A: AM1(1), AM1(2),
AM3. I metodi suoi specifici BM1 e BM2.
Quindi pi la classe (concetto) specifica pi aumentano i metodi (propriet) che definiscono i suoi
oggetti, e di conseguenza si riduce lestensione della classe. Quindi una sottoclasse eredita tutti i
metodi e i costruttori della sua classe superiore, questi metodi possono avere lo stesso nome. In tal
caso per una certa classe il metodo specifico sar selezionato sulla base del numero e tipo di
variabili. Se quelli di una classe e della sua superclasse hanno lo stesso nome quello della classe
andr in sovrapposizione di quello della superclasse a meno che non si voglia accedere direttamente
alla classe superiore con listruzione super.
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
22
2.1) Concetti base OOP : Incapsulazione
Lincapsulazione un modo di autocontenere e proteggere la natura di
un oggetto. Cos come in natura vi un confine di separazione tra un
essere vivente e il mondo esterno, e dei modi ben definiti in cui i
due sistemi interaggiscono. Cos si ha anche per gli oggetti creati
dal programma del computer, vi saranno dei modi ben definiti di
relazione tra elementi d un oggetto e lesterno di esso.
Un modo di definire laccesso quello di distinguerlo in pubblico e
privato, un accesso privato vuol dire che i membri cos designati
(variabili e metodi) sono accessibili solo allinterno della classe e
non dallesterno. Pubblico vuol dire che sono accessibili da
qualsiasi punto esterno.
Ereditariet
Nei linguaggi strutturati, normalmente si copia una struttura, ed ad
essa si d un nuovo nome, si aggiungono e modificano attributi,
creando, in tal modo una nuova entit. In java questo non
necessario, non necessario duplicare un codice per creare una
entit simile ad una gi esistente, si pu semplicemente costruire
questa nuova entit dicendogli che dovr ereditare la struttura e
quindi gli attributi e il comportamento di quella gi esistente.
Creando una nuova classe si possono ereditare tutte le propriet e i
membri di unaltra, ed in pi aggiungerne di sue specifiche.
Polimorfismo
Il polimorfismo vuol dire che una certa funzione (ad esempio odorato)
pu avere differenti modi di manifestarsi. Se un cane percepisce
lodore di un gatto avr un certo comportamento, se quello del cibo
un altro. Quindi lolfatto come funzione polimorfico e si
differenzier sulla base dei dati che sono passati dallesterno. In
java abbiamo una unica interfaccia, che comprende pi metodi con lo
stesso nome e diversi parametri passati. Sar la procedura sulla base
A
B
C
AC1;AC2;AC3
AM1(1); AM1(2); AM3
BC1;BC2;BC3
BM1; BM2
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
23
dei parametri passati a selezionare il metodo che dovr girare per
quella funzione.
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
24
3) La Classe di Java
3.1) Definizione di Classe
Una Classe un nuovo tipo di dati, la classe un MODELLO , mentre un Oggetto una ISTANZA
della classe.
class NomeClasse {
tipo Variabili
tipo Metodo {
}
}
Variabili = Variabili Istanza
Codice = Metodo
Metodo + Variabili = MEMBRI della Classe
Le variabili sono istanze in quanto ogni oggetto della classe, ovvero ogni sua copia, contiene una
copia delle variabili che quindi sono separate per ogni oggetto della classe.
<modi f i er >* class <cl ass_name> {
<at t r i but e_decl ar at i on>* o Var i abi l i
<const r uct or _decl ar at i on>* o Cost r ut t or i
<met hod_decl ar at i on>* o Met odi
}
Attributi:
<modi f i er >* <t ype> <name> [ = <i ni t i al _val ue>] ;
Costruttori:
[ <modi f i er >] <cl ass_name> ( <ar gument >* ) {
<st at ement >*
}
Metodi:
<modi f i er >* <r et ur n_t ype> <name> ( <ar gument >* ) {
<st at ement >*
}
Accesso agli oggetti membri della classe attraverso il punto.
<obj ect >. <member >
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
25
3.2) Creazione di una Classe:
class Box {
double Altezza
double Larghezza
double Lunghezza
}
Ricordiamo che una Classe non ancora un oggetto ma un modello di un oggetto. Esso in realt
un riferimento. Per creare una classe occorre la seguente istruzione:
Box NuovoBox = new Box();
Box = Tipo d oggetto ; NuovoBox = Istanza delloggetto ; new = genera una nuova instanza
Per accedere alle variabili della classe occorre utilizzare loperatore .(punto) che collega
Nome Oggetto . Nome Variabile. Ad esempio per porre laltezza a 100 si fa:
NuovoBox.Altezza = 100
Esempio Completo:
class Box {
double altezza;
double larghezza;
double lunghezza;
}
class Demo_box1
{
public static void main(String [] args)
{
double vol;
Box box1 = new Box();
Box box2 = new Box();
box1.altezza = 12;
box1.larghezza = 2;
box1.lunghezza = 1;
box2.altezza = 6;
box2.larghezza = 2;
box2.lunghezza = 3;
vol = box1.altezza * box1.larghezza * box1.lunghezza;
System.out.println(" Il volume " + vol);
vol = box2.altezza * box2.larghezza * box2.lunghezza;
System.out.println(" Il volume " + vol);
}
}
Il volume 24.0
Il volume 36.0
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
26
Quando si crea un nuovo tipo di dati definita dalla classe la procedura :
1) Dichiarazione della variabile del tipo di classe
Box mybox;
2) Creare una copia delloggetto e assegnarla alla variabile
mybox = new Box();
New genera un costruttore di quella classe che un oggetto specifico della stessa, se il costruttore
non definito esplicitamente nella classe allora viene creato uno di default con le variabili messe a
zero.
Riassumendo:
Classe = crea un nuovo tipo di dati, definisce il rapporto logico tra i membri
Oggetto di una Classe = una istanza della classe reale che occupa uno spazio in memoria con
variabili specifiche per quelloggetto
Box b1 = new Box();
Box b2 = b1;
b2 e b1 fanno riferimento allo stesso oggetto se b1 viene impostato a null b2 punta ancora allo
stesso oggetto.
Mybox
Mybox = null
Altezza
Larghezza
Lunghezza
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
27
3.3) Metodi della classe
I metodi sono le istruzioni eseguite sulle variabili della classe, al metodo si possono passare dei
parametri e pu restituire un valore di ritorno, se non c valore di ritorno il tipo void
Esempio
class BoxE {
double altezza;
double larghezza;
double lunghezza;
double volume() {
return altezza * larghezza * lunghezza ;
}
void setdim (double w, double q , double r) {
altezza = w;
larghezza = q;
lunghezza = r;
}
}
class Demo_box2
{
public static void main(String [] args)
{
double vol;
BoxE box1 = new BoxE();
BoxE box2 = new BoxE();
box1.setdim(12, 2, 1);
box2.setdim(6, 2, 3);
vol = box1.volume();
System.out.println(" Il volume " + vol);
vol = box2.volume();
System.out.println(" Il volume " + vol);
}
}
Il volume 24.0
Il volume 36.0
Come si vede il metodo setdim serve per inizializzare le variabili istanza, ma questa funzione si pu
semplificare utilizzando un costruttore esplicito.
Classe variabili
metodi
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
28
3.4) I costruttori
Esempio con costruttore a parametri
Class Box {
Double alt;
Double lar;
Double lun;
box(double w, double q , double r) {
alt = w;
lar = q;
lun = r;
}
Double vol() {
Return alt * lar * lun ;
}
}
1) il nome del costruttore lo stesso della classe.
2) il costruttore non ha ritorno.
Il questo caso il programma diventer:
class BoxDemo {
public static void main(String args[]) {
box mybox1 = new box(10, 20, 5);
box mybox2 = new box(3, 4, 7);
double v;
v = mybox1.vol();
system.out.println(Il volume + v);
v = mybox2.vol();
system.out.println(Il volume + v);
}
}
In questo caso il nome dei parametri e quello delle variabili di istanza sono differenti, se avessero lo
stesso nome il parametro nasconderebbe la variabile di istanza per evitare questo si usa la funzione
this. In tal caso si avrebbe:
box(double alt, double lar , double lun) {
this.alt = alt;
this.lar = lar;
this.lun = lun;
}
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
29
Esempio con costruttore :
class BoxEE {
double altezza;
double larghezza;
double lunghezza;
BoxEE (double w, double q , double r) {
altezza = w;
larghezza = q;
lunghezza = r;
}
double volume() {
return altezza * larghezza * lunghezza ;
}
}
class Demo_box3
{
public static void main(String [] args)
{
double vol;
BoxEE box1 = new BoxEE(12, 2, 1);
BoxEE box2 = new BoxEE(6, 2, 3);
vol = box1.volume();
System.out.println(" Il volume " + vol);
vol = box2.volume();
System.out.println(" Il volume " + vol);
}
}
Esempio con parametri e variabili con lo stesso nome
class BoxEE {
double altezza;
double larghezza;
double lunghezza;
BoxEE (double altezza, double larghezza , double lunghezza) {
this.altezza = altezza;
this.larghezza = larghezza;
this.lunghezza = lunghezza;
}
double volume() {
return altezza * larghezza * lunghezza ;
}
}
class Demo_box3
{
public static void main(String [] args)
{
double vol;
BoxEE box1 = new BoxEE(12, 2, 1);
BoxEE box2 = new BoxEE(6, 2, 3);
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
30
vol = box1.volume();
System.out.println(" Il volume " + vol);
vol = box2.volume();
System.out.println(" Il volume " + vol);
}
}
Distruttori di classi e liberazione della memoria
Java non utilizza distruttori di classe ma ha una procedura automatica GARBAGE
COLLECTION, che elimina automaticamente le classi non pi utilizzate. E possibile agganciare a
questa funzione automatica il metodo finaline() messo nella classe con le istruzioni da eseguire
prima della distruzione della classe.
NOTA: la garbage collection non gestibile dallutente e, in genere, non sa quando verr eseguita.
Differenza tra equals() e ==
Loperatore == confronta due riferimenti di oggetti per verificare se sono la stessa istanza
Loperatore equals() confronta i caratteri, quindi il contenuto di due stringhe.
class TestUguale {
public static void main(String[] args) {
MiaData date1 = new MiaData(14, 3, 1976);
MiaData date2 = new MiaData(14, 3, 1976);
String a = "universo";
String b = "universo";
String Pa = new String("universo");
String Pb = new String("universo");
// qui viene confrontato il puntatore che non uguale
if ( date1 == date2 ) {
System.out.println("date1 is identical to date2");
} else {
System.out.println("date1 is not identical to date2");
}
// qui viene confrontato il valore
if ( a == b ) {
System.out.println("a is identical to b");
} else {
System.out.println("a is not identical b");
}
// qui viene confrontato il puntatore
if ( Pa == Pb ) {
System.out.println("Pa is identical to Pb");
} else {
System.out.println("Pa is not identical Pb");
}
if ( date1.equals(date2) ) {
System.out.println("date1 is equal to date2");
} else {
System.out.println("date1 is not equal to date2");
}
System.out.println("set date2 = date1;");
date2 = date1;
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
31
// qui viene confrontato il valore
if ( a.equals(b) ) {
System.out.println("a is equal to b");
} else {
System.out.println("a is not equal b");
}
if ( Pa.equals(Pb) ) {
System.out.println("Pa = Pb");
} else {
System.out.println("Pa |= Pb");
}
if ( date1 == date2 ) {
System.out.println("date1 is identical to date2");
} else {
System.out.println("date1 is not identical to date2");
}
}
}
date1 is not identical to date2
a is identical to b
Pa is not identical Pb
date1 is not equal to date2
set date2 = date1;
a is equal to b
Pa = Pb
date1 is identical to date2
Ancora sulla differenza tra == ed equals()
public class booleano
{
public static void main(String [] args)
{
int result = 0;
Boolean b1 = new Boolean("TRUE");
Boolean b2 = new Boolean("true");
Boolean b3 = new Boolean("tRuE");
Boolean b4 = new Boolean("false");
if (b1 == b2) /* Line 10 */
result = 1;
if (b1.equals(b2) ) /* Line 12 */
result = result + 10;
if (b2 == b4) /* Line 14 */
result = result + 100;
if (b2.equals(b4) ) /* Line 16 */
result = result + 1000;
if (b2.equals(b3) ) /* Line 18 */
result = result + 10000;
System.out.println("b1 " + b1 + " b2 " + b2 + " b3 " + b3 + " b4 " +
b4);
System.out.println("result = " + result);
}
}
b1 true b2 true b3 true b4 false
result = 10010
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
32
4) Overload
4.1) Overload dei metodi
Si ha quando pi metodi hanno lo stesso nome, essi saranno differenziati solo per il numero e la
tipologia dei parametri passati.
NOTA: il tipo di parametro di ritorno non differenzia il metodo.
Inoltre se per un certo numero di parametri, ad esempio 2, non esiste una corrispondenza per il tipo
Java provvede alla conversione automatica per la ricerca del metodo corrispondente.
Esempio
Classe OverloadD {
Void test() {
System.out.println(Nessun parametro);
}
void test(int a, int b) {
System.out.println(a e b : +a + + b);
}
void test(double a) {
System.out.println(Parametro double a : + a);
}
}
class Over{
public static void main(String arg[]) {
OverloadD ob = new OverloadD();
Int y = 88;
Ob.test();
Ob.test(10, 20);
Ob.test(y);
Ob.test(234.890) ;
}
}
Le ultime due chiamate andranno sempre su test con double per la converione automatica dei dati.
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
33
4.2) Overload dei costruttori
Si usa quando si vogliono inizializzare le variabili istanza della classe con diversi valori a seconda
delle circostanze del programma.
Esempio
class BoxEE2 {
double altezza;
double larghezza;
double lunghezza;
BoxEE2 () {
this.altezza = -1;
this.larghezza = -1;
this.lunghezza = -1;
}
BoxEE2 (double len) {
this.altezza = this.larghezza = this.lunghezza = len;
}
BoxEE2 (double altezza, double larghezza , double lunghezza) {
this.altezza = altezza;
this.larghezza = larghezza;
this.lunghezza = lunghezza;
}
double volume() {
return altezza * larghezza * lunghezza ;
}
}
class Demo_box4
{
public static void main(String [] args)
{
double vol;
BoxEE2 box1 = new BoxEE2(12, 2, 1);
BoxEE2 box2 = new BoxEE2(2);
BoxEE2 box3 = new BoxEE2();
vol = box1.volume();
System.out.println(" Il volume " + vol);
vol = box2.volume();
System.out.println(" Il volume " + vol);
vol = box3.volume();
System.out.println(" Il volume " + vol);
}
}
Il volume 24.0
Il volume 8.0
Il volume -1.0
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
34
5) Passaggio e ritorno di oggetti
5.1)Passaggio di oggetti come parametri
1) Caso di un metodo che utilizza un altro metodo della classe come parametro
2) Caso di un costruttore che utilizza come parametri un altro costruttore.
Class Test {
Int a, b;
Test(int i, int j) {
a = i;
b = j;
}
Boolean uguale(Test o) {
If(o.a == a && o.b == b) return true;
Else return false;
}
}
class Passob {
public static void main(arg[]) {
Test ob1 = new Test(100, 21);
Test ob2 = new Test(100, 21);
Test ob3 = new Test(-1, 2);
System.out.println(ob1 == ob2 : + ob1.uguale(ob2));
System.out.println(ob1 == ob3 : + ob1.uguale(ob3));
}
}
Esempio con costruttori e con costruttore con parametro con riferimento a un costruttore
class BoxEE2 {
double altezza;
double larghezza;
double lunghezza;
BoxEE2 () {
this.altezza = -1;
this.larghezza = -1;
this.lunghezza = -1;
}
BoxEE2 (double len) {
this.altezza = this.larghezza = this.lunghezza = len;
}
BoxEE2 (double altezza, double larghezza , double lunghezza) {
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
35
this.altezza = altezza;
this.larghezza = larghezza;
this.lunghezza = lunghezza;
}
BoxEE2 (BoxEE2 ob) {
this.altezza = ob.altezza;
this.larghezza = ob.larghezza;
this.lunghezza = ob.lunghezza;
}
double volume() {
return altezza * larghezza * lunghezza ;
}
}
class Demo_box4
{
public static void main(String [] args)
{
double vol;
BoxEE2 box1 = new BoxEE2(12, 2, 1);
BoxEE2 box2 = new BoxEE2(2);
BoxEE2 box3 = new BoxEE2();
BoxEE2 box4 = new BoxEE2(box1);
vol = box1.volume();
System.out.println(" Il volume " + vol);
vol = box2.volume();
System.out.println(" Il volume " + vol);
vol = box3.volume();
System.out.println(" Il volume " + vol);
vol = box4.volume();
System.out.println(" Il volume " + vol);
}
}
Il volume 24.0
Il volume 8.0
Il volume -1.0
Il volume 24.0
Passaggio parametri avviene :
1) Per valore
2) Per riferimento ad un oggetto
Quando si passa un valore si assegna quel valore al parametro, il parametro non cambia prima e
dopo lesecuzione del metodo.
Quando si assegna un riferimento al parametro lesecuzione del metodo cambia il valore del
riferimento e quindi dei parametri.
Esempio
class Test {
int a, b;
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
36
Test(int i, int j) {
a = i;
b = j;
}
boolean uguale(Test o) {
if(o.a == a && o.b == b) return true;
else return false;
}
void Meth(Test o) {
o.a *= 2;
o.b /= 2;
}
void Meth() {
a *= 2;
b /= 2;
}
}
class Es_puntatori
{
public static void main(String [] args) {
int h1 = 100;
int h2 = 21;
Test ob1 = new Test(h1, h2);
Test ob2 = new Test(h1, h2);
Test ob3 = new Test(-1, 2);
System.out.println("ob1 == ob2 :" + ob1.uguale(ob2));
System.out.println("ob1 == ob3 :" + ob1.uguale(ob3));
System.out.println("Valori prima modifica :" + ob1.a + " " + ob1.b);
ob1.Meth(ob1);
System.out.println("Valori dopo modifica :" + ob1.a + " " + ob1.b);
System.out.println(" " + h1 + " " + h2);
}
}
b1 == ob2 :true
ob1 == ob3 :false
Valori prima modifica :100 21
Valori dopo modifica :200 10
100 21
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
37
5.2) Restituzione degli oggetti
E possibile restituire oggetti e questo vuol dire restituire il valore del puntatore o riferimento.
Class Test {
Int a;
Test(int i) {
a = i;
}
Test incre10() {
Test temp = new Test(a+10);
Return temp;
}
}
class Retob() {
public static void main(String arg[]) {
Test ob1 = new Test(2);
Test ob2;
Ob2 = ob1.incre10()
System.out.orintln(a di ob1 : + ob1.a);
System.out.orintln(a di ob2 : + ob2.a);
Ob2 = ob2.incre10();
System.out.orintln(Secondo a di ob2 : + ob2.a);
}
}
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
38
La ricorsione attraverso il metodo che chiama se stesso
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
39
6) Il controllo dellaccesso
6.1) Specificatori dellaccesso
Il controllo dellaccesso permette di stabilire quali metodi e/o variabili possono essere visti e
accessibili al di fuori della classe.
Il controllo dellaccesso avviene attraverso gli specificatori dellaccesso.
Public ; private, protected
Metodi e Variabili sono membri di una Classe e il loro controllo dellaccesso avviene esattamente
allo stesso modo.
Public permette laccesso ai membri della classe dal programma, dallesterno della classe. (con
ambito di visibilit in genere legata al pacchetto).
Private permette laccesso ai membri della classe solo da parte degli altri membri della classe.
Modificatori dellaccesso riguardano le classi di accessibilit e non le istanze.
Protected permette laccessibilit solo alla sottoclasse della classe di un certo pacchetto.
Default molto simile a protected (make sure you spot the difference) default rende il membro
accessibile solo alle classi dello stesso pacchetto.
Abstract dichiara un metodo che non pu essere implementato.
Transient indica una variabile che non persiste per la durata delloggetto..
Volatile indica che un thread deve riconciliare la copia di lavoro di una variabile con il valore
originario tutte le volte che accede alla variabile stessa..
Programma
Classe B
Classe A
Private Metodo X1
Metodo Y1
Public Metodo X2
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
40
In ordine di restrizione:
1) private = variabili e metodi accessibili solo x quella classe
2) protected = accessibili solo alle sottoclassi e superclassi di un certo pacchetto
3) default = accessibili solo alle classi dello stesso pacchetto.
4) pubblic = accessibile a tutte le classi del programma
Esempio
class Stack {
private int stk[] = new int[10];
private int tons;
Stack() {
tons = -1;
}
void push(int item) {
if(tons==9)
System.out.println("Lo stack pieno");
else
stk[++tons] = item;
}
int pop() {
if(tons < 0) {
System.out.println("Stack sottolivello");
return 0;}
else
return stk[tons--];
}
}
class Demo_stack
{
public static void main(String [] args)
{
Stack mystack1 = new Stack();
Stack mystack2 = new Stack();
for(int i=0; i < 11; i++) mystack1.push(i);
for(int i=10; i < 20; i++) mystack2.push(i);
System.out.print("Stack mystack1 ");
for(int i=0; i < 10; i++)
System.out.print(" " + mystack1.pop());
System.out.println(" ");
System.out.print("Stack mystack2");
for(int i=0; i < 10; i++)
System.out.print(" " + mystack2.pop());
}
}
Lo stack pieno
Stack mystack1 9 8 7 6 5 4 3 2 1 0
Stack mystack2 19 18 17 16 15 14 13 12 11 10
Nota : y = ++x se x = 2 allinizio allora y = 3 e x = 3 in quanto ++x incrementa prima x e poi lo
mette in y.
y = x++ mette prima y = x e poi incrementa x, per cui y = 2 e x = 3.
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
41
6.2) Utilizzo di Static
Static permette di utilizzare un membro di una classe (variabile o metodo) prima che di essa venga
creato un oggetto specifico con new.
Le variabili di tipo static sono variabili globali, questo vuol dire che quando una variabile viene
dichiarata static essa condivisa da tutti gli oggetti di quella classe.
Un metodo statico generalmente usato per avere metodi di uso
globale, per invocare un metodo static non necessario creare un
oggetto istanza e tramite esso invocare il metodo, ma basta il nome
della classe che lo contiene, il punto e quindi il nome del metodo.
I metodi static hanno le seguenti limitazioni:
1) possono chiamare solo altri metodi static.
2) possono accedere solo a dati static.
3) non possono fare riferimento a key come this o super
Se si vule inizializzare le variabili static occorre fare un blocco static che viene eseguito una sola
volta quando la classe viene caricata la prima volta.
Esempio
Class UsaStatic {
Static int a =3;
static int b;
static void meth(int x) {
System.out.println(x = + x);
System.out.println(a = + a);
System.out.println(b = + b);
}
static {
System.out.println(Inizializzazione di static);
b = a * 4;
}
public static void main(String arg[]) {
meth(42);
}
}
Il processo il seguente:
1) Viene caricata la classe UsaStatic
2) Sono eseguite tutte le istruzioni static, quindi inizializzazione delle variabili a e b, ed
esecuzione del blocco static per cui b diventa 12
3) Viene eseguita il main
4) Viene eseguito il metodo meth.
Per accedere da qualsiasi altro programma ai metodi e alle variabili globali basta specificare
Nomeclasse.metodo()
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
42
Nomeclasse.variabile
In questo esempio si vede come la variabile passata ad un metodo una duplicazione della variabile
originaria che non viene modificata.
class Accesso2
{
public static void main(String [] args)
{
int x = 11;
Accesso2 s = new Accesso2();
s.inizio(x);
System.out.println("Stampa x 1 "+ x);
}
public void inizio(int x)
{
x = x + 2;
doppia(x);
System.out.println("Stampa x 2 "+ x);
}
public void doppia(int x)
{
x = x* 2;
System.out.println("Stampa x 3 "+ x);
}
}
Stampa x 3 26
Stampa x 2 13
Stampa x 1 11
Per modificare un valore dal chiamante un metodo quello di ritornare il valore dal metodo.
class Accesso3
{
public static void main(String [] args)
{
Accesso3 s = new Accesso3();
s.inizio();
}
public void inizio()
{
String b = "magia";
String a = "Abra";
b = doppia(a);
System.out.println("Stampa a "+ a + " b " + b);
}
public String doppia(String a)
{
a = a + "cadabra";
System.out.println("Stampa a 2 "+ a);
return a;
}
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
43
}
Stampa a 2 Abracadabra
Stampa a Abra b Abracadabra
Con lutilizzo di static sulla variabile abbiamo la possibilit di accere ad essa in ogni punto della
classe e sempre sulla stessa variabile.
class Accesso1
{
static int w;
public static void main(String [] args)
{
Accesso1 s = new Accesso1();
s.inizio();
System.out.println("Stampa x 1 "+ w);
}
void inizio()
{
int x = 11;
doppia(x);
System.out.println("Stampa x 2 "+ x);
}
public void doppia(int x)
{
x = x* 2;
w = x;
System.out.println("Stampa x 3 "+ x);
}
}
Stampa x 3 22
Stampa x 2 11
Stampa x 1 22
public class Accesso4
{
Accesso4()
{
System.out.print("foo");
}
public static void main (String [] args)
{
Accesso4 f = new Accesso4();
f.makeBar();
}
void makeBar()
{
(new Bar() {}).go();
}
}/* class Foo ends */
class Bar
{
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
44
Bar()
{
System.out.print("bar");
}
public void go()
{
System.out.print("hi");
}
}
foobarhi
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
45
7)Ereditariet e polimorfismo
7.1) Ereditariet e gerarchia delle classi
La classe B eredita tutti I membri della classe A oltre ad aggiungere i suoi specifici.
La Classe A la superclasse, la classe B la sottoclasse
Quindi una sottoclasse eredita tutti i membri della sua superclasse pi i suoi specifici.
Per avere questo si deve scrivere:
Class B extends A {
}
Ovvero la classe B una estensione della classe A
NOTA : E possibile specificare solo una superclasse per una classe data.
Inoltre possibile creare una gerarchia di classi per cui:
I)n questo caso avremo:
Class B exstend A {
Public String getDettagli(){ }
}
Class C exstend B {
Public String getDettagli(){ }
}
NOTA : Non possible
Class C exstend C {
}
NOTA: Un membro di una classe che stato dichiarato private rimarr tale per la sua classe. Non
vi potr accedere alcun codice esterno alla sua classe neppure le sottoclassi.
Classe A
Classe B
Classe A
Classe B
Classe C
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
46
<modi f i er > class <name> [ extends <super cl ass>] {
<decl ar at i on>*
}
getDettagli() di C sostituisce getDettagli() di B, ma se da C voglio chiamare getDettagli() di B
allora devo usare super(). Ovvero
super.getDettagli()
Polomorfismo
La collezione di oggetti dello stesso tipo di classe chiamata Omogenea, mentre quella di differenti
tipi di classi chiamata Eterogenea.
Se consideriamo:
public class Employee extends Object
public class Manager extends Employee
public class Engineer extends Employee
Allora possiamo raggruppare oggetti di differenti classi purch siano tra di loro in un ordine
ereditario gerarchico.
Employee [] staff = new Employee[1024];
staff[0] = new Manager();
staff[1] = new Employee();
staff[2] = new Engineer();
Utilizzo di instanceOf
public void doSomething(Employee e) {
if ( e instanceof Manager ) {
// Process a Manager
} else if ( e instanceof Engineer ) {
// Process an Engineer
} else {
// Process any other type of Employee
}
}
Casting degli Oggetti
Trasforma un tipo di oggetto in un altro tipo imparentato.
public void doSomething(Employee e) {
if ( e instanceof Manager ) {
Manager m = (Manager) e;
System.out.println(This is the manager of
+ m.getDepartment());
}
// rest of operation
}
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
47
Esempio
class BoxEE3 {
double altezza;
double larghezza;
double lunghezza;
BoxEE3 () {
this.altezza = -1;
this.larghezza = -1;
this.lunghezza = -1;
}
BoxEE3 (double len) {
this.altezza = this.larghezza = this.lunghezza = len;
}
BoxEE3 (double altezza, double larghezza , double lunghezza) {
this.altezza = altezza;
this.larghezza = larghezza;
this.lunghezza = lunghezza;
}
BoxEE3 (BoxEE3 ob) {
this.altezza = ob.altezza;
this.larghezza = ob.larghezza;
this.lunghezza = ob.lunghezza;
}
double volume() {
return altezza * larghezza * lunghezza ;
}
}
class BoxPeso extends BoxEE3 {
double peso;
BoxPeso (double w, double q , double r, double t) {
altezza = w ;
larghezza = q ;
lunghezza = r ;
peso = t;
}
}
class Demo_box5
{
public static void main(String [] args)
{
double vol;
BoxPeso b1 = new BoxPeso(3, 5, 7, 11.98);
BoxPeso b2 = new BoxPeso(2, 6, 12.0, 34 );
double v;
v = b1.volume();
System.out.println("Volume b1 :" + v);
System.out.println("Peso b1 :" + b1.peso);
System.out.println();
v= b2.volume();
System.out.println("Volume b2 :" + v);
System.out.println("Peso b1 :" + b2.peso);
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
48
}
}
Volume b1 :105.0
Peso b1 :11.98
Volume b2 :144.0
Peso b1 :34.0
Una volta creata una Superclasse con le propriet generali delloggetto, da essa si pu partire per
aggiungere alloggetto propriet specifiche attraverso la creazione di Sottoclassi.
Nellesempio abbiamo 2 tipi di oggetti, loggetto box e loggetto boxpeso, con loggetto box posso
fare riferimento solo ai membri di box. Mentre con loggetto boxpeso posso fare riferimento sia a
quelli di box che a quelli aggiunti in boxpeso.
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
49
7.2) Utilizzo di super
Una sottoclasse pu chiamare un metodo costruttore definito in una superclasse nella forma:
super(elenco-parametri);
Anche in questo caso il numero e il tipo di parametri sono sufficienti per trovare il costruttore pi
vicino presente nella superclasse.
NOTA: super deve essere la prima istruzione eseguita allinterno del costruttore della sottoclasse.
Nel programma precedente noi possiamo definire come private le variabili alt, lun, lar, ed
aggiungere nella sottoclasse la chiamata ai costruttori di box e la variabile pes.
Quando una sottoclasse chiama super chiama il costruttore della superclasse immediatamente
adiacente.
class BoxPeso3 extends BoxEE3 {
double peso;
BoxPeso3 (double w, double q , double r, double t) {
super(w, q, r);
peso = t;
}
BoxPeso3(BoxPeso3 ob) {
super(ob);
peso = ob.peso;
}
BoxPeso3() {
super() ;
peso = -1;
}
BoxPeso3(double len, double t) {
super(len);
peso = t ;
}
}
class Demo_box6
{
public static void main(String [] args)
{
double vol;
BoxPeso b1 = new BoxPeso(3, 5, 7, 11.98);
BoxPeso b2 = new BoxPeso(2, 6, 12.0, 34 );
vol = b1.volume();
System.out.println("Volume b1 :" + vol);
System.out.println("Peso b1 :" + b1.peso);
System.out.println();
vol = b2.volume();
System.out.println("Volume b2 :" + vol);
System.out.println("Peso b1 :" + b2.peso);
}
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
50
}
Volume b1 :105.0
Peso b1 :11.98
Volume b2 :144.0
Peso b1 :34.0
Quando una sottoclasse ha gli stessi nomi dei membri della superclasse allora poich quelli attivi
sono i membri della sottoclasse, per fare esplicito riferimento ai membri della superclasse si usa
super.
Super.membro;
Esempio
Class A {
int i;
}
class B exstend A {
int i;
B(int a, int b) {
Super.i = a;
i = b;
}
void show() {
System.out.println(i nella superclasse . + super.i);
System.out.println(i nella sottoclasse . + i);
}
}
class usasuper {
public static void main(String arg[]) {
B subcl = new B(1, 2);
Subcl.show()
}
}
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
51
7.3) Utilizzo di Final
Final pu essere specificato a livello di variabile, di metodo e di classe.
Variabile
Indica una costante
Metodo
Serve per impedire overload dei metodi, quindi i metodi definiti come final non possono essere
ridefiniti. Il vantaggio quello di un miglioramento delle prestazioni.
Class A {
final void calc() {
System.out.println(Esegue);
}
}
Class B extends A {
void calc(){
System.out.println(Esegue 2); ERRORE ------------
}
}
Classe
Una classe definite come final non pu essere ereditata da un altra classe, ovvero non pu diventare
la superclasse di un'altra..
final Class A {
void calc() {
System.out.println(Esegue);
}
}
Class B extends A { ERRORE ------------
void calc(){
System.out.println(Esegue 2); }
}
In definitiva luso di final impedisce lereditariet e loverloading.
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
52
7.4) Gerarchie di pi livelli
Una sottoclasse pu diventare una superclasse di un'altra sottoclasse, nel caso sotto la classe
BoxPeso3 la sottoclasse di BoxEE3, ma a sua volta stata creata una sottoclasse della classe
BoxPeso3, ovvero BoxCosto3 e quindi BoxPeso3 una superclasse di BoxCosto3.
class BoxPeso3 extends BoxEE3 {
double peso;
BoxPeso3 (double w, double q , double r, double t) {
super(w, q, r);
peso = t;
}
BoxPeso3(BoxPeso3 ob) {
super(ob);
peso = ob.peso;
}
BoxPeso3() {
super() ;
peso = -1;
}
BoxPeso3(double len, double t) {
super(len);
peso = t ;
}
}
class BoxCosto3 extends BoxPeso3 {
double cos;
BoxCosto3(double w, double q , double r, double t, double y) {
super(w, q, r, t) ;
cos = y ;
}
BoxCosto3(BoxCosto3 ob) {
super(ob);
cos = ob.cos;
}
BoxCosto3() {
BoxEE3
BoxPeso3
BoxCosto3
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
53
super() ;
cos = -1;
}
BoxCosto3(double len, double p, double t) {
super(len, p);
cos = t ;
}
}
class Demo_box6
{
public static void main(String [] args)
{
double vol;
BoxPeso3 b1 = new BoxPeso3(3, 5, 7, 11.98);
BoxPeso3 b2 = new BoxPeso3(2, 6, 12.0, 34 );
BoxCosto3 c1 = new BoxCosto3(2, 3, 5, 77.12, 2300);
BoxCosto3 c2 = new BoxCosto3();
BoxCosto3 c3 = new BoxCosto3(c1);
vol = b1.volume();
System.out.println("Volume b1 :" + vol);
System.out.println("Peso b1 :" + b1.peso);
System.out.println();
vol = b2.volume();
System.out.println("Volume b2 :" + vol);
System.out.println("Peso b1 :" + b2.peso);
vol = c1.volume();
System.out.print("Volume c1 :" + vol);
System.out.print("Peso : " + c1.peso);
System.out.print("Costo: " + c1.cos);
System.out.println();
vol = c2.volume();
System.out.print("Volume c2 :" + vol);
System.out.print("Peso : " + c2.peso);
System.out.print("Costo: " + c2.cos);
System.out.println();
vol = c3.volume();
System.out.print("Volume c3 :" + vol);
System.out.print("Peso : " + c3.peso);
System.out.print("Costo: " + c3.cos);
System.out.println();
}
}
Volume b1 :105.0
Peso b1 :11.98
Volume b2 :144.0
Peso b1 :34.0
Volume c1 :30.0Peso : 77.12Costo: 2300.0
Volume c2 :-1.0Peso : -1.0Costo: -1.0
Volume c3 :30.0Peso : 77.12Costo: 2300.0
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
54
super chiama sempre il costruttore della superclasse pi vicina, quindi super del tipo BoxCosto3
chiama i costruttori di BoxPeso3 e super di BoxPeso3 chiama i costruttori di BoxEE3..
NOTA : i costruttori sono chiamati sempre nellordine di derivazione partendo dalla prima
superclasse, per poi passare alla sua sottoclasse e poi alla sottoclasse della sottoclasse, ecc.
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
55
7.5) Smistamento dinamico dei metodi e Classi Atratte
Se in una sottoclasse abbiamo un metodo con lo stesso nome di quello presente nella superclasse
allora quando definisco un tipo di classe della sottoclasse vedr il metodo della sottoclasse. Per
accedere al metodo della superclasse devo usare listruzione super.
Questo solo nel caso che i due metodi siano identici per parametri e tipo variabili, ma se non lo sono
allora non necessario usare super
Laccesso ai metodi avviene run-time questo vuol dire che posso cambiare una sottoclasse
aggiungendo o modificando un metodo senza la necessit di ricompilare tutte le classi collegate.
Esempio
class Figura {
double dim1, dim2;
double are;
Figura (double dim1, double dim2) {
this.dim1 = dim1;
this.dim2 = dim2;
}
double Area() {
are = 0;
return are;
}
}
class Rettangolo extends Figura {
Rettangolo(double w, double q) {
super(w, q) ;
}
double Area() {
are = (dim1 * dim2);
return are;
}
}
class Triangolo extends Figura {
Triangolo(double w, double q) {
super(w, q);
}
double Area() {
are = (dim1 * dim2)/2;
return are;
}
}
class Demo_super
{
public static void main(String [] args)
{
Figura fig = new Figura (3, 5);
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
56
Rettangolo ret = new Rettangolo(2, 7);
Triangolo tri = new Triangolo(4, 11);
Figura f;
f = fig;
System.out.println("Area Figura :" + f.Area());
f = ret;
System.out.println("Area Rettangolo :" + f.Area());
f = tri;
System.out.println("Area Triangolo :" + f.Area());
}
}
Area Figura :0.0
Area Rettangolo :14.0
Area Triangolo :22.0
Il caso di area nella superclasse figura in realt fissa solo un riferimento, un metodo che non
esegue nulla ma definisce il metodo in astratto. Java utilizza il metodo astratto per definire questo
tipo di metodo nella superclasse, lutilit di questo metodo astratto quello di costringere le altre
sottoclassi create dalla superclasse di avere un metodo con lo stesso nome ridefinito.
NOTA: Se un metodo astratto allora la classe deve essere definita astratta
Di una classe astratta non si hanno oggetti.
Esempio
abstract class Figura {
double dim1, dim2;
double are;
Figura (double dim1, double dim2) {
this.dim1 = dim1;
this.dim2 = dim2;
}
abstract double Area();
}
class Rettangolo extends Figura {
Rettangolo(double w, double q) {
super(w, q) ;
}
double Area() {
are = (dim1 * dim2);
return are;
}
}
class Triangolo extends Figura {
Triangolo(double w, double q) {
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
57
super(w, q);
}
double Area() {
are = (dim1 * dim2)/2;
return are;
}
}
class Demo_super
{
public static void main(String [] args)
{
Rettangolo ret = new Rettangolo(2, 7);
Triangolo tri = new Triangolo(4, 11);
Figura f;
f = ret;
System.out.println("Area Rettangolo :" + f.Area());
f = tri;
System.out.println("Area Triangolo :" + f.Area());
}
}
Area Rettangolo :14.0
Area Triangolo :22.0
Non possibile adesso creare oggetti di tipo figura perch una classe astratta. Inoltre adesso
TUTTE le sottoclassi di figura devono avere definito il metodo area. Anche se non possibile
creare un oggetto figura possibile creare un suo riferimento, come stato fatto nellesempio.
Una Classe extends una classe astrata ridefinendo in essa il metodo astratto presente.
Un metodo astratto un metodo che non ha corpo ma solo parametri e specifica di ritorno.
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
58
7.6) Classe Object
Tutte le classi create in java sono sottoclassi di Object. Una variabile di Objiect pu fare riferimento
a qualsiasi classe creata, compresi gli array che in java sono considerati classi
Metodi di Object
Esempio:
public class Object {
public Object() {}
}
public class Employee extends Object {
private String name;
private double salary = 15000.00;
private Date birthDate;
public Employee(String n, Date DoB) {
// implicit super();
name = n;
birthDate = DoB;
}
public Employee(String n) {
this(n, null);
}
}
public class Manager extends Employee {
private String department;
public Manager(String n, String d) {
super(n);
department = d;
}
}
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
59
7.7) Interfaccia
Le interface sono Classi che non hanno variabili di istanza e i loro metodi NON hanno corpo.
Questo meccanismo efficace per avere una gestione dinamica dei metodi pur non avendo classi tra
loro in gerarchia.
Per creare una interfaccia
Accesso (che pu essere publici o niente in questultimo caso laccesso pubblico per tutte le classi
del package) interface nome_interfaccia {
Tipo_ritorno2 nome_metodo1 ( parametri 1) ;
Tipo_ritorno2 nome_metodo2 ( parametri 2) ;
Tipo_ritorno3 nome_metodo3 ( parametri 3) ;
Tipo_valA nome_varA final = valore;
Tipo_valB nome_varB final = valore;
}
Ogni classe che implementa una interfaccia deve implementare TUTTI i suoi metodi. Le variabili
dichiarate in una interfaccia sono TUTTE static e final, questo vuol dire che non possono essere
modificate dalle classi di implementazione
Una classe pu implementare un numero qualsiasi di interfacce.
Una Classe astratta pu implementare una interfaccia.
Una Interfaccia pu estendere un'altra interfaccia.
Una Classe astratta pu estendere un'altra Classe astratta
NOTA : Quando si implementa un metodo di una interfaccia esso deve essere dichiarato
pubblico.
Una Classe ESTENDE Una Classe
Una
Interfaccia
ESTENDE Pi
Interfaccie
Una Classe IMPLEMENTA Pi
Interfaccie
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
60
Implementazione di una interfaccia.
<modi f i er > class <name> [ extends <super cl ass>]
[ implements <i nt er f ace> [ , <i nt er f ace>] * ] {
<member _decl ar at i on>*
}
Esempio: viene definite una superclasse dei modelli di aereo, sulla base del modello selezionato
sono definite una serie di variabili static, inoltre in esso vi un metodo che definisce la distanza
che pu essere percorsa sulla base delle caratteristiche del modello.
Una classe extends superclasse e implements interfaccia
Esempio complesso:
1) Linterfaccia Forma1 definita come estensione dellInterfaccia Forma2, questo vuol dire che
quando implemento una classe con Forma2, implemento anche Forma1. Altrimenti se fossero state
separate era necessario implementare Forma1 e Forma2.
2) La Classe astratta Rife ha il metodo astratto RifeCalc, inoltre essa estensione della Classe Calco
e implementa linterfaccia Forma3. In Calco deve essere esplicitato anche il costruttore di defaul
Calco().
3) La Classe Inferfaccia estende la classe astratta Rife e implementa linterfaccia Forma2. Come si
vede occorre definire tutti i metodi presenti in Forma2 e Forma1, ed inoltre dichiararli pubblici.
Il costruttore di Interfaccia richiama il costruttore di Rife e non aggiunge altro.
Inoltre in Interfaccia va definito anche il metodo astratto RifeCalc.
interface Forma1
{
int a1 = 3;
int b1 = 7;
int FoA(int x, int y);
void FoB(int ass);
}
interface Forma2 extends Forma1
{
int a2 = 31;
double b2 = 12.123;
int WoA(int x, double y);
void WoB(int ass);
}
interface Forma3
{
int a3 = 11;
String b3 = "Pippo";
int ToA(int x);
String ToB(String st);
}
class Calco
{
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
61
int val = 0;
Calco()
{
}
Calco(int val)
{
this.val = val;
}
int rico(int x)
{
x *= 2;
return x;
}
}
abstract class Rife extends Calco implements Forma3
{
int dim1, dim2;
Rife(int dim1, int dim2)
{
this.dim1 = dim1;
this.dim2 = dim2;
}
abstract int RifeCal();
}
public class Interfaccia extends Rife implements Forma2
{
Interfaccia(int dim1, int dim2)
{
super(dim1, dim2);
}
public int RifeCal()
{
int area = dim1 * dim2;
return area;
}
static int w = 13;
public static void main(String [] args)
{
int result = 0;
int resuclas = 7;
Interfaccia In = new Interfaccia(3, 7);
result = In.FoA(In.a1, In.b1);
System.out.println("result = " + result);
In.WoB(w);
In.FoB(w);
result = In.WoA(In.a2, In.b2);
resuclas = In.rico(resuclas);
int area = In.RifeCal();
String w1 = In.ToB("Grande");
System.out.println("Stringa = " + w1);
System.out.println("result = " + result + " " + resuclas + " " +
area);
}
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
62
public int FoA(int x, int y)
{
int z = x * y;
return z;
}
public void FoB(int ass)
{
w = ass * 2;
System.out.println("Valore A = " + w);
}
public int WoA(int x, double y)
{
int f = (int) y;
int z = (x > f) ? x % f : 0;
return z;
}
public void WoB(int ass)
{
w = ass / 2;
System.out.println("Valore B = " + w);
}
public int ToA(int x)
{
int z = x % 2;
return z;
}
public String ToB(String ass)
{
String w1 = ass + ass.charAt(2);
System.out.println("Valore C = " + w1);
return w1;
}
}
result = 21
Valore B = 6
Valore A = 12
Valore C = Grandea
Stringa = Grandea
result = 7 14 21
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
63
7.8) Sulla differenza tra Classe astratta e Interfaccia.
1. Una classe astratta definisce una propriet definente ed essenziale delloggetto da una certa classe
che la richiama. Per esempio la classe astratta Odorato definente la classe di Cane e di
Orso.. Mentre una interfaccia definisce delle propriet che sono accidentali per loggetto creato,
ovvero propriet che pu avere o non avere
2. In Java non possibile, come invece accade in C++ , una eredit multipla di classi. Questo vuol
dire che una classe pu avere solo una superclasse sia astratta che no. Comunque in altervativa vi
la possibilit di ereditare molteplici interfacce.
3. Una classe astratta pu avere anche metodi definiti (non astratti), costruttori e variabili istanze.
Mentre una interfaccia pu avere solo definizioni di metodi, ma pu avere variabili accessibili dalla
classe.
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
64
7.9) Esempio.
MODELLI = Modelli generali di aerei con le caratteristiche tecniche
// Super Classe dei modelli di aerei
public class Modelli {
long con_cro; // consumo a velocit di crocere
long vel_cro; // velocit di crocera
long gas_max; // capienza massima gasolio
// temmpo e consumo per istante di tempo in atterraggio e decollo
long t_takeoff,a_takeoff,t_land,a_land;
public char nomvet;
Modelli(char nome){
nomvet = nome;
switch(nomvet){
case 'A':
con_cro = 4;
vel_cro = 300;
gas_max = 22000;
t_takeoff = 100;
a_takeoff = 10;
t_land = 50;
a_land = 5;
break;
case 'B':
con_cro = 5;
vel_cro = 380;
gas_max = 20000;
t_takeoff = 100;
a_takeoff = 10;
t_land = 50;
a_land = 5;
break;
case 'C':
con_cro = 3;
vel_cro = 250;
gas_max = 28000;
t_takeoff = 100;
a_takeoff = 10;
t_land = 50;
a_land = 5;
break;
default:
con_cro = 2;
vel_cro = 200;
gas_max = 30000;
t_takeoff = 100;
a_takeoff = 10;
t_land = 50;
a_land = 5;
break;
}
}
// calcolo distanza col serbatoio massimo
long Distanza(){
long cons_takeoff = t_takeoff*a_takeoff;
long cons_land = t_land*a_land;
gas_max = gas_max -(cons_takeoff + cons_land);
long dist_cro = gas_max/con_cro;
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
65
return dist_cro;
}
}
FASI = Interfaccia con i metodi comuni ad ogni aereo in fase di volo
// Interfaccia con metodi comuni a tutti i tipi di oggetti che volano
public interface Fasi {
// caratterische del decollo
public void takeOff();
// caratteristiche dell'atterraggio
public void land();
// caratteristiche del volo
public void fly();
}
AEREO = caratteristiche e fasi di ogni aereo, come msg di check prima del
decollo
public class Aereo extends Modelli implements Fasi {
private long vel_vol;
private long vel_cro;
public long gasolio;
public long distanza;
private boolean val_chk, rito;
private long t_to, a_to, t_l, a_l;
public Aereo(char nome) {
super(nome);
vel_vol = 1;
}
public Aereo(char nome, long gasolio, long distanza) {
super(nome);
vel_vol = 1;
this.gasolio = gasolio;
this.distanza = distanza;
}
public void takeOff() {
for(int i = 0; i <t_to; i++){
vel_vol = i * a_to;
gasolio -= a_to;
}
vel_cro = vel_vol;
}
public void land() {
for(int h = 0; h <t_l; h++){
vel_vol = vel_cro - (h * a_l);
}
vel_cro = vel_vol;
}
public void fly() {
for(int j= 0; j < distanza; j++) {
distanza -= j;
gasolio -= (j*10);
}
}
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
66
public boolean Check(long distanza, long gasolio){
String mess = new String();
this.distanza = distanza;
this.gasolio = gasolio;
long dis_max = super.Distanza();
long gasoliom = super.gas_max;
t_to = super.t_takeoff;
a_to = super.a_takeoff;
t_l = super.t_land;
a_l = super.a_land;
if (distanza > dis_max){
System.out.println("Distanza superiore a quella percorribile
dist." + distanza + " dist.max " + dis_max);
val_chk = false;
}
else if (gasolio > gasoliom){
System.out.println("Rifornimento gasolio maggiore capienza Max
gasol." + gasolio + " gasol.max " + gasoliom);
val_chk = false;
}
else if(!Chk_Distanza()){
mess = "Gasolio insufficiente per la distanza da percorrere ";
val_chk = false;
}
else {
mess = "Ok check ";
val_chk = true;
}
System.out.println(mess + " Check dist:" + distanza + "/"+ dis_max +
" gasol." + gasolio + "/"+ gasoliom + " " + val_chk);
return val_chk;
}
boolean Chk_Distanza(){
long cons_takeoff = t_to*a_to;
long cons_land = t_l*a_l;
gasolio = gasolio -(cons_takeoff + cons_land);
long dist_cro = gasolio/super.con_cro;
if (distanza > dist_cro) {rito = false;}
else {rito = true;}
return rito;
}
}
AEREOPORTO = nome e caratteristiche dellaereoporto, check land e take off
public class Aereoporto {
public String nomeA;
int num_aerei = 0;
static final int NUM_MAX = 3;
public Aereoporto(String nomeA, int num_aerei) {
this.nomeA = nomeA;
this.num_aerei = num_aerei;
}
public boolean givePermissiontoLand() {
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
67
boolean ret_per;
int num_nuo = ++num_aerei;
if (num_nuo < NUM_MAX){
num_aerei = num_nuo;
ret_per = true;
} else { ret_per = false;
}
return ret_per;
}
public boolean givePermissiontoTakeoff() {
boolean ret_per;
int num_nuo = --num_aerei;
if (num_nuo < NUM_MAX){
num_aerei = num_nuo;
ret_per = true;
} else { ret_per = false;
}
return ret_per;
}
}
VOLO = definito come un Thread riceve le caratteristiche del volo, contiene il
ciclo del volo con le sue fasi e i suoi controlli
public class Volo extends Thread {
long Dista_volo, Gaso_volo;
Aereoporto Partenza, Arrivo;
Aereo Vett;
boolean ctrl_1, ctrl_2, ctrl_3;
public Volo(Aereoporto AER_P, Aereo AE, Aereoporto AER_A, int dista, int
gaso) {
Dista_volo = dista;
Gaso_volo = gaso;
Partenza = AER_P;
Arrivo = AER_A;
Vett = AE;
}
public void run(){
int flag = 0;
boolean OK_volo, OK_land;
long Fla_dis, Fla_res, Gas_dis, Gas_res;
ctrl_1 = Vett.Check(Dista_volo, Gaso_volo);
System.out.println("Volo : "+ Partenza.nomeA + " " + Arrivo.nomeA +
" " + Vett.nomvet);
if (ctrl_1){
OK_volo = true;
while(OK_volo){
ctrl_2 = Partenza.givePermissiontoTakeoff();
if (ctrl_2) {
System.out.println("OK Take off : "+
Partenza.nomeA + " " + Arrivo.nomeA + " " + Vett.nomvet+ " ");
Vett.takeOff();
try {
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
68
Thread.sleep(100);
} catch(InterruptedException e){
System.out.println("Interrotto");
}
Fla_dis = Vett.distanza;
Gas_dis = Vett.gasolio;
System.out.println("Volo : "+ Partenza.nomeA + " "
+ Arrivo.nomeA + " " + Vett.nomvet);
System.out.println("PARAM Volo : Dist. disp. "+
Fla_dis + " Gas. disponibile "+ Gas_dis);
Vett.fly();
Fla_res = Vett.distanza;
Gas_res = Vett.gasolio;
System.out.println("OK In Volo : "+ Partenza.nomeA
+ " " + Arrivo.nomeA + " " + Vett.nomvet);
System.out.println("PARAM 2 Volo : Dist. res."+
Fla_res + " Gas. residuo "+ Gas_res);
try {
Thread.sleep(Fla_dis);
} catch(InterruptedException e){
System.out.println("Interrotto");
}
do {
OK_land = Arrivo.givePermissiontoLand();
if(OK_land){
System.out.println("OK Land : "+
Partenza.nomeA + " " + Arrivo.nomeA + " " + Vett.nomvet);
Vett.land();
OK_volo = false;
break;
}
} while(!OK_land);
}
}
}
System.out.println("Volo Finito: "+ Partenza.nomeA + " " +
Arrivo.nomeA + " " + Vett.nomvet);
}
}
PIANOVOLOA = piano di attivazione con aeroporti, aerei e voli. Attivazione
Threads
class PianoVoloA
{
public static int sTCS = 100, sMAP = 100;
public static int sCON = 11*13*17*19;
public static int b1 = 5, b2 = 2;
public static void main(String args[])
{
/* Oggetti Aereoporti */
String nome_arp1 = "Atlanta";
String nome_arp2 = "Dallas";
String nome_arp3 = "New York";
Aereoporto ARP1 = new Aereoporto(nome_arp1, 2);
Aereoporto ARP2 = new Aereoporto(nome_arp2, 1);
Aereoporto ARP3 = new Aereoporto(nome_arp3, 2);
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
69
/* Oggetti Aerei */
Aereo AE[] = new Aereo[5];
AE[0] = new Aereo('A');
AE[1] = new Aereo('B');
AE[2] = new Aereo('A');
AE[3] = new Aereo('C');
AE[4] = new Aereo('C');
/* Voli */
Volo VO[] = new Volo[5];
VO[0] = (Volo) new Volo(ARP1, AE[1], ARP2, 700, 11000);
VO[1] = (Volo) new Volo(ARP2, AE[3], ARP3, 500, 13000);
VO[2] = (Volo) new Volo(ARP1, AE[0], ARP2, 700, 11000);
VO[3] = (Volo) new Volo(ARP1, AE[2], ARP3, 600, 12000);
VO[4] = (Volo) new Volo(ARP3, AE[4], ARP1, 600, 12000);
for (int i=0; i<b1;i++){
VO[i].start();
System.out.println("Volo Attivato " + AE[i].nomvet);
}
}
}
Risultato:
Volo Attivato A
Ok check Check dist:700/3750 gasol.11000/18750 true
Volo : Atlanta Dallas B
OK Take off : Atlanta Dallas B
Volo Attivato B
Volo Attivato A
Volo Attivato C
Ok check Check dist:600/5187 gasol.12000/20750 true
Volo : Atlanta New York A
OK Take off : Atlanta New York A
Ok check Check dist:700/5187 gasol.11000/20750 true
Volo : Atlanta Dallas A
OK Take off : Atlanta Dallas A
Ok check Check dist:500/8916 gasol.13000/26750 true
Volo : Dallas New York C
OK Take off : Dallas New York C
Volo Attivato C
Ok check Check dist:600/8916 gasol.12000/26750 true
Volo : New York Atlanta C
OK Take off : New York Atlanta C
Volo : Atlanta Dallas B
PARAM Volo : Dist. disp. 700 Gas. disponibile 8750
OK In Volo : Atlanta Dallas B
PARAM 2 Volo : Dist. res.34 Gas. residuo 2090
Volo : Atlanta New York A
PARAM Volo : Dist. disp. 600 Gas. disponibile 9750
OK In Volo : Atlanta New York A
PARAM 2 Volo : Dist. res.5 Gas. residuo 3800
Volo : Atlanta Dallas A
PARAM Volo : Dist. disp. 700 Gas. disponibile 8750
OK In Volo : Atlanta Dallas A
PARAM 2 Volo : Dist. res.34 Gas. residuo 2090
Volo : Dallas New York C
PARAM Volo : Dist. disp. 500 Gas. disponibile 10750
OK In Volo : Dallas New York C
Guido Massa Finoli Logica Object Oriented e linguaggio Java Versione 2
70
PARAM 2 Volo : Dist. res.4 Gas. residuo 5790
Volo : New York Atlanta C
PARAM Volo : Dist. disp. 600 Gas. disponibile 9750
OK In Volo : New York Atlanta C
PARAM 2 Volo : Dist. res.5 Gas. residuo 3800
OK Land : Dallas New York C
Volo Finito: Dallas New York C
OK Land : New York Atlanta C
Volo Finito: New York Atlanta C
OK Land : Atlanta Dallas B
Volo Finito: Atlanta Dallas B
OK Land : Atlanta Dallas A
Volo Finito: Atlanta Dallas A
OK Land : Atlanta New York A
Volo Finito: Atlanta New York A
Fasi: Interfaccia
+takeOff()
+land()
+fly()
Aereo:
+takeOff()
+land()
+fly()
+Distanza()
Modelli:
Superclasse
+costruttore
+Distanza()