Inheritance in Java
CS 3331
Fall 2009
1
Outline
Overloading
Inheritance and object initialization
Subtyping
Overriding
Hiding
2
Overloading of Methods and
Constructors
Def. Overloading
The ability to allow different methods or constructors
of a class to share the same name.
constructor
public class Point { overloading
public Point() { /* … */ }
public Point(int x, int y) { /* … */ }
public double distance(Point other) { /* … */ }
public double distance(int x, int y) { /* … */ }
public double distance() { /* … */ }
// …
} method
overloading
3
Overloading (Cont.)
Which overloaded method to invoke?
Resolved at compile-time with signature matching,
where signature is name and parameter types.
Constructors/Methods Signatures
1: Point() Point()
2: Point(int x,int y) Point(int,int)
3: double distance(Point other) distance(Point)
4: double distance(int x,int y) distance(int,int)
5: double distance() distance()
Point p1 = new Point(); // which constructor?
Point p2 = new Point(10,20);
p2.distance(p1); // which method?
p2.distance(20,30);
p2.distance();
4
When to Overload?
When there is a general, nondiscriminative description of the
functionality that fits all the overloaded methods.
public class StringBuffer {
public StringBuffer append(String str) { /* … */ }
public StringBuffer append(boolean b) { /* … */ }
public StringBuffer append(char c) { /* … */ }
public StringBuffer append(int i) { /* … */ }
public StringBuffer append(long l) { /* … */ }
// …
}
5
When to Overload? (Cont.)
When all the overloaded methods offer the same functionality,
with some of them providing default arguments.
public class String {
public String substring(int i, int j) {
// base method: return substring from index i to j - 1.
}
public String substring(int i) {
// provide default argument
return substring(i, length());
}
// …
}
6
Outline
Overloading
Inheritance and object initialization
Subtyping
Overriding
Hiding
7
Inheritance
Inheritance models the is-a relationship.
If class S extends class T, then all objects of S
can act-like an object of T.
Only single inheritance is allowed among
classes.
All public and protected members of a
superclass are accessible in the subclasses.*
*All protected members are also accessible within the package.
8
Constructors of Subclasses
Can invoke a constructor of the direct
superclass.
super(…) must be the first statement.
If the super constructor call is missing, by
default the no-arg super() is invoked
implicitly.
Can also invoke another constructor of
the same class.
this(…) must be the first statement.
9
Example of “this” Calls
public class Point {
private int x, y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
public Point() { // default constructor
this.x = 0;
this(0,0);
this.y = 0;
}
}
10
Example of “super” Calls
public class ColoredPoint extends Point {
Point
private Color color;
-x: int
public ColoredPoint(int x, int y, Color color) { -y: int
this.x = x; +Point()
super(x,y);
this.y = y; +Point(x: int, y: int)
this.color = color;
}
public ColoredPoint(int x, int y) {
this(x, y, Color.BLACK); // point with default value
}
public ColoredPoint() {
color = Color.BLACK; // what will be the values of x and y?
}
}
11
Default Constructor
If no constructor is defined, the following form of
no-arg default constructor is automatically
generated by the compiler.
public ClassName() {
super();
}
Q. What would be the use of default constructor?
12
Execution Order of Constructors
Rule: Superclass first and field initialization first
- Instance variable initializer vs.
instance initializer (or initialization block)
Example: S x = new S();
public class S extends T { public class T {
int y = 30; // 3: third int x = 10; // 1: first
public S() { public T() {
super(); x = 20; // 2: second
y = 40; // 4: fourth }
} // ...
// ... }
}
13
Exercise
What value will be printed and why?
class Super {
protected int x = 100;
}
class Sub extends Super {
{ x = 200; }
public static void main(String[] args) {
System.out.println(new Sub().x);
}
}
14
Exercise
What are the room number and capacity of the following
two objects, respectively?
ClassRoom c1 = new ClassRom(100);
ClassRoom c2 = new ClassRoom(300, 100);
class ClassRoom extends Room { class Room {
private int capacity = 60; private int number = 100;
public ClassRoom(int c) { public Room() {
capacity = c; this(++nextNum);
} }
public ClassRoom(int n, int c) { public Room(int n) {
super(n); number = n;
} }
{ if (number % 2 == 1) private static int nextNum = 100;
capacity *= 2; static { nextNum += 100; }
} { number += 2; }
} }
15
Outline
Overloading
Inheritance
Subtyping
Overriding
Hiding
16
Types
What’re types?
Sets of values
Why types?
To statically detect program errors, called type errors.
Typed- vs. untyped-languages (also, static vs. dynamic
typing)
Types in Java
Primitive types (e.g., boolean, int, long, etc.)
Classes (e.g., Object, String, etc.)
Interfaces (e.g., Runnable, List, etc.)
Array types (e.g., int[], Object[], List[][], etc.)
17
Subtyping
What’s subtyping?
Subset relationship among types (e.g., Manager is a
subtype (or subset) of Employee)
Subtype’s values are legitimate values of supertypes.
Why subtyping?
Can organizes types into hierarchy, called subype hierarchy
Can extend programs by adding subtypes
Subtyping in Java
Between classes (subclassing)
Between interfaces (subinterfacing)
Between classes and interfaces (implementation or
realization)
Between arrays
18
Substitution Property
Def. Substitution property
A value of subtype can appear where a value of its
supertype is expected, e.g., in arguments, results, receivers,
and assignments.
// 1. argument
// public void register(Student s);
register(new PhDStudent(“Joe”));
// 2. return value
public Student find(String name) {
// I am lazy, so I am going to return Joe every time.
return new PhDStudent(“Joe”);
}
// 3. receiver of method call
// toString in the class Object
new PhDStudent(“Joe”).toString();
19
Substitution Property (Cont.)
Rules of (polymorphic) assignment
The type of expression at the right-hand side of an
assignment must be a subtype of the type of the variable at
the left-hand side of the assignment.
class Student { … }
class Undergraduate extends Student { … }
class Graduate extends Student { … }
Student s1, s2;
s1 = new Undergradute(); // polymorphic assignment
s2 = new Graudate(); // polymorphic assignment
Graduate s3 = s2; // is this OK?
Graduate s3 = (Graduate) s2; // explicit casting
20
Widening and Narrowing
Def. widening and narrowing
The conversion of a subtype to one of its supertype is called
widening, and the conversion of a supertype to one of its
subtype is called narrowing (or downcasting).
// s is a stack of strings
Stack s = new Stack();
s.push(“Hello”); // widening: void push(Object)
…
// Stack defines a method top, i.e., “public Object top()”.
s.top().size(); // okay?
((String) s.top()).size(); // downcasting
21
Outline
Overloading
Inheritance
Subtyping
Overriding
Hiding
22
Overriding Methods
Def. Overriding
Refers to the introduction of an instance
method in a subclass that has the same
name, signature, and return type of a method
declared in the superclass.
Consequences
Implementation of the method in the
subclass replaces the implementation of the
method in the superclass
23
Overriding Methods (Cont.)
public class T {
public void m() { … }
}
public class S extends T {
public void m() { … }
}
T t = new T();
S s = new S();
t.m(); // invoke m of class T
s.m(); // invoke m of class S
24
Overriding Methods (Cont.)
Dynamic dispatch (binding): The method to be invoked is
determined at runtime by the runtime type of the object,
not by the declared type (static type).
class Student {
public int minCredits() { return 12; }
…
}
class GraduateStudent extends Student {
public int minCredits() { return 9; }
…
}
Student s;
// …
s.minCredits(); // which minCredits method?
25
Overriding Methods (Cont.)
Q. How overriding differ from overloading?
26
Implementation of Dynamic Binding
Storage structure of instance variables
Class instance records (CIRs) store the state of an
object
The CIR for a subclass adds its new fields to the
parent CIR.
Dynamic bindings of messages to methods
Virtual Method Tables (VMTs) are used for dynamic
binding.
27
Dynamic Binding (Cont.)
class Point {
CIR for Point
private int x, y;
public Point(int x, int y) { this.x = x; this.y = y; } x
public int getX() { return x; } y
public int getY() { return y; } …
}
class ColoredPoint extends Point {
private Color color; CIR for ColoredPoint
public ColoredPoint(int x, int y, Color c) { x
super(x, y); y
color = c; color
} …
public Color getColor() { return color; }
}
28
Dynamic Binding (Cont.)
Object.class
ColoredPoint p
= new ColoredPoint(10,20,Color.RED); super:
p.getColor(); vmt:
p.getX(); …
Point.class
super:
vmt:
getX:
…
p: class: getY:
x: 10 …
y: 20
color: ColoredPoint.class
super:
vmt: getColor:
… …
Color.RED
Q: What if getX is overridden in ColoredPoint?
29
Outline
Overloading
Inheritance
Subtyping
Overriding
Hiding
30
Hiding Fields and Class
Methods
Def. Hiding
Refers to the introduction of a field (instance
or class) or a class method in a subclass that
has the same name as a field or class
method declared in the superclass.
Hiding vs. overriding
Statically resolved (bound) at compile-time vs.
dynamically dispatched at run-time
31
Example
class Student {
protected String description = “Student”;
public String getDescription() {
return description; hiding of
} field
}
class Undergraduate extends Student {
protected String description = “Undergraduate”;
}
new Student().getDecription(); // what value is returned?
new Undergraduate().getDescription(); // what value?
Q. How to refer to hidden fields?
32