Core Java

Inheritance

Slide navigation: Forward with space bar, → arrow key, or PgDn. Backwards with ← or PgUp.

Understand and define subclasses

Classes, Superclasses, and Subclasses

• Can build classes from existing classes.
• New class inherits features from existing class.
• Example: Managers are in many aspects like employees.
• But in other aspects they are different.
  • Managers gets a bonus if they actually achieve what they are supposed to do.
• Every manager is an employee, but not every employee is a manager.
• The class of managers is a subclass of the class of employees.
• The Employee class is a superclass.

Defining Subclasses

• Use the extends keyword:

  public class Manager extends Employee
  {
     added methods and fields
  }
  

• Add fields and methods:

  public class Manager extends Employee
  {
     private double bonus;
     . . .
     public void setBonus(double bonus)
     {
        this.bonus = bonus;
     }
  }
  

• Manager inherits methods from superclass: getName, getHireday, getSalary, raiseSalary
• Superclass fields name, salary are present in all Manager objects.

Override methods and provide constructors in subclasses

Overriding Methods

• When an inherited method is not appropriate, need to override it in the subclass.
• First attempt:

  public class Manager extends Employee
  {
     . . .
     public double getSalary()
     {
        return salary + bonus; // won't work
     }   
  }

• Subclass methods cannot access private superclass fields.
• Second attempt:

     public double getSalary()
     {
        return getSalary() + bonus; // still won't work
     }   
  

• Use super to avoid recursive call:

     public double getSalary()
     {
        return super.getSalary() + bonus;
     }   
  

Subclass Construction

• Subclass constructor can invoke superclass constructor:

  public Manager(String name, double salary, int year, int month, int day)
  {
     super(name, salary, year, month, day);
     bonus = 0;
  }
  

• Call using super must be the first statement.
• If no explicit call to superclass constructor, no-arg constructor of superclass is invoked.
• If the superclass does not have a no-arg constructor, the compiler reports an error.

Polymorphism

• Consider a mix of employees and managers:

  staff[0] = boss;
  staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
  staff[2] = new Employee("Tony Tester", 40000, 1990, 3, 15);

• Print out everyone's salaries:

  for (Employee e : staff)
     System.out.println(e.getName() + " " + e.getSalary());

• Which getName method gets called?
  • There is only one: Employee.getName
• Which getSalary method gets called?
  • Employee.getSalary or Manager.getSalary?
  • It depends on the actual type of e!
• Polymorphism: A variable can refer to multiple types.
• Dynamic binding: The appropriate method is selected.
• Makes programs extensible: Other types can be added later.

inheritance

More about Method Calls

• Suppose x is declared to be of type C. Consider a method call:

  x.f(args)

• The compiler finds all accessible methods called f in C and its superclasses.
• The compiler selects the method whose parameter types match the argument types (overloading resolution).
• If the method is private, static, or final, then the compiler knows exactly which method to call (static binding).
• Otherwise, the exact method is found at runtime (dynamic binding).

More about Overriding

• Caution: Argument types of overriding method must match exactly:

  class Employee
  {
     public void setBoss(Employee boss) { ... }
     ...
  }
  
  class Manager
  {
     public void setBoss(Manager boss) { ... } // Error—unrelated method
     ...
  }
  

• Use @Override annotation to make the compiler check:

  @Override public void setBoss(Employee boss)
  

• Return type can be covariant:

  class Employee
  {
     public Employee getBoss() { ... }
     ...
  }
  
  class Manager
  {
     public Manager getBoss() { ... } // Ok
     ...
  }

Understand advanced inheritance concepts in Java

Final Classes and Methods

• A final class cannot be extended:

  public final class Executive extends Manager
  {
     . . .
  }
  

• A final method cannot be overridden:

  public class Employee
  {
     . . .
     public final String getName() { return name; }
  }
  

• Use only for design—not necessary for performance.

Casting

• Sometimes, you know more than the compiler about the actual type of a value.
• Suppose you know that staff[0] is a Manager.
• To call Manager methods, you need to cast:

  Manager boss = (Manager) staff[0];
  boss.setBonus(...); 
  

• If staff[0] wasn't actually a Manager, a ClassCastException occurs.
• Can test with instanceOf operator:

  if (staff[1] instanceof Manager)
  {
     boss = (Manager) staff[1];
     . . .
  }
  

• Compiler won't let you make absurd casts:

  String c = (String) staff[1]; // Compile-time error
  

Abstract Methods

• When factoring out common classes, it can become difficult to implement methods in the most general classes.
• Example: Classes Employee and Student with common superclass Person.
• Each class defines a getDescription method, returning a description string:

  an employee with a salary of $50,000.00
  a student majoring in computer science

