Week-2 (OOP with Java -II)

CEN206 Object-Oriented Programming¶

Week-2 (Inheritance, Polymorphism and Advanced Class Structures)¶

Spring Semester, 2025-2026¶

Download DOC-DOCX, SLIDE

Module A: Java Inheritance¶

Module Outline¶

• Organizing Classes into Inheritance Hierarchies
• The Is-a Rule and Design Principles
• Java Inheritance Syntax and Basics
• Single, Multi-level, Hierarchical, and Hybrid Inheritance

Organizing Classes into Inheritance Hierarchies¶

• Superclasses
• Contain features common to a set of subclasses
• Inheritance hierarchies
• Show the relationships among superclasses and subclasses
• A triangle shows a generalization
• Inheritance
• The implicit possession by all subclasses of features defined in its superclasses

An Example Inheritance Hierarchy¶

• Inheritance
• The implicit possession by all subclasses of features defined in its superclasses

The Is-a Rule¶

• Always check generalizations to ensure they obey the isa rule
• "A checking account is an account"
• "A village is a municipality"
• Should 'Province' be a subclass of 'Country'?
• No, it violates the is-a rule
• "A province is a country" is invalid!

A possible inheritance hierarchy of mathematical objects¶

Make Sure all Inherited Features Make Sense in Subclasses¶

Inheritance, Polymorphism and Variables¶

Some Operations in the Shape Example¶

Java Inheritance¶

Inheritance Concept¶

• The inheritance is a very useful and powerful concept of object-oriented programming.
• In java, using the inheritance concept, we can use the existing features of one class in another class. - The inheritance provides a great advantage called code re-usability.
• With the help of code re-usability, the commonly used code in an application need not be written again and again.

Inheritance Concept¶

Inheritance Concept¶

The inheritance is the process of acquiring the properties of one class to another class.

Inheritance Basics¶

• In inheritance, we use the terms like
• parent class,
• child class,
• base class,
• derived class,
• superclass, and
• subclass.

Inheritance Basics¶

• The Parent class is the class which provides features to another class.

• The parent class is also known as Base class or Superclass.

• The Child class is the class which receives features from another class.

• The child class is also known as the Derived Class or Subclass.

Inheritance Basics¶

• In the inheritance,
• the child class acquires the features from its parent class.
• But the parent class never acquires the features from its child class.

Inheritance Basics¶

There are five types of inheritances, and they are as follows.

• Simple Inheritance (or) Single Inheritance
• Multiple Inheritance
• Multi-Level Inheritance
• Hierarchical Inheritance
• Hybrid Inheritance

Inheritance Basics¶

• Simple Inheritance (or) Single Inheritance

Inheritance Basics¶

• Multiple Inheritance

Inheritance Basics¶

• Multi-Level Inheritance

Inheritance Basics¶

• Hierarchical Inheritance

Inheritance Basics¶

• Hybrid Inheritance

Inheritance Basics¶

• The java programming language does not support multiple inheritance type.
• However, it provides an alternate with the concept of interfaces.

Creating Child Class in java¶

• In java, we use the keyword extends to create a child class.
• The following syntax used to create a child class in java.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

  class <ChildClassName> extends <ParentClassName>{
    ...
    //Implementation of child class
    ...
  }
  ```

  - In a java programming language, a class extends only one class. 
    - Extending multiple classes is not allowed in java.

---

### Single Inheritance in Java Example-1
- In this type of inheritance, one child class derives from one parent class. 

``` Java linenums="1"
class ParentClass{
    int a;
    void setData(int a) {
        this.a = a;
    }
}

1
2
3
4
5

class ChildClass extends ParentClass{
    void showData() {
        System.out.println("Value of a is " + a);
    }
}

Single Inheritance in Java Example-1¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class SingleInheritance {

    public static void main(String[] args) {

        ChildClass obj = new ChildClass();
        obj.setData(100);
        obj.showData();

    }
}

Single Inheritance in Java Example-2¶

1
2
3
4
5
6
7
8

class Animal {

  // field and method of the parent class
  String name;
  public void eat() {
    System.out.println("I can eat");
  }
}

1
2
3
4
5
6
7
8

// inherit from Animal
class Dog extends Animal {

  // new method in subclass
  public void display() {
    System.out.println("My name is " + name);
  }
}

Single Inheritance in Java Example-2¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class Main {
  public static void main(String[] args) {
    // create an object of the subclass
    Dog labrador = new Dog();
    // access field of superclass
    labrador.name = "Rohu";
    labrador.display();
    // call method of superclass
    // using object of subclass
    labrador.eat();
  }
}

Single Inheritance in Java Example-2¶

Single Inheritance / is-a relationship¶

