Metodo (programmazione)

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

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

• una firma (o signature) ovvero la definizione 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.

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

Esempio

Un esempio generico in Java è il seguente:

 public tipo_ritorno <nome_Metodo> (tipo_parametro1 param1, ... , tipo_parametroN paramN){
          ... 
    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

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.

Tipologie

Metodi statici

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.

Esempio

Esempio generico in Java:

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

Costruttori

Una particolare categoria di metodi è costituita dai costruttori, 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 i costruttori sono facilmente distinguibili perché il loro nome deve coincidere con quello della classe di appartenenza.

Esempio

Esempio generico in Java:

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

Metodi astratti

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.

Metodi di accesso

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.

Voci correlate

• Programmazione (informatica)
• Costruttore (programmazione)
• Funzione
• Subroutine