Problem description:   we need to write a program (software) to solve a new problem:

How can we do this efficiently (i.e.: use the least effort as possible)

How to re-use existing sofware to build more complex software prior to ~1995

Before the invention of Object Oriented Programming (OOP)

How to re-use existing sofware to build more complex software prior to ~1995

Before the invention of Object Oriented Programming (OOP)

How to re-use existing sofware to build more complex software prior to ~1995

Before the invention of Object Oriented Programming (OOP)

Redundancy:

Hard to maintain programs: when we update the original software (from which we made the new software), we may need to update our programs that are based on the existing software

How to re-use existing sofware to build more complex software with OOP

After the invention of Object Oriented Programming (OOP)

How to re-use existing sofware to build more complex software with OOP

The new class (= software) will inherit (= "receive") all the variables and (normal) methods from an existing class

DEMO: demo/04-inheritance/01-extends

public class SomeClass
{
    public int x;

    public SomeClass()
    {
        x = 99;
    }

    public void method1( )
    {
        System.out.println("I am SomeClass.method1(). x = " + x);
    }
    
    public void method2( )
    {
        System.out.println("I am SomeClass.method2(). x = " + x);
    }
}

public class NewClass extends SomeClass
{
    NewClass()
    {
        
    }

    // No other methods defined !
}

public class myProg
{
    public static void main(String[] args)
    {
        NewClass b = new NewClass();
        b.method1(); // Invokes SomeClass.method1()
        b.method2(); // Invokes SomeClass.method2()
    }
}
  

How to re-use existing sofware to build more complex software with OOP

Methods defined inside the NewClass will take priority over an inherited method with the same method signature (this mechanism is called overriding)

DEMO: demo/04-inheritance/02-override

public class SomeClass
{
    public int x;

    public SomeClass()
    {
        x = 99;
    }

    public void method1( )
    {
        System.out.println("I am SomeClass.method1(). x = " + x);
    }
    
    public void method2( )
    {
        System.out.println("I am SomeClass.method2(). x = " + x);
    }
}

public class NewClass extends SomeClass
{
    NewClass()
    {
        
    }

    public void method1( )  // Overrides the inherited method1
    {
        System.out.println("I am **NewClass**.method1(). x = " + x);
    }
}

public class myProg
{
    public static void main(String[] args)
    {
        NewClass b = new NewClass();
        b.method1(); // Invokes NewClass.method1()
        b.method2(); // Invokes SomeClass.method2()
    }
} 

How to re-use existing sofware to build more complex software with OOP

These new methods will only be defined in the NewClass (and will not be defined (inherit) in the orignal class (SomeClass))

DEMO: demo/04-inheritance/03-add

public class SomeClass
{
    public int x;

    public SomeClass()
    {
        x = 99;
    }

    public void method1( )
    {
        System.out.println("I am SomeClass.method1(). x = " + x);
    }
    
    public void method2( )
    {
        System.out.println("I am SomeClass.method2(). x = " + x);
    }
}

public class NewClass extends SomeClass
{
    NewClass()
    {
        
    }

    public void method1( )  // Overrides the inherited method1
    {
        System.out.println("I am **NewClass**.method1(). x = " + x);
    }

    public void method3( )  // Defines a new method
    {
        System.out.println("I am **NewClass**.**method3**(). x = " + x);
    }
}

public class myProg
{
    public static void main(String[] args)
    {
        NewClass b = new NewClass();

        b.method1(); // Invokes NewClass.method1()  
        b.method2(); // Invokes SomeClass.method2()  
        b.method3(); // Invokes NewClass.method3()  

    //  SomeClass a;
    //  a.method3();  // is ILLEGAL --> SomeClass does not have method3() !
    }
} 

Notice there are two (different) methods named method1(...) with the same signature:

When writing methods in NewClass, both methods are available for use (= accessible) !

Notice there are two (different) methods named method1(...) with the same signature:

The super keyword always refers to members in the super class
DEMO: demo/04-inheritance/03a-super/Demo.java + NewClass.java

How to re-use existing sofware to build more complex software using OOP