• In Java, inheritance is an is-a relationship. That is, we use inheritance only if there exists an is-a relationship between two classes. For example,
• Car is a Vehicle
• Orange is a Fruit
• Surgeon is a Doctor
• Dog is an Animal
  • Here, Car can inherit from Vehicle, Orange can inherit from Fruit, and so on.

Multi-level Inheritance in java¶

• In this type of inheritance, the child class derives from a class which already derived from another class

1
2
3
4
5
6

class ParentClass{
    int a;
    void setData(int a) {
        this.a = a;
    }
}

Multi-level Inheritance in java¶

1
2
3
4
5

class ChildClass extends ParentClass{
    void showData() {
        System.out.println("Value of a is " + a);
    }
}

1
2
3
4
5

class ChildChildClass extends ChildClass{
    void display() {
        System.out.println("Inside ChildChildClass!");
    }
}

Multi-level Inheritance in java¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class MultipleInheritance {

    public static void main(String[] args) {

        ChildChildClass obj = new ChildChildClass();
        obj.setData(100);
        obj.showData();
        obj.display();

    }
}

Hierarchical Inheritance in java¶

• In this type of inheritance, two or more child classes derive from one parent class.

1
2
3
4
5
6

class ParentClass{
    int a;
    void setData(int a) {
        this.a = a;
    }
}

Hierarchical Inheritance in java¶

1
2
3
4
5
6

class ChildClass extends ParentClass{
    void showData() {
        System.out.println("Inside ChildClass!");
        System.out.println("Value of a is " + a);
    }
}

1
2
3
4
5
6

class ChildClassToo extends ParentClass{
    void display() {
        System.out.println("Inside ChildClassToo!");
        System.out.println("Value of a is " + a);
    }
}

Hierarchical Inheritance in java¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class HierarchicalInheritance {
    public static void main(String[] args) {
        ChildClass child_obj = new ChildClass();
        child_obj.setData(100);
        child_obj.showData();

        ChildClassToo childToo_obj = new ChildClassToo();
        childToo_obj.setData(200);
        childToo_obj.display();
    }
}

Hybrid Inheritance in java¶

• The hybrid inheritance is the combination of more than one type of inheritance.
• We may use any combination as a
  • single with multiple inheritances,
  • multi-level with multiple inheritances, etc.,

Takeaway: Java Inheritance¶

• Inheritance enables code reuse through parent-child class relationships
• The Is-a Rule: use inheritance only when "A Dog is-a Animal" makes sense
• Java supports single, multi-level, and hierarchical inheritance
• 'extends' keyword creates the inheritance relationship
• All inherited features must make sense in subclasses - design carefully

Module B: Constructors in Inheritance¶

Module Outline¶

• Constructor Chain in Inheritance
• super() for Parent Constructor Calls
• Method Overriding in Inheritance Context

Java Constructors in Inheritance¶

Java Constructors in Inheritance¶

• It is very important to understand how the constructors get executed in the inheritance concept.
• In the inheritance, the constructors never get inherited to any child class.
• In java, the default constructor of a parent class called automatically by the constructor of its child class.
• That means when we create an object of the child class,
• the parent class constructor executed, followed by the child class constructor executed.

Java Constructors in Inheritance - Example¶

1
2
3
4
5
6

class ParentClass{
    int a;
    ParentClass(){
        System.out.println("Inside ParentClass constructor!");
    }
}

1
2
3
4
5
6

class ChildClass extends ParentClass{

    ChildClass(){
        System.out.println("Inside ChildClass constructor!!");      
    }
}

Java Constructors in Inheritance - Example¶

1
2
3
4
5
6

class ChildChildClass extends ChildClass{

    ChildChildClass(){
        System.out.println("Inside ChildChildClass constructor!!");     
    }   
}

1
2
3
4
5
6
7

public class ConstructorInInheritance {

    public static void main(String[] args) {

        ChildChildClass obj = new ChildChildClass();
    }
}

Java Constructors in Inheritance¶

• if the parent class contains both default and parameterized constructor,
• then only the default constructor called automatically
  • by the child class constructor

Java Constructors in Inheritance - Example¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class ParentClass{
    int a;
    ParentClass(int a){
        System.out.println("Inside ParentClass parameterized constructor!");
        this.a = a;
    }
    ParentClass(){
        System.out.println("Inside ParentClass default constructor!");
    }
}

Java Constructors in Inheritance - Example¶

1
2
3
4
5

class ChildClass extends ParentClass{
    ChildClass(){
        System.out.println("Inside ChildClass constructor!!");      
    }
}

1
2
3
4
5

public class ConstructorInInheritance {
    public static void main(String[] args) {
        ChildClass obj = new ChildClass();
    }
}

Java Constructors in Inheritance¶

• The parameterized constructor of parent class must be called explicitly using the super keyword.

Method Overriding in Java Inheritance¶

1
2
3
4
5
6
7

class Animal {

  // method in the superclass
  public void eat() {
    System.out.println("I can eat");
  }
}

