Welcome to Lesson 10!

• How to use methods of the Object class
• How to override methods of the Object superclass
• The difference between this() and super() method calls
• The difference among public, private, protected, and package access
  
• What is a final class
  
• How to cast objects up and down inheritance chains
• How to write abstract classes
• How to describe the difference between abstract classes and regular classes
  

Review Activity

Working With the Object Class

Methods of the Object Class

• Every class implicitly extends java.lang.Object
• This makes the Object class the ancestor of all Java classes
  • Including all programmer-defined classes
• Thus, every class you write has access to the fields and methods of the Object class
• That means you need to know how to work with the Object class
• The following is a summary of some of the methods of the Object class
• Method clone() is complicated, and it is recommended to write a copy constructor rather than overriding
  clone()
• We already looked at overriding toString(), which you should do for almost every class you write
• In the following sections we will look at how to make use of the other methods

Object Class Methods

Determining an Object's Type

• To work with methods of the Object class, we need to know how to check the type of an object
• Many times you have a parameter of type Object
• For instance, when you use the equals() method to compare two objects

  public boolean equals(Object obj)

• Also, some methods, like clone(), return an Object type

  protected Object clone()

• To work with these methods, you need to know the actual type of the object
• Java has two main ways of determining this information:
  • instanceof operator
  • Run-time type identification (Reflection API)

Using the instanceof Operator

• The instanceof operator checks if a test object is in the inheritance hierarchy of a class type
• Syntax:

  testObject instanceof ClassName
  

• Where:
  • testObject: the object to test
  • ClassName: the class to compare again
• For example:

  Person bao = new Person("Bao", 25);
  System.out.println(bao instanceof Person);
  

• instanceof returns true if the testObject is a descendant of any ClassName

Using Reflection

• You can use reflection to determine the exact type of an object
• When Java runs an application, it keeps track of all the objects it loads using a class named Class
• For each object it loads, Java creates a Class object that has information about the object
• The getClass() method of Object returns the run-time class of an object
• For example:

  Person bao = new Person("Bao", 25);
  Class info = bao.getClass();
  System.out.println(info);
  

• Thus, you can get the Class information about any object
• Among other methods, the Class object has a method named getName() that returns the name of the type
• You can use these methods to determine the exact type of an object:

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

More Information

• Trail: The Reflection API

Casting Objects

• Once you know what type of object you have, you may need to cast objects to their actual type
• This allows you to use the methods of the more specialized object
• Following is the inheritance chain for Student
  
  
  
• Java will implicitly cast an object up the inheritance chain (upcasting)
• However, you must explicitly cast an object down the inheritance chain (downcasting)

Student martina = new Student("Martina", 32, 19556);
Object obj = martina;             // cast Student to Object
Student martina2 = (Student) obj; // cast Object to Student

• Following shows how casting affects the methods you can call

Object obj = new Student("Martina", 32, 19556);
// String name = obj.getName();  // does not compile
Student martina = (Student) obj; // cast Object to Student
String name = martina.getName(); // OK

• Once we cast obj to Student, we can use the getName() method
• Note that if you try to cast to an incompatible type you will get a compiler error

  String str = (String) martina; // compiler error

• How would you convert martina to a String?
  

Overriding the equals() Method

• To test if two objects refer to the same location, you use the equals() method of the Object class
• For example:

1
2
3
4
5
6
7
8
9
10

public class EqualsTestApp {
    public static void main(String[] args) {
        Person p1 = new Person("Ed");
        Person p2 = new Person("Ed");
        if (p1.equals(p2))
            System.out.println("true");
        else
            System.out.println("false");
    }
}

• This is often not the behavior you want and then you will need to override the equals() method

• Per the Oracle documentation for the equals method for Object, when you override equals(), you must ensure that your method adheres to what is known as the "equals contract:"

• It is reflexive: for any non-null reference value x, x.equals(x) should return true.
• It is symmetric: for any non-null reference values x and y, x.equals(y) should return true if and only if y.equals(x) returns true.
• It is transitive: for any non-null reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.
• It is consistent: for any non-null reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the objects is modified.
• For any non-null reference value x, x.equals(null) should return false.

• Therefore, we must write equals() with care to ensure that we do not violate the above aspects of the contract.
• According to Joshua Bloch in Effective Java, all overriden equals() methods should do the following:

• Use the == operator to check if the argument is a reference to this object
• Use the instanceof operator to check if the argument has the correct type.
• Cast the argument to the correct type.
• For each significant field in the class, check if that field of the argument matches the corresponding field of this object.

• As an example, we build a correct equals() method for Person:

• Use the == operator to check if the argument is a reference to this object:

  if (obj == this) { //will also check if o is null
      return true;
  }
  

• We also want our equals() to work for any kind of object reference
• Thus, if the passed object is not the same kind, we return false
• To test the exact type, we use the instanceOf operator:

  if (!(o instanceof Person)) {
      return false;
  }
  

