super

In the Activity class, Android provides runtime enforcement that super() must be called for overridden lifecycle callback methods. If you forget do do so, it throws SuperNotCalledException. Exactly how was this implemented specifically on Android? Please point me to the actual source implementation if possible. It looks like they clear a flag in the super methods and check that it was set : final void performStart() { mCalled = false; mInstrumentation.callActivityOnStart(this); if (!mCalled) { throw new SuperNotCalledException( "Activity " + mComponent.toShortString() + " did not call through

super has 2 args, super(type, obj_of_type-or-subclass_of_type) I understand how and why to use super with the 2nd arg being obj_of_type. But I don't understand the matter for the 2nd arg being subclass. Anyone can show why and how? outis You pass an object if you want to invoke an instance method. You pass a class if you want to invoke a class method. The classic example for using super() for class methods is with factory methods, where you want all the superclass factory methods to be called. class Base(object): @classmethod def make(cls, *args, **kwargs): print("Base.make(%s, %s) start" %

This question already has answers here : Closed 8 years ago . Possible Duplicate: Understanding Python super() Class B subclasses class A , so in B's __init__ we should call A's __init__ like this: class B(A): def __init__(self): A.__init__(self) But with super() , I saw something like this: class B(A): def __init__(self): super(B, self).__init__() #or super().__init__() My questions are: Why not super(B, self).__init__(self) ? Just because the return proxy object is a bound one? If I omit the second argument in super and the return proxy object is an unbound one, then should I write super(B).

I can't understand how to develop Scala code similar to the following on Java: public abstract class A { protected A() { ... } protected A(int a) { ... } } public abstract class B { protected B() { super(); } protected B(int a) { super(a); } } public class C extends B { public C() { super(3); } } while it's clear how to develop C class, I can't get how to receive B. Help, please. P.S. I'm trying to create my own BaseWebPage derived from wicket WebPage which is a common practice for Java Do you mean something like: abstract class A protected (val slot: Int) { protected def this() = this(0) }

In Python 3.x, super() can be called without arguments: class A(object): def x(self): print("Hey now") class B(A): def x(self): super().x() >>> B().x() Hey now In order to make this work, some compile-time magic is performed, one consequence of which is that the following code (which rebinds super to super_ ) fails: super_ = super class A(object): def x(self): print("No flipping") class B(A): def x(self): super_().x() >>> B().x() Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 3, in x RuntimeError: super(): __class__ cell not found Why is super()

Simple question. I made a class called Tester1 which extends another called Tester2. Tester2 contains a public string called 'ABC'. Here is Tester1: public class Tester1 extends Tester2 { public Tester1() { ABC = "Hello"; } } If I instead change line 5 to super.ABC = "Hello"; am I still doing the exact same thing? Yes. There's only one ABC variable within your object. But please don't make fields public in the first place. Fields should pretty much always be private. If you declared a variable ABC within Tester1 as well, then there'd be a difference - the field in Tester1 would hide the field

While investigating this question , I came across this strange behavior of single-argument super : Calling super(some_class).__init__() works inside of a method of some_class (or a subclass thereof), but throws an exception when called anywhere else. Code sample: class A(): def __init__(self): super(A).__init__() # doesn't throw exception a = A() super(A).__init__() # throws exception The exception being thrown is Traceback (most recent call last): File "untitled.py", line 8, in <module> super(A).__init__() # throws exception RuntimeError: super(): no arguments I don't understand why the