Basically, nothing in a companion object can be abstract or open (and thus be overridden), and there’s no way to require the implementations’ companion objects to have a method or to define/require a constructor in an interface. A possible solution for you is to separate these two functions into two interfaces: interface Serializable<ToType> { fun … Read more
There are two main differences. 1. The value of self inside the static method The metatype that you call the static method on is available to you in the method as self (it’s simply passed as an implicit parameter). Therefore if you call doIt() on type(of: self), self will be the dynamic metatype of the … Read more
Maybe a bit of example code will help: Notice the difference in the call signatures of foo, class_foo and static_foo: class A(object): def foo(self, x): print(f”executing foo({self}, {x})”) @classmethod def class_foo(cls, x): print(f”executing class_foo({cls}, {x})”) @staticmethod def static_foo(x): print(f”executing static_foo({x})”) a = A() Below is the usual way an object instance calls a method. The … Read more
Each thread has its own stack space, each time a thread calls a method (static or virtual) that call allocates a stack frame, which holds local variables. nothing about this is specific to static methods. Static methods can be called concurrently by multiple threads, unless you specifically do something to thwart that, such as requiring … Read more
Inheritance clearly means a knowledge of the base class. @staticmethod is ignorant of the class it is ‘attached’ to(hence they earlier-not now-a-days-called it ‘unbound;’ now technically @staticmethod is not a method at all; it is a function. But @classmethod is fully aware of the class it is attached to; it is technically not a function, … Read more
So my question is why are they called class methods instead of a static method? What is the difference between a static method and a class method? From Wikipedia: Static methods neither require an instance of the class nor can they implicitly access the data (or this, self, Me, etc.) of such an instance. This … Read more
There’s little difference in your example, but suppose you created a subclass of Foo and called the create_new method on the subclass… class Bar(Foo): pass obj = Bar.create_new() …then this base class would cause a new Bar object to be created… class Foo: @classmethod def create_new(cls): return cls() …whereas this base class would cause a … Read more
You didn’t override anything here. To see for yourself, Try putting @Override annotation before public static void a() in class B and Java will throw an error. You just defined a function in class B called a(), which is distinct (no relation whatsoever) from the function a() in class A. But Because B.a() has the … Read more