Inheritance

Objective #1: Explain how inheritance can be used to develop a child class from a parent class.

Inheritance in Java allows a class developer programmer to efficiently build one class from another class. Rather than having to "re-invent the wheel", a class developer can take advantage of the methods in one class and automatically include them in another class plus add some more of his/her own methods.
The new class that is based upon the original class is called a child class (aka subclass or derived class). The original class is known as the parent class (aka superclass or base class).

For example, consider a Person class for which a Person object has a myAge private property as well as setAge, getAge, haveBirthday and saySomething public methods.

public class Person
{
	private int myAge;



	public Person()
	{
		myAge = 0;
	}

	public void setAge(int age)
	{
		myAge = age;
	}

	public int getAge()
	{
		return myAge;
	}

	public void haveBirthday()
	{
		myAge++;
	}

	public void saySomething()
	{
		System.out.println("I am a person");
	}

}

If you want to build a Student class which has an additional myGrade property (as in grade level like 9th grade, 10th grade, etc.) as well as setGrade, getGrade, passExams, and saySomething public methods, then you can "extend" the Person class in this way:

public class Student extends Person
{
	private int myGrade;


	public Student()
	{
		myGrade = 9;
	}

	public void setGrade(int grade)
	{
		myGrade = grade;
	}

	public int getGrade()
	{
		return myGrade;
	}
	public void passExams()
	{
		myGrade++;
	}


	public void saySomething()
	{
		System.out.println("I am a student");
	}

}

If you want to build an APStudent class which has an additional myAPExamScore property (as in a number between 1 and 5) as well as setAPExamScore, getAPExamScore, studyForExam, saySomething, compareTo, toString, and equals public methods, then you can "extend" the Student class in this way:

public class APStudent extends Student implements Comparable
{
	private int myAPExamScore;



	public APStudent()
	{
		myAPExamScore = 3;
	}

	public void setAPExamScore(int apExamScore)
	{
		myAPExamScore = apExamScore;
	}

	public int getAPExamScore()
	{
		return myAPExamScore;
	}

	public void studyForExam()
	{
		if (myAPExamScore < 5)
		{
			myAPExamScore++;
		}
	}

	public void saySomething()
	{
		System.out.println("I am an AP student");
	}

	public int compareTo(Object other)
	{
		return getAPExamScore() - ((APStudent) other).getAPExamScore());
	}

	public String toString()
	{
		return "myAPExamScore = " + myAPExamScore;
	}

	public boolean equals(Object other)
	{

		if (myAPExamScore == ((APStudent) other).myAPExamScore)
		{
			return true;
		}

		return false;
	}

}

All public methods in a parent class are inherited to its child class. So a Student can call the haveBirthday, getAge, or setAge methods above.
A child class can have its own additional methods that are not inherited from its parent class. This allows the child class to have new behavior that the parent class didn't need or that wasn't relevant for the parent class. In the example above, the child class Student has a passExams method that its parent class Person doesn't have.
All properties of a parent class are inherited by its child class. However, a client programmer cannot directly refer to any of the inherited properties in the parent class since they are usually private. Therefore a client programmer must use the inherited public accessor and modifier methods to access or modify the inherited private properties. For example, you may inherit your grandfathers liquor or gun collection when he passes away, but you still can't make use of those items since they are "private" (i.e. you aren't 21 years old yet.)
A child class can have its own additional properties that are not inherited from its parent class. In the example above, the child class Student has a myGrade property (as in grade level like 9th grade, 10th grade, etc.) which its parent class Person doesn't have. You should never redeclare the properties from the parent class in the child class. Doing that is called shadowing and leads to horrible logic errors. For example, if you typed private int myAge; in both the Person and Student classes, then a Student object would really have two myAge values and it would be hard to tell them apart besides the fact that there is no reason & its impossible for a student to have two ages!
Notice the use of "extends Person" on the first line of the Student class. By doing this you are allowing Student objects in client programs to make use of any public method from the Person class since those methods are "inherited". So the following lines of code would be valid in a client program

Student studentJane= new Student();
studentJane.myAge = 15; // error since myAge is private in the Person class
studentJane.setAge(15);
studentJane.haveBirthday(); // myAge is now 16
System.out.println(studentJane.getAge()); // displays 16
The saySomething method is overridden in the Student class. Therefore, a Student object like studentJane would behave differently from a Person object when the saySomething method is executed. This is an example of polymorphism since the saySomething method is used in multiple ways depending on the context in how its being used. Consider this code segment from a client program