• What is the description of a Person?
• Declare method as abstract and don't provide implementation:

  public abstract String getDescription();

Abstract Classes

• Class with abstract methods must be declared abstract:

  public abstract class Person

• Ok for abstract classes to have fields, constructors, and concrete methods:

  public abstract class Person
  {
     private String name;
     public Person(String n) { name = n; }
     public String getName() { return name; }
     ...
  }
  

• Abstract classes cannot be instantiated:

  Person p1 = new Person("Vince Vu"); // Error!
  Person p2 = new Student("Vince Vu", "Economics"); // Ok
  

• A class can be declared abstract even if it has no abstract methods.
  • Then another class must extend it in order to construct instances.

abstractClasses

Protected Access

• A protected field or method is accessible from subclasses:

  public class Employee
  {
     protected double salary;
  }
  

• A Manager method can access the salary field.
• But only in Manager instances.
• Caution: Protected features have package visibility.
• Caution: Protected fields restrict evolution—anyone can extend a class.
• Protected methods are sometimes useful for methods that are “tricky” to use.

Work with the Object class and its methods

Object: The Cosmic Superclass

• Object is superclass of all Java classes.
• Only primitive types int, double, etc. are not objects.
• Arrays are objects.
• Any object or array reference can be stored in a variable of type Object:

  Object obj1 = new Employee(...);
  Object obj2 = new int[10];
  

• Object class has useful methods: equals, hashCode, toString

The equals Method

• Object.equals tests whether the object references are identical.
• Override to test when two objects should be equal.
• Example: Consider two Employee objects equal if their fields are the same.

  public boolean equals(Object otherObject)
  {
     if (this == otherObject) return true;
     if (otherObject == null) return false;
     if (getClass() != otherObject.getClass()) return false;
  
     Employee other = (Employee) otherObject;
     return name.equals(other.name)
        && salary == other.salary
        && hireDay.equals(other.hireDay);
  }
  

• Static Objects.equals method is null safe:

  return Objects.equals(name, other.name)
     && salary == other.salary
     && Object.equals(hireDay, other.hireDay);

The equals Method in a Subclass

• Call super.equals, then compare subclass fields:

  public class Manager extends Employee
  {
     . . .
     public boolean equals(Object otherObject)
     {
        if (!super.equals(otherObject)) return false;
  
        Manager other = (Manager) otherObject;
        return bonus == other.bonus;
     }
  }

• The superclass method checks that the classes match.

Equality Testing and Inheritance

• Should an Employee ever equal a Manager?
• The equals method needs to be:
  • Reflexive—x.equals(x)
  • Symmetric—if x.equals(y), then y.equals(x)
  • Transitive—if x.equals(y) and y.equals(z), then x.equals(z)
• Hard to do with mixed types.
  • If m is a Manager, then m.equals(e) and e.equals(m) must be the same.
  • The meaning of equals must be fixed in the superclass:

    public class Person
    {
       public final boolean equals(Object otherObject)
       {
          if (this == otherObject) return true;
          if (otherObject == null) return false;
          if (!(otherObject instanceOf Person)) return false;
    
          Person other = (Person) otherObject;
          return id == other.id; 
       }
    }

The hashCode Method

• Hash code=integer derived from an object.
• Hash codes should be scrambled: If x and y are not equal, then x.hashCode() and y.hashCode() should be different.
  • Hash code computation in the String class:

    int hash = 0;
    for (int i = 0; i < length(); i++)
       hash = 31 * hash + charAt(i);

  • "Hello".hashCode() is 69609650, "Harry".hashCode() is 69496448.
• Hash codes must be consistent: If x and y are equal, then their hash codes must be equal.
  • Object.hashCode is derived from memory location.
  • Override hashCode whenever you override equals!
  • Combine the hash codes of the fields that the equals method compares:

    public class Employee
    {
       . . .
       public int hashCode()
       {
          return Objects.hash(name, salary, hireDay);
       }
    }

The toString Method

• Yields a string representation of an object.
• When you concatenate a string and an object, the toString method is invoked on the object:

  "Center: " + p // Calls p.toString()

• Object.toString yields class name and hash code.
• Override for a more meaningful result, such as:

  java.awt.Point[x=10,y=20]

• Implementation:

  public class Point
  {
     . . .
     public String toString()
     {
        return "java.awt.Point[x=" + x + ",y=" + y + "]";
     }
  }
  

Inheritance and the toString Method

• In Employee class:

  public String toString()
  {
     return getClass().getName()
        + "[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay + "]";
  }

