Inheritance and Polymorphism

1
Chapter 13

• Inheritance and Polymorphism

2
Topics

• Inheritance
• Access Modifiers
• Abstract Classes

3
Defining Classes with Inheritance

• To explain the concept of inheritance, we will
  consider an example of a class roster.
• The class roster should contain both
  undergraduate and graduate students.
• Each students record will contain his or her
  name, three test scores, and the final course
  grade.
• The formula for determining the course grade is
  different for graduate students than for
  undergraduate students.

4
Defining Classes with Inheritance

• There are two broad ways to design the classes to
  model undergraduate and graduate students.
• We can define two unrelated classes, one for
  undergraduates and one for graduates.
• We can model the two kinds of students by using
  classes that are related in an inheritance
  hierarchy.
• Two classes are unrelated if they are not
  connected in an inheritance relationship.

5
Defining Classes with Inheritance

• If two object types are expected to share common
  behaviors and data, it is better to design their
  classes using inheritance.
• Using unrelated classes in such an instance will
  result in duplicating code common to both classes.

6
Student Classes

• For this example, we will design three classes
• Student
• UndergraduateStudent
• GraduateStudent
• The Student class will incorporate behavior and
  data common to both UndergraduateStudent and
  GraduateStudent objects.
• The UndergraduateStudent class and the
  GraduateStudent class will each contain behaviors
  and data specific to their respective objects.

7
Access Modifiers

• The modifier protected makes a data member or
  method visible and accessible to the instances of
  the class and the descendant classes.
• Public data members and methods are accessible to
  everyone.
• Private data members and methods are accessible
  only to instances of the class.

8
Student Classes

• The UndergraduateStudent and GraduateStudent
  classes are descendants of the Student class.
• A subclass extends its superclass.

9
UML Diagram

• A superclass Student and its subclasses
  GraduateStudent and UndergraduateStudent.

10
Polymorphism

• Polymorphism allows a single variable to refer to
  objects from different classes.
• For example, if we declare
• Student student
• We can say
• student new Student()
• student new GraduateStudent()
• and
• student new UndergraduateStudent()

11
Polymorphism

• A variable of class X may not refer to an object
  from the superclass or sibling classes of X.
• Sibling classes are those that share the common
  ancestor class.

12
Using Polymorphism

• We can maintain our class roster using an array,
  combining objects from the Student,
  UndergraduateStudent, and GraduateStudent
  classes.
• Student roster 40
• roster0 new GraduateStudent()
• roster1 new UndergraduateStudent()
• roster2 new UndergraduateStudent()
• and so on.

13
Object Diagram

• The roster array with elements referring to
  instances of GraduateStudent or
  UndergraduateStudent classes.

14
Using Polymorphism

• To compute the course grade using the roster
  array, we execute
• for (int i0 iltnumberOfStudents i)
• rosteri.computeCourseGrade()
• If rosteri refers to a GraduateStudent, then
  the computeCourseGrade method of the
  GraduateStudent class is executed.
• If rosteri refers to an UndergraduateStudent,
  then the computeCourseGrade method of the
  UndergraduateStudent class is executed.

15
Polymorphism

• The computeCourseGrade method is called
  polymorphic because the message refers to methods
  from different classes depending on the object
  referenced by rosteri.
• Polymorphism, as you can see, permits the smooth
  and easy extension and modification of a program.

16
Polymorphism

• The instanceof operator can help us learn the
  class of an object.
• Student x new UndergraduateStudent()
• if(x instanceof UndergraduateStudent )
• System.out.println(Mr. X is an
  undergraduate student)
• else
• System.out.println(Mr. X is a graduate
  student)

17
Member Accessibility

• In addition to declaring members private and
  public, we can declare them protected.
• The protected modifier is meaningful only if used
  with inheritance.

18
Member Accessibility

• class Super
• public int public_Super_Field
• protected int protected_Super_Field
• private int private_Super_Field
• public Super()
• public_Super_Field 10
• protected_Super_Field 20
• private_Super_Field 30
• ...

19
Member Accessibility

• class Sub extends Super
• public int public_Sub_Field
• protected int protected_Sub_Field
• private int private_Sub_Field
• public Sub()
• public_Sub_Field 100
• protected_Sub_Field 200
• private_Sub_Field 300
• ...

20
UML Diagram

• A graphical representation of superclasses and
  subclasses with public, private, and protected
  members.

21
Member Accessibility

• A public member is accessible to any method.
• A private member is accessible only to the
  methods that belong to the same class.
• Use accessor and mutator functions just as you
  would from any external class.

22
Member Accessibility

• class Client
• public void test()
• Super mySuper new Super()
• Sub mySub new Sub()
• int i mySuper.public_Super_Field
• int j mySub.public_Super_Field
• // inherited by mySub
• int k mySub.public_Sub_Field
• The above three statements are valid.

23
Private Member Accessibility

• class Client
• public void test()
• Super mySuper new Super()
• Sub mySub new Sub()
• int l mySuper.private_Super_Field
• int m mySub.private_Sub_Field
• int n mySub.private_Super_Field
• The above three statements are invalid.

24
Protected Member Accessibility

• A protected member is accessible only to the
  methods that belong to the same class or to the
  descendant classes.
• It is inaccessible to the methods of an unrelated
  class.

25
Protected Members

• class Client
• public void test()
• Super mySuper new Super()
• Sub mySub new Sub()
• int o mySuper.protected_Super_Field
• int p mySub.protected_Sub_Field
• int q mySub.protected_Super_Field
• The statements above are invalid.

26
Outside Access

• The difference between public, private, and
  protected modifiers. Only public members are
  visible from outside.

