I don't know why I need the constructor without parameter

Question about the task

Under discussion

Below code fails to pass the verification. Hint says to have the NormalCat constructor without parameter. So I deleted and pass. But I don't know why I need that constructor because the code runs well without it.

public class Solution {
    public static void main(String[] args) {
        SiamCat coco = new SiamCat("Coco");
        NakedCat nakedCoco = coco.shave();
    }

    public static class NakedCat {

    }

    public static class NormalCat extends NakedCat {
        //public NormalCat() {}

        public NormalCat(String name) {
            System.out.println("My name is " + name);
        }

        public NakedCat shave() {
            return this;
        }
    }

    public static class SiamCat extends NormalCat {
        public SiamCat(String name) {
            super(name);
        }
    }
}

Comments (3)

Popular
New
Old

You must be signed in to leave a comment

Marek Pasierbek Working at Nexus Polska

24 August 2020, 06:23

NakedCat shud be without constructor (it will be automaticly add) but NormalCat shoud has only no-argumnet simple constructor NormalCat(){}

Mary Khan

Level 23 , Russia, Russian Federation

5 August 2022, 23:02

But WHY???

Brandon Waites

Level 26 , Cincinnati, United States

9 February 2023, 10:31

The task for this is to remove code that will be generated automatically (which is usually default class constructors). It is okay to remove NakedCat's constructor NakedCat(){} because it only has one constructor, and that constructor has no arguments. It is essentially a default constructor, which is what would be generated without us explicitly stating that. In the instance of NormalCat, we don't need to call the super() constructor because when a child class is constructed, a super() constructor call is generated as the first line of code within this class' constructor line in order to have access to all of the data that it is utilizing from the parent class. Under normal circumstances, we could just remove the NormalCat(){} constructor altogether, but this would be an issue because the NormalCat class has a second constructor stated: NormalCat(String name){}. If we were to remove NormalCat(){}, we would always have to create NormalCat objects with (String name) associated. But what happens if we wanted to create a cat that had absolutely no name at all? We could pass a String of "", but say we were to add tons more cats that inherited one after the other and we wanted to tweak their constructors with differing arguments. The further down the inheritance tree we go, the harder it would be to remember all of these special situations for each class above our current one. That's why in this instance where there is another constructor listed for the NormalCat class, we should explicity keep the public NormalCat(){} constructor code. I hope that helps.