• In Manager subclass:

  public String toString()
  {
     return super.toString() + "[bonus=" + bonus + "]";
  }
  

• Result format:

  Manager[name=...,salary=...,hireDay=...][bonus=...]

equals

Understand how inheritance shapes Java language features

Generic Array Lists

• The length of an array is fixed—inconvenient when it is not known in advance.
• ArrayList class manages an Object[] array that grows and shrinks on demand.
• Generic class: Use a type parameter such as ArrayList<Employee> to specify element type.
• Can omit type parameter in the constructor (diamond syntax):

  ArrayList<Employee> staff = new ArrayList<>();

• Use add method to add object to the end:

  staff.add(new Employee("Harry Hacker", . . .));

• The call staff.size() yields the current size.
• Access and modify elements with the get and set methods:

  Employee e = staff.get(i);
  staff.set(i, tony);
  

• Can use “for each” loop to visit elements:

  for (Employee e : staff) System.out.println(e);
  

arrayList

Object Wrappers and Autoboxing

• ArrayList can only hold objects, not int values.
• An object of the Integer wrapper class wraps an int value.
• Conversion between int and Integer is automatic:

  ArrayList<Integer> list = new ArrayList<>();
  list.add(3); // same as list.add(Integer.valueOf(3));
  int n = list.get(i); // same as int n = list.get(i).intValue();
  

• Even works with increment:

  Integer n = 1000;
  n++;

• Caution: == doesn't work with wrappers.

  Integer a = n + 1;
  Integer b = n + 1;
  System.out.println(a == b); // May be false
  

• Caution: Wrappers can be null.

  Integer n = null;
  System.out.println(n + 1); // Null pointer exception
  

Methods with a Variable Number of Parameters

• Some methods take a variable number of arguments. Example:

  System.out.printf("%d", n);
  System.out.printf("%d %s", n, "widgets");

• Variable arguments are indicated with ellipsis:

  public class PrintStream
  {
     . . .
     public PrintStream printf(String fmt, Object... args) { . . . }
  }

• Method receives an Object[] array of the arguments.
• You can define your own “variable arguments” methods:

  public static double max(double... values)
  {
     double largest = Double.NEGATIVE_INFINITY;
     for (double v : values) if (v > largest) largest = v;
     return largest;
  }

• Call the method like this:

  double m = max(3.1, 40.4, -5);

Enumeration Classes

• Enumeration class defines all instances:

  public enum Size { SMALL, MEDIUM, LARGE, EXTRA_LARGE };

• Can add constructors, methods, and fields:

  public enum Size
  {
     SMALL("S"), MEDIUM("M"), LARGE("L"), EXTRA_LARGE("XL");
  
     private String abbreviation;
  
     private Size(String abbreviation) { this.abbreviation = abbreviation; }
     public String getAbbreviation() { return abbreviation; }
  }
  

• All enumeration classes are subclasses of Enum and inherit methods:
  • toString—yields the name "SMALL", "MEDIUM", ...
  • ordinal—yields the position 0, 1, ...
• Useful static methods:
  • Enum.valueOf(Size.class, "SMALL") yields Size.SMALL
  • Size.values() yields all values in an array of type Size[]

enums

Use reflection to work with arbitrary objects

The Class Class

• Reflection: Analyze and manipulate arbitrary Java objects at runtime.
• Given an object, get its Class object:

  Object obj = ...;
  Class cl = obj.getClass();
  

• Find the class name:

  System.out.println(cl.getName());

• Find the methods that you can apply:

  System.out.println(Arrays.toString(cl.getMethods()));
  

• newInstance yields an instance constructed with the no-arg constructor:

  Object newObj = cl.newInstance();

Obtaining Class Instances

• Can get a Class instance from a string:

  String className = ... // e.g., "java.util.Random";
  Class cl = Class.forName(className);
  

• Shorthand for class literals:

  Class cl1 = Random.class; // if you import java.util.*;
  Class cl2 = int.class;
  Class cl3 = Double[].class;
  

• Class describes a type which need not be a class.
• Class instances are unique:

  if (obj.getClass() == Employee.class) // Ok
  

A Primer on Catching Exceptions

• Methods such as forName and newInstance can throw exceptions.
• These exceptions are checked: You need to explain how you will handle them.
• You can declare them with a throws statement.
• You can catch them with a try/catch block:

  try
  {
     statements that might throw exceptions
  }
  catch (Exception e)
  {
     handler action
  }
  

• We will do the latter with methods such as forName and newInstance.

reflection

Analyzing Objects at Runtime

