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

Una funzione è un pezzo di codice che viene chiamato per nome. Può essere passato i dati su cui operare (cioè i parametri) e può facoltativamente restituire dati (il valore di ritorno). Tutti i dati passati a una funzione vengono esplicitamente passati.

Un metodo è un pezzo di codice che viene chiamato da un nome associato a un oggetto. Per molti aspetti è identico a una funzione, tranne per due differenze chiave:

1. Un metodo viene implicitamente passato l'oggetto su cui è stato chiamato.
2. Un metodo è in grado di operare su dati contenuti nella classe (ricordando che un oggetto è un'istanza di una classe: la classe è la definizione, l'oggetto è un'istanza di tali dati).

(questa è una spiegazione semplificata, ignorando le questioni di portata ecc.)

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

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

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

"metodo" è la parola orientata agli oggetti per "funzione" . Questo è praticamente tutto ciò che c'è da fare (cioè, nessuna vera differenza).

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

Davvero - non c'è molto da dire, solo parole diverse per la stessa cosa.

[aggiunta tardiva]

In effetti, 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 è in realtà un linguaggio orientato agli oggetti; tuttavia, preferisco prenderlo come un'indicazione che un gruppo piuttosto intelligente di persone non pensava che ci fosse una ragione particolarmente forte per usare un termine diverso.

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 "Porta" che ha un metodo o un'azione chiamata "aperta", si chiama metodo perché è stata dichiarata all'interno di una classe. C'è un'altra porzione di codice con "def" appena sotto che 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 viene chiamato da solo.

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

Pensa ai metodi come 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 scrivi una funzione "feed" perché non appartiene a nessuna classe poiché sia ​​gli uomini che i cani possono essere nutriti e potresti chiamarla funzione poiché non appartiene a nessuna classe in particolare.

Modo semplice da ricordare:

• F unzione → F ree (libero significa non appartenere a un oggetto o una classe)
• M etodo → M ember (Un membro di un oggetto o di 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.

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

L'idea alla base del paradigma Object Oriented è di "minacciare" il software è composto da ... beh "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 dipendente in questo momento, glielo chiederemmo.

employe whatAreYouDoing.

Quel "whatAreYouDoing" è 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 gli oggetti artefatti che devono "fare" qualcosa.

Altri possibili metodi sono

employee whatIsYourName
employee whatIsYourDepartmentsName

eccetera.

Le funzioni d'altra parte sono i modi in cui un linguaggio di programmazione deve calcolare alcuni dati, ad esempio potresti 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, chiamano 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 alcune azioni, perché le funzioni sono più correlate a cose matematiche mentre un Dipendente ha poca matematica su di esso, ma puoi avere metodi che fanno esattamente lo stesso delle funzioni, ad 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, nell'implementazione potrebbero sembrare uguali, ma nella documentazione OO questi sono chiamati metodo.

Ecco un esempio dell'oggetto precedentemente 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, sta nel "dominio" in cui viene applicato.

AppleScript ha l'idea del matphor "linguaggio naturale", che ad un certo punto OO aveva. Ad esempio Smalltalk. Spero che dopo aver letto questo sia più facile per te comprendere i metodi negli oggetti.

NOTA: il codice non deve essere compilato, ma serve solo come esempio. Sentiti libero di modificare il post e aggiungere l'esempio di Python.

Nel mondo OO, i due sono comunemente usati per significare la stessa cosa.

Da una prospettiva matematica e CS pura, una funzione restituirà sempre lo stesso risultato quando viene chiamata con gli stessi argomenti (f (x, y) = (x + y)). Un metodo, d'altra parte, è in genere associato a un'istanza di una classe. Ancora una volta, tuttavia, la maggior parte delle lingue OO moderne non utilizza più il termine "funzione" per la maggior parte. Molti metodi statici possono essere abbastanza simili alle funzioni, in quanto in genere non hanno uno stato (non sempre vero).

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

Un metodo è una funzione di proprietà di un oggetto (in alcuni sistemi orientati agli oggetti, è più corretto affermare che appartiene a una classe). Essere "posseduti" da un oggetto / classe significa che si fa riferimento al metodo attraverso l'oggetto / classe; ad esempio, in Java se si desidera invocare un metodo "open ()" di proprietà di un oggetto "door", è necessario scrivere "door.open ()".

Di solito i metodi ottengono anche alcuni attributi extra che descrivono il loro comportamento all'interno dell'oggetto / classe, ad esempio: visibilità (relativa 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 ad alcuni oggetti (o classi) e quindi in questi linguaggi non esistono funzioni che non siano metodi.

I metodi sono funzioni di classi. Nel gergo normale, le persone scambiano il metodo e funzionano dappertutto. Fondamentalmente puoi pensarli come la stessa cosa (non sei sicuro che le funzioni globali siano chiamate metodi).

http://en.wikipedia.org/wiki/Method_(computer_science)

Una funzione è un concetto matematico. Per esempio:

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

dice che la funzione f () restituirà il peccato del primo parametro aggiunto al coseno del secondo parametro. È solo matematica. Come accade 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 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, viene passato il parametro x, lo stesso dell'esempio di funzione precedente. Tuttavia, il parametro di 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.

Una funzione o un metodo è un pezzo di codice richiamabile chiamato che esegue alcune operazioni e facoltativamente restituisce un valore.

Nel linguaggio C viene usato il termine funzione. Java e C # persone lo direbbero un metodo (e una funzione in questo caso è definita all'interno di una classe / oggetto).

Un programmatore C ++ potrebbe chiamarlo una funzione o talvolta un metodo (a seconda se stanno scrivendo un codice c ++ in stile procedurale o stanno facendo un modo di C ++ orientato agli oggetti, anche un programmatore solo C / C ++ lo chiamerebbe probabilmente una funzione perché il termine "metodo" è usato meno spesso nella letteratura C / C ++).

Usa una funzione chiamando semplicemente il suo nome come,

result = mySum(num1, num2);

Chiameresti un metodo facendo prima riferimento al suo oggetto come,

result = MyCalc.mySum(num1,num2);

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

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

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

In C # che si tradurrebbe in:

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

Ma davvero, ribadisco che non c'è davvero alcuna differenza nei 2 concetti. Se usi il termine "funzione" nelle discussioni informali su Java, la gente supporrà che tu abbia inteso "metodo" e proseguirà. Non utilizzarlo in documenti o presentazioni corretti su Java, altrimenti sembrerai sciocco.

La funzione è un insieme di logiche che possono essere utilizzate per manipolare i dati.

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

I metodi su una classe agiscono sull'istanza della classe, chiamata 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"
   }
}

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" è indipendente (fornisce la lunghezza di una stringa fornita come argomento). È quindi solo una "funzione". Anche Javascript è tecnicamente orientato agli oggetti, ma presenta molte limitazioni rispetto a un linguaggio completo come C ++, C # o Pascal. Tuttavia, la distinzione dovrebbe ancora valere.

Un paio di ulteriori fatti: C # è completamente orientato agli oggetti, quindi non è possibile creare "funzioni" autonome. 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 vera distinzione da fare.

Alla fine - solo così tutti i guru di Pascal non saltano su di me qui - Pascal distingue anche tra "funzioni" (che restituiscono un valore) e "procedure" che non lo fanno. C # non fa questa distinzione in modo esplicito sebbene sia possibile, ovviamente, scegliere di restituire un valore oppure no.

Dato che hai citato Python, quanto segue potrebbe essere un'utile illustrazione della relazione tra metodi e oggetti nella maggior parte dei moderni linguaggi orientati agli oggetti. In poche parole quello che chiamano "metodo" è solo una funzione a cui viene passato un argomento in più (come hanno sottolineato altre risposte), ma Python lo rende più esplicito della maggior parte delle lingue.

# perfectly normal function
def hello(greetee):
  print "Hello", greetee

# generalise a bit (still a function though)
def greet(greeting, greetee):
  print greeting, greetee

# hide the greeting behind a layer of abstraction (still a function!)
def greet_with_greeter(greeter, greetee):
  print greeter.greeting, greetee

# very simple class we can pass to greet_with_greeter
class Greeter(object):
  def __init__(self, greeting):
    self.greeting = greeting

  # while we're at it, here's a method that uses self.greeting...
  def greet(self, greetee):
    print self.greeting, greetee

# save an object of class Greeter for later
hello_greeter = Greeter("Hello")

# now all of the following print the same message
hello("World")
greet("Hello", "World")
greet_with_greeter(hello_greeter, "World")
hello_greeter.greet("World")

Ora confronta la funzione greet_with_greetere il metodo greet: l'unica differenza è il nome del primo parametro (nella funzione l'ho chiamato "greeter", nel metodo l'ho chiamato "self"). Quindi posso usare il greetmetodo esattamente nello stesso modo in cui uso la greet_with_greeterfunzione (usando la sintassi "punto" per ottenerlo, dal momento che l'ho definito all'interno di una classe):

Greeter.greet(hello_greeter, "World")

Quindi ho effettivamente trasformato un metodo in una funzione. Posso trasformare una funzione in un metodo? Bene, poiché Python ti consente di fare confusione con le classi dopo che sono state definite, proviamo:

Greeter.greet2 = greet_with_greeter
hello_greeter.greet2("World")

Sì, la funzione greet_with_greeterè ora nota anche come metodo greet2. Questo mostra l'unica vera differenza tra un metodo e una funzione: quando chiami un metodo "su" un oggetto chiamando object.method(args), il linguaggio lo trasforma magicamente in method(object, args).

(I puristi di OO potrebbero obiettare che un metodo è qualcosa di diverso da una funzione, e se entri in Python o Ruby - o Smalltalk!) Inizierai a capire il loro punto. Inoltre alcune lingue danno ai metodi un accesso speciale ai bit di un oggetto. Ma la principale differenza concettuale è ancora il parametro extra nascosto.)

