Lab 9: Inheritance
CS 141: Introduction to Programming , Fall 2017

This lab is due Wednesday, Nov 15, by the end of the lab.

Reading

Chp 9 Inheritance
Chp 10 Interfaces
Chp 12.2: Object Oriented Design: UML relationship symbols used in the diagram below are described Chp 12 section 2, and summarized in Table 1 on p 572. The categories are
- Inheritance: "Is-a" relationship. See below.
- Interface: See below
- Dependency: "Knows about" relationship. A class depends on another class if it uses objects of that class.
- Aggregation: "Has-a" relationship. A class aggregates another if its objects (member variables) contain objects of the other class. Stronger form than dependency. (e.g. local variables count as dependency but not aggregation.)

Important Concepts

In this lab, you will gain experience working with the concepts below by implementing a program for storing data about different kinds of vehicles. Concepts are:

Inheritance: The hierarchical relationship between a more general class (superclass or base class or parent class) and a more specialized class (subclass or derived class or child class)
Concrete class: Contains member/class variables and methods. All methods must be implemented.
Abstract class: The same as a concrete class except not all methods are implemented. It is assumed there are subclasses which implement these methods.
Interface: Generally contains only method headers. There are no instance variables. There are no constructors. Methods are public and not implemented (i.e. abstract). An interface type is used to specify required operations , i.e. interfaces force a class and all its subclasses to implement the methods in the interface.
Overloaded methods: Methods in the same class that have the same name but different parameter types.
Overriding a method: A method in the subclass that has the same method header (name & parameters) as in the superclass. When a subclass object calls this method, the method executed is the one defined in the subclass. When a superclass object calls this method, the method executed is the one defined in the superclass.
Polymorphism: (Having multiple forms) allows one to manipulate objects that share a set of tasks even though the tasks are executed in different ways (as in different subclasses of the same superclass).

Instructions

You are to implement the program given by the UML class diagram shown below. The program creates a Vehicle database containing 3 different kinds of vehicles: Gas, Electric and Bicycles. The circled green numbers indicate the suggested order of implementation. You will need to look up, in your text, the syntax for creating an interface, abstract, super or subclass.

Description/Comments

Super/sub classes: Each of these vehicles share a number of different properties. The common properties are contained in the Vehicle (blue) super class.
Each subclass (Gas, Electric, Bicycle) (green) contain the properties and methods that are unique to that type of vehicle. For example, only gas powered vehicles contain a gas tank and mpg.
MaxDistance Interface: We want to be able to compare all of these vehicles based on how far they can travel without any servicing (i.e. without filling a gas tank, charging a battery, or resting a human body). This distance is computed in the distance() method. Since one must know what type of vehicle it is before calculating this distance, the distance() method is not implemented in the Vehicle class. However, we want to force all of the subclasses to implement the distance() method; We do this by having the Vehicle class implement the MaxDistance interface (yellow). The Vehicle class is said to be abstract because the distance() method is required but not implemented in the Vehicle class. It is only implemented in the subclasses.
VehicleList and polymorphism: The VehicleList class (red) contains an ArrayList of Vehicle objects. Even though Gas, Electric and Bicycle objects are all different object types, we can place them in the same ArrayList if we set the type of the ArrayList to be Vehicle, because Gas, Electric, and Bicycle objects are all subtypes of the Vehicle class. This is the concept behind polymorphism (an object can take on mutliple forms).
Sorting and the Comparable Interface: We want to be able to sort the ArrayList based on the distance(). The standard Java sort method compares objects using a compareTo() method. This is why we require that the Vehicle class implement the Comparable interface (yellow), i.e. the Comparable interface forces the Vehicle class to implement a compareTo() method. In the Javadoc, look up the Comparable interface and look to see what the compareTo method does. You must implement the comparTo() method using the distance() method.

Unit Testing: Finally, in main (not shown in the above picture), you are to create a VehicleListobject and add different types of Vehicle objects to it. For example, the code in main, could be:

public static void main(String[] args) {
        VehicleList vehicles = new VehicleList();
        
        vehicles.addVehicle(new Electric("Nissan" , "Leaf", 4,  107 )); 
        vehicles.addVehicle(new Electric("Chevrolet" , "Bolt", 4, 238)); 
        vehicles.addVehicle(new Gas("Harley-Davison" , "SuperLow", 2, 51, 4.5)); 
        vehicles.addVehicle(new Gas("Mercedez-Benz", "C 300 Sedan", 4, 33, 17.4 )); 
        vehicles.addVehicle(new Bicycle("Trek","Madone 9.9", 2, 11, 27 )); 
        vehicles.addVehicle(new Bicycle("Unicycle.com","Purple Monster", 1, 1, 27 )); 
        
        System.out.println(vehicles);
        vehicles.sortList();
        System.out.println("\nSorted by distance: ");
        System.out.println(vehicles);     
    }

The output of running the above instructions should look something like output.txt

Deliverables

To receive full credit, you need to: