Can't understand Java inheritance

Question

i'm studying java as first language, so i'm a complete newbie. I'm now studying inheritance between classes, and there's something i can't understand. I give you an example:

This is the main class:

public class Bici {

protected int misura;
protected String modello;

public Bici(int misura, String modello)
{
this.misura=misura;
this.modello=modello;
}

public void stampaCaratteristiche()
{
System.out.println("Size is: "+misura);
System.out.println("Model is: "+modello);
System.out.println();
}
}

This is the subclass:

public class Tandem extends Bici {

private int ruote;

public Tandem (int ruote)
{
super(misura, modello);
this.ruote=ruote;
}

public void stampaCaratteristicheTandem()
{
System.out.println("Le ruote del tandem sono "+ruote);
}

}

but when declaring super variables i get this error: "Cannot refer to an instance field modello while explicitly invoking a constructor"

Why? Thank you!

Answer 1

1. you do not have default constructor in Bici class, it means in Tandem class it has to be invoked explicitly. like this :

   private int ruote;
   
   public Tandem (int ruote, int misura, String modello)
   {
   super(misura, modello);
   this.ruote=ruote;
   

   }

    public void stampaCaratteristicheTandem()
    {
    System.out.println("Le ruote del tandem sono "+ruote);
    }
   

2. A superclass constructor must execute before a subclass constructor. So that the state and behavior defined by the superclass may be correctly and completely initialized before a subclass constructor executes.

Java compiler assumes that the first line of every constructor is an implicit call to the default superclass constructor unless you explicitly use super() or this().

Note that Super keyword is used to explicitly invoke a superclass constructor. If you use this form, it must appear as the first statement of the constructor to ensure that the superclass constructor executes before the subclass constructor

3. The Java inheritance mechanism does not include constructors. In other words, constructors of a superclass are not inherited by subclasses. Subclasses can still call the constructors in the superclass using the super() contruct. In fact, a subclass constructor is required to call one of the constructors in the superclass as the very first action inside the constructor body. You may have seen Java classes where the subclass constructors did not seem to call the constructors in the superclass. Maybe the superclass did not even have a constructor. However, the subclass constructors have still called superclass constructors in those case. You just could not see it. Let me explain why:

If a class does not have any explicit constructor defined, the Java compiler inserts an implicit no-arg constructor. Thus, a class always has a constructor.