$64,000 question:   what is the easiest way to write programs to solve a problem:

But things will change when you have programmed for many years and have written many programs

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

How can we write the NewClass class 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:

Problem:   redundancy make maintenance very difficult (think: many copies, making a change is difficult)

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/13-inheritance/01-extends/Demo.java + SomeClass.java + NewClass.java

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(); // NewClass contains a method1() - It's SomeClass.method1()
        b.method2(); // NewClass contains a method2() - It's SomeClass.method2()
    }
}
  

Advantage of re-using existing sofware with inheritance:

DEMO: 13-inheritance/01-extends/Demo.java + SomeClass.java + NewClass.java   --   edit SomeClass.java

What if some method that was inherited does not work correctly for a NewClass object ?

Rule:   methods defined inside NewClass will supersede an inherited method with the same method signature
(This mechanism is called overriding)

DEMO: demo/13-inheritance/02-override/Demo.java + SomeClass.java + NewClass.java

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()
    }
} 

What if the original class does not have a method to perform some action in the NewClass object ?

These new methods will only be available in a NewClass object (and will not be available in a SomeClass object)

DEMO: demo/13-inheritance/03-add/Demo.java + SomeClass.java + NewClass.java

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() !
    }
} 

Note:   a NewClass object has two (different) methods named method1(...) with the same signature:

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

How to invoke the two (different) methods named method1(...) inside NewClass:

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

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

DEMO: demo/13-inheritance/03a-super/Demo.java + NewClass.java    --    change x from public to private