Calling exactly super() is always redundant. It’s explicitly doing what would be implicitly done otherwise. That’s because if you omit a call to the super constructor, the no-argument super constructor will be invoked automatically anyway. Not to say that it’s bad style; some people like being explicit. However, where it becomes useful is when the … Read more
This is added in the support annotation library: dependencies { compile ‘com.android.support:support-annotations:22.2.0’ } http://tools.android.com/tech-docs/support-annotations @CallSuper
Well, when dealing with multiple inheritance in general, your base classes (unfortunately) should be designed for multiple inheritance. Classes B and C in your example aren’t, and thus you couldn’t find a proper way to apply super in D. One of the common ways of designing your base classes for multiple inheritance, is for the … Read more
Don’t make the method static. The issue is that when you invoke getClass() you are calling the method in the super class – static methods are not inherited. In addition, you are basically name-shadowing Object.getClass(), which is confusing. If you need to log the classname within the superclass, use return this.getClass().getName(); This will return “Entity” … Read more
Sometimes texts have to be read more for the flavor of the idea rather than for the details. This is one of those cases. In the linked page, Examples 2.5, 2.6 and 2.7 should all use one method, do_your_stuff. (That is, do_something should be changed to do_your_stuff.) In addition, as Ned Deily pointed out, A.do_your_stuff … Read more
Every Activity you make is started through a sequence of method calls. onCreate() is the first of these calls. Each and every one of your Activities extends android.app.Activity either directly or by subclassing another subclass of Activity. In Java, when you inherit from a class, you can override its methods to run your own code … Read more
The reason is that super() only operates on new-style classes, which in the 2.x series means extending from object: >>> class X(object): def a(self): print ‘a’ >>> class Y(X): def a(self): super(Y, self).a() print ‘b’ >>> c = Y() >>> c.a() a b
The keyword super doesn’t “stick”. Every method call is handled individually, so even if you got to SuperClass.method1() by calling super, that doesn’t influence any other method call that you might make in the future. That means there is no direct way to call SuperClass.method2() from SuperClass.method1() without going though SubClass.method2() unless you’re working with … Read more
The new magic super() behaviour was added to avoid violating the D.R.Y. (Don’t Repeat Yourself) principle, see PEP 3135. Having to explicitly name the class by referencing it as a global is also prone to the same rebinding issues you discovered with super() itself: class Foo(Bar): def baz(self): return super(Foo, self).baz() + 42 Spam = … Read more
Firstly some terminology: No-args constructor: a constructor with no parameters; Accessible no-args constructor: a no-args constructor in the superclass visible to the subclass. That means it is either public or protected or, if both classes are in the same package, package access; and Default constructor: the public no-args constructor added by the compiler when there … Read more