|
Una classe definisce sia il modo in cui rappresentiamo una determinata
collezione di oggetti sia
le operazioni per manipolare tali oggetti (tramite i metodi di istanza) .
Se vogliamo rappresentare un conto corrente, ad esempio, le operazioni che possiamo voler definire possono essere:
-
leggere il saldo del conto,
-
prelevare una cifra dal conto,
-
depositare una cifra sul conto,
-
modificare il tasso di interesse applicato.
Nel caso dei rettangoli un' operazione che può
essere utile per manipolarli è l'operazione che permette di translare
(spostare) un rettangolo nel piano.
La
classe Rectangle
[locale,
Medialab,
Sun] descrive
sia il modo in cui
costruire un rettangolo con i valori desiderati
per la variabili d'istanza sia un metodo
d'istanza translate che sposta il rettangolo nel piano (assieme a molti altri).
Il metodo translate ha due parametri formali che rappresentano lo spostamento lungo l'asse x e quello lungo l'asse y.
|
Supponiamo adesso di voler rappresentare un rettangolo di coordinate
x = 5 e y =
10 e di dimensioni height =
20 e width =
30 e di volerlo spostare di 15 unità lungo l'asse
x e di 25 lungo l'asse
y;
Scriviamo quindi un programma che crea
un oggetto (un particolare rettangolo) con le dimensioni desiderate e
successivamente lo sposta come desiderato.
I passi da intraprendere sono:
- Creare un rettangolo di coordinate x = 5 e y =
10 e di dimensioni height =
20 e width =
30;
- Stampare lo stato del rettangolo;
- Spostare il rettangolo di 15 unità lungo l'asse
x e di 25 lungo l'asse
y;
- Stampare il nuovo stato del rettangolo.
Il programma risultante è il seguente:
import java.awt.Rectangle;
public class MoveRectangle {
public static void main(String[] args) {
Rectangle rect;
rect = new Rectangle(5, 10, 20, 30);
System.out.println(rect);
rect.translate(15, 25);
System.out.println(rect);
}
}
|
|
Dichiariamo di voler usare la classe Rectangle del package
java.awt:
import java.awt.Rectangle;
...
|
Dichiariamo una variabile rect di tipo
Rectangle e le
assegnamo un nuovo oggetto con i valori desiderati per le
variabili d'istanza:
...
public class MoveRectangle {
public static void main(String[] args) {
Rectangle rect;
rect = new Rectangle(5, 10, 20, 30);
... |
Con new Rectangle(5, 10, 20, 30) creiamo un nuovo oggetto (istanza) della classe Rectangle con i valori iniziali desiderati.
Dopo l'assegnamento rect= new Rectangle(5, 10, 20, 30) possiamo riferirci al nuovo oggetto creato usando il nome rect. In particolare l'effetto dell'assegnamento consiste nell'assegnare un riferimento al nuovo oggetto creato alla variabile rect.
Stampiamo lo stato del rettangolo:
...
System.out.println(rect);
...
Output:
java.awt.Rectangle[x=5,y=10,width=20,height=30]
|
Invochiamo il metodo d'istanza translate sull'oggetto
rect per spostarlo
della quantità voluta:
...
rect.translate(15, 25);
...
|
Infine stampiamo lo stato finale:
...
System.out.println(rect);
}
}
Output:
java.awt.Rectangle[x=20,y=35,width=20,height=30]
|
|
  |
Dichiarazione e creazione di oggetti
|
 
|
|
Abbiamo visto che i dati che vengono manipolati in un programma Java sono
divisi in due categorie:
- gli elementi dei tipi di dati
primitivi
- gli oggetti.
Le variabili corrispondenti a queste due categorie di
dati hanno comportamenti diversi.
Una variabile che si riferisce a un dato primitivo contiene
direttamente il valore del
dato, mentre una variabile che si
riferisce a un oggetto contiene solo un riferimento alla zona di memoria
dove si trova l'oggetto.
|
double capitale; |
|
La dichiarazione della variabile capitale alloca la
memoria necessaria per contenere un double. |
|
Rectangle rect; |
|
La dichiarazione della variabile rect alloca la
memoria necessaria per un
riferimento ad un'oggetto. |
|
capitale = 1756; |
|
Il valore 1756
viene scritto nella variabile capitale. |
|
rect =
new Rectangle(5, 10, 20, 30) |
|
Viene creato l'oggetto di
tipo Rectangle
(con i valori per le variabili di istanza richiesti) e nella variabile rect viene scritto
un
riferimento ad esso. |
|
|
Un effetto del diverso comportamento delle variabili di tipi
primitivi e di oggetti si riscontra nell'assegnamento tra variabili.
Un assegnamento tra variabili di tipi primitivi causa una
copia del valore.
|
double capitale = 1756;
double altroCapitale; |
capitale
altroCapitale
|
|
altroCapitale = capitale;
|
capitale
altroCapitale
|
Il valore 1756
viene copiato nella variabile altroCapitale. |
|
capitale = capitale * 2;
|
capitale
altroCapitale
|
La variabile capitale
viene aggiornata con il valore 3512 |
Invece un assegnamento tra variabili di tipi oggetto causa una
copia del riferimento, e
quindi una condivisione dell'oggetto.
|
|
Una conseguenza del fatto che quando assegniamo un oggetto ad una variabile l'effetto è quello di copiare in tale variabile un riferimento all'oggetto, è che l'opearatore di confronto "==" non si comporta (con gli oggetti) come uno si potrebbe aspettare....
Infatti
(obj1 == obj2) vale true solo
se obj1 e obj2 sono (riferimenti al) lo stesso
oggetto
Esempio:
Rectangle rectUno = new Rectangle(5,10,20,30);
Rectangle rectDue = rectUno;
Rectangle rectTre = new Rectangle(5,10,20,30);
|
|
| |
boolean b = (rectUno == rectDue);
|
b = true |
boolean b1 = (rectUno == rectTre);
|
b1 = false |
Il modo per confrontare due oggetti (e non i loro riferimenti) è quello di utilizzare il metodo di istanza equals che è definito (con le modalità qui descritte) per tutte le classi della libreria di Java che vedremo in questo semestre.
obj1.equals(obj2) normalmente vale
true
se i due oggetti hanno "la stessa struttura" (anche se non coincidono fisicamente in memoria).
Esempio:
boolean b2 = rectUno.equals(rectTre);
|
b2 = true |
Parlaremo ancora del diverso
comportamento delle variabili di tipi primitivi e di oggetti
a proposito del passaggio
dei parametri.
|
|