Method Overriding in Java Inheritance¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// Dog inherits Animal
class Dog extends Animal {

  // overriding the eat() method
  @Override
  public void eat() {
    System.out.println("I eat dog food");
  }

  // new method in subclass
  public void bark() {
    System.out.println("I can bark");
  }
}

Method Overriding in Java Inheritance¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

class Main {
  public static void main(String[] args) {

    // create an object of the subclass
    Dog labrador = new Dog();

    // call the eat() method
    labrador.eat();
    labrador.bark();
  }
}

Method Overriding in Java Inheritance¶

• In the above example, the eat() method is present in both the superclass Animal and the subclass Dog.
• Here, we have created an object labrador of Dog.
• Now when we call eat() using the object labrador, the method inside Dog is called. This is because the method inside the derived class overrides the method inside the base class.

Takeaway: Constructors in Inheritance¶

• Parent class constructor runs before child class constructor
• Use super() to explicitly call a specific parent constructor
• If no explicit super() call, Java calls the parent's no-arg constructor automatically
• Method overriding allows child classes to provide specific implementations
• Constructor chaining ensures proper initialization of the entire hierarchy

Module C: Java super Keyword - Comprehensive¶

Module Outline¶

• What is the super keyword?
• super to Access Parent Data Members
• super to Call Parent Methods
• super() to Call Parent Constructor
• Accessing Overridden Methods via super
• Complete Examples (5 detailed examples)

super Keyword in Java Inheritance¶

super Keyword in Java Inheritance¶

• the same method in the subclass overrides the method in superclass.

• In such a situation, the super keyword is used to call the method of the parent class from the method of the child class.

super Keyword in Java Inheritance¶

1
2
3
4
5
6
7

class Animal {

  // method in the superclass
  public void eat() {
    System.out.println("I can eat");
  }
}

super Keyword in Java Inheritance¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// Dog inherits Animal
class Dog extends Animal {

  // overriding the eat() method
  @Override
  public void eat() {

    // call method of superclass
    super.eat();
    System.out.println("I eat dog food");
  }

  // new method in subclass
  public void bark() {
    System.out.println("I can bark");
  }
}

super Keyword in Java Inheritance¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

class Main {
  public static void main(String[] args) {

    // create an object of the subclass
    Dog labrador = new Dog();

    // call the eat() method
    labrador.eat();
    labrador.bark();
  }
}

Java super keyword¶

Java super keyword¶

• In java, super is a keyword used to refers to the parent class object.
• The super keyword came into existence to solve the naming conflicts in the inheritance.
• When both parent class and child class have members with the same name,
• then the super keyword is used to refer to the parent class version.

Java super keyword¶

• In another word, The super keyword in Java is used in subclasses to access superclass members (attributes, constructors and methods).

Java super keyword¶

• In java, the super keyword is used for the following purposes.
• To refer parent class data members
• To refer parent class methods
• To call parent class constructor

Java super keyword¶

• To call methods of the superclass that is overridden in the subclass.
• To access attributes (fields) of the superclass if both superclass and subclass have attributes with the same name.
• To explicitly call superclass no-arg (default) or parameterized constructor from the subclass constructor.

Java super keyword¶

• The super keyword is used inside the child class only.

super to refer parent class data members¶

• When both parent class and child class have data members with the same name,
• then the super keyword is used to refer to the parent class data member from child class.

super to refer parent class data members¶

1
2
3
4
5

class ParentClass{

    int num = 10;

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class ChildClass extends ParentClass{

    int num = 20;

    void showData() {
        System.out.println("Inside the ChildClass");
        System.out.println("ChildClass num = " + num);
        System.out.println("ParentClass num = " + super.num);       
    }
}

super to refer parent class data members¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public class SuperKeywordExample {

    public static void main(String[] args) {
        ChildClass obj = new ChildClass();

        obj.showData();

        System.out.println("\nInside the non-child class");
        System.out.println("ChildClass num = " + obj.num);
        //System.out.println("ParentClass num = " + super.num); //super can't be used here
    }
}

super to refer parent class method¶

• When both parent class and child class have method with the same name,
• then the super keyword is used to refer to the parent class method from child class.

super to refer parent class method¶

class ParentClass{

    int num1 = 10;

    void showData() {
        System.out.println("\nInside the ParentClass showData method");
        System.out.println("ChildClass num = " + num1);     
    }   
}

super to refer parent class method¶

class ChildClass extends ParentClass{

    int num2 = 20;

    void showData() {
        System.out.println("\nInside the ChildClass showData method");
        System.out.println("ChildClass num = " + num2); 

        super.showData();

    }
}

super to refer parent class method¶

public class SuperKeywordExample {

