• Here the superclass is a BankAccount
  
• The class has several variables and methods used to define a BankAccount object
• For instance, getBalance() returns the current totalBalance
• In the CheckingAccount and SavingAccount subclasses you can use all the variables and methods inherited from BankAccount
• In addition, you can add new fields, constants and methods

About the Diagram

• The first rectangular section of a class diagram contains the class name
• The second section describes the attributes (fields or variables)
• The third (bottom) section describes the operations (methods)
• A minus sign (-) marks attributes and operations are private, i.e. that cannot be accessed by other classes, including child classes (private)
  
• A plus sign (+) marks attributes and operations that are public, i.e. that can be accessed by other classes
  
• Parameters are listed in parenthesis separated by commas
• The upward pointing arrow indicates inheritance

Class Hierarchies

• You can derive classes from derived classes
  • Subclasses become superclasses for their descendants
  • Child classes become parent classes in turn
• When you have multiple levels of subclasses, you create an inheritance hierarchy
• Classes higher in the hierarchy are called ancestor classes
• Classes lower in the hierarchy are called descendent classes
• A class can use the variables and methods of any of its superclasses
• For example, a WeinerDog (below) uses the variables and methods provided by both Dog and Animal
• Note that inheritance describes an is-a relationship
  • For instance: a Cat is an Animal
• This is in contrast to the has-a relationship, where a class contains a reference to another class

Diagram Showing an Inheritance Hierarchy

• The following diagram shows some classes from the Java API
• From the diagram, you can see that a superclass may have more than one subclass
• For instance, Dog has two subclasses: Rottweiler and WeinerDog

image source

Another Way to Draw Inheritance

• There are many ways to draw inheritance diagrams
• The following is another way to show the inheritance hierarchy for Container
• Note how the superclass is always drawn higher than the subclass

  Animal
     |
     +--Cat
     |     |
     |     +--Siamese
     |
     +--Dog
           |
           +--Rottweiler
           |
           +--Chihuahua
  
  

Designing with Inheritance

• Note in the inheritance diagram above that a Chihuahua is a type of Dog
• When using inheritance in an application, it is important to keep "is a" in mind
• Make sure a subclass has an is-a relationship with the superclass
  • A subclass must be a type of a superclass
• Which of the following are valid is-a relationships?
  • Car ==> Vehicle
  • Car ==> Motorcycle
  • Student ==> Person
  • Student ==> College
• Substitute the words "is a type of" for the arrow (==>)

Inheritance Example

• To deriving a new class from an existing one, you use the extends clause
• Syntax:

  [accessModifier] class SubclassName extends SuperclassName

• A subclass can only extend one superclass
• Java does not support multiple inheritance
• Interfaces (discussed later) achieve much of the same effect

Example Superclass

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 

public class Person {
    private String name;

    public Person() {
        name = "No name yet";
    }

    public Person(String initialName) {
        name = initialName;
    }

    public String getName() {
        return name;
    }

    public void setName(String newName) {
        name = newName;
    }

    public boolean samePerson(Person other) {
        return (name.equalsIgnoreCase(other.name));
    }
    
    public void printAttributes() {
        System.out.println("Name: " + name);
    }

    public void special() {
        System.out.println("I am special");
    }
}

Example Subclass

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 

public class Student extends Person {
    private int studentNumber;

    public Student() {
        super(); //call Person default constructor
        studentNumber = 0;
    }

    public Student(String name, int number) {
        super(name); //call Person one argument constructor
        studentNumber = number;
    }

    public int getStudentNumber() {
        return studentNumber;
    }
    
    public boolean sameStudent(Student other) {
        return (super.samePerson(other) && other.studentNumber == studentNumber);
    }

    @Override public void printAttributes() {
        super.printAttributes();
        System.out.println("Student Number : "
                + studentNumber);
        super.special();
    }
}

Example Test Application

1
2
3
4
5
6
7
8
9
10
11
12
13
14 

