Difference Between Class and Instance Methods

What is the difference between class and instance methods?

Like most of the other answers have said, instance methods use an instance of a class, whereas a class method can be used with just the class name. In Objective-C they are defined thusly:

@interface MyClass : NSObject

+ (void)aClassMethod;
- (void)anInstanceMethod;

@end

They could then be used like so:

[MyClass aClassMethod];

MyClass *object = [[MyClass alloc] init];
[object anInstanceMethod];

Some real world examples of class methods are the convenience methods on many Foundation classes like NSString's +stringWithFormat: or NSArray's +arrayWithArray:. An instance method would be NSArray's -count method.

Difference between class and instance methods

Instance methods

When creating an instance method, the first parameter is always self.
You can name it anything you want, but the meaning will always be the same, and you should use self since it's the naming convention.
self is (usually) passed hiddenly when calling an instance method; it represents the instance calling the method.

Here's an example of a class called Inst that has an instance method called introduce():

class Inst:

    def __init__(self, name):
        self.name = name

    def introduce(self):
        print("Hello, I am %s, and my name is " %(self, self.name))

Now to call this method, we first need to create an instance of our class.
Once we have an instance, we can call introduce() on it, and the instance will automatically be passed as self:

myinst = Inst("Test Instance")
otherinst = Inst("An other instance")
myinst.introduce()
# outputs: Hello, I am <Inst object at x>, and my name is Test Instance
otherinst.introduce()
# outputs: Hello, I am <Inst object at y>, and my name is An other instance

As you see, we're not passing the parameter self. It gets hiddenly passed with the period operator. We're calling Inst class's instance method introduce, with the parameter of myinst or otherinst.
This means that we can call Inst.introduce(myinst) and get the exact same result.

Class methods

The idea of a class method is very similar to an instance method, only difference being that instead of passing the instance hiddenly as a first parameter, we're now passing the class itself as a first parameter.

class Cls:

    @classmethod
    def introduce(cls):
        print("Hello, I am %s!" %cls)

Since we're passing only a class to the method, no instance is involved.

This means that we don't need an instance at all, and we call the class method as if it was a static function:

 Cls.introduce() # same as Cls.introduce(Cls)
 # outputs: Hello, I am <class 'Cls'>

Notice that again Cls is passed hiddenly, so we could also say Cls.introduce(Inst) and get output "Hello, I am <class 'Inst'>.

This is particularly useful when we're inheriting a class from Cls:

class SubCls(Cls):
    pass

SubCls.introduce()
# outputs: Hello, I am <class 'SubCls'>

difference between class method , instance method , instance variable , class variable?

First take a look at this diagram:

from "Metaprogramming Ruby" book

You can rightly say that “obj has a method called my_method( ),” meaning that you’re able to call obj.my_method(). By contrast, you shouldn’t say that “MyClass has a method named my_method().” That would be confusing, because it would imply that you’re able to call MyClass.my_method() as if it were a class method.

To remove the ambiguity, you should say that my_method() is an instance method (not just “a method”) of MyClass, meaning that it’s defined in MyClass, and you actually need an instance of MyClass to call it. It’s the same method, but when you talk about the class, you call it an instance method, and when you talk about the object, you simply call it a method. Remember this distinction, and you won’t get confused when writing introspective code like this:

String.instance_methods == "abc".methods # => true String.methods == "abc".methods # => false

an object’s instance variables live in the object itself, and an object’s methods live in the object’s class. That’s why objects of the same class share methods but don’t share instance variables.

What's the difference between class methods and instance methods in Swift?

Some text from the documentation:

Instance Methods

Instance methods are functions that belong to instances of a particular class, structure, or enumeration. They support the functionality of those instances, either by providing ways to access and modify instance properties, or by providing functionality related to the instance’s purpose.

ie. An Instance of the class has to call this method. Example :

var a:classAdoptingNoteProtocol=classAdoptingNoteProtocol()
a.update()

Class Methods

Instance methods, as described above, are methods that are called on an instance of a particular type. You can also define methods that are called on the type itself. These kinds of methods are called type methods. You indicate type methods for classes by writing the keyword class before the method’s func keyword, and type methods for structures and enumerations by writing the keyword static before the method’s func keyword.

They are what are called as Static methods in other languages.To use them, this is what I would do:

var b=classAdoptingNoteProtocol.noteFromNoteEntity(...)

This will return a instance of a class which adopts NoteProtocol. ie. you don't have to create a instance of the class to use them.

Any striking difference between class/instance methods vs static methods for use in applications?

If static is not added, then the method can only be called on an instance of the object.

If static is added, then the method can only be called with the class name prefix, not an instance of the object.

If you have a method that could be static (does not reference any instance data or use this to refer to an object instance), then you can make it either static or not static. If you make it non-static, it will still work just fine, but it will only be callable on an instance of the object itself or with a direct reference to Foo.prototype.method().

