Metodo (programmazione)

Nella programmazione orientata agli oggetti, un metodo (o anche "funzione membro") è una una funzione associata in modo esclusivo ad una classe e che costituisce un'operazione eseguibile sulla sua istanza o sul suo tipo.

Caratteristiche

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.

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

Esempio

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

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

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. Per richiamare o invocare un metodo statico basta scrivere il nome del metodo seguito dalla specifica dei parametri attuali.

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, tra cui ad esempio Java, C++, C# e PHP (fino alla versione 4), 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)
{
    attributo1 = 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.

Metodi di estensione

Un metodo di estensione (extension method in inglese) è un tipo di metodo che, una volta dichiarato, viene aggiunto automaticamente ad una classe o ad un tipo dopo la sua compilazione. Non c'è differenza sintattica tra la chiamata ad un metodo di estensione e la chiamata ad un metodo dichiarato nella definizione del tipo. I metodi di estensione esistono in molti linguaggi di programmazione; in C#, ad esempio, vengono implementati come metodi statici all'interno di classi statiche, e il primo argomento della loro firma ha per tipo la classe estesa ed è preceduto dalla parola chiave "this". Il vantaggio dei metodi di estensione è la possibilità di evitare la creazione di vari helper, solitamente sotto forma di classi statiche con metodi statici, che rappresenterebbero un'alternativa peggiore dal punto di vista della leggibilità del codice. Inoltre, i metodi di estensione vengono automaticamente integrati nell'Intellisense dell'ambiente di sviluppo Visual Studio, migliorando così anche la manutenzione del codice stesso. Il motivo principale per cui i metodi di estensione furono introdotti è rappresentato da LINQ, componente del .NET Framework di Microsoft dal 2007.

Esempio in C# di una classe con due metodi d'estensione della classe String: il primo ne capovolge il contenuto, e il secondo ne trasforma in maiuscola la prima lettera:

public static class StringExtensions
{
    public static string Reverse(this string input)
    {
        if (string.IsNullOrEmpty(input))
        {
            return string.Empty;
        }
        char[] chars = input.ToCharArray();
        Array.Reverse(chars);
        return new String(chars);
    }
    
    public static string FirstCharToUpper(this string input)
    {
        if (string.IsNullOrEmpty(input))
        {
            return string.Empty;
        }
        return char.ToUpper(input[0]) + input.Substring(1);
    }
}

Note

Annotazioni

Fonti

Voci correlate

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

Altri progetti

Altri progetti

• Wikizionario

• Wikizionario contiene il lemma di dizionario «metodo»

Collegamenti esterni

• (EN) method, in Free On-line Dictionary of Computing, Denis Howe. Disponibile con licenza GFDL