27
Subclass Access

• Everything except the private members of the
  Super class is visible from a method of the Sub
  class.

28
Member Accessibility

• If a member X, whether inherited or defined in a
  class, is accessible from an instance of the
  class, then X is also accessible from all
  instances of the same class.
• Data members accessible from an instance are also
  accessible from other instances of the same
  class.

29
Inheritance and Constructors

• Unlike members of a superclass, constructors of a
  superclass are not inherited by its subclasses.
• You must define a constructor for a class or use
  the default constructor added by the compiler.

30
Inheritance and Constructors

• A class definition such as
• Class Person
• public void sayHello()
• System.out.println(Well, hello.)
• is equivalent to
• Class Person
• public Person()
• super()
• public void sayHello()
• System.out.println(Well, hello.)

31
Inheritance and Constructors

• The statement
• super()
• calls the superclasss constructor.
• If the class declaration does not explicitly
  designate the superclass with the extends clause,
  then the classs superclass is the Object class.

32
Inheritance and Constructors

• If you declare a constructor, then no default
  constructor is added to the class. If you define
  a class as
• class MyClass
• public MyClass(int x)
• ...
• then a statement
• MyClass test new MyClass()
• is invalid because MyClass has no matching
  constructor.

33
Inheritance and Constructors

• If the constructor you define does not contain an
  explicit call to a superclass constructor, then
  the compiler adds the statement
• super()
• as the first statement of the constructor.

34
Inheritance and Constructors

• If a class has a superclass that is not the
  Object class, then a constructor of the class
  should make an explicit call to a constructor of
  the superclass.
• Always provide a constructor for every class you
  define. Dont rely on default constructors.

35
Abstract Superclasses and Methods

• When we define a superclass, we do not always
  need to create any instances of the superclass.
• Sometimes you don't have enough information to
  write methods at the superclass level
• Depending on whether we need to create instances
  of the superclass, we must define the class
  differently.
• We will study examples based on the Student
  superclass defined earlier.

36
Abstract Superclasses and Methods

• Example Case 1 Student Must Be Undergraduate or
  Graduate
• If a student must be either an undergraduate or a
  graduate student, we only need instances of
  UndergraduateStudent or GraduateStudent.
• We can enforce this by defining the Student class
  so that no instances may be created of it.

37
Abstract Classes

• An abstract class is a class defined with the
  modifier abstract. No instances can be created
  from an abstract class.
• Abstract classes and interfaces have some
  properties in common.

38
Abstract Methods

• An abstract method is a method with the keyword
  abstract, and it ends with a semicolon instead of
  a method body.
• A class is abstract if the class contains an
  abstract method or does not provide an
  implementation of an inherited abstract method.
• The methods in an interface are abstract
  automatically.

39
Abstract Classes and Abstract Methods

• We say a method is implemented if it has a method
  body.
• If a subclass has no abstract methods and no
  unimplemented inherited abstract methods, then
  the subclass is no longer abstract, and instances
  may be created of it.
• An abstract class must contain the keyword
  abstract in its definition.

40
UML Diagrams

• In a program diagram, we represent an abstract
  class by using the keyword abstract.

41
Student Classes

• Example Case 2 Student Does Not Have to Be
  Undergraduate or Graduate.
• In this case, we may design the Student class in
  one of two ways.
• We can make the Student class instantiable.
• We can leave the Student class abstract and add a
  third subclass, OtherStudent, to handle a student
  who does not fall into the UndergraduateStudent
  or GraduateStudent categories.

42
Student Classes

• With the first approach, we delete the keyword
  abstract from the class definition and provide a
  method body for computeCourseGrade.
• class Student ...
• public void computeCourseGrade()
• int total 0
• for (int i0 iltNUM_OF_TESTS i)
• total testi
• if (total/NUM_OF_TESTS gt50)
• courseGrade Pass
• else
• courseGrade No Pass
• ...
• This design allows us to create an instance of
  Student to represent a nonregular student.

43
Student Classes

• In the second approach, we leave the Student
  class abstract. We define a third subclass,
  OtherStudent
• class OtherStudent extends Student
• public void computeCourseGrade()
• int total 0
• for (int i0 iltNUM_OF_TESTS i)
• total testi
• if (total/NUM_OF_TESTS gt50)
• courseGrade Pass
• else
• courseGrade No Pass

44
UML Diagram

• A program diagram of the abstract superclass
  Student and its three subclasses.

45
Design Decisions

• The best approach depends on the particular
  situation.
• When considering design options, we can ask
  ourselves which approach allows easier
  modification and extension.
• Finally, private methods and static methods may
  not be declared abstract.

46
Inheritance versus Interface

• Java interface and inheritance both model an IS-A
  relationship
• class ButtonHandler implements ActionListener
• Class SavingsAccount extends Account
• We say ButtonHandler is an ActionListener and
  SavingsAccount is an Account.
• However, their uses are very different.
• The Java interface is used to share common
  behavior (only method headers) among the
  instances of different classes.
• Inheritance is used to share common code
  (including both data members and methods) among
  the instances of related classes.

47
Inheritance versus Interface

• In your program designs, remember
• Use the Java interface to share common behavior.
• Use inheritance to share common code.
• If an entity A is a specialized form of another
  entity B, then model them by using inheritance.
  Declare A as a subclass of B.

48
In-Class Exercise

• Imagine that you are writing classes to be used
  in a program for registering vehicles at the DMV
• Sketch an inheritance hierarchy for the following
  classes.
• vehicle car truck motorcycle trailer commercial
  vehicle non-commercial vehicle
• Feel free to add additional classes