Extending a class

The word extends makes one class a kind of another.

public class Fern extends Plant

That line says a Fern is a Plant. Anywhere a Plant is wanted, a Fern is accepted. A Fern starts out able to do everything a Plant can do. The department's own list of problem areas names this word: Unfamiliarity with keywords in Java required for basic things like inheritance (extends) and interface use (implements).

What the child gets

Write extends Plant and every field and every method declared in Plant becomes part of a Fern object. The object carries the parent's fields whether or not the child's code may read them. Call a method that Plant declared on a Fern, and it runs, with no code in Fern at all.

A class has exactly 1 direct parent (its super class). A class that names no parent extends Object, which is where toString, equals and hashCode come from on every class.

The type of the variable against the type of the object

Plant p = new Cactus();

That line has 2 types, and they do different jobs.

So p.isIndoor() compiles, because Plant declares isIndoor. When it runs, it runs Cactus's body, because the object is a Cactus.

Now give Cactus a method that Plant does not have.

public class Cactus extends Plant
{
    // constructor and isIndoor as before

    public String spines()
    {
        return "sharp";
    }
}

Plant p = new Cactus();
System.out.println(p.spines());   // does not compile

In a driver file Drive.java, where that call is line 7, the compiler says:

Drive.java:7: error: cannot find symbol
        System.out.println(p.spines());
                            ^
  symbol:   method spines()

The object is a Cactus, and it has a spines method. The call still fails, at compile time. The compiler reads the variable's type, Plant, and Plant declares no spines. Write Cactus c = new Cactus(); and c.spines() compiles and returns sharp.

Code written against Plant keeps working when someone adds an Orchid class later, because it only calls what every Plant declares.

A class you cannot build

There is no such thing as a plain plant. Every real one is a cactus, a fern or some other kind. Java can enforce that.

public abstract class Plant
{
    private String name;
    private int waterDays;

    public abstract boolean isIndoor();
}

A method header with no body, marked abstract, is a promise that every subclass you can build will supply a body (an abstract method). A class that holds an abstract method has to be marked abstract too (an abstract class). Leave the word off the class line and the file does not compile:

Plant.java:1: error: Plant is not abstract and does not override abstract method isIndoor() in Plant
public class Plant
       ^

The abstract class line has a second effect. new Plant(...) stops compiling everywhere, with the message Plant is abstract; cannot be instantiated.

Cactus.java:1: error: Cactus is not abstract and does not override abstract method isIndoor() in Plant
public class Cactus extends Plant
       ^

A chain longer than 2

A child can have children.

Plant
  Fern extends Plant
    TreeFern extends Fern

A TreeFern is a Fern, and a Fern is a Plant, so a TreeFern is a Plant too. A TreeFern can call every public method of Fern and of Plant, and a variable of type Plant holds any of the 3. Each rule above applies at each step of the chain.

In the practice APE

The Inheritance problem uses this lesson. Its header comments are the specification.

Here is the same kind of task on the Plant family. Plant is given as below. Write Succulent from its comment.

public abstract class Plant
{
    private String name;
    private int waterDays;

    protected Plant(String name, int waterDays)
    {
        this.name = name;
        this.waterDays = waterDays;
    }

    public abstract boolean isIndoor();
}

// Succulent is a Plant. It is built from a name, it is watered
// every 10 days, and it lives indoors.

public class Succulent extends Plant
{
    public Succulent(String name)
    {
        super(name, 10);
    }

    @Override
    public boolean isIndoor()
    {
        return true;
    }
}

Readiness check

Work each one on paper and write the answer down before you open it.