Person personBob = new Person();
Student studentJane = new Student();
personBob.saySomething(); // displays "I am a person"
studentJane.saySomething(); // displays "I am a student"
A child class can only be based on one parent class in Java.
Use the keyword extends to create a child class as in

public class CheckingAccount extends BankAccount

or

public class BoxBug extends Bug

If a class implements one or more interfaces and extends a parent class, you use syntax like this where the keyword extends must be before the keyword implements:

public class BoxBug extends Bug implements Comparable, Movable
The relationship between a subclass such as Student and its superclass such as Person is called an is-a relationship. That is, a Student is a Person but you can't necessarily say that a Person is a Student. The is-a relationship is transitive. So if APStudent is-a subclass of Student and if Student is-a subclass of Person then you can say that a APStudent object is-a Person.
A class diagram (or hierarchy chart) is a diagram where each class is represented with a rectangle and they are connected with arrows to show the is-a relationship between inherited classes. Parent classes are drawn at the top of the chart.

A solid line with a hollow arrowhead is drawn from a child class to the parent class that it extends.This indicates an "is-a" relationship.

A dotted line with a hollow arrowhead is used to point from a class to an interface that it implements.

Classes in the same level of a hierarchy chart are called sibling classes.

A UML (Unified Modeling Language) diagram goes even further than a class hierarchy chart in illustrating the inheritance relationships between classes. We will not formally study UML diagrams this year, but in a college programming course you would probably need to use them.
An interface can extend another interface. For example you could have

public interface Movable extends Locatable

In fact, an interface can extend multiple interfaces as in

public interface Movable extends Locatable, Comparable

Questions related to this are rarely asked on the AP exam by the way.

Objective #2: Explain how a child class object can be referenced (i.e. "cloaked") as its parent class data type.

Usually you declare an object with the same data type that you use to instantiate the object as in

Person personBob = new Person();

where the data type Person is used on both sides of the statement (i.e. the left-hand "declaration" side and the right-hand "instantiation" side).

However, there are times in Java when you take advantage of inheritance to declare a reference for an object to its parent class but instantiate it to its own class as in

Person studentJane = new Student();

Trust me to know that there are times when you want and need to do this but the AP exam rarely includes questions where you need to know why this is done. You simply need to know how to trace the code that is explained in the examples below.

Doing this prevents studentJane from executing any method that are not found in the Person class. Even if the Student class has a method such as studyForExam, studentJane cannot execute studyForExam since she's "cloaked" (i.e. referenced) as only a Person. However casting can be used to "uncloak" studentJane and then allow her to call the studyForExam method as in

((Student) studentJane).studyForExam();
Keep in mind that referencing/cloaking an object does not affect which version of an overridden method that executes. If both the Person and the Student classes have their own unique version of the saySomething method and studentJane is referenced/cloaked as a Person, she can therefore execute the saySomething method since it is found in the Person class. However, the Student class version of the method is the one that executes!
For the following examples, assume that APStudent is a child class of Student and that Student is a subclass of Person. OR SUBSTITUTE Freshman FOR APStudent if you are doing the Inheritance RC worksheet #1 in April, 2012!

The following statements are VALID.

Example 1/

Person john = new Student();

john is declared as a Person reference but behind-the-scenes john is instantiated as a Student object. This is legal however only the methods found in the Person class can be invoked. However, if john is casted to a Student, then methods from the Student class can be invoked.

john.haveBirthday(); // legal
john.passExams(); // error
((Student) john).passExams(); // legal

Example 2/

Person sally = new APStudent();

sally is declared as a Person reference but behind-the-scenes sally is instantiated as a APStudent object. This is a legal but only the methods found in the Person class can be executed. However, if sally is casted to a Student, then the methods from the Student class can be invoked. If sally is casted to an APStudent, then methods from the APStudent class can be used.
sally.haveBirthday(); // legal
sally.studyForExam(); // error
((APStudent) sally).studyForExam(); // legal

Example 3/

Person person1 = new Person();
Person person2 = new Person();

person2 = person1;

is legal but remember the assignment statement is really only copying a memory address (i.e. aliasing).

Example 4/

Person person1 = new Person();
Student student1 = new Student();

person1 = student1;

is legal. However there could be "information loss" since the possible extra non-inherited properties in the Student object are not necessary in the Person object.

The following statements are NOT VALID.

Example 5/

Student fred = new Person();

is illegal.

Example 6/

Person person1 = new Person();
Student student1 = new Student();

student1 = person1;

is illegal since a Student object possibly has additional properties that a Person object doesn't have. What would Java store in those additional properties if this were legal?
Carefully review these examples that illustrates how Java uses "the best available" or "closest version" of an overrided method