per me: la funzione di un metodo e una funzione è la stessa se sono d'accordo che:

• una funzione può restituire un valore
• possono aspettarsi parametri

Proprio come qualsiasi pezzo di codice in cui potresti avere oggetti che inserisci e potresti avere un oggetto che ne deriva. Nel fare ciò potrebbero cambiare lo stato di un oggetto ma ciò non cambierebbe il loro funzionamento di base per me.

Potrebbe esserci una differenza nella definizione delle funzioni di chiamata di oggetti o altri codici. Ma non è qualcosa per una differenza verbale ed è per questo che le persone li scambiano? L'esempio menzionato di calcolo con cui starei attento. perché assumo dipendenti per fare i miei calcoli:

new Employer().calculateSum( 8, 8 );

In questo modo posso contare sul fatto che un datore di lavoro sia responsabile dei calcoli. Se vuole più soldi, lo libero e lascio che la funzione di collezionista di carabine di disporre di impiegati inutilizzati faccia il resto e ottenga un nuovo impiegato.

Persino sostenere che un metodo è una funzione di oggetti e una funzione è un calcolo non collegato non mi aiuterà. Il descrittore della funzione stessa e idealmente la documentazione della funzione mi diranno di cosa ha bisogno e cosa può restituire. Il resto, come manipolare lo stato di alcuni oggetti, non è molto trasparente per me. Mi aspetto che funzioni e metodi forniscano e manipolino ciò a cui sostengono senza bisogno di sapere in dettaglio come lo fanno. Anche una pura funzione computazionale potrebbe cambiare lo stato della console o aggiungerla a un file di registro.

