function - metodi - metodo java definizione




Qual è la differenza tra un metodo e una funzione? (20)

Differenza tra metodi e funzioni

Dalla lettura di questo documento su Microsoft

I membri che contengono codice eseguibile sono noti collettivamente come membri della funzione di una classe. La sezione precedente descrive i metodi, che sono il tipo principale di membri di funzioni. Questa sezione descrive gli altri tipi di membri di funzione supportati da C #: costruttori, proprietà, indicizzatori, eventi, operatori e finalizzatori.

Quindi i metodi sono il sottoinsieme delle funzioni. Ogni metodo è una funzione, ma non ogni funzione è un metodo, ad esempio, un constructor non può essere detto come un metodo ma è una funzione.

Qualcuno può fornire una semplice spiegazione dei metodi rispetto alle funzioni nel contesto OOP?


Dalla mia comprensione un metodo è qualsiasi operazione che può essere eseguita su una classe. È un termine generale utilizzato nella programmazione.

In molti linguaggi i metodi sono rappresentati da funzioni e subroutine. La principale distinzione che la maggior parte delle lingue usa per questi è che le funzioni possono restituire un valore al chiamante e una subroutine no. Tuttavia molti linguaggi moderni hanno solo funzioni, ma questi possono facoltativamente non restituire alcun valore.

Ad esempio, diciamo che vuoi descrivere un gatto e vorresti che fosse capace di sbadigliare. Dovresti creare una classe Cat, con un metodo Yawn, che molto probabilmente sarebbe una funzione senza alcun valore di ritorno.


Diciamo che una funzione è un blocco di codice (di solito con un proprio ambito, e talvolta con una propria chiusura) che può ricevere alcuni argomenti e può anche restituire un risultato.

Un metodo è una funzione che è di proprietà di un oggetto (in alcuni sistemi orientati agli oggetti, è più corretto dire che è di proprietà di una classe). Essere "posseduti" da un oggetto / classe significa che ci si riferisce al metodo attraverso l'oggetto / classe; per esempio, in Java se vuoi invocare un metodo "open ()" di proprietà di un oggetto "door" devi scrivere "door.open ()".

Solitamente i metodi ottengono anche attributi aggiuntivi che descrivono il loro comportamento all'interno dell'oggetto / classe, ad esempio: visibilità (correlata al concetto di incapsulamento orientato agli oggetti) che definisce da quali oggetti (o classi) il metodo può essere invocato.

In molti linguaggi orientati agli oggetti, tutte le "funzioni" appartengono a qualche oggetto (o classe) e quindi in questi linguaggi non ci sono funzioni che non siano metodi.


Ecco alcune spiegazioni per metodo vs. funzione utilizzando esempi JavaScript:

test(20, 50); è la funzione define e use per eseguire alcuni passi o restituire qualcosa che può essere memorizzato / usato da qualche parte.

È possibile riutilizzare il codice: definire il codice una sola volta e utilizzarlo più volte.

È possibile utilizzare lo stesso codice molte volte con argomenti diversi per produrre risultati diversi.

var x = myFunction(4, 3);   // Function is called, return value will end up in x

function myFunction(a, b) {
    return a * b;          // Function returns the product of a and b
}

var test = something.test(); qui test () può essere un metodo di qualche oggetto o personalizzato definito un prototipo per oggetti insiti, qui c'è più spiegazione:

I metodi JavaScript sono le azioni che possono essere eseguite sugli oggetti.

Un metodo JavaScript è una proprietà contenente una definizione di funzione.

Proprietà / metodo integrato per le stringhe in javascript:

var message = "Hello world!";
var x = message.toUpperCase();
//Output: HELLO WORLD!

Esempio personalizzato:

function person(firstName, lastName, age, eyeColor) {
    this.firstName = firstName;  
    this.lastName = lastName;
    this.age = age;
    this.eyeColor = eyeColor;
    this.changeName = function (name) {
        this.lastName = name;
    };
}

something.changeName("SomeName"); //This will change 'something' objject's name to 'SomeName'

Ad esempio, è possibile definire proprietà per String, Array, ecc

String.prototype.distance = function (char) {
    var index = this.indexOf(char);

    if (index === -1) {
        console.log(char + " does not appear in " + this);
    } else {
        console.log(char + " is " + (this.length - index) + " characters from the end of the string!");
    }
};

var something = "ThisIsSomeString"

// now use distance like this, run and check console log

something.distance("m");

Alcuni riferimenti: metodo oggetto JavaScript , Functions , maggiori informazioni sul prototipo


In generale: i metodi sono funzioni che appartengono a una classe, le funzioni possono essere su qualsiasi altro ambito del codice in modo da poter affermare che tutti i metodi sono funzioni, ma non tutte le funzioni sono metodi:

