I metodi

Metodo=operazione su un oggetto

Esempio: spostare un punto. 

  p.translate(10,-20);

Il punto p viene spostato di 10 sulla coordinata x e di -20 sulla coordinata y.

Esempio: muovere il punto alle coordinate specificate. 

  p.move(5, 14);

Le stesse cose si possono fare con delle istruzioni (es. p.x=5 ecc.)

Esempio di programma che usa un metodo

Programma della distanza, con il metodo move per definire il punto. 

import java.awt.*;

class Distanza {
  public static void main(String args[]) {
    Point p;
    p=new Point();

    p.move(10,20);

    double dis;

    dis=Math.sqrt(p.x*p.x+p.y*p.y);

    System.out.println(dis);
  }
}

Metodi di oggetti di tipo diverso

rettangoli
esiste il metodo setSize (che modifica altezza a larghezza) che non c'è per i punti
punti
esiste il metodo move (che dà nuove coordinate per il punto) che non c'è per i rettangoli.

Ogni tipo di oggetto (Point, Rectangle, ecc) ha i suoi metodi.

Metodi: argomenti

Il metodo move dei punti ha due argomenti:

Gli argomenti sono i dati che servono per poter fare l'operazione.

Rappresentazione grafica:

Il metodo ``usa'' gli argomenti per fare qualcosa.

Metodi: risultato

Un metodo è una operazione che riguarda l'oggetto.

Il metodo move è una operazione di modifica dell'oggetto.

Certe operazioni sull'oggetto non fanno modifiche, ma producono un risultato

Questi metodi vanno usati in modo leggermente diverso.

Metodi: risultato

Alcuni metodi producono dei dati come risultato

Per esempio, getX ritorna il valore di x, espresso come double 

  double a;

  a=p.getX();

Il metodo getX() trova il valore della coordindata x.

Facendo a=p.getX(); viene trovato il valore di p.x, che viene messo in a

Graficamente, il metodo ha una ``uscita'' (output) ma nessuna ``entrata'' (input).

Metodi: argomenti e risultato

Certi metodi calcolano qualcosa, sulla base di dati.

Questi metodi hanno degli ``input'' (argomenti) ma anche degli ``output'' (risultati)

Per i punti, esiste il metodo distance, che calcola la distanza fra il punto e un altro punto: 

  Point a;
  Point b;
  ...

  double dist;

  dist=a.distance(b);

Il metodo riceve un altro punto, e fornisce la distanza come risultato.

Uso di un metodo con risultato

Se abcd è un metodo, allora scrivere p.abcd(arg) equivale a dire:

esegui l'operazione abcd usando arg come dati...

Il risultato dove va?

... e il risultato mettilo nel punto dove appariva originariamente p.abcd(arg)

Cosa succede quando c'è un metodo?

Uso di un metodo con argomenti e risultato: 

  dist=a.distance(b);

Cosa succede quando il calcolatore deve eseguire questa istruzione?

  1. prima si valuta quello che sta a destra di =
  2. contiene un metodo, ossia a.distance(b)
  3. viene valutato il metodo, ossia si esegue l'operazione (in questo caso, il calcolo della distanza)
  4. se il risultato è, per esempio, 2.34, allora si passa ad eseguire dist=2.34
  5. si prosegue come al solito

L'effetto è che il valore calcolato va nella variabile dist

Il punto 4 corrisponde ad eseguire l'istruzione, ma mettendo il risultato 2.34 nel punto in cui in realtà c'è scritto il metodo a.distance(b)

Metodi come dispositivi

È come se i metodi fossero dei dispositivi a cui è possibile dare dati, e che possono produrre un risultato.

Usare un metodo=inviare dati a un dispostivo, e ricevere il risultato.

Tutto questo avviene ``internamente'' al calcolatore: i metodi visti fino ad ora non stampano niente!

Esercizio: il programma del perimetro

Riscrivere il programma del perimetro usando il metodo distance

Distanza fra due punti usando un metodo

Al posto dell'espressione si mette semplicemente il metodo. 

import java.awt.*;

class DistMet {
  public static void main(String args[]) {
    Point p;
    p=new Point();
    p.move(20,2);

    Point s;
    s=new Point();
    s.move(1,20);

    double dist;
    dist=p.distance(s);

    System.out.println(dist);
  }
}

Osservazione: il metodo equivale a più istruzioni.

Quindi, si può fare la stessa cosa anche senza il metodo.