    public static void main(String[] args) {
        ChildClass obj = new ChildClass();

        obj.showData();
        //super.showData(); // super can't be used here

    }
}

super to call parent class constructor¶

• When an object of child class is created, it automatically calls the parent class default-constructor before it's own.
• But, the parameterized constructor of parent class must be called explicitly using the super keyword inside the child class constructor.

super to call parent class constructor¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

class ParentClass{

    int num1;

    ParentClass(){
        System.out.println("\nInside the ParentClass default constructor");
        num1 = 10;
    }

    ParentClass(int value){
        System.out.println("\nInside the ParentClass parameterized constructor");
        num1 = value;
    }   
}

super to call parent class constructor¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class ChildClass extends ParentClass{

    int num2;

    ChildClass(){
        super(100);
        System.out.println("\nInside the ChildClass constructor");
        num2 = 200;     
    }
}

super to call parent class constructor¶

1
2
3
4
5
6
7
8

public class SuperKeywordExample {

    public static void main(String[] args) {

        ChildClass obj = new ChildClass();

    }
}

super to call parent class constructor¶

• To call the parameterized constructor of the parent class,
• the super keyword must be the first statement inside the child class constructor,
• and we must pass the parameter values.

Access Overridden Methods of the superclass¶

• If methods with the same name are defined in both superclass and subclass, the method in the subclass overrides the method in the superclass. This is called method overriding.

Example 1: Method overriding¶

1
2
3
4
5
6
7

class Animal {

  // overridden method
  public void display(){
    System.out.println("I am an animal");
  }
}

Example 1: Method overriding¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class Dog extends Animal {

  // overriding method
  @Override
  public void display(){
    System.out.println("I am a dog");
  }

  public void printMessage(){
    display();
  }
}

Example 1: Method overriding¶

1
2
3
4
5
6

class Main {
  public static void main(String[] args) {
    Dog dog1 = new Dog();
    dog1.printMessage();
  }
}

Example 1: Method overriding¶

In this example, by making an object dog1 of Dog class, we can call its method printMessage() which then executes the display() statement.

Since display() is defined in both the classes, the method of subclass Dog overrides the method of superclass Animal. Hence, the display() of the subclass is called.

Example 1: Method overriding¶

What if the overridden method of the superclass has to be called?¶

• We use super.display() if the overridden method display() of superclass Animal needs to be called.

Example 2: super to Call Superclass Method¶

1
2
3
4
5
6
7

class Animal {

  // overridden method
  public void display(){
    System.out.println("I am an animal");
  }
}

Example 2: super to Call Superclass Method¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

class Dog extends Animal {

  // overriding method
  @Override
  public void display(){
    System.out.println("I am a dog");
  }

  public void printMessage(){

    // this calls overriding method
    display();

    // this calls overridden method
    super.display();
  }
}

Example 2: super to Call Superclass Method¶

1
2
3
4
5
6

class Main {
  public static void main(String[] args) {
    Dog dog1 = new Dog();
    dog1.printMessage();
  }
}

Example 2: super to Call Superclass Method¶

Access Attributes of the Superclass¶

• The superclass and subclass can have attributes with the same name.
• We use the super keyword to access the attribute of the superclass.

Example 3: Access superclass attribute¶

1
2
3

class Animal {
  protected String type="animal";
}

1
2
3
4
5
6
7
8

class Dog extends Animal {
  public String type="mammal";

  public void printType() {
    System.out.println("I am a " + type);
    System.out.println("I am an " + super.type);
  }
}

Example 3: Access superclass attribute¶

1
2
3
4
5
6

class Main {
  public static void main(String[] args) {
    Dog dog1 = new Dog();
    dog1.printType();
  }
}

Example 3: Access superclass attribute¶

• In this example, we have defined the same instance field type in both the superclass Animal and the subclass Dog.
• We then created an object dog1 of the Dog class. Then, the printType() method is called using this object.
• Inside the printType() function,
  • type refers to the attribute of the subclass Dog.
  • super.type refers to the attribute of the superclass Animal.

Use of super() to access superclass constructor¶

• As we know, when an object of a class is created, its default constructor is automatically called.
• To explicitly call the superclass constructor from the subclass constructor, we use super(). It's a special form of the super keyword.
• super() can be used only inside the subclass constructor and must be the first statement.

Example 4: Use of super()¶

1
2
3
4
5
6
7

class Animal {

  // default or no-arg constructor of class Animal
  Animal() {
    System.out.println("I am an animal");
  }
}

Example 4: Use of super()¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

class Dog extends Animal {

