This document discusses Java inheritance including composition vs inheritance, inheritance definitions, types of inheritance (single, multilevel, hierarchical), why multiple inheritance is not supported, the super keyword and its uses, method overriding rules and examples. It defines inheritance as a parent-child relationship between classes that allows code and method reuse/overriding. Composition exhibits a "has-a" relationship while inheritance exhibits an "is-a" relationship. The super keyword can be used to access parent class members and call parent class methods/constructors. Method overriding provides a specific implementation of a method already in the parent class.

1. Java Inheritance
There are two ways to reuse the existing classes
Composition
define a new class, which is composed of existing classes.
Composition exhibits a "has-a" relationship.
Inheritance
derive a new class based on an existing class
with modifications / extensions.
Inheritance exhibits a “is-a" relationship.

2. 2
Inheritance: Definition
 inheritance: a parent-child relationship between classes
 Reuse of existing code or Method Overriding (Runtime Polymorphism).
 allows sharing of the behavior of the parent class into its child classes
 child class can add new behavior / override existing behavior from parent
 The more general class is called:
 superclass, base class, parent class
 The more specific class is called:
 subclass, derived class, child class

3. 3
 Two kinds:
 implementation: the code that defines methods.
 Derived class inherits the implementations of all methods
from base class.
 interface: the method prototypes only.
 Accessing superclass methods from derived class.
 Can use super() to access all (non-private) superclass methods.
 Can use super() to call base class constructor.

4. Syntax of Inheritance:
class Subclass-name extends Superclass-name
{
//methods and fields
}
keyword extends:
Indicates that you are making a new class that derives from an existing class.

5. Types of Inheritance:
On the basis of class, there can be three types of inheritance:
Single Inheritance
Multilevel Inheritance
Hierarchical Inheritance
Multiple & Hybrid - supported through interface only

8. Why multiple inheritance is not supported in java?
class A
{
void msg(){System.out.println("Hello");}
}
class B
{
void msg(){System.out.println("Welcome");}
}
class C extends A,B
{ //suppose if it were
Public Static void main(String args[]){
C obj=new C();
obj.msg(); //Now which msg() method would be invoked?
}
}

9. super keyword
The super is a reference variable that is used to refer immediate
parent class object.
Usage of super Keyword
super is used to refer immediate parent class instance variable.
super() is used to invoke immediate parent class constructor.
super is used to invoke immediate parent class method.

10. Example:
class Vehicle
{
int speed=50;
}
class Bike extends Vehicle
{
int speed=100;
void display()
{
System.out.println(speed);
//will print speed of Bike
}
public static void main(String args[])
{
Bike b=new Bike();
b.display();
}
}
class Vehicle
{
int speed=50;
}
class Bike extends Vehicle
{
int speed=100;
void display()
{
System.out.println(super.speed);
//will print speed of Vehicle now
}
public static void main(String args[])
{
Bike b=new Bike();
b.display();
}
}

11. super is used to invoke parent class constructor.
class Vehicle
{
Vehicle()
{
System.out.println("Vehicle is created");
}}
class Bike extends Vehicle
{
Bike()
{
super();//will invoke parent class constructor
System.out.println("Bike is created");
}
public static void main(String args[])
{
Bike b=new Bike();
}}

12. super can be used to invoke parent class method.
class Person
{
void message(){System.out.println("welcome");}
}
class Student extends Person
{
void message() { System.out.println("welcome to java");
}
void display()
{
message();//will invoke current class message() method
super.message();//will invoke parent class message() method
}
public static void main(String args[])
{
Student s=new Student();
s.display();}}

13. Method Overriding in Java
Having the same method in the subclass as declared in the parent
class is known as method overriding.
In other words, If subclass provides the specific implementation of
the method i.e. already provided by its parent class, it is known as
Method Overriding.
Method Overriding is used for Runtime Polymorphism
Rules for Method Overriding:
method must have same name as in the parent class
method must have same parameter as in the parent class.
must be inheritance (IS-A) relationship.

14. class Vehicle
{
void run()
{
System.out.println("Vehicle");
}
}
class Bike extends Vehicle
{
public static void main(String args[])
{
Bike obj = new Bike();
obj.run();
}
}
class Vehicle
{
void run()
{
System.out.println("Vehicle is running");
}
}
class Bike extends Vehicle
{
void run()
{
System.out.println("Bike is running");
}
public static void main(String args[])
{
Bike obj = new Bike();
obj.run();
}

15. Method Overloading Method Overriding
1) Method overloading is used to
increase the readability of the program.
Method overriding is used to provide
the specific implementation of the
method that is already provided by its
super class.
2) method overloading is performed
within a class.
Method overriding occurs in two
classes that have IS-A relationship.
3) In case of method overloading
parameter must be different.
In case of method overriding parameter
must be same.