You never need just super(); That’s what will be there if you don’t specify anything else. You only need to specify the constructor to call if: You want to call a superclass constructor which has parameters You want to chain to another constructor in the same class instead of the superclass constructor You claim that: … Read more
Because it will ensure that when a constructor is invoked, it can rely on all the fields in its superclass being initialised. see 3.4.4 in here
You can think of an interface as a “contract”. You are defining a set of methods that classes which implement this interface must implement. An abstract class, on the other hand, is used when you have some code that could be common to all the child classes you want to implement. So you might have … Read more
What you should do: Add a constructor to your super class: public Superclass { public SuperClass(String flavour) { // super class constructor this.flavour = flavour; } } In the Crisps class: public Crisps(String flavour, int quantity) { super(flavour); // send flavour to the super class constructor this.quantity = quantity; } Comments Some comments to … Read more
This won’t compile since Animal does not have a method called bark. Think of it this way, all dogs are animals, but not all animals are dogs. All dogs bark, but not all animals bark.
The crucial distinction between Python’s __init__ and those other languages constructors is that __init__ is not a constructor: it’s an initializer (the actual constructor (if any, but, see later;-) is __new__ and works completely differently again). While constructing all superclasses (and, no doubt, doing so “before” you continue constructing downwards) is obviously part of saying … Read more
If you are using JDK7, you can use MethodHandle to achieve this: public class Test extends Base { public static void main(String[] args) throws Throwable { MethodHandle h1 = MethodHandles.lookup().findSpecial(Base.class, “toString”, MethodType.methodType(String.class), Test.class); MethodHandle h2 = MethodHandles.lookup().findSpecial(Object.class, “toString”, MethodType.methodType(String.class), Test.class); System.out.println(h1.invoke(new Test())); // outputs Base System.out.println(h2.invoke(new Test())); // outputs Base } @Override public String toString() … Read more
Alright, it’s the usual “super() cannot be used with an old-style class”. However, the important point is that the correct test for “is this a new-style instance (i.e. object)?” is >>> class OldStyle: pass >>> instance = OldStyle() >>> issubclass(instance.__class__, object) False and not (as in the question): >>> isinstance(instance, object) True For classes, the … Read more
This is one of the problems of using visible fields – you end up using them… You’ve got a color field in both Rect and CRect. Fields are not polymorphic, so when you use cr2.color, that uses the field declared in Rect, which is always set to “transparent”. Your CRect class should not have its … Read more
There is an implicit call to super() with no arguments for all classes that have a parent – which is every user defined class in Java – so calling it explicitly is usually not required. However, you may use the call to super() with arguments if the parent’s constructor takes parameters, and you wish to … Read more