Question: After researching a bit I can see that `super()` is beneficial when a child class extends a parent class.

But what if I have 1 `Foo.class` with two methods

```
private variable variable;
private String variable2;

public Foo()
{
   this.variable = new variable();
}

```

and

```
public Foo(String Paramater)
{
   super();
   this.variable2 = Paramater;
}

```

does this work in the sense that the first method is called when using `super()`

Just to clarify my question.. Can someone explain to me what is happening then in this code?

```
public ProductDimensions() { }
public ProductDimensions(String sku, String size, double width, double depth, double height, double weight) {
    super();
    this.sku = sku;
    this.size = size;
    this.width = width;
    this.height = height;
    this.depth = depth;
    this.weight = weight;
}

```

Why is super being called when my class doesn't extend anything? is it just useless?

Answer: 
`super()` in a constructor always calls the matching constructor in the base class. In this case probably `java.lang.Object`. So in your code, the two constructors have no relation except that they are in the same class.

If you want to chain constructors within the same class, you have to use `this()` (or the necessary parameters).
super() is used to pass arguments parent class' constructor with matching arguments.
Even if you don't put one, the compiler adds it to the first line of your constructor.

In case of Constructor chaining i.e. calling one constructor from another using this()- matching arguments.

In this case, at least one constructor must call super().

Example of Constructor Chaining:

```
//Execute multiple constructors in chain
//Advantage: Allocation of multiple type of resources at initialization level. One constructor per resource example: GUI, Database, Network etc.
//Easy Debugging
//We use this() for constructor chaining.
//Can be achieved in any order.
class ConstructorChaining
{
ConstructorChaining()
{
this(10);//always the first line
System.out.println("Default Constructor Completed");
}
ConstructorChaining(int x)
{
this(x,20);//always the first line
System.out.println("X="+x);
System.out.println("Parameter 1 Constructor Completed");
}
ConstructorChaining(int x, int y)
{
// atleast one constructor without this() must be used. - here either you can write super() or compiler will add it for you.
System.out.println("X+Y="+(x+y));
System.out.println("Parameter 2 Constructor Completed");
}
public static void main(String... s)
{
new ConstructorChaining();
}
}

```