  // default or no-arg constructor of class Dog
  Dog() {

    // calling default constructor of the superclass
    super();

    System.out.println("I am a dog");
  }
}

Example 4: Use of super()¶

1
2
3
4
5

class Main {
  public static void main(String[] args) {
    Dog dog1 = new Dog();
  }
}

Example 4: Use of super()¶

• when an object dog1 of Dog class is created, it automatically calls the default or no-arg constructor of that class.

• Inside the subclass constructor, the super() statement calls the constructor of the superclass and executes the statements inside it. Hence, we get the output I am an animal.

Example 4: Use of super()¶

The flow of the program then returns back to the subclass constructor and executes the remaining statements. Thus, I am a dog will be printed.

However, using super() is not compulsory. Even if super() is not used in the subclass constructor, the compiler implicitly calls the default constructor of the superclass.

Example 4: Use of super()¶

• So, why use redundant code if the compiler automatically invokes super()?

• It is required if the parameterized constructor (a constructor that takes arguments) of the superclass has to be called from the subclass constructor.

• The parameterized super() must always be the first statement

• in the body of the constructor of the subclass,
• otherwise, we get a compilation error.

Example 5: Call Parameterized Constructor Using super()¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class Animal {

  // default or no-arg constructor
  Animal() {
    System.out.println("I am an animal");
  }

  // parameterized constructor
  Animal(String type) {
    System.out.println("Type: "+type);
  }
}

Example 5: Call Parameterized Constructor Using super()¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

class Dog extends Animal {

  // default constructor
  Dog() {

    // calling parameterized constructor of the superclass
    super("Animal");

    System.out.println("I am a dog");
  }
}

Example 5: Call Parameterized Constructor Using super()¶

1
2
3
4
5

class Main {
  public static void main(String[] args) {
    Dog dog1 = new Dog();
  }
}

Example 5: Call Parameterized Constructor Using super()¶

If a parameterized constructor has to be called, we need to explicitly define it in the subclass constructor.

Example 5: Call Parameterized Constructor Using super()¶

Note that in the above example, we explicitly called the parameterized constructor super("Animal"). The compiler does not call the default constructor of the superclass in this case.

Takeaway: Java super Keyword¶

• super refers to the parent (superclass) object
• Three main uses: access parent data members, call parent methods, invoke parent constructor
• super.fieldName accesses parent's field when child has same-named field
• super.methodName() calls parent's method - useful for extending (not replacing) behavior
• super() must be the first statement in a constructor if used

Module D: Java this Keyword and instanceof Operator¶

Module Outline¶

• Java this Keyword: Resolving Ambiguity
• this with Getters and Setters
• this in Constructor Overloading
• Passing this as an Argument
• Java instanceof Operator
• instanceof with Inheritance and Interfaces

Java this Keyword¶

Java this Keyword¶

• In Java, this keyword is used to refer to
• the current object
  • inside a
  • method or a
  • constructor

Java this Keyword¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

class Main {
    int instVar;

    Main(int instVar){
        this.instVar = instVar;
        System.out.println("this reference = " + this);
    }

    public static void main(String[] args) {
        Main obj = new Main(8);
        System.out.println("object reference = " + obj);
    }
}

Using this for Ambiguity Variable Names¶

• In Java, it is not allowed to declare two or more variables having the same name inside a scope (class scope or method scope).
• However, instance variables and parameters may have the same name.

Using this for Ambiguity Variable Names¶

WRONG

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class Main {

    int age;
    Main(int age){
        age = age;
    }

    public static void main(String[] args) {
        Main obj = new Main(8);
        System.out.println("obj.age = " + obj.age);
    }
}

Using this for Ambiguity Variable Names¶

CORRECT

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class Main {

    int age;
    Main(int age){
        this.age = age;
    }

    public static void main(String[] args) {
        Main obj = new Main(8);
        System.out.println("obj.age = " + obj.age);
    }
}

this with Getters and Setters¶

• Another common use of this keyword is in setters and getters methods of a class

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

class Main {
   String name;

   // setter method
   void setName( String name ) {
       this.name = name;
   }

   // getter method
   String getName(){
       return this.name;
   }
   ...

this with Getters and Setters¶

1
2
3
4
5
6
7
8
9

...
   public static void main( String[] args ) {
       Main obj = new Main();

       // calling the setter and the getter method
       obj.setName("Toshiba");
       System.out.println("obj.name: "+obj.getName());
   }
}

Using this in Constructor Overloading¶

• While working with constructor overloading,
• we might have to invoke one constructor from another constructor.
• In such a case,
• we cannot call the constructor explicitly. Instead,
• we have to use this keyword.

Using this in Constructor Overloading¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

class Complex {

    private int a, b;

    // constructor with 2 parameters
    private Complex( int i, int j ){
        this.a = i;
        this.b = j;
    }

    // constructor with single parameter
    private Complex(int i){
        // invokes the constructor with 2 parameters
        this(i, i); 
    }

    // constructor with no parameter
    private Complex(){
        // invokes the constructor with single parameter
        this(0);
    }
    ...

Using this in Constructor Overloading¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

    @Override
    public String toString(){
        return this.a + " + " + this.b + "i";
    }