• The getDeclaredFields method yields an array of Field objects.
• The getDeclaredField method yields a Field object for a given field name.
• Can use it to inspect or modify a field value.

  Employee harry = new Employee("Harry Hacker", 35000, 10, 1, 1989);
  Class cl = harry.getClass();
  Field f = cl.getDeclaredField("name");
  Object v = f.get(harry);
  f.set(harry, "Wimpy Whiner");

• Problem: name is a private field. Make this call first:

  f.setAccessible(true);
  

• Application: Generic toString method in sample code.

objectAnalyzer

Generic Array Code

• Array class lets you create and analyze arrays dynamically.
• Task: Implement copyOf method:

  Employee[] a = new Employee[100];
  . . .
  // array is full
  a = Arrays.copyOf(a, 2 * a.length);
  

• First attempt:

  public static Object[] badCopyOf(Object[] a, int newLength) // not useful
  {
     Object[] newArray = new Object[newLength];
     System.arraycopy(a, 0, newArray, 0, Math.min(a.length, newLength));
     return newArray;
  }

• Problem: The method is useless since it returns an Object[] array.

Generic Array Code

• Second attempt:

  public static Object goodCopyOf(Object a, int newLength)
  {
     Class cl = a.getClass();
     if (!cl.isArray()) return null;
     Class componentType = cl.getComponentType();
     int length = Array.getLength(a);
     Object newArray = Array.newInstance(componentType, newLength);
     System.arraycopy(a, 0, newArray, 0, Math.min(length, newLength));
     return newArray;
  }

• Even works with primitive type arrays:

  int[] a = { 1, 2, 3, 4, 5 };
  a = (int[]) goodCopyOf(a, 10);

• Note the return type: Object, not Object[]

arrays

Invoking Arbitrary Methods

• The getMethods method yields an array of Method objects.
• The getMethod method yields a Method object:

  Method m1 = Employee.class.getMethod("getName");
  Method m2 = Employee.class.getMethod("raiseSalary", double.class);
  

• The invoke method lets you call a method:

  String n = (String) m1.invoke(harry);
  double s = (Double) m2.invoke(harry);

• Application: Print a table of values of a mathematical function.
• Do this only for situations where reflection is necessary, such as debuggers, interpreters, and so on.
• For most situations, interfaces and lambda expressions are better—see the next lesson.

methods

Java 9 News Flash - Reflection

• Class.newInstance is now deprecated.
• It was able to hide checked exceptions.
• Suppose a no-arg constructor throws a checked exception:

  class Fred {
     public Fred() throws IOException {
        throw new IOException("No Fred.properties"); } }
  

Reflection

• This method promises a Fred without throwing any checked exception:

  public Fred haveFred() {
     try {
        return Fred.class.newInstance();
     } catch (ReflectiveOperationException ex) {
        System.out.println("Caught ROE"); return null; } } 

• This method promises to throw no checked exceptions, yet calling it throws an IOException.
• Remedy—call:

  Fred.class.getDeclaredConstructor().newInstance()
  

  which throws a checked InvocationTargetException.

JShell and Arrays

• The version of JShell in the video faithfully called toString on arrays.

  String.class.getConstructors()
     [Ljava.lang.reflect.Constructor;@706a04ae 

• In Java 9, JShell relents and gives you the array elements:

  String.class.getConstructors()
  $17 ==> Constructor[15] { public java.lang.String(byte[]),
  public java.lang.String(byte[],int,int),
  public java.lang.String(byte[],java.nio.charset.Charset), ...}
  

• No need to call Arrays.toString(...)

Use inheritance effectively

Design Hints for Inheritance

• Place common operations and fields in the superclass.
• Don’t use protected fields.
• Use inheritance to model the “is–a” relationship:

  public class Contractor extends Employee
  {
     private double hourlyWage; // ???
  . . .
  }

• Don’t use inheritance unless all inherited methods make sense:

  class Holiday extends GregorianCalendar { . . . } // ???
  . . .
  Holiday christmas;
  christmas.add(Calendar.DAY_OF_MONTH, 12);
  

Design Hints for Inheritance

• Don’t change the expected behavior when you override a method.
  • Can you “fix” the issue of the Holiday add method?
  • The following code should work no matter whether x is a GregorianCalendar or Holiday object:

    int d1 = x.get(Calendar.DAY_OF_MONTH);
    x.add(Calendar.DAY_OF_MONTH, 1);
    int d2 = x.get(Calendar.DAY_OF_MONTH);
    System.out.println(d2 - d1);

• Use polymorphism, not type information:

  if (x is of type 1) action1(x); else if (x is of type 2) action2(x);

  ⇒

  x.action();

• Don’t overuse reflection.