Introduzione Modifica

Una classe è il concetto più importante della programmazione ad oggetti, infatti una classe rappresenta un oggetto, fin'ora abbiamo programmato sempre utilizzando funzioni e variabili, ma era tutto lineare.

Cos'è una classe? Modifica

Una classe può essere vista come l'astrazione di un problema, per interagire con essa ci si serve di variabili e funzioni, tutte messe insieme dentro una classe, solitamente le variabili non sono direttamente accessibili all'utente per una questione di astrazione, ma possono essere modificate indirettamente tramite le funzioni che offre.

La prima classe Modifica

Creazione Modifica

Ora vedremo praticamente la creazione di una classe, la sua sintassi è molto semplice, ed è la seguente:

 class NomeClasse
 {
   //Funzioni e variabili che appartengono alla classe
 }

 NOTA BENE
 Le classi dovranno essere dichiarate fuori dalle funzioni.

Supponiamo di dover simulare il comportamento di una lampadina, però a livello di codice, per semplificare il problema ci serviremo di una classe "Lampadina", una lampadina può:

• Essere Accesa
• Essere Spenta

import std.stdio;
 
/*La nostra classe lampadina 
(il significato di private e public saranno spiegati più avanti)*/
class Lampadina
{
  //Queste variabili sarano utilizzate indirettamente dall'utente
  private bool accesa;  //La lampadina è accesa??
 
  //Funzioni che ci permettono di interagire con la lampadina
  public void Accendi()
  {
    if(accesa)
    {
      writefln("La lampadina e' già accesa!!");
    }
    else
    {
      writefln("Ho acceso la lampadina!!");
      accesa = true;
    }
  }
 
  public void Spegni()
  {
    if(accesa)
    {
      writefln("Ho spento la lampadina!!");
      accesa = false;
    }
    else
    {
       writefln("La lampadina e' già spenta!!");
    }
  }
}
 
int main(string[] args)        
{
   //Codice del main...
   return 0;
}

Utilizzo Modifica

Ora andiamo ad utilizzare la nostra classe "Lampadina"; prima di utilizzare una classe deve prima di tutto essere istanziata, ovvero: dobbiamo creare una copia utilizzabile della nostra classe, non possiamo modificare quella originale.

Una classe si istanzia col la parola chiave new, la sua sintassi è la seguente:

 MiaClasse nomeVariabile = new MiaClasse();

Ora andiamo a istanziare ed utilizzare la classe, per utilizzare le funzioni (e anche le variaibli, se permesso) dobbiamo utilizzare il dot ovvero il "puntino" preceduto dal nome della classe:

 miaClasseIstanziata.MiaFunzione();

import std.stdio;
class Lampadina
{
  //Queste variabili sarano utilizzate indirettamente dall'utente
  private bool accesa;  //La lampadina è accesa??
 
  //Funzioni che ci permettono di interagire con la lampadina
  public void Accendi()
  {
    if(accesa)
    {
      writefln("La lampadina e' già accesa!!");
    }
    else
    {
      writefln("Ho acceso la lampadina!!");
      accesa = true;
    }
  }
 
  public void Spegni()
  {
    if(accesa)
    {
      writefln("Ho spento la lampadina!!");
    }
    else
    {
       writefln("La lampadina e' già spenta!!");
      accesa = false;
    }
  }
}
 
int main(string[] args)        
{
   //Istanziamo la classe "Lampadina"
   Lampadina lamp = new Lampadina();
 
   //Accendiamo la lampadina
   lamp.Accendi();
   //Spegniamo la lampadina
   lamp.Spegni();
 
   return 0;
}

 Output:
 Ho acceso la lampadina!!
 Ho spento la lampadina!!

I Costruttori Modifica

Un costruttore è una particolare funzione, che viene eseguita automaticamente nel momento in cui la classe viene istanziata, può essere utile ad esempio per inserire dei valori di default nelle variabili che si trovano all'interno della classe; riferendoci all'esempio della classe "Lampadina", possiamo fare in modo che sia spenta appena istanziano la classe, la sintassi del costruttore è la seguente:

  this()
  {
     //Codice di inizializzazione
  }

 NOTA BENE
 I Costruttori possono avere uno o più parametri, si comportano come le funzioni.

Il Costruttore non può avere un nome scelto dall'utente, ma dovrà SEMPRE avere il this, il compilatore così capisce che quella funzione sarà il costruttore della classe, per avere la variabile "accesa" settata su false appena istanziamo la classe si può fare:

import std.stdio;
 
class Lampadina
{
  private bool accesa;  
 
  /*
   * Costruttore della classe, viene eseguito automaticamente appena la classe 
   * è stata istanziata
   */     
  public this()
  {
    accesa = false;
  }
 