Prendi il seguente esempio di python:

class Door:
  def open(self):
    print 'hello stranger'

def knock_door:
  a_door = Door()
  Door.open(a_door)

knock_door()

L'esempio fornito mostra una classe chiamata "Door" che ha un metodo o un'azione chiamata "open", è chiamata metodo perché è stata dichiarata all'interno di una classe. C'è un'altra porzione di codice con "def" appena sotto la quale definisce una funzione, è una funzione perché non è dichiarata all'interno di una classe, questa funzione chiama il metodo che abbiamo definito all'interno della nostra classe come puoi vedere e infine la funzione è in corso chiamato da solo.

Come puoi vedere puoi chiamare una funzione ovunque ma se vuoi chiamare un metodo devi passare un nuovo oggetto dello stesso tipo della classe che il metodo è dichiarato (Class.method (oggetto)) o devi richiamare il metodo all'interno dell'oggetto (object.Method ()), almeno in python.

Pensa ai metodi come le cose che solo un'entità può fare, quindi se hai una classe Dog avrebbe senso avere una funzione di corteccia solo all'interno di quella classe e sarebbe un metodo, se hai anche una classe Person potrebbe avere senso scrivere una funzione "feed" perché quella non appartiene a nessuna classe poiché sia ​​l'uomo che il cane possono essere nutriti e si potrebbe chiamarla una funzione poiché non appartiene a nessuna classe in particolare.


In linguaggi OO come Object Pascal o C ++, un "metodo" è una funzione associata a un oggetto. Quindi, ad esempio, un oggetto "Cane" potrebbe avere una funzione "corteccia" e questo sarebbe considerato un "Metodo". Al contrario, la funzione "StrLen" sta da sola (fornisce la lunghezza di una stringa fornita come argomento). È quindi solo una "funzione". Javascript è anche tecnicamente Object Oriented ma affronta molte limitazioni rispetto a un linguaggio completo come C ++, C # o Pascal. Nondimeno, la distinzione dovrebbe ancora valere.

Un paio di fatti aggiuntivi: C # è completamente orientato agli oggetti, quindi non è possibile creare "funzioni" indipendenti. In C # ogni funzione è legata a un oggetto ed è quindi, tecnicamente, un "metodo". Il kicker è che poche persone in C # si riferiscono a loro come "metodi" - usano semplicemente il termine "funzioni" perché non c'è alcuna distinzione reale da fare.

Infine, solo così i guru Pascal non mi saltano addosso: Pascal distingue anche tra "funzioni" (che restituiscono un valore) e "procedure" che non lo fanno. C # non fa questa distinzione esplicitamente sebbene tu possa, naturalmente, scegliere di restituire un valore o meno.


La funzione è un insieme di logica che può essere utilizzato per manipolare i dati. While, Method è una funzione che viene utilizzata per manipolare i dati dell'oggetto a cui appartiene. Quindi, tecnicamente, se hai una funzione che non è completamente correlata alla tua classe ma è stata dichiarata nella classe, non è un metodo; Si chiama cattivo design.


La funzione è un insieme di logica che può essere utilizzato per manipolare i dati.

While, Method è una funzione che viene utilizzata per manipolare i dati dell'oggetto a cui appartiene. Quindi, tecnicamente, se hai una funzione che non è completamente correlata alla tua classe ma è stata dichiarata nella classe, non è un metodo; Si chiama cattivo design.


Le persone IMHO volevano solo inventare nuove parole per facilitare la comunicazione tra i programmatori quando volevano riferirsi a funzioni all'interno degli oggetti.

Se stai dicendo metodi intendi funzioni all'interno della classe. Se stai dicendo che le funzioni vuoi dire semplicemente funzioni al di fuori della classe.

La verità è che entrambe le parole sono usate per descrivere le funzioni. Anche se l'hai usato erroneamente, non succede nulla di sbagliato. Entrambe le parole descrivono bene ciò che vuoi ottenere nel tuo codice.

La funzione è un codice che deve svolgere un ruolo ( una funzione ) di fare qualcosa. Il metodo è un metodo per risolvere il problema.

Fa la stessa cosa. E 'la stessa cosa. Se vuoi essere molto preciso e andare d'accordo con la convenzione, puoi chiamare i metodi come funzioni all'interno degli oggetti.


Metodi su un atto di classe sull'istanza della classe, chiamato l'oggetto.

class Example
{
   public int data = 0; // Each instance of Example holds its internal data. This is a "field", or "member variable".

   public void UpdateData() // .. and manipulates it (This is a method by the way)
   {
      data = data + 1;
   }

   public void PrintData() // This is also a method
   {
      Console.WriteLine(data);
   }
}

class Program
{
   public static void Main()
   {
       Example exampleObject1 = new Example();
       Example exampleObject2 = new Example();

       exampleObject1.UpdateData();
       exampleObject1.UpdateData();

       exampleObject2.UpdateData();

       exampleObject1.PrintData(); // Prints "2"
       exampleObject2.PrintData(); // Prints "1"
   }
}

Non complicare ulteriormente ciò che dovrebbe essere una risposta molto semplice. Metodi e funzioni sono la stessa cosa. Si chiama una funzione una funzione quando è al di fuori di una classe e si chiama una funzione un metodo quando è scritta all'interno di una classe.


Non sono un esperto, ma questo è quello che so:

  1. La funzione è termine in linguaggio C, si riferisce a un pezzo di codice e il nome della funzione sarà l'identificatore per utilizzare questa funzione.

  2. Il metodo è il termine OO, in genere ha un puntatore nel parametro della funzione. Non puoi invocare questo pezzo di codice come C, devi usare l'oggetto per invocarlo.

  3. Anche i metodi di richiamo sono diversi. Qui invoco il significato per trovare l'indirizzo di questo pezzo di codice. C / C ++, il tempo di collegamento utilizzerà il simbolo della funzione per individuare.

  4. Objecive-C è diverso. Invoke che indica una funzione C per utilizzare la struttura dei dati per trovare l'indirizzo. Significa che tutto è noto in fase di esecuzione.


Se hai voglia di leggere qui c'è "La mia introduzione ai metodi OO"

L'idea dietro il paradigma Object Oriented è "minacciare" che il software sia composto da ... "oggetti". Gli oggetti nel mondo reale hanno proprietà, ad esempio se hai un Dipendente, il dipendente ha un nome, un ID dipendente, una posizione, appartiene a un dipartimento ecc. Ecc.

L'oggetto sa anche come gestire i suoi attributi ed eseguire alcune operazioni su di essi. Diciamo che se vogliamo sapere cosa sta facendo un impiegato in questo momento, gli chiederemo.

employe whatAreYouDoing.

Quel "WhatreYouDoing" è un "messaggio" inviato all'oggetto. L'oggetto sa come rispondere a queste domande, si dice che abbia un "metodo" per risolvere la domanda.

Quindi, il modo in cui gli oggetti devono esporre il suo comportamento sono chiamati metodi. I metodi quindi sono l'oggetto artefatto che devono "fare" qualcosa.

Altri metodi possibili sono

employee whatIsYourName
employee whatIsYourDepartmentsName

eccetera.

Le funzioni nell'altro sono i modi in cui un linguaggio di programmazione deve calcolare alcuni dati, ad esempio si potrebbe avere la funzione addValues ​​(8, 8) che restituisce 16

// pseudo-code
function addValues( int x, int y )  return x + y 
// call it 
result = addValues( 8,8 )
print result // output is 16...

Poiché i primi linguaggi di programmazione popolari (come fortran, c, pascal) non coprivano il paradigma OO, chiamavano solo queste "funzioni" di artefatti.

per esempio la funzione precedente in C sarebbe:

int addValues( int x, int y ) 
{
   return x + y;
}

Non è "naturale" dire che un oggetto ha una "funzione" per eseguire qualche azione, perché le funzioni sono più legate a cose matematiche mentre un Dipendente ha poca matematica su di esso, ma puoi avere metodi che fanno esattamente lo stesso di funzioni, per esempio in Java questa sarebbe la funzione addValues ​​equivalente.

public static int addValues( int x, int y ) {
    return x + y;
}

Sembra familiare? Questo perché Java ha le sue radici su C ++ e C ++ su C.

Alla fine è solo un concetto, in fase di implementazione potrebbero sembrare uguali, ma nella documentazione OO questi sono chiamati metodo.

Ecco un esempio del precedente oggetto Employee in Java.

public class Employee {

    Department department;
    String name;

    public String whatsYourName(){
        return this.name;
    }
    public String whatsYourDeparmentsName(){
         return this.department.name();
    }
    public String whatAreYouDoing(){
        return "nothing";
    } 
    // Ignore the following, only set here for completness
    public Employee( String name ) {
        this.name = name;
    }

}

// Usage sample.
Employee employee = new Employee( "John" ); // Creates an employee called John

// If I want to display what is this employee doing I could use its methods.
// to know it.
String name = employee.whatIsYourName():
String doingWhat = employee.whatAreYouDoint();

// Print the info to the console.

 System.out.printf("Employee %s is doing: %s", name, doingWhat );