So, the disadvantage of not making a static method actually be declared static is that it's not as clean to use it when you don't have an instance of the object around. That's what static methods were invented for - to make it clean to declare and use functions namespaced to your class that don't require an instance.

How does ruby tell the difference between instance method and class method definition?

In a method body, self refers to the receiver. In lines 3..4 of the following, once the receiver is determined to be a User instance (by the def greeting syntax), self refers to that instance.

class User
  def greeting
    puts "Hi, #{name}"      # method body
    puts "Hi, #{self.name}" # method body
  end
end

In a class body, self refers to the class. In lines 2, 4, 8, 10 of the following, the class is User, so def self.greeting is the same as def User.greeting.

class User
  def self.greeting # class body
    # ...
  end               # class body
end

class User
  def greeting      # class body
    # ...
  end               # class body
end

But I actually think your real issue is not what self means, but rather what "an omitted receiver" means, in different contexts.

In method-calling syntax, an omitted receiver stands for self. So the following two are the same:

name
self.name

In method-defining syntax, an omitted receiver stands for "any instance of the class". So the following two are not the same:

def User.greeting; ... end
def greeting; ... end

When you define an instance method, there is no explicit way to express "any instance of the class", so actually omission is mandatory.

What is the difference between class methods and instance methods [sequelize]

Class is the object you get when you call sequelize.define. It stands for the whole table.

var User = sequelize.define('user', {...});

Instance is like one unit of that class, i.e. a row in the collection's table:

User.create({}).then(function(user) {
  // `user` is an instance.
});

Class methods are functions that don't expect an instance. You can call those like this:

User.myMethod();

Instance methods are ones that operate on a single instance. You can call them like this:

user.myMethod();

this in class methods is a class. this in instance methods is an instance (obviously).

Difference between class methods and instance methods?

All the other answers seem to have been caught out by the incorrect tag that has now been fixed.

In Objective-C, an instance method is a method that is invoked when a message is sent to an instance of a class. So, for instance:

id foo = [[MyClass alloc] init];
[foo someMethod];
//   ^^^^^^^^^^   This message invokes an instance method.

In Objective-C, classes are themselves objects and a class method is simply a method that is invoked when a message is sent to a class object. i.e.

[MyClass someMethod];
//       ^^^^^^^^^^   This message invokes a class method.

Note that, in the above examples the selector is the same, but because in one case it is sent to an instance of MyClass and in the other case it is sent to MyClass, different methods are invoked. In the interface declaration, you might see:

@interface MyClass : NSObject
{
}

+(id) someMethod;  // declaration of class method
-(id) someMethod;  // declaration of instance method

@end

and in the implementation

@implementation MyClass

+(id) someMethod
{
    // Here self is the class object
}
-(id) someMethod
{
    // here self is an instance of the class
}

@end

Edit

Sorry, missed out the second part. There are no advantages or disadvantages as such. It would be like asking what is the difference between while and if and what are the advantages of one over the other. It's sort of meaningless because they are designed for different purposes.

The most common use of class methods is to obtain an instance when you need one. +alloc is a class method which gives you a new uninitialised instance. NSString has loads of class methods to give you new strings, e.g. +stringWithForma

Another common use is to obtain a singleton e.g.

+(MyClass*) myUniqueObject
{
    static MyUniqueObject* theObject = nil;
    if (theObject == nil)
    {
        theObject  = [[MyClass alloc] init];
    }
    return theObject;
}

The above method would also work as an instance method, since theObject is static. However, the semantics are clearer if you make it a class method and you don't have to first create an instance.

Difference between Class Attributes, Instance Attributes, and Instance Methods in Python

Class attributes are same for all instances of class whereas instance attributes is particular for each instance. Instance attributes are for data specific for each instance and class attributes supposed to be used by all instances of the class.

"Instance methods" is a specific class attributes which accept instance of class as first attribute and suppose to manipulate with that instance.

"Class methods" is a methods defined within class which accept class as first attribute not instance(that's why the are class methods).

You can easily see class attributes by accessing A.__dict__:

class A:
   class_attribute = 10
   def class_method(self):
       self.instance_attribute = 'I am instance attribute'

print A.__dict__
#{'__module__': '__main__', 'class_method': <function class_method at 0x10978ab18>, 'class_attribute': 10, '__doc__': None}

And instance attributes as A().__dict__:

a = A()
a.class_method()
print a.__dict__
# {'instance_attribute': 'I am instance attribute'}

Some useful links from official python documentation and SO, which i hope won't confuse you more and give clearer understanding...

Python Classes
Dive into python, 5.8. Introducing Class Attributes
Definition of python getattr and setattr
What are Class methods in Python for?
Difference between Class and Instance methods