Non compliciamo troppo quella che dovrebbe essere una risposta molto semplice. Metodi e funzioni sono la stessa cosa. Chiamate una funzione una funzione quando è al di fuori di una classe e chiamate una funzione un metodo quando è scritta all'interno di una classe.

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

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

Ad esempio, supponiamo che tu voglia descrivere un gatto e vorresti che fosse in grado di sbadigliare. Dovresti creare una classe Cat, con un metodo Yawn, che molto probabilmente sarebbe una funzione senza alcun valore di ritorno.

Per un'approssimazione del primo ordine, un metodo (in stile O ++ in C ++) è un'altra parola per una funzione membro, ovvero una funzione che fa parte di una classe.

In linguaggi come C / C ++ puoi avere funzioni che non sono membri di una classe; non si chiama una funzione non associata a una classe un metodo.

La funzione è il concetto che appartiene principalmente alla programmazione orientata alla procedura in cui una funzione è un'entità che può elaborare dati e restituire valore

Il metodo è il concetto di programmazione orientata agli oggetti in cui un metodo è un membro di una classe che si occupa principalmente dei membri della classe.

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

Se stai dicendo metodi intendi funzioni all'interno della classe. Se stai dicendo funzioni intendi semplicemente funzioni esterne alla classe.

La verità è che entrambe le parole sono usate per descrivere le funzioni. Anche se lo hai usato nel modo sbagliato, 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 ) nel fare qualcosa. Il metodo è un metodo per risolvere il problema.