public class StudentApp {
    public static void main(String[] args) {
        Person al = new Person("Al");
        Student xing = new Student("Xing", 55555);
        Student buford = new Student("Buford", 11111);

        System.out.println("Printing " + al.getName() + "'s information:");
        al.printAttributes();
        System.out.println("\nPrinting " + xing.getName() + "'s information:");
        xing.printAttributes();
        System.out.println("\nPrinting " + buford.getName() + "'s information:");
        buford.printAttributes();
    }
}

Adding Methods to Subclasses

• We added a member variable to the Student subclass

  public class Student extends Person {
      private int studentNumber;

• A Student has this attribute in addition to a name
  • name is inherited from Person
• Also, we added a new instance method to the subclass:

  public int getStudentNumber() {
      return studentNumber;
  }
  

• A Student has this method in addition to all the methods of the superclass

Overriding Methods

• In addition to adding new members, we can change the way a method works for objects of a subclass
• Changing the way a method works in a subclass is known as overriding a method
• We overrode this method in our Student subclass

• Both superclass and subclass has a printAttributes method
• Both methods have the same parameters (i.e. none)
  • Thus, they have the same signature
• The method from the subclass overrides the superclass method
• Note that a subclass method will NOT override a superclass method if the parameters are different
  • Would have different signatures
• Note that calling this method has a different effect whether it is called for an object of type Person or an object of type Student:
  

• Sometimes people confuse overriding with overloading
• See the table below for the similarities and differences

Overriding Verses Overloading

Overriding	Overloading
Same method name	Same method name
Same signature One method in superclass, one in subclass	Different signature Both methods can be in same class

Constructors and Inheritance

• Constructors are not inherited by a subclass
• Instead, superclass constructors are called by the subclass constructor
• Superclass constructors are called either implicitly or explicitly using super()

Examples of Subclass Constructors

• Here is a no-parameter constructor for Student:

  public class Student extends Person {
      private int studentNumber;
      public Student() {
          super();
          studentNumber = 0;
      }
  ...
  

• The first statement of the constructor is super() which calls the no-argument constructor of the superclass
• After the superclass constructor finishes, this constructor then initializes the attribute studentNumber to 0
• We could have left out the call to super() because Java automatically includes it if not explicitly stated
• If you want to call a different constructor, then you use super() with arguments of the correct type:

  ...
  public Student(String name, int number) {
      super(name);
      studentNumber = number;
  }
  

• This constructor passes the parameter name to the constructor of the superclass
• After which the Student() constructor initializes the instance variable studentNumber
• Note that super() must be first action in a constructor definition

Activity 11.1: An Employee Subclass (10 pts)

2. Using Access Modifiers

• You use the keywords public, private and protected to control access to class members
• Controls access to class instance variables and methods

public Access: Interface Access

• Least restrictive of all access modifiers
• public fields and methods can be accessed from anywhere the class is accessible:

  public class MyClass {
      public double x;
      public void foo() {}
  }
  

private Access: Don't Touch That!

• Most restrictive of all access modifiers
• private fields and methods cannot be accessed from outside of the class
• Good design practice to make all variables private and to provide accessor methods where needed
• Auxiliary ("helper") methods are declared private often as well
• Generally do not declare a class private -- how would you use it?

  public class MyClass {
      private double x;
      private void foo() {}
  }
  

protected Access: Inheritance Access

• Accessible in the package of this class and any subclass of this class (which may be in other packages)
  
• More restrictive than public accessibility but less restrictive than default

  public class MyClass {
      protected double x;
      protected void foo() {}
  }
  

Package Access: the Default

• No access modifier: known as default or package accessibility
• Only accessible to other classes in the same package (directory)
• Less restrictive than private accessibility, but more restrictive than public or protected access

  class MyClass {
      double x;
      void foo() {}
  }

• In our course, we will be using private and public access modifiers only as these are the most common 
  

Group Activity: Why will the below code not compile?