public class Person
{
   private String myName;

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

   public String getName() { return myName; }

   public String toString() { return getName(); }
}

public class Student extends Person
{
   private int myGradeLevel;

   public Student(String name, int gradeLevel)
   {
      super(name);
      myGradeLevel = gradeLevel;
   }

   public int getGradeLevel() { return myGradeLevel; }

   public String getName() { return "student: " + super.getName(); }
}

The output to the following code from a client program is   student: Alice is in grade 10

Person person1 = new Student("Alice", 10);
System.out.println(person1 + " is in grade " + ((Student) person1).getGradeLevel());

While this is an example of polymorphism where both the child class has overridden the getName method from its parent class. When the computer calls the toString method on person1, the version of the getName method that executes is NOT the parent's version of getName as you might think. Instead, the child class' version of getName is executed despite the fact that person1 is a "cloaked" as a Person reference. In these situations, the computer invokes the "best available" version of a polymorphic, overridden method despite any "cloaking."

Objective #3: Be able to override methods from a parent class and add new methods to a child class.

If you wish a method to perform differently in a subclass from the way that it performs in the superclass, you can override the method by typing another implementation in the subclass. A method must have the same return type and method signature (parameters and parameter types) as the method that it overrides.
A child class may not override a public method from its parent class and make it private.
If a method is marked final in a parent class, then that method cannot be overridden in a child class. For example,

public final void run() { ... }

while the method run may be called within a client program or child class, the method cannot be overridden in a child class.
If the original method from the superclass is called in the subclass's version of an overriding method it is called partial overriding. You can use the keyword super to invoke the method from the superclass.
A child class may not override static methods from its parent class.
Methods that are private in a parent class may be overridden in the child class.
The default access for a class or a method or property within a class is package. That is, if you do not specify (or forget to specify) whether a method or property is public or private, Java will allow any class within the package to use that method or property. Remember from our earlier studies that a package is a collection of classes like java.util or java.math. Normally, it is not a good idea to allow methods or especially properities to have package access. As we have already studied, you should usually give properties an access of private and methods should be public. Constants should usually be public as well. Questions relating to this are usually not asked on the AP exam.
A child class does not automatically realize any interfaces that are realized (i.e. implemented) by its parent class. Note that if a parent class implements a method from an interface such as the compareTo from the Comparable interface and makes it a final method then a child class cannot realize the Comparable interface and implement its own compareTo method!

Objective #4: Invoke inherited methods.

A method that is overriden in at least one subclass is called polymorphic.
When methods are overloaded and they have different method signatures, the compiler selects the correct version of a method at compile time. This process is called early binding (aka static binding). Do not confuse the term overload with override!
When the Java Virtual Machine determines which version of an overridden, polymorphic method to execute at runtime, it uses the type of the actual instantiated object and not the type of the object reference. This determination occurs at run-time and is called late-binding (aka dynamic binding). It is very, very important that you understand this for the AP exam!
From within the subclass, you can specifically call the version of the overridden method by using the keyword super.
Study the following examples:

public class SuperClass
{
   public void A()
   {
      System.out.println("super A");
   }

   public void B()
   {
      A();
   }
}

public class SubClass extends SuperClass
{
   public void A()
   {
      System.out.println("sub A");
   }

   public void C()
   {
      super.A();
   }
}

Example 1/

The client code

SubClass thing = new SubClass();
thing.B();

will display the output

sub A

since the subclass' overridden version of A will be invoked even though it seems as if it's being invoked from within the SuperClass. It's not really being invoked from within SuperClass since SubClass has its own overridden version of A().

Example 2/

The client clode

SubClass thing = new SubClass();
thing.C();

will display the output

super A

since the C method is specifically invoking the SuperClass version of the A method with the use of the super keyword.

Example 3/

SuperClass thing = new SubClass();
thing.C();

will result in compile error since the SubClass object is "cloaked" as a SuperClass reference. In other words, it is only legal to invoke methods that are found in SuperClass since due to this SuperClass reference.

Example 4/

SuperClass thing = new SubClass();
thing.A();

will display the output

sub A

since the compiler will automatically invoke the version of A found in the SubClass, even though thing is "cloaked" as a SuperClass reference.

Example 5/

SuperClass sup = new SuperClass();
SubClass sub = new SubClass();
sup = sub;
sup.A();

will display the output

sub A

since the compiler will automatically invoke the version of A found in the SubClass, because the object variable sup now stores the object memory reference that is stored in sub. So sup really is a SubClass object deep down and invokes the method in the subclass.

