What’s the difference between a method and a function?

function is a piece of code that is called by name. It can be passed data to operate on (i.e. the parameters) and can optionally return data (the return value). All data that is passed to a function is explicitly passed.

method is a piece of code that is called by a name that is associated with an object. In most respects it is identical to a function except for two key differences:

  1. A method is implicitly passed the object on which it was called.
  2. A method is able to operate on data that is contained within the class (remembering that an object is an instance of a class – the class is the definition, the object is an instance of that data).

What’s the difference between a method and a function?

A method is on an object or is static in class.
A function is independent of any object (and outside of any class).

For Java and C#, there are only methods.
For C, there are only functions.

For C++ and Python it would depend on whether or not you’re in a class.
But in basic English:

  • Function: Standalone feature or functionality.
  • Method: One way of doing something, which has different approaches or methods, but related to the same aspect (aka class).

Simple way to remember:

  • Function → Free (Free means it can be anywhere, no need to be in an object or class)
  • Method → Member (A member of an object or class)

In other words,

‘method’ is the object-oriented word for ‘function’. That’s pretty much all there is to it (ie., no real difference).

Unfortunately, I think a lot of the answers here are perpetuating or advancing the idea that there’s some complex, meaningful difference.

Really – there isn’t all that much to it, just different words for the same thing.

Functions vs methods in programming explained by example:

In general: methods are functions that belong to a class, functions can be on any other scope of the code so you could state that all methods are functions, but not all functions are methods:

Take the following python example:

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

def knock_door:
  a_door = Door()


The example given shows you a class called “Door” which has a method or action called “open”, it is called a method because it was declared inside a class. There is another portion of code with “def” just below which defines a function, it is a function because it is not declared inside a class, this function calls the method we defined inside our class as you can see and finally the function is being called by itself.

As you can see you can call a function anywhere but if you want to call a method either you have to pass a new object of the same type as the class the method is declared (Class.method(object)) or you have to invoke the method inside the object (object.Method()), at least in python.

Think of methods as things only one entity can do, so if you have a Dog class it would make sense to have a bark function only inside that class and that would be a method, if you have also a Person class it could make sense to write a function “feed” for that doesn’t belong to any class since both humans and dogs can be fed and you could call that a function since it does not belong to any class in particular.

Answer #3:

A Function is a piece of code to run.
A Method is a Function inside an Object.

Example of a function:

function sum(){

Example of a Method:

const obj = {

So that’s why we say that a “this” keyword inside a Function is not very useful unless we use it with call, apply or bind .. because call, apply, bind will call that function as a method inside object ==> basically it converts function to method.

Difference between function and method using Java example:

If you feel like reading here is “My introduction to OO methods”

The idea behind Object Oriented paradigm is to “threat” the software is composed of .. well “objects”. Objects in real world have properties, for instance if you have an Employee, the employee has a name, an employee id, a position, he belongs to a department etc. etc.

The object also know how to deal with its attributes and perform some operations on them. Let say if we want to know what an employee is doing right now we would ask him.

employe whatAreYouDoing.

That “whatAreYouDoing” is a “message” sent to the object. The object knows how to answer to that questions, it is said it has a “method” to resolve the question.

So, the way objects have to expose its behavior are called methods. Methods thus are the artifact object have to “do” something.

Other possible methods are

employee whatIsYourName
employee whatIsYourDepartmentsName


Functions in the other hand are ways a programming language has to compute some data, for instance you might have the function addValues( 8 , 8 ) that returns 16

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

Since first popular programming languages ( such as fortran, c, pascal ) didn’t cover the OO paradigm, they only call to these artifacts “functions”.

for instance the previous function in C would be:

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

It is not “natural” to say an object has a “function” to perform some action, because functions are more related to mathematical stuff while an Employee has little mathematic on it, but you can have methods that do exactly the same as functions, for instance in Java this would be the equivalent addValues function.

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

Looks familiar? That´s because Java have its roots on C++ and C++ on C.

At the end is just a concept, in implementation they might look the same, but in the OO documentation these are called method.

Here´s an example of the previously Employee object 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 );

Employee John is doing nothing.

The difference then, is on the “domain” where it is applied.

AppleScript have the idea of “natural language” matphor , that at some point OO had. For instance Smalltalk. I hope it may be reasonable easier for you to understand methods in objects after reading this.

NOTE: The code is not to be compiled, just to serve as an example.

For more details, keep reading…

Methods vs functions in programming

In just 2 words: non-static (“instance”) methods take a hidden pointer to “this” (as their 1st param) which is the object you call the method on.

That’s the only difference with a regular standalone function, dynamic dispatching notwithstanding.

If you are interested, read the details below.

I’ll try to be short and will use C++ as an example although what I say can be applied to virtually every language.

  • For your CPU, both functions and methods are just pieces of code. Period.
  • As such, when functions/methods are called, they can take parameters

Ok, I said there’s no actual difference. Let’s dig a bit deeper:

  • There are 2 flavors of methods: static and non-static
  • Static methods are like regular functions but declared inside the class that acts merely like a namespace
  • Non-static (“instance”) methods take a hidden pointer to “this”. That’s the only difference with a regular standalone function.

Dynamic dispatching aside, it means it’s as simple as that:

class User {
    public string name; // I made it public intentionally

    // Each instance method takes a hidden reference to "this"
    public void printName(/*User & this*/) {
        cout << this.name << endl;

is equivalent to

public getName(User & user) {
    // No syntactic sugar, passing a reference explicitly
    cout << user.name << endl;

So, essentially, user->printName() is just syntactic sugar for getName(user).

If you don’t use dynamic dispatch, that’s all. If it is used, then it’s a bit more involved, but the compiler will still emit what looks like a function taking this as a first parameter.

In this post, we learned the difference between function and method in programming.

Hope you learned something from this post.

Follow Programming Articles for more!

About ᴾᴿᴼᵍʳᵃᵐᵐᵉʳ

Linux and Python enthusiast, in love with open source since 2014, Writer at programming-articles.com, India.

View all posts by ᴾᴿᴼᵍʳᵃᵐᵐᵉʳ →