Super() means invoke the constructor of the parent class. That is how instantiation of classes in an inheritance hierarchy works in java: the top level parent has to be created first and then the second most top level all the way until the class level that we are actually instantiating. In java implicitly the default constructor of the parent(i.e. with no arguments) is called as the first instruction in every constructor from a class that inherits another. So there is a hidden super() as the first line in any constructor. Of course you can always call it explicitly and sometimes you have to. For example if the parent has only a constructor with a parameter, then in the subclass constructors you always have to explicitly call that constructor using super(paramValue) since there will be no default constructor in the parent so the implicit super() will fail generating a compile error. More on reddit.com

Explore Stack Internal ... I am new to Java. I have a problem to solve, but I don't quite understand how constructors work. I understand how to create a superclass and a subclass but I don't understand the constuctors within them (or how they actually work - I have done rediculous amounts of research on constructors, but it's just not making much sense). I am trying to write a program that creates a superclass called Employees. This Employee class ... More on stackoverflow.com

So the purpose of the constructor is to initialize an object. The most basic way of using it is to initialize any starting data values that an object relies on. If a class does not have a no-argument constructor, it is not possible to instantiate a new object without first inputting some values. Imagine you have a Person class, that has a String name data field. You want your code to operate such that any Person object you create must have a name, therefore you require that the user enters the name when they instantiate a new Person object: public class Person { String name; public Person(String name){ this.name = name; } } If you know the basics, it should be pretty clear that you will not be able to instantiate a new Person object without including a name: Person myPerson = new Person(); // will return an error Person myPerson = new Person("John"); //will create a Person object as desired Now, let's say we want to create another class that extends Person, for example Programmer. Let's try creating this class using a no-arg constructor: public class Programmer extends Person { String language = "Java"; public Programmer(){ //we'll get to this later } public void helloWorld(){ System.out.println("Hello world! My name is " + name + ". I can program in " + language); } } Now what happens if we try to instantiate a Programmer object, and run the helloWorld() function using it? The superclass Person has the name variable, so we should be able to access it in the subclass -- sharing data in this way is one of the major benefits of inheritance, after all. But the object that we've instantiated doesn't have a name associated with it. Hopefully, now it is starting to make sense why this wouldn't work. Instead, when we write the constructor for the Programmer class, we do it in this way: public Programmer(String name){ super(name); //this calls the constructor in Person, allowing us to initialize the name variable! } Does it now make sense why if the superclass lacks a no-argument constructor, you must use the super() call with the correct arguments in your subclass constructor? It's because otherwise, you have no way of initializing the variables in your superclass that you may want to use in your subclass. I hope that this is helpful, let me know if you have further questions. More on reddit.com

OK. The idea behind a constructor is to set up an instance of your class. You can think of the parameters of a constructor as "prerequisites" to make an instance.

If you define no constructors in a class, the compiler will generate a zero-argument constructor that does nothing.

So, let's say your class models a Car. Well, what are some things all Cars have? It probably has a top speed, a fuel efficiency, and a number of people it seats. (Trying to keep things simple for example's sake.) Since you don't ever want to create a car without those values, we want them as constructor parameters rather than relying on the user of your class to call all the right set...() methods. With the constructor, the user of the Car class is forced to provide the required parameters whenever they instantiate Cars. You can have multiple constructors that take different parameters, but you can only pick a constructor from the ones that are defined, so if we define one constructor for a Car, you must use that constructor to create them.

So, the car constructor might look like this:

public class Car { 

   private int topSpeed, passengersSeated;
   private Integer milesPerGallon;


   public Car (int topSpeed, Integer milesPerGal, int passengers) { 
      this.topSpeed = topSpeed;
      this.milesPerGallon = milesPerGal;
      this.passengersSeated = passengers;

   }

   // start the engine...
   public void start(int someVal) { ... }

}

Now, let's say we want to build a Fire Truck. A Fire Truck is just a specialized type of car. We want our FireTruck to have an Engine Number and a hose length, right? So, let's define a FireTruck.

public class FireTruck extends Car {

    private int engine, hose;

    public FireTruck(int engineNum, int hoseLength) { 
     this.engine = engineNum;
     this.hose = hoseLength; 
    }
}

Looks good, right? No! Why? Because a Fire Truck is a Car, and a Car must have a topSpeed, a milesPerGal and a passenger count. Our FireTruck has to have those values too, or it's not a Car. We could pass those parameters into our FireTruck constructor, but we can't just assign them to our Car member variables in the FireTruck constructor because they're private. The Car constructor sets those values for us, and it might do other logic we need. So, we'll call the Car constructor from inside our FireTruck constructor, so we can build the part of the FireTruck that is a Car before we add the FireTruck stuff. We use the "super" keyword to reference the base class's constructors and methods.

 public class FireTruck extends Car {

   private int engineNum, hoseLength;
  
   public FireTruck(int topSpeed, Integer mpg, int passengers, int engine, int hose) { 

     // Call the base class's constructor. 
     // Must be the first line in this constructor.
     super(topSpeed, mpg, passengers);

     // Now we've set up the base Car "inside" our FireTruck.
     // Add the rest of our details.
     engineNum = engine;
     hoseLength = hose;

 }

  // you can also use "super" to call functions that are in the base class -- 
  // do this when you override a function to add more functionality.

  @Override
  public void start(int someVal) { 

       // Radio dispatch and tell them you're leaving! 
       // Cars don't have to do this but we do
       sendDispatch("Engine " + engineNum + " is heading to the fire!");

       // Call the start() method of the base class to turn on the engine, like Cars do.
       // Unlike super() constructors, super. member methods can be called anywhere in any member method.
       // If the super. keyword were omitted, this would become an infinite recursive loop 
       // because this same method would get called.
       super.start(someVal);

       // After starting the truck, there could be more steps to do...
       startSiren();
       addPassenger(dalmatian);
 
  }
}

You can also use subclass constructors to hard-code values. For example, a Tesla Model S is a Car with no miles per gallon, since it's electric. So...

 public class Tesla extends Car { 

      private int volts;

      public Tesla (int topSpeed, int passengers, int batteryVolts) { 
             
            // no MPG since it's electric
            super(topSpeed, null, passengers);
            
            this.volts = batteryVolts;
      }
 }

You can even call a constructor in the same class, by using the "this" keyword.

public class Car { 
     
       private int topSpeed, passengers;
       private Integer mpg;

      // radio comes standard, so it's 'true' by default; we don't need to set it in every constructor.
      private boolean radio = true;

       public Car (int topSpeed, Integer mpg, int passengers) { 
            this.topSpeed = topSpeed;
            this.mpg = mpg;
            this.passengers = passengers;


           // Lots of complicated German engineering goes here...

       }

      // Some cars might not have a radio; set that in this alternate constructor.
      public Car (int topSpeed, Integer mpg, int passengers, boolean satelliteRadio) { 

            // Don't rewrite all the hard stuff from the other constructor, just call it! 
            // Like super() constructors, must be the first line in this constructor if you want to use it.
            this(topSpeed, mpg, passengers);

            // Special stuff in this constructor
            this.radio = satelliteRadio;               
      }

   }

More on reddit.com