java inheritance field setup vs constructor

Question

I'm new to Java. I've had following classes:

public abstract class Beverage {
    String description = "Unknown beverage";

    public String getDescription() {
        return description;
    }

    public abstract double cost();
}

and:

public class DarkRoast extends Beverage {
    String description = "Dark roast";

    @Override
    public double cost() {
        return 0.99;
    }
}

When I construct a new DarkRoast object:

Beverage beverage2 = new DarkRoast();

I expect it to have desctiption equal to "Dark roast":

assertEquals("Dark roast", beverage2.getDescription());

But actually it's "Unknown beverage". I know I should implement DarkRoast constructor that sets description, but I don't know why, I don't know how it works internally. Shouldn't the subclass field overwrite superclass field?

Answer 1

Shouldn't the subclass field overwrite superclass field?

No - the subclass field is actually an entirely new field. Since you mean to assign to the superclass field, you need to create a constructor like this:

public DarkRoast()
{
    description = "Dark roast";
}

(This is unlike the method cost() - technically when you override a non-abstract method you still 'sort of' have the old method as well)

Answer 2

Because the called getDescription method is the method of the class Beverage (DarkRoast doesn't have its own), so the method getDescription access to his description property, whose value is "Unknown beverage".

Answer 3

You do not override the .getDescription() method in subclasses; as a result, the method called is the one in Beverage, and the method in Beverage only knows about the description declared (and initialized, in this case) in Beverage itself.

You could have it display the value in all subclasses by using instead:

return this.description;

However, there is a much better way to solve this problem; and that is:

public abstract class Beverage
{
    private final String description;

    public abstract Beverage(final String description)
    {
        this.description = description;
    }

    public final String getDescription()
    {
        return description;
    }
    // etc
}

// Subclass
public class DarkRoast
    extends Beverage
{
    public DarkRoast()
    {
        super("Dark Roast");
    }
}

You should note that it makes no sense at all to describe an "Unknown beverage" to start with. Beverage being abstract, it cannot be instantiated! The solution proposed here basically forbids anyone from creating a Beverage without a description, so it's a win-win ultimately.

Answer 4

If the subclass must always provide a description, then you could make getDescription abstract, which would force the subclasses to implement and return a value. Just another technique.

Answer 5

It is allowed for class to hide the members. When you declare a member for field in class and declare in the child class some with the same name you will hide it but not override.

If you want to provide unique name for each class that implement your abstract class you should declare an abstract method

public abstract String getDescription();

Or you can pass the value to the member.

 BaseClass(String description) {
   this.description = description;
 }

then in child class you can use the super to access the constructor

 ChildClass(String description) {
   super(description);
 }

The key word super allows you to access directly the members of parent class.

So in case of your class you could be able to do something like this

  private void test() {
     System.out.println(super.description); //This will refer to parent class
     System.out.println(this.description);  //This will refer to child class
  }

So when you declare a field you create always a new reference point.

Answer 6

The problem is there are 2 attributes called description, one in the super class 'Beverage' and one in the subclass 'DarkRoast', and since you are using Beverage as the the reference type you get the description attribute/instance variable of the reference class and that of the subclass is shadowed(not accessible at least to my humble knowledge in Java).

You don't need to define the attribute again in the subclass because it's already there, so basically if you remove the attribute description from the DarkRoast class you will find that it will print unknown description as well, because it is already there.

To make things more clear try this code to see how there are 2 different description instance variables.

public class DarkRoast extends Beverage {
    String description = "Dark roast";

    public String getDescription() {
        return description;
    }

    public String getSuperDescription() {
        return super.description;
    }

    @Override
    public double cost() {
        return 0.99;
    }
    public static void main(String[] args) {
    DarkRoast b = new DarkRoast();
    System.out.println(b.getDescription());
    System.out.println(b.getSuperDescription());
}
}

To see the shadowing try to do the following:

public static void main(String[] args) {
 Beverage b = new DarkRoast();
     DarkRoast b2 = new DarkRoast();
 System.out.println(b.description);
 System.out.println(b2.description);
}