Develop Reference

Super class object invoking a subclass constructor? How does that work?

public class NewClass
{
public static class superclass
{
static void print()
{
System.out.println("print in superclass.");
}
}
public static class subclass extends superclass
{
static void print()
{
System.out.println("print in subclass.");
}
}
public static void main(String[] args)
{
superclass A = new superclass();
superclass B = new subclass(); //This line?
A.print();
B.print();
}
}
I came across this code while learning static binding from geeksforgeeks. I am unable to understand this particular line:
superclass B = new subclass();
Not sure how this works. Basically, are we creating an object of super class and invoking the subclass' constructor? That doesn't make much sense to me because I have always seen and am used to : A obj = new obj(); type object creation.

While preparing my answer, I found that I had to use the words superclass and subclass in two different meanings. I'll rename the classes to be Thing and Car and use the words "superclass" and "subclass" for the general concepts.
public class NewClass
{
public static class Thing
{
static void print()
{
System.out.println("print in superclass.");
}
}
public static class Car extends Thing
{
static void print()
{
System.out.println("print in subclass.");
}
}
public static void main(String[] args)
{
Thing A = new Thing();
Thing B = new Car(); //This line?
A.print();
B.print();
}
}
An expression new Car() always creates an instance of type Car. Always. And the result is [a reference to] an instance of Car.
Now, you can store [a reference to] an instance of Car into a variable of any type that allows for Car instances. And that is:
a Car-typed variable,
a variable declared with any superclass of Car (and this matches a Thing B declaration),
a variable declared with an interface type directly or indirectly implemented by Car.
So, what happens with the line of code
Thing B = new Car(); //This line?
It creates a new Car instance, and therefore of course invokes the Car constructor (*1) (*2). And then it stores a reference to this instance in the variable B, which allows for all kinds of Thing instances as long as they inherit from Thing and thus support everything that is expected from a Thing object.
And what happens at
B.print();
It calls the print() method of the instance that's referenced by B. And as that instance is a Car instance, you get the Car.print() results, not the Thing.print().
Some more remarks:
If Car had some additional methods not found in Thing (e.g. a drive() method), the compiler wouldn't allow you to call them on B, as not all Thing objects have them, but only some specialized Thing versions (i.e. the Car ones).
And I recommend to get used to the Java naming conventions, e.g. that classnames always begin with an upper-case letter and variables with lower-case. Java guys are so much used to these conventions that we find it really confusing to read code that doesn't follow these rules.
(*1) In your case the constructor is not explicitly defined, but auto-generated by the Java compiler.
(*2) A subclass constructor always calls the constructor of its superclass, and so on up to the Object constructor, to initialize all the aspects of the instance that the subclass inherits from its superclass.

Which class does "super" keyword refer to?

When working with multiple inheritance, which class does the keyword "super" refer to, the very first class created? or the parent class of the subclass we are working with?
Thank you for you consideration.

In an inheritance chain, if you call super on an instance of class D, which is derived from C, which itself is derived from B and that from A, a call to super will go to the direct parent. If the method isn't found there, the chain of parents is climbed up:
class A {
void print () { System.out.println ("from A"); }
}
class B extends A {
void print () { System.out.println ("from B"); }
}
class C extends B {
// no own print method
}
class D extends C {
void print () { super.print (); }
}
D d = new D ();
d.print ();
So here, super of D is C, where no print is found, so a lookup is made to B, as if C.print () was called. There a concrete implementation is found which is used to perform the action.
from B
This is normally not called multiple inheritance, but if you derive from multiple parents, which you can't in Java. You can implement multiple interfaces with their methods, and their names are, most of the time, not in naming conflict.
Example:
interface RocknRoller {
void roll ();
}
interface Gambler {
void roll ();
}
class Dice implements Gambler {
public void roll () { System.out.println ("roll a dice"); }
}
class Harrisson implements RocknRoller {
public void roll () { System.out.println ("while my guitar gently weeps"); }
}
class E extends D implements RocknRoller, Gambler {
RocknRoller rr = new Harrisson ();
Gambler g = new Dice ();
public void roll () {
rr.roll ();
g.roll ();
}
}
-> E e = new E ();
| Added variable e of type E with initial value E#47ef968d
-> e.roll ()
while my guitar gently weeps
roll a dice
You can have some kind of multiple inheritance via Interfaces. But interface normally don't have their own implementation of code, so when you implement multiple interfaces, you're only declaring to conform to some contract.
The implentation has to be done by yourself (or explicitly delegated). But by doing so, you're responsible yourself in solving the conflict; there is no mechanism to solve it automatically. In this example, both implementations are called in a specific order.

