chapter 8.2

23
USING CLASSES WITH POLYMORPHISM Chapter 8.2:

Upload: sotlsoc

Post on 05-Dec-2014

121 views

Category:

Technology


2 download

DESCRIPTION

 

TRANSCRIPT

Page 1: Chapter 8.2

USING CLASSES WITH POLYMORPHISM

Chapter 8.2:

Page 2: Chapter 8.2

Defining Classes with Inheritance Case Study:

Suppose we want implement a class roster that contains both undergraduate and graduate students.

Each student’s 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.

Undergrads: pass if avg test score >= 70

Grads: pass if avg test score >= 80

Page 3: Chapter 8.2

Modeling Two Types of Students

There are two 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.

Page 4: Chapter 8.2

Classes for the Class Roster For the Class Roster sample, we 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.

Page 5: Chapter 8.2

Inheritance Hierarchy

Page 6: Chapter 8.2

Definition of GraduateStudent & UndergraduateStudent classes

class GraduateStudent extends Student {

//constructor not shown

public void computeCourseGrade() { int total = 0; total = test1 + test2 + test3; if (total / 3 >= 80) { courseGrade = "Pass"; } else { courseGrade = "No Pass"; } }}

class UndergraduateStudent extends Student {

//Constructor not shown

public void computeCourseGrade() { int total = 0;

total = test1 + test2 + test3;

if (total / 3 >= 70) { courseGrade = "Pass"; } else { courseGrade = "No Pass"; } }

}

Page 7: Chapter 8.2

Declaring a Subclass A subclass inherits data and methods from the

superclass. In the subclass, you can also:Add new dataAdd new methodsOverride the methods of the superclass

○ Modify existing behaviour of parent

Page 8: Chapter 8.2

Overriding vs. Overloading

public class Test { public static void main(String[] args) { A a = new A(); a.p(10); } } class B { public void p(int i) { } } class A extends B { // This method overrides the method in B public void p(int i) { System.out.println(i); } }

public class Test { public static void main(String[] args) { A a = new A(); a.p(10); } } class B { public void p(int i) { } } class A extends B { // This method overloads the method in B public void p(double i) { System.out.println(i); } }

Page 9: Chapter 8.2

Inheritance Rules

1. The private members of the superclass are private to the superclass

2. The subclass can access the members of the superclass according to the accessibility rules

3. The subclass can include additional data and/or method members

Page 10: Chapter 8.2

Inheritance Rules (continued)4. The subclass can override, that is, redefine

the methods of the superclass The overriding method in subclass must have similar

Name Parameter list Return type

5. All members of the superclass are also members of the subclassSimilarly, the methods of the superclass (unless

overridden) are also the methods of the subclassRemember Rule 1 & 2 when accessing a member

of the superclass in the subclass

Page 11: Chapter 8.2

Inheritance Rules (continued)6. (Using the Keyword super)

The keyword super refers to the direct superclass of a subclass . This keyword can be used in two ways:

To call a superclass constructor

super(); //must be the first statement in subclass’s constructor

To call a superclass method super.methodname();

this is only used if the subclass overrides the superclass method

Page 12: Chapter 8.2

The Object Class is the Superclass of Every Java Class

Page 13: Chapter 8.2

INHERITANCE: (Accessibility Modifier) Sometimes , it is called visibility modifier Not all properties can be accessed by sub

class. Super class can control a data accessing

from subclass by giving the type of accessing to the members and methods.

A class can declare the data members or method as a public, private or protected.

If it is not declared, the data or method will be set to default type.

Page 14: Chapter 8.2

INHERITANCE: Member Accessibility

Accessibility criteria

Modifier Same Class Same Package

Subclass Universe

private Yes No No No

default Yes Yes No No

protected Yes Yes Yes No

public Yes Yes Yes Yes

Page 15: Chapter 8.2

INHERITANCE: Data Accessibility

Sub class B

public int bprotected int c

Super class

int apublic int b

protected int cprivate int d

Sub class A

int apublic int b

protected int c

Package B

Package A

Page 16: Chapter 8.2

Refer to the previous slide Super class has 2 subclasses : Subclass A and

Subclass B. Subclass A is defined in same package with

superclass, subclass B is defined outside the package.

There are 4 accessibility data types: public, protected, private and default.

Subclass A can access all properties of superclass except private.

But, subclass B can only access the properties outside the package which are public and protected.

Page 17: Chapter 8.2

Example: Visibility Modifiers

public class C1 { public int x; protected int y; int z; private int u; protected void m() { } }

public class C2 { C1 o = new C1(); can access o.x; can access o.y; can access o.z; cannot access o.u; can invoke o.m(); }

public class C3 extends C1 { can access x; can access y; can access z; cannot access u; can invoke m(); }

package p1;

public class C4 extends C1 { can access x; can access y; cannot access z; cannot access u; can invoke m(); }

package p2;

public class C5 { C1 o = new C1(); can access o.x; cannot access o.y; cannot access o.z; cannot access o.u; cannot invoke o.m(); }

Page 18: Chapter 8.2

What’s wrong with the code?How to fix it?

class ClassX{ private int m; public String toString() { return new String("(" + m + ")"); }}public class ClassY extends ClassX{ private int n; public String toString() { return new String("(" + m + " , " + n + ")"); }}

class TestAccesibility{ public static void main(String [] args) { ClassX x = new ClassX; ClassY y = new ClassY; System.out.println("x = " + x); System.out.println("y = " + y); }}

Page 19: Chapter 8.2

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. The statement super();

calls the superclass’s constructor. super(); must be the first statement in the

subclass contructor.

Page 20: Chapter 8.2

A call to the constructor of the superclass must be in the first statement in the child constructor.

public Box(double l, double w, double h){ super(l,w); height = h;}

Page 21: Chapter 8.2

Rectangle myRectangle = new Rectangle(5, 3);Box myBox = new Box(6, 5, 4);

Page 22: Chapter 8.2

Superclass’s Constructor Is Always Invoked A subclass constructor may invoke its superclass’s

constructor. If none is invoked explicitly, the compiler puts super() as the first statement in the constructor. For example, the constructor of class A:

public A(double d) { // some statements

}

is equivalent to

public A(double d) { super(); // some statements

}

public A() {

}

is equivalent to

public A() { super();

}

Page 23: Chapter 8.2

Example on the Impact of a Superclass without no-arg Constructor Find out the error in the program:

class Fruit { public Fruit(String name) { System.out.println("Fruit constructor is invoked"); }}

public class Apple extends Fruit { public Apple(String name) { System.out.println(“Apple constructor is invoked"); }}