  public void Accendi()
  {
    if(accesa)
    {
      writefln("La lampadina e' già accesa!!");
    }
    else
    {
      writefln("Ho acceso la lampadina!!");
      accesa = true;
    }
  }
 
  public void Spegni()
  {
    if(accesa)
    {
      writefln("Ho spento la lampadina!!");
      accesa = false;
    }
    else
    {
       writefln("La lampadina e' già spenta!!");
    }
  }
}
 
int main(string[] args)        
{
   //Codice del main...
   return 0;
}

I Distruttori Modifica

Sono la "controparte" dei costruttori, vengono eseguiti quando si esce ad una funzione, solitamente sono usati per liberare le risorse che utilizza una classe (puntatori, file e quant'altro...), la sintassi è analoga a quella del costruttore, solo che il this deve essere preceduto da una tilde:

 NOTA BENE
 I Distruttori NON possono avere parametri

 ~this()
 {
   //Codice del distruttore...
 }

Riferendoci ancora una volta all'esempio della lampadina quindi:

import std.stdio;
class Lampadina
{
  private bool accesa;
 
  /*
   * Costruttore della classe, viene eseguito automaticamente appena la classe 
   * è stata istanziata
   */     
  public this()
  {
    accesa = false;
    writefln("Costruttore eseguito!!");
  }
 
  /*
   * Distruttore della classe, viene eseguito automaticamente appena si esce dalla funzione
   * (verrà spiegato meglio più avanti)
   */
  public ~this()
  {
    writefln("Distruttore eseguito!!");
  }
 
  public void Accendi()
  {
    if(accesa)
    {
      writefln("La lampadina e' già accesa!!");
    }
    else
    {
      writefln("Ho acceso la lampadina!!");
      accesa = true;
    }
  }
 
  public void Spegni()
  {
    if(accesa)
    {
      writefln("Ho spento la lampadina!!");
      accesa = false;
    }
    else
    {
       writefln("La lampadina e' già spenta!!");
    }
  }
}
 
int main(string[] args)        
{
   //Istanziamo la classe "Lampadina"
   Lampadina lamp = new Lampadina();
 
   //VERRA' CHIAMATO IL COSTRUTTORE AUTOMATICAMENTE
 
   //Accendiamo la lampadina
   lamp.Accendi();
   //Spegniamo la lampadina
   lamp.Spegni();
 
   //VERRA' CHIAMATO IL DISTRUTTORE AUTOMATICAMENTE
   return 0;
}

 Output:
 Costruttore eseguito!!
 Ho acceso la lampadina!!
 Ho spento la lampadina!!
 Distruttore eseguito!!

I Modificatori d'accesso Modifica

All'inizio abbiamo detto che il programmatore può impedire all'utente di utilizzare certe variabili, come si può fare??, semplice utilizziamo i modificatori d'accesso, li abbiamo utilizzati anche precedentemente e sono:

• public: Le funzioni o le variabili con "public" possono essere usate sia all'interno della classe che al di fuori di essa.
• private: Le funzioni o le variabili con "private" possono essere usate SOLO all'interno della classe.
• protected: Le funzioni o le variabili con "protected" possono essere usate SOLO all'interno della classe e anche dalle classi che ereditano da essa (verrà visto in seguito).

Nella classe lampadina, infatti, abbiamo messo la variabile booleana "accesa" come private, ciò significa che l'utente non può accederci e modificare il suo valore, perchè a serve alla classe internamente per controllare se la lampadina è accesa o spenta, invece le funzioni "Accendi()" e "Spegni()" sono public perchè all'utente è permesso accendere e spegnere la lampadina (da notare che la variabile viene modificata indirettamente dall'utente)

Il this Modifica

Oltre ad essere usato per differenziare il costruttore e il distruttore dalle altre funzioni, il this viene usato per riferirsi all'istanza della classe corrente, ovvero può stare a dire con questa classe..., DEVE essere usato all'interno della classe stessa, e si utilizza per utilizzare le variabili o le funzioni che stanno al suo interno.

 NOTA BENE
 Il 'this' può anche essere omesso, non influenza il comportamento del programma.

Ecco un esempio pratico del suo impiego all'interno di una classe:

import std.stdio;
class StampaNumeri
{
  private int num;
 
  public this(int userNum)
  {
     //Utilizziamo le variabili all'interno della classe col 'this'
     this.num = userNum;
  }
 
  public void PrintNumero()
  {
    writefln("Numero inserito: %d", this.num);
  }
}
 
int main(string[] args)        
{
   StampaNumeri sm = new StampaNumeri(135);
 
   sm.PrintNumero();
   return 0;
}

 Output
 Numero inserito: 135