Inheritance and Polymorphism - PowerPoint PPT Presentation

1 / 48
About This Presentation
Title:

Inheritance and Polymorphism

Description:

Inheritance is used to share common code (including both data members and ... vehicle car truck motorcycle trailer commercial vehicle non-commercial vehicle ... – PowerPoint PPT presentation

Number of Views:76
Avg rating:3.0/5.0
Slides: 49
Provided by: csBois
Learn more at: http://cs.boisestate.edu
Category:

less

Transcript and Presenter's Notes

Title: 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
Write a Comment
User Comments (0)
About PowerShow.com