super() refers to the immediate parent of your class.
super() class supposed to be the first statement in constructor.
If your super class doesn't have default constructor. you have to specify the
super() call that match your parent class constructor.
refer this Link

The super keyword in java is a reference variable that is used to refer parent class objects. This is used when we want to call parent class method. So whenever a parent and child class have same named methods then to resolve ambiguity we use super keyword. This code snippet helps to understand the said usage of super keyword.
Suppose we have 2 classes like:
class Parent {
String a ="parent string";
}
class Child extends Parent{
String a= "child string";
void show(){
System.out.println(a);
System.out.println(super.a);
}
}
public class Sample{
public static void main(String []args){
Child c= new Child();
c.show();
}
}
Now output will be :
child string
parent string
Simple a refers to child class.
super.a refers to immediate parent class.
Hope it helps. :)

Java supports linear inheritance. This can be of multiple levels but it does not support a class deriving from multiple immediate parent classes.
Now Suppose there is a below hierarchy of classes.
classes : A, B, C
hierarchy : C extends B, B extends A.
When inside any instance method (or instance block) defined in C if we use super keyword it refers to instance members and fields of immediate parent. If used in C means it refers to instance members or fields of B, if used in B it means it refers to instance members or fields of A and if used in A it means it refers to instance members or fields of Object.java
Also for invoking a particular constructor of the immediate parent class super can be used from within a constructor of child class, with the condition that it should be the first statement.
P.S. if the instance member or method is not visible to child class then compilation will fail. A class inherites all the properties and behavior from it's parent class. The keyword is useful in cases when we override the behavior in child class and still we want to invoke a behavior defined by parent class.

overriding protected method of Superclass

In the below example why does the String b prints null and String c prints "gg".
Correct me if I am wrong, whenever a subclass (BClass) overrides a protected method (i.e initClass()) of the superclass (AClass).If you instantiate the subclass. The superclass must make use of overriden method specified by the subclass.
public class Example {
public class AClass {
private String a;
public AClass() {
initClass();
}
protected void initClass() {
a = "randomtext";
}
}
public class BClass extends AClass {
private String b = null;
private String c;
#Override
protected void initClass() {
b = "omg!";
c = "gg";
}
public void bValue() {
System.out.println(b); // prints null
System.out.println(c); // prints "gg"
}
}
public static void main(String[] args) {
Example.BClass b = new Example().new BClass();
b.bValue();
}
}

As of the JSF 12.5
In the example you can see the execution order. The first steps are the callings of the Constructor down to the Object constructor.
Afterwards this happens:
Next, all initializers for the instance variables of class [...] are executed.
Since your instance variable b is initialized to null it will be null again afterwards

This is happening because the superclass constructor is called before the fields of ClassB is initialized. Hence the initClass() method is called which sets b = "omg!" but then again when the super class constructor returns, b is initialized to the value declared in ClassB which is null.
To debug, put a break point and go step by step, you will find that b is first set to null and then changes to omg! and then comes back to null.

There have been already given several correct answers about what's happening. I just wanted to add that it is generally bad practice to call overridden methods from constructor (except of course if you know exactly what you are doing). As you can see, the subclass may not be completely initialised at the time its instance method is invoked (subclass constructor logic has not been executed yet, so effectively overridden method is invoked on an unconstructed object which is dangerous) which might lead to confusions like the one described in this question.
It is much better to write initialisation logic in the constructor and if it is too long then divide it between several private methods invoked from the constructor.