    public static void main( String[] args ) {

        // creating object of Complex class
        // calls the constructor with 2 parameters
        Complex c1 = new Complex(2, 3); 

        // calls the constructor with a single parameter
        Complex c2 = new Complex(3);

        // calls the constructor with no parameters
        Complex c3 = new Complex();

        // print objects
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
    }
}

Using this in Constructor Overloading¶

• In the example, we have used this keyword,
• to call the constructor Complex(int i, int j) from the constructor Complex(int i)
• to call the constructor Complex(int i) from the constructor Complex()
• the line, System.out.println(c1); process, the toString() is called Since we override the toString() method inside our class, we get the output according to that method.

Using this in Constructor Overloading¶

• One of the huge advantages of this() is to reduce the amount of duplicate code. However, we should be always careful while using this().

• This is because calling constructor from another constructor adds overhead and it is a slow process. Another huge advantage of using this() is to reduce the amount of duplicate code.

Using this in Constructor Overloading¶

• Invoking one constructor from another constructor is called explicit constructor invocation.

Passing this as an Argument¶

• We can use this keyword to pass the current object as an argument to a method

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

class ThisExample {
    // declare variables
    int x;
    int y;

    ThisExample(int x, int y) {
       // assign values of variables inside constructor
        this.x = x;
        this.y = y;

        // value of x and y before calling add()
        System.out.println("Before passing this to addTwo() method:");
        System.out.println("x = " + this.x + ", y = " + this.y);

        // call the add() method passing this as argument
        add(this);

        // value of x and y after calling add()
        System.out.println("After passing this to addTwo() method:");
        System.out.println("x = " + this.x + ", y = " + this.y);
    }

    void add(ThisExample o){
        o.x += 2;
        o.y += 2;
    }
}

Passing this as an Argument¶

1
2
3
4
5

class Main {
    public static void main( String[] args ) {
        ThisExample obj = new ThisExample(1, -2);
    }
}

Passing this as an Argument¶

• In the example, inside the constructor ThisExample(), notice the line, add(this);
• Here, we are calling the add() method by passing this as an argument.
• Since this keyword contains the reference to the object obj of the class,
• we can change the value of x and y inside the add() method.

Java instanceof Operator¶

Java instanceof Operator¶

• The instanceof operator in Java is used to
• check whether an object is an instance of
  • a particular class or not.
• Its syntax is

objectName instanceOf className;

Example: Java instanceof¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

class Main {

  public static void main(String[] args) {

    // create a variable of string type
    String name = "My App";

    // checks if name is instance of String
    boolean result1 = name instanceof String;
    System.out.println("name is an instance of String: " + result1);

    // create an object of Main
    Main obj = new Main();

    // checks if obj is an instance of Main
    boolean result2 = obj instanceof Main;
    System.out.println("obj is an instance of Main: " + result2);
  }
}

Example: Java instanceof¶

• In the example, we have created a variable name of the String type and an object obj of the Main class.

• Here, we have used the instanceof operator to check whether name and obj are instances of the String and Main class respectively. And, the operator returns true in both cases.

Java instanceof during Inheritance¶

• We can use the instanceof operator to check if objects of the subclass is also an instance of the superclass.

Java instanceof during Inheritance¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// Java Program to check if an object of the subclass
// is also an instance of the superclass

// superclass
class Animal {
}

// subclass
class Dog extends Animal {
}

class Main {
  public static void main(String[] args) {

    // create an object of the subclass
    Dog d1 = new Dog();

    // checks if d1 is an instance of the subclass
    System.out.println(d1 instanceof Dog);        // prints true

    // checks if d1 is an instance of the superclass
    System.out.println(d1 instanceof Animal);     // prints true
  }
}

Java instanceof during Inheritance¶

• In the above example, we have created a subclass Dog that inherits from the superclass Animal. We have created an object d1 of the Dog class.

• Inside the print statement, notice the expression,

1

d1 instanceof Animal

• Here, we are using the instanceof operator to check whether d1 is also an instance of the superclass Animal

Java instanceof in Interface¶

• The instanceof operator is also used to check whether an object of a class is
• also an instance of the interface implemented by the class

Java instanceof in Interface¶

1
2
3
4
5
6
7
8

// Java program to check if an object of a class is also
//  an instance of the interface implemented by the class

interface Animal {
}

class Dog implements Animal {
}

Java instanceof in Interface¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

class Main {
  public static void main(String[] args) {

    // create an object of the Dog class
    Dog d1 = new Dog();

    // checks if the object of Dog
    // is also an instance of Animal
    System.out.println(d1 instanceof Animal);  // returns true
  }
}

Java instanceof in Interface¶

• In the example, the Dog class implements the Animal interface. Inside the print statement, notice the expression,

1

d1 instanceof Animal

• Here, d1 is an instance of Dog class. The instanceof operator checks
• if d1 is also an instance of the interface Animal.

Java instanceof in Interface¶

In Java, all the classes are inherited from the Object class. So, instances of all the classes are also an instance of the Object class.

In the previous example, if we check,

1

d1 instanceof Object

The result will be true.

Takeaway: this Keyword and instanceof¶

• this refers to the current object instance
• Use this to disambiguate between instance variables and parameters with same name
• this() calls another constructor in the same class (constructor chaining)
• instanceof checks if an object is an instance of a specific class or interface
• instanceof returns true for parent classes and implemented interfaces too

Module E: Java Method Overriding¶

Module Outline¶

• What is Method Overriding? Conceptual Understanding
• How the JVM Decides Which Method to Run (Dynamic Binding)
• Java Method Overriding Syntax and Rules
• Access Specifiers in Overriding
• Using super with Overriding
• Overriding Abstract Methods

Overriding¶

• A method would be inherited, but a subclass contains a new version instead
• For extension
  • E.g. SavingsAccount might charge an extra fee following every debit
• For optimization
  • E.g. The getPerimeterLength method in Circle is much simpler than the one in Ellipse
• For restriction (best to avoid)
  • E.g. scale(x,y) would not work in Circle

How a decision is made about which method to run¶

• If there is a concrete method for the operation in the current class, run that method.
• Otherwise, check in the immediate superclass to see if there is a method there; if so, run it.
• Repeat step 2, looking in successively higher superclasses until a concrete method is found and run.
• If no method is found, then there is an error In Java and C++ the program would not have compiled
• In Java and C++ the program would not have compiled

Dynamic binding¶

• Occurs when decision about which method to run can only be made at run time
• Needed when:
  • A variable is declared to have a superclass as its type, and
  • There is more than one possible polymorphic method that could be run among the type of the variable and its subclasses

Java Method Overriding¶

Java Method Overriding¶

• The method overriding is the process of re-defining a method in a child class that is already defined in the parent class.
• When both parent and child classes have the same method, then that method is said to be the overriding method.
• The method overriding enables the child class to change the implementation of the method which aquired from parent class according to its requirement.

Java Method Overriding¶

The method overriding is also known as - dynamic method dispatch or - run time polymorphism or - pure polymorphism.

Java Method Overriding Example¶

1
2
3
4
5
6
7
8
9

class ParentClass{

