Method Overriding in Java

If subclass (child class) has the same method as declared in the parent class, it is known as method overriding in java. In other words, If subclass provides the specific implementation of the method that has been provided by one of its parent class, it is known as method overriding. Usage of Java Method Overriding Method overriding is used to provide specific implementation of a method that is already provided by its super class. Method overriding is used for runtime polymorphism Rules for Java Method Overriding method must have same name as in the parent class method must have same parameter as in the parent class. must be IS-A relationship (inheritance). Understanding the problem without method overriding Let's understand the problem that we may face in the program if we don't use method overriding. class Vehicle{     void run(){System.out.println("Vehicle is running");}   }   class Bike extends Vehicle{          public static void main(String args[]){     Bike obj = new Bike();     obj.run();     }   }   Output:Vehicle is running Problem is that I have to provide a specific implementation of run() method in subclass that is why we use method overriding. Example of method overriding In this example, we have defined the run method in the subclass as defined in the parent class but it has some specific implementation. The name and parameter of the method is same and there is IS-A relationship between the classes, so there is method overriding. class Vehicle{   void run(){System.out.println("Vehicle is running");}   }   class Bike2 extends Vehicle{   void run(){System.out.println("Bike is running safely");}      public static void main(String args[]){   Bike2 obj = new Bike2();   obj.run();   }   Output:Bike is running safely Real example of Java Method Overriding Consider a scenario, Bank is a class that provides functionality to get rate of interest. But, rate of interest varies according to banks. For example, SBI, ICICI and AXIS banks could provide 8%, 7% and 9% rate of interest. class Bank{   int getRateOfInterest(){return 0;}   }      class SBI extends Bank{   int getRateOfInterest(){return 8;}   }      class ICICI extends Bank{   int getRateOfInterest(){return 7;}   }   class AXIS extends Bank{   int getRateOfInterest(){return 9;}   }      class Test2{   public static void main(String args[]){   SBI s=new SBI();   ICICI i=new ICICI();   AXIS a=new AXIS();   System.out.println("SBI Rate of Interest: "+s.getRateOfInterest());   System.out.println("ICICI Rate of Interest: "+i.getRateOfInterest());   System.out.println("AXIS Rate of Interest: "+a.getRateOfInterest());   }   }   Output: SBI Rate of Interest: 8 ICICI Rate of Interest: 7 AXIS Rate of Interest: 9 Can we override static method? No, static method cannot be overridden. It can be proved by runtime polymorphism, so we will learn it later. Why we cannot override static method? because static method is bound with class whereas instance method is bound with object. Static belongs to class area and instance belongs to heap area. Can we override java main method? No, because main is a static method.

Aggregation in Java

If a class have an entity reference, it is known as Aggregation. Aggregation represents HAS-A relationship. Consider a situation, Employee object contains many informations such as id, name, emailId etc. It contains one more object named address, which contains its own informations such as city, state, country, zipcode etc. as given below. class Employee{   int id;   String name;   Address address;//Address is a class   ...   }   In such case, Employee has an entity reference address, so relationship is Employee HAS-A address. Why use Aggregation? For Code Reusability. Simple Example of Aggregation In this example, we have created the reference of Operation class in the Circle class. class Operation{    int square(int n){     return n*n;    }   }      class Circle{    Operation op;//aggregation    double pi=3.14;         double area(int radius){      op=new Operation();      int rsquare=op.square(radius);//code reusability (i.e. delegates the method call).      return pi*rsquare;    }                  public static void main(String args[]){      Circle c=new Circle();      double result=c.area(5);      System.out.println(result);    }   }   Output:78.5 When use Aggregation? Code reuse is also best achieved by aggregation when there is no is-a relationship. Inheritance should be used only if the relationship is-a is maintained throughout the lifetime of the objects involved; otherwise, aggregation is the best choice. Understanding meaningful example of Aggregation In this example, Employee has an object of Address, address object contains its own informations such as city, state, country etc. In such case relationship is Employee HAS-A address. Address.java public class Address {   String city,state,country;      public Address(String city, String state, String country) {       this.city = city;       this.state = state;       this.country = country;   }      }   Emp.java public class Emp {   int id;   String name;   Address address;      public Emp(int id, String name,Address address) {       this.id = id;       this.name = name;       this.address=address;   }      void display(){   System.out.println(id+" "+name);   System.out.println(address.city+" "+address.state+" "+address.country);   }      public static void main(String[] args) {   Address address1=new Address("gzb","UP","india");   Address address2=new Address("gno","UP","india");      Emp e=new Emp(111,"varun",address1);   Emp e2=new Emp(112,"arun",address2);          e.display();   e2.display();          }   }   Output:111 varun gzb UP india 112 arun gno UP india

Inheritance in Java

Inheritance in java is a mechanism in which one object acquires all the properties and behaviors of parent object. The idea behind inheritance in java is that you can create new classes that are built upon existing classes. When you inherit from an existing class, you can reuse methods and fields of parent class, and you can add new methods and fields also. Inheritance represents the IS-A relationship, also known as parent-child relationship. Why use inheritance in java For Method Overriding (so runtime polymorphism can be achieved). For Code Reusability. Syntax of Java Inheritance class Subclass-name extends Superclass-name   {      //methods and fields   }   The extends keyword indicates that you are making a new class that derives from an existing class. In the terminology of Java, a class that is inherited is called a super class. The new class is called a subclass. Understanding the simple example of inheritance As displayed in the above figure, Programmer is the subclass and Employee is the superclass. Relationship between two classes is Programmer IS-A Employee.It means that Programmer is a type of Employee. class Employee{    float salary=40000;   }   class Programmer extends Employee{    int bonus=10000;    public static void main(String args[]){      Programmer p=new Programmer();      System.out.println("Programmer salary is:"+p.salary);      System.out.println("Bonus of Programmer is:"+p.bonus);   }   }   Programmer salary is:40000.0 Bonus of programmer is:10000 In the above example, Programmer object can access the field of own class as well as of Employee class i.e. code reusability. Types of inheritance in java On the basis of class, there can be three types of inheritance in java: single, multilevel and hierarchical. In java programming, multiple and hybrid inheritance is supported through interface only. We will learn about interfaces later. Note: Multiple inheritance is not supported in java through class. When a class extends multiple classes i.e. known as multiple inheritance. For Example: Q) Why multiple inheritance is not supported in java? To reduce the complexity and simplify the language, multiple inheritance is not supported in java. Consider a scenario where A, B and C are three classes. The C class inherits A and B classes. If A and B classes have same method and you call it from child class object, there will be ambiguity to call method of A or B class. Since compile time errors are better than runtime errors, java renders compile time error if you inherit 2 classes. So whether you have same method or different, there will be compile time error now. 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?   }   }   Compile Time Error