Capitolo 2 - OOP

OOP sta per ObjectOriented Programming, ovvero Programmazione Orientata agli Oggetti. OOP è il paradigma di programmazione più usato nei linguaggi moderni e consente di progettare e realizzare programmi ragionando in modo molto simile ai processi che usa in nostro cervello per osservare e controllare la realtà.

Se, ad esempio, io pronuncio la parola automobile, chi sta leggendo richiamerà un concetto astratto che associamo a degli oggetti reali che conosciamo per esperienza e che sono dotati di alcune proprietà e funzionalità. Anche senza vederne una in particolare, pensiamo ad un'automobile come un oggetto che ha quattro ruote, una carrozzeria, un abitacolo, un motore, etc. Quando poi vediamo passare UNA automobile la riconosciamo come tale perché ha tutte le caratteristiche del concetto astratto della nostra esperienza, per cui non abbiamo bisogno di vedere TUTTE le possibili automobili per classificarle come tali. Nel modello OOP il concetto di automobile corrisponde ad una classe, ovvero all'astrazione del concetto, mentre QUELLA specifica automobile che vediamo passare è una istanza, ovvero una particolare concretizzazione di quel concetto astratto. Ogni classe è definita da proprietà e metodi. Nel caso di un'automobile le proprietà sono quelle che attribuiamo al concetto astratto, ovvero, ad esempio, quattro ruote, una carrozzeria, un abitacolo, un motore. Mentre i metodi sono le funzionalità di cui è dotato quel concetto e attraverso le quali possiamo adoperarlo; per esempio, accendi il motore, apri lo sportello, mettiti in movimento, cambia la direzione di movimento, etc.

Tornando all'esempio del nostro cerchio in movimento, proviamo a capire come funziona una classe partendo da questo esempio già fatto.

Creiamo un nuovo progetto dal nome cerchio_in_movimento e aggiungiamo una nuova scheda dal nome Ball come spiegato nell'immagine seguente. (NB in realtà non è necessario dividere il progetto in più schede, ma questa è una soluzione pratica offerta dall'ambiente di sviluppo per organizzare meglio le sezioni logiche del progetto, soprattutto quando si tratta di progetti molto grandi)

Nella scheda Ball copiamo il codice seguente:

class Ball

{

  ////////////////////

  // PROPRIETA'

  ////////////////////

  float x, y, vx, vy;  // posizione e velocità

  int dim; // raggio

  color col; // colore

  // costruttore 1: non ha parametri di ingresso, decide tutto

  // autonomamente

  Ball()

  {

    x = width/2;

    y = height/2;

    vx = random(-5, 5);

    vy = random(-5, 5);

    dim = (int)random(5, 60);

    col = color(random(255), random(255), random(255));

  }

  // costruttore 2: ha due parametri di ingresso, x e y della

  // posizione

  Ball(float _x, float _y)

  {

    x = _x;

    y = _y;

    vx = random(-5, 5);

    vy = random(-5, 5);

    dim = (int)random(5, 30);

    col = color(random(255), random(255), random(255));

  }

  Ball(float _x, float _y, float _vx, float _vy)

  {

    // costruite il costruttore

  }

  ////////////////////

  // METODI

  ////////////////////

  // metodo show: definisce la visualizzazione dell'oggetto

  void show()

  {

    stroke(0);

    strokeWeight(1);

    fill(col);

    ellipse(x, y, dim, dim);

  }

  // metodo update: definisce l'aggiornamento dello stato

  // dell'oggetto

  void update()

  {

    x += vx;

    y += vy;

  }

}

Questa è la classe che realizza il concetto di cerchio in movimento. Le sue proprietà sono le componenti di posizione e velocità, il raggio, il colore. I primi metodi che incontriamo sono dei metodi particolari che si chiamano costruttori perché sono le funzioni che si attivano quando viene creata un'istanza, cioè un oggetto concreto stampato attraverso lo stampo della classe. Ogni classe può avere tanti costruttori, perché io posso decidere di determinare nessuna, alcune o tutte le proprietà dell'oggetto nel momento in cui lo creo. Gli altri due metodi, show e update hanno la funzione di visualizzare l'oggetto (quando viene creato, un oggetto è dentro la memoria del computer e non è visualizzabile finché noi non lo visualizziamo) e aggiornare il suo stato.

Fin qui abbiamo definito il concetto, le sue proprietà, e le sue funzionalità (metodi). Ora impariamo a capire come si usa nella pratica. Copiamo il codice seguente nella scheda cerchio_in_movimento

// definisco l'oggetto "b" (ma ancora non lo creo)

// come se fosse una variabile, ma il suo tipo è definito da me

// ed è la classe "Ball"

Ball b; 

void setup()

{

  size(800, 600);

  b = new Ball(); //creo l'oggetto "b" usando il costruttore "vuoto"

}

void draw()

{

  background(255);

  fill(0);

  text("vx: " + b.vx, 20, 20, 120, 80);

  text("vy: " + b.vy, 20, 40, 120, 80);

  b.update(); // uso il metodo "update" per aggiornare lo stato

  b.show();   // uso il metodo "show" per mostrare l'oggetto

}

Qual è la funzione delle istruzioni? Come posso utilizzare un altro costruttore per creare l'oggetto cerchio? Come posso modificare il codice della classe Ball per far muovere il cerchio in un universo sferico (ovvero in modo che rientri dalla parte opposta a quella da cui esce)?