• If our test object passes these cases, then we compare all the instance variables of our class for equality
• To do this, we must first cast our object to the actual type and then make the comparisons:

  Person p = (Person) obj;
  if (name.equals(p.getName())) {
      return true;
  }
  return false;
  

• Putting all this together we have:

  @Override public boolean equals(Object o) {
      if (o == this) {
          return true;
      } else if (!(o instanceof Person)) {
          return false;
      } else { // now safe to cast
          Person p = (Person) o;
          return name.equals(p.name);         
      }
      
  }
  

Overriding the hashCode() Method

• If you override equals(), then good practice states that you should override the hashCode() method as well.
• Otherwise, your code will not work correctly with the hash-based classes of the Java Collection like HashTable
• You will learn more about HashTable in CIS 22C and will practice overriding this method at that time.
  

Activity 10.1: Overriding Equals for the Address, Person and Employee Classes (10 pts)

• Copy and paste the new test file below into EmployeeTest.java (you can erase the old contents of the file):

• When you get the correct output (as shown in the example below), both partners should upload Address.java, Person.java, and Employee.java to Canvas

Wrapping Up Basic Inheritance

More About Subclass Constructors

• Constructors cannot be overridden because they are not inherited
• However, as we have seen before, constructors can be overloaded within the same class
• Another capability of constructors is that they can call other constructors -- known as chaining
• To call another constructor, you use the construct this()
• Like a call to super(), Java will call the constructor (within the same class) that matches the types of arguments with the constructor parameters
• Here is an example using this() and super() together

Example of this() and super() Constructor Calls

• Class Student has a constructor with two parameters:
  • String for the name attribute
  • int for the studentNumber attribute

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

• Another constructor within Student takes just a String argument
• Initializes the studentNumber attribute to a value of 0:

  public Student(String initialName) {
     this(initialName, 0);
  }
  

• Calls the constructor having two arguments within the same class
• Note that you can call either this() or super() in a constructor, but not both
• Whichever is used, it must be the first action taken by the constructor
• "For subtle reasons" beyond the scope of this course
  
• Oracle considering lifting this restriction
• See conversation here
  
• Only one of them can be first, so if you want to invoke both:
  • Use a call with this() to call a constructor using super()

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 
  

Final Classes, Methods and Parameters

• The keyword final is used in many ways

Final Classes

• Use final to prevent a class from being extended
• For example:

  public final class String {}
  

• String is an example of a class which cannot be extended from the Java API

Final Methods

• Specifies that a method definition cannot be overridden with a new definition in a subclass
• For example:

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

• Since you would never want the method to do anything else, it makes sense to make it final
• Allows the compiler to generate more efficient code

Final Parameters

• Use final in a parameter list to prevent a method from assigning a new value
• For example:

  public void doSomething(final int i, final int j) {
      //...
  }
  

• This can prevent a bug where you might set new values to the parameter variables in error
• The keyword final is not part of the method signature and does not affect how a method is overridden

Abstract Classes

Abstract Classes and Methods

• When designing a program using inheritance, you often create a superclass that you do not want instantiated
• Instead, you only want subclasses of this superclass to be instantiated
• The superclass contains code common to all the subclasses but should not be instantiated
• For example: Shape
• You cannot draw a generic shape -- what would it look like?
• Instead, you create subclasses that implement specific shapes
• Here is an example of an inheritance hierarchy for drawing various shapes

Inheritance Hierarchy

Creating Abstract Classes

• One solution to preventing a superclass from being instantiated is to make it abstract
• Abstract classes provide common code for all its subclasses
• A subclass inherits all non-private variables and methods from the abstract class
• An abstract class often defines a set of operations for subclasses, providing a common interface for the subclasses

Coding an Abstract Class

• Any class can become abstract using the keyword abstract
• Declaring a class abstract means that you cannot instantiate an object of the class
• Instead, you must subclass the abstract superclass to make use of its operations
• The following example shows a class defined as abstract

Example Abstract Class

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

public abstract class Shape { // regular instance variable declarations private int x1, x2, y1, y2; // regular constructor and method declarations public Shape() { } public Shape(int newX1, int newY1, int newX2, int newY2) { x1 = newX1; x2 = newX2; y1 = newY1; y2 = newY2; } public int getX1() { return x1; } public int getX2() { return x2; } public int getY1() { return y1; } public int getY2() { return y2; } // Abstract method declaration public abstract void draw(); }

Abstract Methods

• An abstract class may or may not contain abstract methods
• An abstract method is a method declaration without a method body:

  public abstract void draw();
  

• Any abstract methods must be implemented in any non-abstract subclass
• You must declare a class abstract if it contains an abstract method

Activity 10.2: An Abstract Account Class (10 pts)

Wrap Up: 

• With a partner, answer the questions from our learning objectives.

Upcoming Assignments:

• Assignment 10 due Wednesday
  
• Quiz 5 due Friday
  
• Lab 6 due Monday