Method receivers and class methods: who gets bound?

Read what a call hands a method automatically, an object, the class the call went through, or nothing, in Java and Python. Methods and type contracts · Object-oriented programming.

A dashboard keeps a Meter class. One line calls meter.reading() on a particular meter, another calls Meter.unit() on the class itself, and a third calls FastMeter.from_label("fast") on a subclass. All three look like an ordinary method call, yet the language quietly hands each method a different first thing: an object, a class, or nothing. The method's kind decides which, and that decides what its body can reach.

Method dispatch showed which body runs. This lesson asks only what is bound before the first argument you write.

An object call and a class call

An instance method works on one object's state, so the call hands it that object, the one the call is made on, called the receiver. Java supplies it as the implicit this. Python shows it as the first parameter, conventionally self, filled in when you reach the method through the object. Nothing is copied: self is the very object meter refers to.

A method that needs no object's state can be declared static in Java or @staticmethod in Python. The call then hands over nothing: no this, no self, no cls.

final class Meter {
    private final String label;
    Meter(String label) { this.label = label; }

    String reading() { return label; }     // this is the receiver
    static String unit() { return "ms"; }  // no this exists here
}

Meter meter = new Meter("queue");
meter.reading();   // "queue"
Meter.unit();      // "ms"

class Meter:
    def __init__(self, label):
        self.label = label

    def reading(self):              # self is the receiver
        return self.label

    @staticmethod
    def unit():                     # nothing is bound
        return "ms"

meter = Meter("queue")
print(meter.reading())   # queue
print(Meter.unit())      # ms
print(meter.unit())      # ms: reaching it through meter still binds nothing

Reading label inside unit is a compile error in Java, because there is no this. In Python self is an undefined name there, and the call raises NameError. The static body can use only the arguments you pass it.

A classmethod gets the class the call went through

Python adds a third kind of method. A method marked @classmethod is handed a class, conventionally cls, and it is the class named in the call, not the class where the code was written. That makes it the natural home for an alternate constructor, because cls(...) builds whatever class the call went through. The example below only reports cls.__name__, so the one thing on show is which class arrived.

class Meter:
    @classmethod
    def from_label(cls, label):
        return "made " + cls.__name__

class FastMeter(Meter):
    pass

print(Meter.from_label("queue"))      # made Meter
print(FastMeter.from_label("fast"))   # made FastMeter

The search for from_label climbs from FastMeter to Meter along the class's __mro__, as dispatch taught. Binding is a separate step: whatever class holds the code, cls is the class the call went through. So FastMeter does not need its own from_label to report FastMeter, and a call through a class involves no object at all.

Java has no invoking class to hand over

Java has no counterpart to @classmethod. A static factory is declared once and inherited, and a call through a subclass name finds it, but the body is not told which name was used.

class Meter {
    static Meter make() { return new Meter("made"); }
    // constructor and fields omitted
}
class FastMeter extends Meter { /* ... */ }

Meter made = FastMeter.make();
System.out.println(made.getClass().getSimpleName());   // Meter
System.out.println(made instanceof FastMeter);         // false

The call compiled, ran Meter's code, and returned a Meter. If the factory must make a FastMeter, FastMeter needs its own make, or the factory must be told which class to build.

Choosing the kind

Ask what the body must touch. If it reads or changes one object's state, write an instance method. If it is an alternate constructor that should respect subclasses, such as building from a label or a default, write a classmethod in Python and give each Java subclass its own static factory or constructor. If it needs neither an object nor a class, such as converting a unit or checking a format, make it static. A static helper is also the easiest to test, because nothing has to be built first. A static method that starts needing self is the wrong kind.

Recap

• An instance call binds the object as this in Java and self in Python, with no copy.
• A Java static method and a Python staticmethod bind nothing, even when an object exists.
• A Python classmethod binds the class the call went through as cls; a Java static method is told nothing about the name used.

Continue to generic type contracts when one class should be reusable across a family of element types. Revisit method dispatch when the next question is which implementation a runtime object supplies. Practise receiver state in Linked List Fundamentals, where each node operation still acts through a particular object.