Example 6/

SubClass thing = new SuperClass();
thing.A();

will cause a compile error since it is illegal to "cloak" a superclass object with a reference to its subclass.
It is legal and necessary to cast an object to the type necessary to make use of an available method. Using the same classes as illustrated above, study the following examples:

Example 7/

SuperClass thing = new SubClass();
((SubClass) thing).C();

is legal since thing, which was "cloaked" as a SuperClass reference, is casted to the SubClass that he really is "deep down under the cloak". Without being casted, it would cause a compile error to try to invoke the method C on a SuperClass reference since there is no method named C in the SuperClass class.

Example 8/

SuperClass thing = new SuperClass();
((SubClass) thing).C();

The cast in this example is illegal and causes an ClassCastException run-time error since thing is only instantiated as a SuperClass object. He can never be turned into or casted into a SubClass object.

Objective #5: Invoke superclass constructors.

Constructors of a parent class are not inherited by a child class. Therefore, a child class must define its own constructors since they are not inherited.
However, you can invoke a constructor of a parent class (assuming its public which it most likely is) with the statement   super();   . If you want to call the parent class's constructor, you must do so on the first line of the child class constructor.

Study the following examples:

public class SuperClass
{
   public SuperClass()
   {
      System.out.println("super constructor ");
      num = 10;
   }

   public SuperClass(int amount)
   {
      System.out.println("other super constructor");
      num = amount;
   }

   private int num;
}

public class SubClass extends SuperClass
{
   public SubClass()
   {
      super();
      System.out.println("sub constructor");
      age = 5;
   }

   public SubClass(int amount)
   {
      System.out.println("other sub constructor");
      num = 2 * amount;
      age = 5;
   }

   private int age;
}

Example 1/

The client code

SubClass thing = new SubClass();

will display the output

super constructor
sub constructor

Example 2/

The client code

SuperClass thing = new SubClass();

will display the output

super constructor
sub constructor

since the constructor from the SubClass is being invoked. Remember that constructors are not inherited.

Example 3/

The client code

SubClass thing = new SubClass(8);

will display the output

super constructor
other sub constructor

since the default constructor of the parent class is automatically called from within the "other constructor" of the child class whether it is invoked with the statement    super();    or not.

Objective #6: Override its toString and equals methods from the Object superclass.

The Object class is the "cosmic" superclass of all classes. In other words, the Object class is found at the top of the Java class hierarchy chart. All classes that you create automatically extend the Object class. Do not type "extends Object" in your own classes. Therefore all methods found in the Object class are inherited by all classes even ones that you create from scratch.
The methods toString and equals are found in the Object class and should be understood for the AP exam. Additional methods are found there but they are not covered on the AP exam.
It is efficient and wise to override the toString method in any class that you create so you have any easy way to examine the state of an object variable for debugging purposes. When overriding the toString method, you should return a string that shows the properties and values of an object. If you don't override the toString method, the inherited Object class's toString method is used but it returns the object's hash code.
The following is an example of an overridden toString method in a fictious Student class that contains myFirstName, myLastName, and myGpa properties:

public String toString()
{
return "first = " + myFirstName + " last = " + myLastName + " gpa = " + myGpa;
}

Be careful not to make the return type void and to use System.out.println from within the toString method since it is required to return a string.
In a client class, the System.out.println method can be used to invoke the toString method as in

System.out.println(widget.toString());

or

System.out.println(widget);

The latter is preferable since the println method automatically invokes an object's toString method when the object is a parameter of the println method.
To override the equals method from the Object class, you must use the header

public boolean equals(Object other)
Ordinarily, you would compare each property of the this object with the corresponding property of the parameter and return true if they are all equal and false otherwise. For example, in a fictious Student class that contains mFirstName, myLastName, and myGpa properties:

public boolean equals(Object other)
{
   if (myFirstName.equals(((Student) other).myFirstName) && myLastName.equals(((Student) other.myLastName) && myGpa == ((Student) other).myGpa))
   {
      return true;
   }

   return false;
}
If the compareTo method from the Comparable interface is implemented, then you could use

public boolean equals(Object other)
{
return compareTo(other) == 0;
}

Objective #7: Explain protected access control. NOT REALLY STRESSED ON AP EXAM.

Use protected access rather than public access or private access with methods and/or instance fields that need to be directly accessible only to subclasses of a given class. A protected method or field cannot be used by client programmers.
On the AP exam, protected access is only used in the Case Study. It will not be tested in the multiple choice questions.