I metodi dei rettangoli

setBounds
modifica le quattro componenti del rettangolo
translate
fa la stessa cosa che fa sui punti
intersection
trova l'intersezione del rettangolo con un altro
union
trova il più piccolo rettangolo che contiene questo e un altro
grow
espande il rettangolo mantenendo lo stesso centro

Il metodo setBounds riceve quattro interi, e modifica l'oggetto (non produce nessun risultato).

Il metodo intersection riceve un altro rettangolo (oltre a quello nominato prima del punto);

Il metodo intersection non modifica nulla, ma crea un nuovo rettangolo, che è l'intersezione dei due.

Esercizio: calcolare l'area dell'intersezione

Dati due rettangoli, stampare l'area della loro intersezione. 

import java.awt.*;

class AreaInt {
  public static void main(String args[]) {
    Rectangle a;
    a=new Rectangle();
    Rectangle b;
    b=new Rectangle();

    a.setBounds(10,10,40,30);

    b.setBounds(30,30,10,50);

    ...
  }
}

Area dell'intersezione: soluzione

Si può fare in questo modo: prima calcolo il rettangolo intersezione, e poi calcolo l'area. 

import java.awt.*;

class AreaInt {
  public static void main(String args[]) {
    Rectangle a;
    a=new Rectangle();
    Rectangle b;
    b=new Rectangle();

    a.setBounds(10,10,40,30);

    b.setBounds(30,30,10,50);

    Rectangle c;

    c=a.intersection(b);

    int area;

    area=c.width*c.height;

    System.out.println(area);
  }
}

Mentre distance ha come risultato un valore reale, il metodo translate ha come risultato un oggetto (un nuovo rettangolo).

Per il resto non cambia niente: c=a.intersection(b) calcola il rettangolo che è l'intersezione dei due, e memorizza il risultato usando la variabile c

Niente di strano, in questo programma?

Manca c=new Rectangle();!

Nella lezione precedente, si era detto: per ogni oggetto servono due operazioni: 

  Point p;
  p=new Point();

Nel caso dei rettangoli: 

  Rectangle r;
  r=new Rectangle();

Nel programma di sopra viene fatto Rectangle c ma non c'è c=new Rectangle()

Spiegazione:

Si può pensare che questa operazione c=new Rectangle() la esegue il metodo intersection

Dichiarazione/creazione

Perchè per int basta una istruzione mentre per Point ne servono due? 

  int a;
  Point p;
  p=new Point();

In memoria:

Non serve (per ora) capire perchè si usa questo modo di rappresentazione.

Serve solo sapere che per una variabile di tipo oggetto servono due zone di memoria.

Point p; crea la prima zona, mentre la new crea la seconda.

Definizione e creazione di un oggetto: parte I

  Point p;

Viene creata solo la casellina con p accanto.

È la stessa cosa che succede facendo int a; (si crea una casellina con accanto il nome della variabile).

La differenza è che dopo int a; si può subito usare la variabile a, perchò i dati sono memorizzati in questa casellina.

Non si può invece nel caso degli oggetti, dato che i dati vanno memorizzati in una seconda area di memoria.

Quindi, dopo int a la variabile a si può subito usare per fare a=12;. Dopo aver fatto Point p;, non esistono ancora le due variabili p.x e p.y

Definizione e creazione di un oggetto: parte II

  p=new Point();

Viene creata la zona di memoria dove si trovano p.x e p.y

L'istruzione mette anche la freccia.

Solo a questo punto l'oggetto si può usare (esistono p.x e p.y)

Metodi che restituiscono un oggetto

Il metodo intersection si occupa lui di fare la creazione dell'oggetto.

In particolare, il metodo fa:

Dato che la creazione del rettangolo grande la fa lui, non è necessario fare new

Spiegazione alternativa: è il metodo che esegue new Rectangle(); prima di mettere i dati nelle componenti x, y, width e height

Il programma che fa l'intersezione: esecuzione

Quando di esegue Rectangle c; lo stato della memoria (a parte le variabili a e b) è:

Cosa fa il metodo

Quando si esegue c=a.intersection(b), questo metodo fa due cose:

Primo: crea un nuovo oggetto (solo il blocco con le variabili!)

Secondo: calcola i valori del rettangolo che rappresenta l'intersezione e li mette nell'oggetto.

La freccia viene aggiunta quando il metodo termina:

A questo punto, esistono tutte e due le zone di memoria, per cui l'oggetto c si può usare.