pgcros.blogg.se

It does, however, requirethat you learn some new techniques in order to use it productively. Inheritance via derived classes is a powerful tool. You do not have to die in order to pass along your inheritance. Learn More Buy Programming with Inheritance One caveat, we cannot call both this() method and super() method in the same constructor.Java: An Introduction to Computer Science & Programming, 2nd Edition The call to super must be the first statement in the subclass constructors. Ok, before we move next, just remember a subclass must call at least one constructor of the superclass in all of its own constructors, implicitly or explicitly. I am the Animal Constructor with name: Husky Well, we add the line super(name) and by that we call the super() method with a parameter signature just like the parameter signature of class Animal’s constructor. But as we know that the superclass Animal only has one constructor and its signature is public Animal(String name), so we have to call super() method with that parameter signature, which is super(String name). Ok, we just create the super() method on our own. If Java won’t do it for free, we have to call the superclass Animal constructor on our own. The super() method exactly points to the Animal() constructor, and Java cannot find it. That is because when we add our own constructor with this signature public Animal(String name), Java won’t create an no-argument constructor for us.Īnd in Dog class, Java will see that there’s no constructor in superclass Animal that suits the auto-added line super(). Now go to the Dog.java file and you will see that the IDE throws errors immediately. If we change the signature of the constructor in Animal class, to something, say: That explains why the line “I am the Animal Constructor” always goes first in the output. The super() method is the call to base class’s no-argument constructor, it is automatically added as the first statement in every subclass’s constructors. This line is automatically added if we do not It is easy done than said here, it is simple as this: Actually the call to an empty-parameter constructor of the base class is always auto-created by Java as the first statement in every subclass constructors. Now, we can understand the way Java works here. Well, we can see the superclass’s constructor is always called first. I am the Dog Constructor with a name: Husky In Test class we call the added constructor:

Now we run the Test.java again (Test class no changes), and the results: This constructor will print out the line “I am the Dog Constructor” when a new Dog instance is created. We test more, in Dog class, we add the constructor and add a line, like this: In other words, actually the constructor of the base class Animal must have been called somewhere. So how does Java print out the line “I am the Animal Constructor”?. Well, we know that in class Dog, Java auto-creates an empty constructor for us, it just looks like this: Now in Test class we just create a Dog instance and run the program.Ĭan we explain what happens here? We should think carefully in some minutes before going on with our journey. In subclass Dog thing is even more simple, just an empty class: What does this constructor do? It simply prints out the line “I am the Animal Constructor”. Now we will modify the Animal class so it will have a simple-almost-empty constructor:

We all know that when we don’t add a constructor to a class, then Java will auto-create an empty constructor in that class for us. In all previous examples, we don’t see these, because good old Java did it all for us. Ahh thing seems not easy, right? And where are all these requirements in previous examples? Actually it is easier done than said here. In Java, when a class extends a superclass, then that subclass must call at least one constructor of the superclass in all of its own constructors, and this call statement must be the first statement in the subclass’s constructors. For all examples about inheritance so far, we did not add any Java constructor to superclass and subclass.