Inheritance in Java

In programming we always try to write short code and avoid repetition of same code. Inheritance is useful in this work very much. Just like real life, we can create a family hierarchy in programming just like 4-wheeler -> car -> farari. Each child class ( called sub class) inherits all public and protected property (variables, methods, etc.). For example we have two classes one is Father and another is Child.

  1. package flowkl;
  2. class Father
  3. {
  4. // father's public property
  5. public int father_int = 12;
  6. // father's protected (inheritable property)
  7. protected void who_i_am()
  8. {
  9. System.out.println("I am Father");
  10. }
  11. // father's inheritable property
  12. protected void father_property()
  13. {
  14. System.out.println("this is father's property");
  15. }
  16. }
  17. public class Child extends Father
  18. {
  19. // modifying father's property
  20. public void who_i_am()
  21. {
  22. System.out.println("I am Child");
  23. }
  24. // accessing father's property using super keyword
  25. public void access_father()
  26. {
  27. System.out.println("father variable is "+super.father_int);
  28. }
  29. // child is adding its own property
  30. public void child_property()
  31. {
  32. System.out.println("It is child's property");
  33. }
  34. public static void main(String args[])
  35. {
  36. Child object = new Child();
  37. // child object using its own method
  38. object.who_i_am();
  39. object.child_property();
  40. // child object using father's method
  41. object.father_property();
  42. // using father's variable
  43. System.out.println(object.father_int);
  44. object.access_father();
  45. }
  46. }


  1. I am Child
  2. It is child's property
  3. this is father's property
  4. 12
  5. father variable is 12

Now we have two classes. Look at the syntax of Child class. It is extending Father class and inheriting all its public and protected properties. Properties of inheritance is:

  • Child (sub) class inherits all public and protected instances of the parent (super) class.
  • Child class can use these instances directly without defining them using super keyword.
  • Child class object has modified instances (in child class) and remaining parent class instances. For example in main method, object has who_i_am() method from from Child class and father_property() method from Father class. In other words, we can say that every property (except private) of father is also property of child and child can modify this property. Child can also add its own property (Child class has its own method called child_property()).
  • Child can not low the visibility of the parent's instances. Visibility sequence is public > protected > private. So, parents public instances can only be public even in child class. Parent's protected instances can be public or protected (depends upon modification) in the child class. Child class can not access parent's private instances.
  • Inheritance is one way. We can not make any cycle like this a=> b=> c=> a or a=> b => c=> b.
  • Java allows single inheritance. One class can not inherit from more than one class. In other words, there can be only one father of one child.


When we overload the methods of the super class in sub class then it is called overriding.

  1. package flowkl;
  2. class Father
  3. {
  4. protected void method()
  5. {
  6. System.out.println("this is parent function");
  7. }
  8. }
  9. public class Child extends Father
  10. {
  11. //method overriding by changing parameter
  12. // we can also change return type along with parameter(s)
  13. protected int method(int a)
  14. {
  15. return a;
  16. }
  17. public static void main(String args[])
  18. {
  19. Child object = new Child();
  20. System.out.println(object.method(47));
  21. }
  22. }

Multiple level Inheritance:

Java allow hierarchy. For example: Child is inheriting Father which is inheriting Grandfather. It means that Child also inheriting from Grandfather indirectly because every non-private property of Grandfather is property of Father and all non-private property of Father is property of Child.

  1. package flowkl;
  2. class Grandfather
  3. {
  4. protected void method()
  5. {
  6. System.out.println("method in grandfather");
  7. }
  8. protected void method2()
  9. {
  10. System.out.println("method2 in grandfather");
  11. }
  12. }
  13. class Father extends Grandfather
  14. {
  15. protected void method2()
  16. {
  17. System.out.println("method2 in father");
  18. }
  19. }
  20. public class Child extends Father
  21. {
  22. public static void main(String args[])
  23. {
  24. Child object = new Child();
  25. // method call from grandfather
  26. object.method();
  27. // method call from father
  28. object.method2();
  29. }
  30. }


  1. method in grandfather
  2. method2 in father

Click on banner below to Learn: PHP with Laravel for beginners - Become a Master in Laravel

About Harish Kumar

Harish, a technical core team member at with five year experience in full stack web and mobile development, spends most of his time on coding, reading, analysing and curiously following businesses environments. He is a non-graduate alumni from IIT Roorkee, Computer Science and frequently writes on both technical and business topics.

Related Articles

PHP stands for PHP: Hypertext Preprocessor. PHP is known as a server side scripting and interpreter language for web ...
Introduction to PHP
In this tutorial, we will study about conditional statements (if else statements and switch statements). These statem...
Conditional statements in php
In this tutorial, we will study about strings and operations upon strings. Due to long length of this section, I have...
Strings in PHP (part-1)

Full-Stack Web Development with React

Best Udemy Courses

Top Posts

Recent Posts

The Complete Web Developer Course - Build 25 Websites


Subscribe now and get weekly updates directly in your inbox!

Any Course on Udemy in $6 (INR 455)

Development Category (English)300x250