Metodo (programmazione)

Da Wikipedia, l'enciclopedia libera.

Un metodo (o anche funzione membro), in informatica, è un termine che viene usato principalmente nel contesto della programmazione orientata agli oggetti per indicare un sottoprogramma associato in modo esclusivo ad una classe e che rappresenta (in genere) un'operazione eseguibile sugli oggetti e istanze di quella classe.

Caratteristiche[modifica | modifica sorgente]

Come in una procedura di un linguaggio di programmazione procedurale, un metodo solitamente consiste di:

  • una firma (signature) ovvero la definizione/dichiarazione del metodo con tipo di ritorno, nome del metodo, tipo e nome degli eventuali parametri passati in input (detti parametri formali); in genere dunque la definizione di un metodo usa la stessa sintassi impiegata per le procedure (nei linguaggi object-oriented che le supportano), con alcuni indicatori aggiuntivi che consentono di ottenere l'incapsulamento delle informazioni.
  • il corpo del metodo, opportunamente delimitato da inizio e fine, con all'interno una o più sequenze o blocchi di istruzioni scritte per eseguire una determinata azione eventualmente attraverso strutture di controllo del flusso di esecuzione quali selezioni/controllo e iterazione/cicli e sulla base dei parametri passati in input, in grado di restituire al programma chiamante un valore di ritorno (o di output) dello stesso tipo di quello dichiarato nella firma iniziale. Inoltre, nei linguaggi che dispongono di un meccanismo di gestione delle eccezioni, il blocco del metodo può terminare sollevando un'eccezione nel caso si verifichi una situazione anomala che impedisce il corretto completamento delle sue operazioni.

Una delle operazioni che possono essere eseguite da un metodo è la lettura/scrittura di dati "privati" memorizzati in un oggetto o in una classe: in questo modo il programmatore può gestire in modo flessibile l'accesso ai dati, prevedendo, ove necessario, opportuni meccanismi di protezione e validazione.

Le differenze fra il concetto generale di sottoprogramma e quello di metodo derivano dal fatto che il metodo viene interpretato come un'operazione eseguita da un oggetto. Per riferirsi all'invocazione di un metodo si usano talvolta locuzioni che rendono più esplicito questo legame; si parla per esempio di dare un comando a un oggetto o anche spedire un messaggio a un oggetto.[1]

Molti linguaggi supportano inoltre le tecniche di overloading e/o overriding dei metodi.

Esempio[modifica | modifica sorgente]

Un esempio generico in Java è il seguente:

 //firma o dichiarazione del metodo
 public tipo_ritorno <nome_Metodo> (tipo_parametro1 param1, ... , tipo_parametroN paramN){
   //segue corpo del metodo
          ... 
    blocco_istruzioni;
          ...
     if  (condizione logica){
          ...
       blocco_istruzioni;
          ...
       } 
      else if {
           ...
       blocco_istruzioni;
           ...
       }
      else {
           ...
       blocco_istruzioni;
           ...
       }
           ...
       blocco_istruzioni;
            ...
     for (int i=0; i<10; i++){
           ...
      blocco_istruzioni;
           ...
      }
           ...
    blocco_istruzioni;
           ...
 return <oggetto_tipo_metodo>;
 }

Sintassi[modifica | modifica sorgente]

Da un punto di vista sintattico, un formalismo molto diffuso per esprimere questa relazione fra oggetto e metodo è chiamato dot notation, dal nome inglese dot del punto. Per esempio,

cdplayer.play()

rappresenta l'invocazione del metodo play sull'oggetto cdplayer.

Il riferimento a un oggetto nell'invocazione di un metodo serve anche a indicare il contesto operativo dell'attivazione del metodo; questo infatti ha la possibilità di accedere a tutti i dati interni dell'oggetto su cui è stato invocato. All'atto della chiamata o invocazione vanno passati, se richiesti dal metodo, i valori dei parametri da passare (parametri attuali).

Tipologie[modifica | modifica sorgente]

Metodi statici[modifica | modifica sorgente]

La categoria di metodi più comune è quella dei metodi che, come si è detto sopra, vengono invocati con riferimento a un oggetto; questi possono essere detti anche metodi di istanza. I metodi di classe - detti anche metodi statici - rappresentano invece operazioni che non sono da riferirsi ai singoli oggetti, ma alla classe nel suo insieme. Per richiamare o invocare un metodo statico basta scrivere il nome del metodo seguito dalla specifica dei parametri attuali.

