I.4: SUPER KEYWORD

OBJECTIVE

I can:

• use the super keyword to call a superclass’s constructors and methods

Sometimes you want the subclass to do more than what a superclass' method is doing.

You want to still execute the superclass method, but you also want to override the method to do something else.

But, since you have overridden the parent method how can you still call it?

You can use super.method() to force the parent's method to be called.

There are two uses of the keyword super:

1) super(); or super(arguments); calls the super constructor if put in as the first line of a subclass constructor. 

2) super.method(); calls a superclass' method (not constructors).

The keyword super is very useful in allowing us to first execute the superclass method and then add on to it in the subclass.

In the example below, the Student class overrides the getFood() method of the Person() class, and it uses super.getFood() to call the Person getFood() method before adding on to it.

Here, a Person is associated with the food "Hamburger" and a Student is associated with "Hamburger" and "Pizza".

Next, I added another subclass called Vegan that inherits from the Student class.

I added a Vegan constructor that takes veganName as an argument and passes it to the super constructor.

I override the getFood() method in Vegan to call the superclass getFood() but add a "No " in front of it and then "but " before adding a vegan food.

Notice in the main() I changed Javier to a Vegan object!

How does this work? 

Remember that an object always keeps a reference to the class that created it and always looks for a method during execution starting in the class that created it.

If it finds the method in the class that created it, it will execute that method.

If it doesn't find it in the class that created it, it will look at the parent of that class.

It will keep looking up the ancestor chain until it finds the method, all the way up to the Object class.

The method has to be there, or else the code would not have compiled.

When the student getFood() method is executed it will start executing the getFood method in Student.

When it gets to super.getFood() it will execute the getFood method in Person.

This method will return the string "Hamburger". 

Then execution will continue in the getFood method of Student and return the string "Hamburger and Pizza".

The toString() method is a common method that is overridden.

A subclass can override the superclass toString() method and call the super.toString() before adding on its own instance variables:

SUMMARY

• The keyword super can be used to call a superclass's constructors and methods.

• The superclass method can be called in a subclass by using the keyword super with the method name and passing appropriate parameters.

EVIDENCE

1) Complete the following Google Form. This form must be 100% correct and includes released AP practice questions. To stop working and return later, hit submit! You can "edit your response" and continue where you left off.

I.4 Evidence

2) The  Customer class below keeps track of the names and addresses of customers. It has a toString() method that prints out the name and address of the object.

a. Create a subclass OnlineCustomer that inherits from the Customer class and adds a new instance variable for the email address of the online customer.

b. Write an OnlineCustomer constructor that takes 3 arguments: name, address, and email.

c. Make sure that the OnlineCustomer constructor passes the name and address to the super (Customer) constructor.

d. Override the toString(method) in the OnlineCustomer class to call the super class toString() method and then add on the email address. See the example above for help.

e. Test the class by uncommenting the OnlineCustomer objects in the main method.

public class Customer

{

    private String name;

    private String address;

    public Customer(String n, String a)

    {

       name = n;

       address = a;

    }

    public String toString()

    {

       return "Name: " + name + "\nAddress: " + address;

    }

    public static void main(String[] args)

    {

       Customer c = new Customer("Fran Santiago", "123 Main St., Anytown, USA");

       System.out.println(c);

       // Uncomment these to test OnlineCustomer

       // OnlineCustomer c2 = new OnlineCustomer("Jasper Smith", "456 High St., Anytown, USA", "jsmith456@gmail.com");

       // System.out.println(c2);

    }

 }

 // Complete the OnlineCustomer class to inherit from Customer

 // It should have an email attribute,

 // a constructor with 3 arguments (name, address, email) that uses the super constructor,

 // and an overridden toString() method that calls the super toString() method

 //  and then prints "\nEmail:" and the email variable.

 class OnlineCustomer

 {

 }