Output:
Employee John is doing nothing.

La differenza quindi è sul "dominio" in cui è applicata.

AppleScript ha l'idea del "linguaggio naturale", che a un certo punto OO aveva. Per esempio Smalltalk. Spero che possa essere più facile per te capire i metodi negli oggetti dopo aver letto questo.

NOTA: il codice non deve essere compilato, solo per servire da esempio. Sentiti libero di modificare il post e aggiungere l'esempio di Python.


Semplice modo di ricordare:

  • F unction → F ree (Free significa non appartenere a un oggetto o classe)
  • M etodo → M embro (membro di un oggetto o classe)

Storicamente, potrebbe esserci una sottile differenza con un "metodo" che è qualcosa che non restituisce un valore, e una "funzione" che fa. Ogni lingua ha il suo lessico di termini con un significato speciale.

In "C" , la parola "funzione" indica una routine di programma .

In Java , il termine "funzione" non ha alcun significato speciale. Mentre "metodo" indica una delle routine che costituisce l'implementazione di una classe.

In C # che tradurrebbe come:

public void DoSomething() {} // method
public int DoSomethingAndReturnMeANumber(){} // function

Ma in realtà, ribadisco che non c'è davvero alcuna differenza nei 2 concetti. Se usi il termine "funzione" nelle discussioni informali su Java, le persone assumeranno che tu intenda "metodo" e continui. Non usarlo in documenti appropriati o presentazioni su Java, o sembrerai sciocco.


Un metodo è su un oggetto.
Una funzione è indipendente da un oggetto.

Per Java, ci sono solo metodi.
Per C, ci sono solo funzioni.

Per il C ++ dipenderà dal fatto che tu sia o meno in una classe.


Una definizione molto generale della principale differenza tra una funzione e un metodo :

Le funzioni sono definite al di fuori delle classi, mentre i metodi sono definiti all'interno e parte delle classi.


Una funzione è un concetto matematico. Per esempio:

f(x,y) = sin(x) + cos(y)

dice che la funzione f () restituirà il sin del primo parametro aggiunto al coseno del secondo parametro. È solo matematica Come succede, sin () e cos () sono anche funzioni. Una funzione ha un'altra proprietà: tutte le chiamate a una funzione con gli stessi parametri dovrebbero restituire lo stesso risultato.

Un metodo, d'altra parte, è una funzione che è correlata a un oggetto in un linguaggio orientato agli oggetti. Ha un parametro implicito: l'oggetto su cui si agisce (ed è lo stato).

Quindi, se hai un oggetto Z con un metodo g (x), potresti vedere quanto segue:

Z.g(x) = sin(x) + cos(Z.y)

In questo caso, il parametro x viene passato, come già nell'esempio di funzione precedente. Tuttavia, il parametro su cos () è un valore che vive all'interno dell'oggetto Z. Z e i dati che vivono al suo interno (Zy) sono parametri impliciti del metodo g () di Z.


'metodo' è la parola orientata agli oggetti per 'funzione' . Questo è praticamente tutto quello che c'è (ad es., Nessuna vera differenza).

Sfortunatamente, penso che molte delle risposte qui riportate stiano perpetuando o avanzando l'idea che ci sia una differenza complessa e significativa.

Davvero - non c'è molto di più, solo parole diverse per la stessa cosa.

[aggiunta in ritardo]

Infatti, come ha sottolineato Brian Neal in un commento a questa domanda , lo standard C ++ non usa mai il termine "metodo" quando si fa riferimento alle funzioni membro. Alcune persone potrebbero prenderlo come un'indicazione che il C ++ non è realmente un linguaggio orientato agli oggetti; tuttavia, preferisco prenderlo come un'indicazione che un gruppo piuttosto intelligente di persone non pensava che esistesse una ragione particolarmente forte per usare un termine diverso.


Una classe è la raccolta di alcuni dati e funziona opzionalmente con un costruttore.

Durante la creazione di un'istanza (copia, replica) di quella particolare classe, il costruttore inizializza la classe e restituisce un oggetto.

Ora la classe diventa oggetto (senza costruttore) e le funzioni sono conosciute come metodo nel contesto dell'oggetto.

Quindi in poche parole

Classe <== nuovo ==> Oggetto

Funzione <== nuovo ==> Metodo

In Java viene generalmente detto che il nome del costruttore è uguale al nome della classe, ma in realtà quel costruttore è come un blocco di istanza e un blocco statico ma con un utente che definisce il tipo di ritorno (cioè il tipo di classe)

Mentre la classe può avere un blocco statico, un blocco di istanze, un costruttore, una funzione L'oggetto generalmente ha solo dati e metodo.





terminology