public class Saluto { public static void main(String[] x) { System.out

public class Saluto {
public static void main(String[] x) {
System.out.println(x[1]);
}
}
Brandelli di spiegazione del codice soprastante
(non tutto viene spiegato; inoltre le spiegazione sono
incomplete e
hanno margini di imprecisione)
String[] x:
x e' il vettore costituito dalle stringhe di caratteri che
scriveremo a destra
di "java Lezione ........................"
Se scriviamo
java Lezione Filippo Andrea Roberto,
x[1] identifica "Andrea" (x[0] Filippo etc.)
In Java si formano classi. Esse consistono,
USUALMENTE:
- degli oggetti della classe;
- dei metodi della classe.
L'esempio scritto sopra, per la verita', non rientra nella
tipologia
soprastante: la classe Saluto e' costituita unicamente
dal metodo "main" (che non viene applicato ad alcun
oggetto). Altre classi sono costituite da diversi metodi,
e non sono concepite per costruire nuovi oggetti;
quindi
i metodi di queste classi saranno destinati ad essere
applicati ad oggetti di altre classi.
I metodi possono modificare gli oggetti a cui si
applicano, oppure estrarre/passare informazioni agli
oggetti, oppure svolgere altri compiti che non riguardano
gli oggetti (come il metodo main sopra: semplicemente
stampa un messaggio).
I metodi determinano completamente l'interazione fra
l'utente esterno
e gli oggetti all'interno di una classe.
Vediamo una semplice classe dove creiamo oggetti
"Numero": la creazione di un numero prevede l'impiego
di una "variabile istanza" della classe, di tipo intero, ed il
riferimento a essa. Vediamo prima il codice,
nel mezzo compariranno dei commenti, fra
i simboli /*...... */ seguira' qualche commento.
public class Numero {
private int num;
public Numero(int m) {
num = m;
}
/* Quello sopra e' il costruttore degli oggetti Numero.
Se vorremo creare un nuovo numero, a cui riferirsi
attraverso
il nome x, ed attribuire a esso il valore 3, scriveremo
Number x = new Number(3);
Si noti che il costruttore (il costruttore e' quel metodo
che ha esattamente lo stesso nome della classe)
produce
oggetti della classe che porta il suo nome, senza che
appaia
l'esplicita specificazione del tipo di dato prodotto.
Continuiamo ora con altri metodi della classe .*/
public int get_value() {
return num;
}
/* L'interazione minima con l'oggetto, che consiste, dato
un numero, nel poterne estrarre il valore (che sara'
contenuto
nella variabile istanza (una per ciascun oggetto della
classe))
non e' garantita. Il metodo sopra serve, appunto, a
estrarre
l'informazione sul valore contenuto dall'oggetto.
x.getvalue() produrra' come risultato il valore 3.
La sintassi e' questa:
<oggetto>.<metodo>(<parametri_eventuali_del_metodo
>)
Dopo l'attributo public (che e' stato spiegato a voce)
segue
il tipo del risultato offerto, un numero, nel presente caso)
*/
public void succ() {
num = num + 1;
}
/* Questo metodo produce incrementa di uno il valore
dell'oggetto a cui si applica:
dopo avere applicato succ a x:
x.succ();
l'applicazione del metodo getvalue()
x.getvalue()
ci consentira' di verificare che x, ora, contiene il valore 4
*/
public void somma(int m) {
num = num + m;
}
/*
Questo metodo lavora su un oggetto numero, e ne
modifica
il contenuto, sommando un valore m, passato come
parametro.
Ecco una possibile applicazione:
dopo avere applicato somma come segue a x:
x.somma( 5 );
x.getvalue() dara' 9 come risultato.
*/
public static void main(String[] args) {
Numero x = new Numero(Integer.parseInt(args[0]));
x.succ();
System.out.println(x.get_value());
}
/* conclusione della classe: e' il metodo che l'interprete
java cerca quando si da', ad esempio, il comando
java Numero 3. Si noti la conversione del carattere
3 da cifra numero, ottenuta attraverso il metodo
parseInt della classe Integer) */
}
altra classe: punti sul piano cartesiano
Per qualche motivo (dipendente da qualche contesto
esterno),
decidiamo che sui punti vogliamo interagire con
i seguenti metodi:
- costruttore dei punti;
- estrattori delle singole componenti;
- traslazione del punto di due valori (per ascissa e
ordinata) fissati;
- somma vettoriale di due punti (ossia si sommano le
due ascisse
e le due ordinate)
public class Point {
private int ascissa;
private int ordinata;
public Point(int n, int m) {
ascissa = n;
ordinata = m;
}
public int get_ascissa() {
return ascissa;
}
public int get_ordinata() {
return ordinata;
}
public void trasla(int n, int m) {
ascissa = n + ascissa;
ordinata = m + ordinata;
}
public void somma_vettoriale(Point p) {
ascissa = ascissa + p.get_ascissa();
ordinata = ordinata + p.get_ordinata();
}
public static void main(String[] args) {
Point p = new
Point(Integer.parseInt(args[0]),Integer.parseInt(args[1]));
p.somma_vettoriale(p);
System.out.println(p.get_ascissa());
System.out.println(p.get_ordinata());
}
}