 In the preceding video, we talked about using super to call the superclass constructor. Consider this chain of classes and subclasses, where brush is the parent class for toothbrush and toothbrush is the parent class for electric toothbrush. Here's the code for the three classes. I've left out getters and setters to keep the code size to a minimum. The brush class specifies the color, and here are its constructors. Toothbrush extends brush by adding a bristle type, and electric toothbrush extends toothbrush by adding a battery size. One thing to notice is that in the constructors for electric toothbrush, I never called the superclass constructor explicitly. Similarly, in the toothbrush constructors, I never called the superclass constructor for brush explicitly. What happens here in testbrushes.java when I create a new electric toothbrush? Even though I've not explicitly called the superclass constructor inside electric toothbrush, Java implicitly will call that no argument constructor for toothbrush. Toothbrush doesn't have an explicit call, but Java implicitly calls the no argument constructor for its superclass. This is called constructor chaining. When we call new electric toothbrush, the no argument constructor implicitly calls the no argument superclass constructor. That's the toothbrush, and its no argument constructor implicitly calls its parent classes no argument superclass constructor, which prints out these words zero argument constructor for brush. Once that constructor finishes, we resume with the toothbrush constructor, and it prints zero argument constructor for toothbrush. Once that constructor is done, it finishes the electric toothbrush constructor by printing zero argument constructor for electric toothbrush. And finally, our new electric toothbrush has been constructed correctly. Let's run the program, and sure enough, that's what happens. What if we do this? If we say electric toothbrush electric to equals new electric toothbrush, and we'll call its one argument constructor with the battery size double a, and we'll put a dividing line in here so that we can distinguish one set of output from the other. Let's recompile and let's rerun. Again, it calls the zero argument constructor implicitly for the parent and grandparent classes. This brings up two questions. First, what would happen if we explicitly called a one argument constructor? If here, in electric toothbrush, we called super with soft bristles for our toothbrush. The answer is that it would then explicitly call the one argument toothbrush constructor here, which would again implicitly call the zero argument constructor for the brush class. Let's recompile and rerun it. Our zero argument constructor for electric toothbrush called the one argument constructor for toothbrush, which implicitly called the zero argument constructor for brush. Here's another question. What happens if there's no zero argument constructor for one of the superclasses? Let's put everything back to the way it was. We're going to remove this explicit call to the superclass constructor, and here in toothbrush.java, we are going to comment out the zero argument constructor so that it can no longer be found. Let's recompile toothbrush and let's recompile electric toothbrush, and we get an error. The constructor toothbrush in class toothbrush cannot be applied to the given types. Java gets this error because it can no longer find the zero argument constructor for toothbrush that is implicitly attempting to call. What if we'd done it differently? I'm going to uncomment the constructor here, and now I'm going to recompile electric toothbrush. That will succeed. Now again I'm going to remove the zero argument constructor so that no longer can be found, and I'm going to recompile only that class. What happens now when I run testbrushes.java? The answer? I get a runtime error telling me that there's no zero argument constructor for toothbrush. So no matter how sneaky you try to be to get around not having a no argument constructor, Java will stop you, either at compile time or at runtime. That having been said, I would strongly suggest that you do not leave constructor chaining to chance. Instead, you should explicitly call the superclass constructors. This will avoid any possible compile or runtime errors from a missing no argument constructor.