Companion objects is a rather surprising Kotlin feature. Being a replacement (allegedly an improvement) for the static members that we find in most other languages (Java, C#, Python), in order to grasp its advantages I've needed first to review how static members work in these other languages. That's what this post is about.
In Java static members (fields or methods) can be accessed from the class and also from instances of the class (which is not recommended because of what I'm going to explain). Static members are inherited, but static methods are not virtual, their resolution is done at compile-time, based on the compile-time type, which is something pretty important to take into account if we are going to invoke them through an instance rather than through the class (it seems to be a source of confusion, and one of the reasons why Kotlin designers decided not to add "static" to the language). If we define a same static method in a Parent class and its Child class, and we invoke it through a Parent variable pointing to a Child instance, as the resolution is done at compile time (there's no polymorphism for static members) the method being invoked will be the one in Parent rather than in Child. You can read more here.
Things are a bit different in C#. Probably aware of that problem in Java, C# designers decided to make static members only accessible from the class, not from instances. static members are inherited (you can use class Child to access a static member defined in class Parent) and you can redefine a static method (hide the inherited one with a new one) in a Child class using the new modifier.
Recent versions of JavaScript have seen the addition of static members to classes (of course remember that classes in JavaScript are just syntactic sugar, the language continues to be prototype based). They work in the same way as in C#. They can be accessed only through the class, not through instances. You have access to them using a Child class (they are inherited) and you can also redefine them in a Child class.
class Person {
static planet = "Earth"
constructor(name) {
this.name = name;
}
static shout() {
return `${this.planet} inhabitant AAAAAAAAAAAA`;
}
}
class ExtendedPerson extends Person {
}
console.log(Person.shout())
try {
console.log(new Person("Francois").shout());
}
catch (ex) {
console.log(ex);
}
// inheritance of static fields/methods works OK
console.log(ExtendedPerson.shout());
//it works because of this:
console.log(Object.getPrototypeOf(ExtendedPerson) === Person);
//true
I assume static members are implemented by just setting properties in the object for that class (Person is indeed a function object), I mean: Person.shout = function(){};. Inheritance works because as you can see in the last line [[Prototype]] of a Child "class" points to the Parent.
An interesting thing is that from a static method you can (and should) access other static methods of the same class using "this". This makes pretty good sense, "this" is dynamic, it's the "receiver" and in a static method such receiver is the class itself. Using "this" rather than the class name allows a form of polymorphism, let's see:
class Person {
static shout() {
return "I'm shouting";
}
static kick() {
return "I'm kicking";
}
static makeTrouble() {
return `${this.shout()}, ${Person.kick()}`;
}
}
class StrongPerson extends Person {
static shout() {
return "I'm shouting Loud";
}
static kick() {
return "I'm kicking Hard";
}
}
console.log(Person.makeTrouble());
console.log("--------------");
console.log(StrongPerson.makeTrouble());
// I'm shouting, I'm kicking
// --------------
// I'm shouting Loud, I'm kicking
Notice how thanks to using this we end up invoking the Child.shout() method, while for kick() we are stuck in the Parent.kick()
Static/class members in Python have some particularities. In Python any attribute declared in a standard class belongs to the class. This means that for static data attributes we don't have to use any extra keyword, we just add them at the class level (rather than in the __init__() method). For static/class methods we have to use the @classmethod decorator (if it's going to call other class methods) of the @staticmethod decorator if not. When we invoke a method in an object Python uses the attribute lookup algorithm to get the function that then will be invoked. As explained here Functions are indeed data-descriptors that have a __get__ method, so when we retrieve this function via the attribute lookup the __get__ method of the descriptor is executed, creating a bound method object, bound to the instance or to the class (if the function has been decorated with classmethod) or a staticmethod object, that is not bound, if the function has been decorated with staticmethod. Based on this we have that class/static methods can be invoked both via the class or also via an instance, that they are inherited, and that the polymorphism we saw in JavaScript works also nicely in Python. Let's see some code:
class Person:
planet = "Earth"
def __init__(self, name: str):
self.name = name
def say_hi(self):
return f"Bonjour, je m'appelle {self.name}"
@staticmethod
def shout():
return "I'm shouting"
@staticmethod
def kick():
return "I'm kicking"
@classmethod
def makeTrouble(cls):
return f"{cls.shout()}, {cls.kick()}"
class StrongPerson(Person):
@staticmethod
def shout():
return "I'm shouting Loud"
@staticmethod
def kick():
return "I'm kicking hard"
print(Person.makeTrouble())
p1 = Person("Iyan")
print(p1.makeTrouble())
print("--------------")
# inheritance works fine, with polymorphism, both invoked through the class or through an instance
print(StrongPerson.makeTrouble())
p2 = StrongPerson("Iyan")
print(p2.makeTrouble())
# I'm shouting, I'm kicking
# I'm shouting, I'm kicking
# --------------
# I'm shouting Loud, I'm kicking hard
# I'm shouting Loud, I'm kicking hard
print(Person.planet) # Earth
print(p1.planet) # Earth
Person.planet = "New Earth"
print(Person.planet) # New Earth
print(p1.planet) # New Earth
# this assignment will set the attibute in the instance, not in the class
p1.planet = "Earth 22"
print(Person.planet) # New Earth
print(p1.planet) # Earth 22
Notice how we can read a static attribute (planet) both via the class or via an instance, but if we modify it via an instance the attribute will added to the instance rather than updated in the class.
One extra note. We know that when using dataclasses we declare the instance members at the class level (then the dataclass decorator will take care of the logic for setting them in the instance in each instantiation), so for declaring static/class attributes in our dataclasses we have to use ClassVar type annotation: cvar: ClassVar[float] = 0.5