This is happening like this because, first constructor of AClass, which set value of b = omg! and c=gg. After that When BClass gets load in memory it set b=null and c remain as it is which is gg, this is happening because, because in BClass, for b you are doing declaration as well as initialization and for c you are doing only declaration, so as c is already in the memory it even won't get it's default value and as you are not doing any initialization for c, it remain with it's earlier state.

I believe that this example explains the issue:
public class Main {
private static class PrintOnCreate {
public PrintOnCreate(String message) {
System.out.println(message);
}
}
private static class BaseClass {
private PrintOnCreate member =
new PrintOnCreate("BaseClass: member initialization");
static {
System.out.println("BaseClass: static initialization");
}
public BaseClass() {
System.out.println("BaseClass: constructor");
memberCalledFromConstructor();
}
public void memberCalledFromConstructor() {
System.out.println("BaseClass: member called from constructor");
}
}
private static class DerivedClass extends BaseClass {
private PrintOnCreate member =
new PrintOnCreate("DerivedClass: member initialization");
static {
System.out.println("DerivedClass: static initialization");
}
public DerivedClass() {
System.out.println("DerivedClass: constructor");
}
#Override
public void memberCalledFromConstructor() {
System.out.println("DerivedClass: member called from constructor");
}
}
public static void main (String[] args) {
BaseClass obj = new DerivedClass();
}
}
The output from this program is:
BaseClass: static initialization
DerivedClass: static initialization
BaseClass: member initialization
BaseClass: constructor
DerivedClass: member called from constructor
DerivedClass: member initialization
DerivedClass: constructor
... which demonstrates that the derived class's members are initialized after the base class's constructor (and the invocation of the derived class's member function have completed). This also demonstrates a key danger of invoking an overridable function from a constructor, namely that the function can be invoked before the members of the class on which it depends have been initialized. For this reason, constructors should generally avoid invoking member functions (and, when they do, those functions should either be final or static, so that they either depend only on the current class which has been initialized or on none of the instance variables).

JAVA How to pass initialization information to multiple superclasses

I have another question on constructors. I have a hierarchy of more than 2 layers, Say
A,
B extends A,
C extends B.
Can I get constructors from all three layers to fire when I create an instance of C? What if I want to pass super(int anArgumentForA, int anArgumentForB); Is that even possible? Seems like that's where it's going but I don't find a way to differentiate the arguments going to A vs B. Default constructor from B seems to run and I can't feed it the value it needs in order to run a different constructor because I don't know how.

You can have each layer call super(...) to set the information in each layer.
public Class A
{
public A(Object a, Object b)
{
//do any initialization needed
}
}
public Class B extends A
{
public B(Object a, Object b, Object c)
{
super(a, b); //This will call A(a, b)
//do any initialization needed
}
}
public Class C extends B
{
public C(Object a, Object b, Object c)
{
super(a, b, c); //This will call B(a, b, c)
//do any initialization needed
}
}
Keep in mind I don't think it is advisable to use these constructors to set the Objects to a variable at each level. So you don't want to have the constructors for A, B, and C each set some object Object x = a in the constructor. Only one, at most, level in the hierarchy should maintain a reference to the Objects being passed into the constructors.

In the world of Java, when you are extending another class, you only see your direct super class' constructor. The super class is supposed to proper encapsulate the super-super class constructor.
That means, in your case, B should provide a constructor that proper encapsulate A. In case B cannot determine the argument to pass to A's constructor, it is reasonable to ask for it in B's own constructor:
class A {
A (int aArg) {
// init base on aArg
}
}
class B extends A {
B (int aArg, int bArg) {
super(aArg);
// extra initialization base on bArg and aArg
}
}
class C extends B {
C() {
super(SOME_A_ARG, SOME_B_ARG);
}
}

As per Java Specification the constructors are not inherited by sub-classes.
So, as per you requirement you should keep in mind that the super class should have scope to pass objects.
When you are declaring a class by extending another class B extends A and C extends B , you should define the constructor
such a way so that you can customize that for initialization . This declaration always depends on the depth and hierarchy of the
inheritance .
class A{
A(Object firstObj, Object secondObj){
//Do you stuff for initialization
}
}
class B extends A{
//Keep in mind that this B class will be inherited by other class
B(Object firstObj,Object secondObj,Object thirdObj){
//Call super class constructor
super(firstObj,secondObj);
//Do other initialization stuff here
}
}
class C extends B{
//Keep in mind that this C class will be inherited by other class
C(Object firstObj,Object secondObj,Object thirdObj){
//Call super class constructor
super(firstObj, secondObj, thirdObj); //call constructor of B
//Do other initialization stuff here
}
}
It always depends how you parent class constructor has defined. It depends on the number of parameter passes to parent class constructor, you need to call accordingly from child class constructor.
Hope it will help you.

Java compiler super() constructor generals [duplicate]

This question already has answers here:
Closed 10 years ago.
Possible Duplicate:
Use of ‘super’ keyword when accessing non-overridden superclass methods
I'm new to Java and have been reading a lot about it lately to get more knowledge and experience about the language. I have a question about inherited methods and extending classes when the compiler inserts automatic code.
I've been reading that if I create class A with some methods including lets say a method called checkDuePeriod(), and then create a class B which extends class A and its methods.
If I then call the method checkDuePeriod() within class B without using the super.checkDuePeriod() syntax, during compilation will the compiler include the super. before checkDuePeriod() or will the fact that the compiler includes the super() constructor automatically when compiling the class imply the super. call of the methods that class B calls from class A?
I'm a little confused about this. Thanks in advance.

The super class's implementation of regular methods is not automatically invoked in sub classes, but a form of the super class's constructor must be called in a sub class's constructor.
In some cases, the call to super() is implied, such as when the super class has a default (no-parameter) constructor. However, if no default constructor exists in the super class, the sub class's constructors must invoke a super class constructor directly or indirectly.
Default constructor example:
public class A {
public A() {
// default constructor for A
}
}
public class B extends A {
public B() {
super(); // this call is unnecessary; the compiler will add it implicitly
}
}
Super class without default constructor:
public class A {
public A(int i) {
// only constructor present has a single int parameter
}
}
public class B extends A {
public B() {
// will not compile without direct call to super(int)!
super(100);
}
}

If you call checkDuePeriod() in B without super., means you want to invoke the method that belongs to the this instance (represented by this within B) of B. So, it equivalent to saying this.checkDuePeriod(), so it just doesn't make sense for the compiler to add super. in the front.
super. is something that you must explicitly add to tell the compiler that you want to call the A's version of the method (it is required specially in case B has overridden the implementation provided by A for the method).

Call of super() as a default constructor (constructor with no args) can be direct or non direct but it garants that fields of extendable class are properly initialized.
for example:
public class A {
StringBuilder sb;
public A() {
sb = new StringBuilder();
}
}
public class B extends A {
public B() {
//the default constructor is called automatically
}
public void someMethod(){
//sb was not initialized in B class,
//but we can use it, because java garants that it was initialized
//and has non null value
sb.toString();
}
}
But in case of methods:
Methods implement some logic. And if we need to rewrite logic of super class we use
public class B extends A {
public B() {
}
public boolean checkDuePeriod(){
//new check goes here
}
}
and if we want just implement some extra check, using the value returned from checkDuePeriod() of superclass we should do something like this
public class B extends A {
public B() {
}
public boolean checkDuePeriod(){
if(super.checkDuePeriod()){
//extra check goes here
}else{
//do something else if need
}
return checkResult;
}
}

First about the Constructors:
- When ever an object of a class is created, its constructor is initialized and at that time immediately the constructor of its super-class is called till the Object class,
- In this process all the instance variables are declared and initialized.
- Consider this scenario.
Dog is a sub-class of Canine and Canine is a sub-class of Animal
Now when Dog object is initialized, before the object actually forms, the Canine class object must be form, and before Canine object can form the Animal class object is to be formed, and before that Object class object must be form,
So the sequence of object formed is:
Object ---> Animal ---> Canine ---> Dog
So the Constructor of the Super-Class is Called before the Sub-Class.
Now with the Method:
The most specific version of the method that class is called.
Eg:
public class A{
public void go(){
}
}
class B extends A{
public static void main(String[] args){
new B().go(); // As B has not overridden the go() method of its super class,
// so the super-class implementation of the go() will be working here
}
}