Fa la stessa cosa. E 'la stessa cosa. Se vuoi essere super preciso e seguire la convenzione, puoi chiamare metodi come funzioni all'interno degli oggetti.

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

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

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

3. Anche i metodi invoke sono diversi. Qui invoca 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. Richiama il significato di una funzione C per utilizzare la struttura dei dati per trovare l'indirizzo. Significa che tutto è noto in fase di esecuzione.

So che molti altri hanno già risposto, ma ho scoperto che di seguito è una risposta a riga singola semplice ma efficace. Anche se non sembra molto meglio delle altre risposte qui, ma se lo leggi attentamente, ha tutto ciò che devi sapere sul metodo vs funzione.

Un metodo è una funzione che ha un ricevitore definito, in termini di OOP, un metodo è una funzione su un'istanza di un oggetto.

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 della funzione. Questa sezione descrive gli altri tipi di membri di funzioni 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 constructornon può essere detto come metodo ma è una funzione.

Funzione - Una funzione in un pezzo di codice indipendente che include un po 'di logica e deve essere chiamata in modo indipendente e viene definita al di fuori della classe.

Metodo: un metodo è un pezzo di codice indipendente che viene chiamato in riferimento a un oggetto e che viene definito all'interno della classe.

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

test(20, 50); è la funzione definita e utilizzata per eseguire alcuni passaggi o restituire qualcosa che può essere archiviato / utilizzato da qualche parte.

Puoi riutilizzare il codice: definisci il codice una volta e usalo più volte.

È possibile utilizzare più volte lo stesso codice 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 alcuni oggetti o un prototipo definito per oggetti incorporati, qui c'è più spiegazione:

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

Un metodo JavaScript è una proprietà che contiene una definizione di funzione.

Proprietà / metodo integrati 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 , Funzioni , Ulteriori informazioni sul prototipo

TL; DR

Una funzione è un pezzo di codice da eseguire.
Un metodo è una funzione all'interno di un oggetto.

Esempio di una funzione:

function sum(){
  console.log("sum")l
}

Esempio di un metodo:

const obj = {
a:1,
b:2,
sum(){
  }
}

Ecco perché diciamo che una parola chiave "this" all'interno di una funzione non è molto utile a meno che non la utilizziamo con call, apply o bind .. perché call, apply, bind chiamerà quella funzione come metodo all'interno dell'oggetto ==> sostanzialmente converte la funzione in metodo

Sono spesso intercambiabili, ma un metodo di solito si riferisce a una subroutine all'interno di una classe e una funzione di solito si riferisce a una subroutine esterna alla classe. per esempio, in Ruby:

# function
def putSqr(a)
   puts a ** 2
end


class Math2
   # method
   def putSqr(a)
      puts a ** 2
   end
end

In Java, dove tutto (tranne i pacchetti e le istruzioni di importazione) devono essere all'interno della classe, le persone quasi sempre si riferiscono a loro come "metodi".