Esempio[modifica | modifica sorgente]

Esempio generico in Java:

 public static tipo_ritorno <nome_Metodo> (tipo_parametro1 param1, ... , tipo_parametroN paramN){
           ... 
      blocco_istruzioni;
           ...
  return <oggetto_tipo_metodo>;
 }

Costruttori[modifica | modifica sorgente]

Exquisite-kfind.png Per approfondire, vedi Costruttore.

Una particolare categoria di metodi è costituita dai costruttori,[2] che vengono invocati implicitamente ogni volta che un oggetto viene creato, e che hanno lo scopo generale di inizializzarne i dati interni. In molti linguaggi[3] i costruttori sono facilmente distinguibili perché il loro nome deve coincidere con quello della classe di appartenenza.

Esempio[modifica | modifica sorgente]

Esempio generico in Java:

 public <nome_classe> (tipo_parametro1 param1, ... , tipo_parametroN paramN){
       attribuito1=param1;
            ...
       attributoN=paramN;
  }

Metodi astratti[modifica | modifica sorgente]

In programmazione a oggetti, le classi astratte sono classi che rappresentano concetti troppo generali (e quindi astratti) per poter avere istanze dirette. In una classe di questo genere può accadere che, analogamente, un metodo rappresenti un'operazione troppo astratta per poter avere un'implementazione. Un metodo astratto è un metodo privo di implementazione (definito in una classe astratta) che rappresenta un'operazione generale.

Un esempio potrebbe essere un ipotetico metodo area() nella classe Poligono. Sebbene si possa dire che di ogni poligono si può calcolare l'area, potrebbe non essere semplice scrivere le istruzioni che svolgono effettivamente tale calcolo in termini così generali. Tale calcolo si può invece agevolmente introdurre nelle implementazioni di specifiche sottoclassi di Poligono, come Rettangolo. Dichiarando il metodo area nella classe Poligono come metodo astratto, si indica che tutti i poligoni (tutte le sottoclassi di Poligono) devono avere quell'operazione, e allo stesso tempo non la si fornisce (implementata) nel corpo della classe. La conseguenza è che ogni sottoclasse dovrà necessariamente fornire una propria implementazione del metodo attraverso overriding.[4]

Metodi di accesso[modifica | modifica sorgente]

Un metodo di accesso (accessor method in inglese) è un tipo di metodo, di solito molto semplice e composto da poche righe di codice, che consente l'accesso (in lettura o scrittura) a un attributo dell'oggetto. L'uso di metodi di accesso è preferibile rispetto all'accesso diretto ai dati di stato in quanto compatibile con il principio dell'information hiding. La pratica di scrivere metodi di lettura e di scrittura degli attributi è talmente diffusa che in letteratura esistono nomi specifici per questo genere di metodi: setter (per un metodo che scrive un attributo) e getter (per un metodo che serve a leggere il valore di un attributo). Molti IDE (per esempio Netbeans e Eclipse) forniscono strumenti di refactoring che consentono la generazione automatica dei getter e dei setter degli attributi degli oggetti.

Note[modifica | modifica sorgente]

  1. ^ La metafora della chiamata di metodo come messaggio deriva storicamente dalla terminologia di Smalltalk, uno dei primi linguaggi di programmazione a oggetti, ed è tuttora molto diffusa (in certi contesti, per esempio, viene utilizzata anche nella terminologia del linguaggio di modellazione UML).
  2. ^ Nella terminologia tecnica dei vari linguaggi i costruttori vengono talvolta classificati come metodi, altre volte no.
  3. ^ Per esempio Java, C++, C# e PHP
  4. ^ Più propriamente, una sottoclasse potrebbe non fornire l'implementazione di area, ma in tal caso il metodo rimarrebbe astratto anche nella sottoclasse. Poiché i metodi astratti sono ammessi solo nelle classi astratte, la sottoclasse dovrebbe quindi a sua volta essere astratta. Questo schema può essere effettivamente usato per rappresentare gerarchie di concetti astratti.

Voci correlate[modifica | modifica sorgente]

informatica Portale Informatica: accedi alle voci di Wikipedia che trattano di informatica