Inheritance (cont.
Vũ Thị Hồng Nhạn
([email protected])
Dept. of software engineering, UET
Vietnam National Univ., Hanoi
Static & dynamic binding
Static vs. dynamic binding
Static binding refers to the execution of a program where type of
object is determined/known at compile time
i.e., when compiler executes the code it knows the type of object (class)
to which object belongs to
In case of dynamic binding, the type of object is determined at run
time
Dynamic binding is slower than static binding
24/10/2023 Inheritance Page 3
Binding
Private, final and static modifiers binds to the class level,
so methods and variables use static binding & bonded by compiler
while the other methods are bonded during runtime based upon
runtime object
In general, overloaded methods are bonded using static binding,
while overridden methods are bonded using dynamic binding
Static binding is better performance wise
Compiler knows that all such methods cannot be overridden and will
always be accessed by objects of local class
24/10/2023 Inheritance Page 4
example static binding
Output:
print in superclass.
print in superclass.
Since the print() method of superclass is static, compiler knows that it will not be
overridden in subclasses
compiler knows during compile time which print() method to call and hence no
ambiguity
24/10/2023 Interface - multiple inheritance Page 5
Example dynamic binding
• Methods are not static
• During compilation, the compiler
has no idea as to which print()
has to be called since compiler
goes only by referencing variable
not by type of object
the binding would be delayed
to runtime and therefore the
corresponding version of print()
will be called based on type on
Output: object.
print in superclass.
print in subclass.
24/10/2023 Interface - multiple inheritance Page 6
Remarks
Cannot override static methods in java
In a static context, cannot access a non-static variable
i.e., in a static method, can access only to static variables because non-
static variables depend on the existence of an instance of a class.
Same for static class (nested static class)
Final method: cannot be overridden
Final class: cannot be inherited
24/10/2023 Interface - multiple inheritance Page 7
Abstract classes in Java
Abstract class & method
Goal: hiding the internal implementation of the features and
only showing the functionality to the users
There are some related classes that need to share some lines of
code, so these lines of codes can be put within abstract class
this abstract class should be extended by all these related classes
can include abstract method
But, abstract method must be overridden in the inherited classes
24/10/2023 Inheritance Page 9
Cannot create an object of an abstract class
abstract class Shape {
protected int x, y;
Shape(int x1, int y1) {
x = x1; y = y1;
}
}
class Circle extends Shape
{ ...
}
Shape s = new Shape(10, 10) // compile error
Shape s = new Circle();
24/10/2023 Inheritance Page 10
Constructor of abstract class is called
when creating an object of inherited class
abstract class MyBase {
MyBase() { System.out.println(“MyBaseClass Constructor called"); }
abstract void fun();
}
class DerivedClass extends MyBase {
DerivedClass(int x) { System.out.println("DerivedClass Constructor called"); }
void fun() { System.out.println("DerivedClass fun() called"); }
}
class Main {
public static void main(String args[]) {
DerivedClass d = new DerivedClass(3);
Output:
} Output???
} MyBaseClass Constructor called
DerivedClass Constructor called
24/10/2023 Inheritance Page 11
Example
import java.io.*;
abstract class Shape {
String objectName = " ";
Shape(String name) {
this.objectName = name;
}
public void moveTo(int x, int y) {
System.out.println(this.objectName + " " + "has been moved to"
+ " x = " + x + " and y = " + y);
}
// abstract methods which will be
// implemented by its subclass(es)
abstract public double area();
abstract public void draw();
}
24/10/2023 Inheritance Page 12
Example…
class Rectangle extends Shape{
int length, width;
// constructor
Rectangle(int length, int width, String name) {
super(name);
this.length = length;
this.width = width;
}
@Override
public void draw() {
System.out.println("Rectangle has been drawn ");
}
@Override
public double area() {
return (double)(length*width);
}
}
24/10/2023 Inheritance Page 13
Example…
class Circle extends Shape {
double pi = 3.14; int radius;
//constructor
Circle(int radius, String name) {
super(name);
this.radius = radius;
}
@Override
public void draw() {
System.out.println("Circle has been drawn "); }
@Override
public double area() {
return (double)((pi*radius*radius)/2); }
}
24/10/2023 Inheritance Page 14
Example…
class MAIN{
public static void main (String[] args) {
// creating the Object of Rectangle class
// and using shape class reference.
Shape rect = new Rectangle(2,3, "Rectangle");
System.out.println("Area of rectangle: " + rect.area());
rect.moveTo(1,2);
System.out.println(" ");
// creating the Objects of circle class
Shape circle = new Circle(2, "Cicle");
System.out.println("Area of circle: " + circle.area());
circle.moveTo(2,4);
}
}
24/10/2023 Inheritance Page 15