    int num = 10;

    void showData() {
        System.out.println("Inside ParentClass showData() method");
        System.out.println("num = " + num);
    }
}

Java Method Overriding Example¶

1
2
3
4
5
6
7

class ChildClass extends ParentClass{

    void showData() {
        System.out.println("Inside ChildClass showData() method");
        System.out.println("num = " + num);
    }
}

Java Method Overriding Example¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public class PurePolymorphism {

    public static void main(String[] args) {

        ParentClass obj = new ParentClass();
        obj.showData();

        obj = new ChildClass();
        obj.showData();

    }
}

Rules for method overriding¶

While overriding a method, we must follow the below list of rules.

• Static methods can not be overridden.
• Final methods can not be overridden.
• Private methods can not be overridden.
• Constructor can not be overridden.
• An abstract method must be overridden.
• Use super keyword to invoke overridden method from child class.

Rules for method overriding¶

• The return type of the overriding method must be same as the parent has it.
• The access specifier of the overriding method can be changed, but the visibility must increase but not decrease. For example, a protected method in the parent class can be made public, but not private, in the child class.

Rules for method overriding¶

• If the overridden method does not throw an exception in the parent class, then the child class overriding method can only throw the unchecked exception, throwing a checked exception is not allowed.
• If the parent class overridden method does throw an exception, then the child class overriding method can only throw the same, or subclass exception, or it may not throw any exception.

Method Overriding Example¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

class Animal {
   public void displayInfo() {
      System.out.println("I am an animal.");
   }
}

class Dog extends Animal {
   @Override
   public void displayInfo() {
      System.out.println("I am a dog.");
   }
}

class Main {
   public static void main(String[] args) {
      Dog d1 = new Dog();
      d1.displayInfo();
   }
}

Method Overriding Example¶

• annotations are the metadata that we used to provide information to the compiler

• It is not mandatory to use @Override. However, when we use this, the method should follow all the rules of overriding. Otherwise, the compiler will generate an error.

Method Overriding Example¶

super Keyword in Java Overriding¶

• Can we access the method of the superclass after overriding?
• The answer is Yes. To access the method of the superclass from the subclass, we use the super keyword

Use of super Keyword Example¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

class Animal {
   public void displayInfo() {
      System.out.println("I am an animal.");
   }
}

class Dog extends Animal {
   public void displayInfo() {
      super.displayInfo();
      System.out.println("I am a dog.");
   }
}

class Main {
   public static void main(String[] args) {
      Dog d1 = new Dog();
      d1.displayInfo();
   }
}

Use of super Keyword Example¶

• In the above example, the subclass Dog overrides the method displayInfo() of the superclass Animal.

• When we call the method displayInfo() using the d1 object of the Dog subclass, the method inside the Dog subclass is called; the method inside the superclass is not called

• Inside displayInfo() of the Dog subclass, we have used super.displayInfo() to call displayInfo() of the superclass.

Use of super Keyword Example¶

• note that constructors in Java are not inherited. Hence, there is no such thing as constructor overriding in Java.

• However, we can call the constructor of the superclass from its subclasses. For that, we use super()

Access Specifiers in Method Overriding¶

• The same method declared in the superclass and its subclasses can have different access specifiers. However, there is a restriction.

• We can only use those access specifiers in subclasses that provide larger access than the access specifier of the superclass. For example,

• Suppose, a method myClass() in the superclass is declared protected. Then, the same method myClass() in the subclass can be either public or protected, but not private.

Access Specifier in Overriding Example¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

class Animal {
   protected void displayInfo() {
      System.out.println("I am an animal.");
   }
}

class Dog extends Animal {
   public void displayInfo() {
      System.out.println("I am a dog.");
   }
}

class Main {
   public static void main(String[] args) {
      Dog d1 = new Dog();
      d1.displayInfo();
   }
}

Access Specifier in Overriding Example¶

• In the above example, the subclass Dog overrides the method displayInfo() of the superclass Animal.

• Whenever we call displayInfo() using the d1 (object of the subclass), the method inside the subclass is called.

• Notice that, the displayInfo() is declared protected in the Animal superclass. The same method has the public access specifier in the Dog subclass.

• This is possible because the public provides larger access than the protected.

Overriding Abstract Methods¶

• In Java, abstract classes are created to be the superclass of other classes.
• And, if a class contains an abstract method,
• it is mandatory to override it.

Takeaway: Java Method Overriding¶

• Override: subclass provides its own implementation of a parent method
• The JVM decides at RUNTIME which method to call (dynamic binding / late binding)
• Rules: same name, same parameters, covariant return type allowed
• Cannot override: final methods, static methods, private methods
• Access modifier in overriding method cannot be more restrictive than parent

Module F: Java Polymorphism¶

Module Outline¶

• Conceptual Understanding of Polymorphism
• Methods, Operations, and Polymorphism
• Ad hoc Polymorphism (Method Overloading)
• Pure Polymorphism (Method Overriding)
• Polymorphic Variables and Dynamic Binding in Action

Methods, Operations and Polymorphism¶

• Operation
• A higher-level procedural abstraction that specifies a type of behaviour
• Independent of any code which implements that behaviour
  • E.g. calculating area (in general)

Methods, Operations and Polymorphism¶

• Method
• A procedural abstraction used to implement the behaviour of a class
• Several different classes can have methods with the same name
  • They implement the same abstract operation in ways suitable to each class
  • E.g. calculating area in a rectangle is done differently from in a circle

Polymorphism¶

• A property of object oriented software by which an abstract operation may be performed in different ways in different classes.
• Requires that there be multiple methods of the same name
• The choice of which one to execute depends on the object that is in a variable
• Reduces the need for programmers to code many if-else or switch statements

Inheritance, Polymorphism and Variables¶

Some Operations in the Shape Example¶

Java Polymorphism¶

Java Polymorphism¶

• The polymorphism is the process of defining same method with different implementation. That means creating multiple methods with different behaviors.
• In java, polymorphism implemented using
• method overloading and
• method overriding.

Ad hoc polymorphism¶

• The ad hoc polymorphism is a technique used to define
• the same method with different implementations and
• different arguments.
• In a java programming language, ad hoc polymorphism carried out with
• a method overloading concept.

Ad hoc polymorphism¶

• In ad hoc polymorphism the method binding happens at the time of compilation.
• Ad hoc polymorphism is also known as compile-time polymorphism.
• Every function call binded with the respective overloaded method based on the arguments.

Ad hoc polymorphism¶

• The ad hoc polymorphism implemented within the class only.

Ad hoc polymorphism example-1¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import java.util.Arrays;

public class AdHocPolymorphismExample {

    void sorting(int[] list) {
        Arrays.parallelSort(list);
        System.out.println("Integers after sort: " + Arrays.toString(list) );
    }
    void sorting(String[] names) {
        Arrays.parallelSort(names);
        System.out.println("Names after sort: " + Arrays.toString(names) );     
    }
...

Ad hoc polymorphism example-1¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

...
    public static void main(String[] args) {

        AdHocPolymorphismExample obj = new AdHocPolymorphismExample();
        int list[] = {2, 3, 1, 5, 4};
        obj.sorting(list);  // Calling with integer array

        String[] names = {"rama", "raja", "shyam", "seeta"};
        obj.sorting(names); // Calling with String array
    }
}