Polymorphism Part-2 (Method Overriding)

Method Overriding:

In object-oriented programming, method overriding is a language feature that allows a subclass or child class to provide a specific implementation of a method that is already provided by one of its superclasses or parent classes. The benefit of overriding is the ability to define a subclass implementing a parent class method based on its requirement that has same name, same parameters or signature, and same return type as the method in the parent class.
An overriding method can also return a subtype of the type returned by the overridden method. This subtype is called a covariant return type. When overriding a method, you might want to use the @Override annotation that instructs the compiler that you intend to override a method in the superclass. If, for some reason, the compiler detects that the method does not exist in one of the superclasses, then it will generate an error. For more information on @Override, see Annotations.

Rules for Java Method Overriding

  1. The argument list should be exactly the same as that of the overridden method.
  2. Method must have same name as in the parent class.
  3. Method must have same parameter as in the parent class.
  4. Must be IS-A relationship (inheritance).
  5. Method can also return a subtype of the type returned by the overridden method.
  6. The access level cannot be more restrictive than the overridden method's access level. For example: If the superclass method is declared public then the overridding method in the sub class cannot be either private or protected.
  7. Instance methods can be overridden only if they are inherited by the subclass.
  8. A method declared final cannot be overridden.
  9. A method declared static cannot be overridden but can be re-declared.
  10. If a method cannot be inherited, then it cannot be overridden.
  11. A subclass within the same package as the instance's superclass can override any superclass method that is not declared private or final.
  12. A subclass in a different package can only override the non-final methods declared public or protected.
  13. An overriding method can throw any uncheck exceptions, regardless of whether the overridden method throws exceptions or not. However, the overriding method should not throw checked exceptions that are new or broader than the ones declared by the overridden method. The overriding method can throw narrower or fewer exceptions than the overridden method.
  14. Constructors cannot be overridden.

Let’s look at an example:
class Language {
   public void write() {
      System.out.println("Any language can be written here");
   }
}

class Hindi extends Language{
   public void write() {
      System.out.println("Hindi is a very sweet language ");
   }
}

public class Test {

   public static void main(String args[]) {
      Language a = new Language();   // Language reference and object
      Language b = new Hindi();   // Language reference but Hindi object
      a.write();   // runs the method in Language class
      b.write();   // runs the method in Hindi class
   }
}
Therefore, in the above example, the program will compile properly since Language class has the method write. Then, at the runtime JVM, runs the method figure out the object type and would run the method that belongs to that particular object.
Output
Any language can be written here
Hindi is a very sweet language

If you still have any question you can reach me any time through email (jigyasu2010@hotmail.com)


Comments

Post a Comment

Popular posts from this blog

How Method Overloading Helping in Java - Part 9

I'm sharing my experience with you as these are the questions which have been asked to me while interviewing on java profile. Where have u observed method overloading helped us in java? Where have you seen in java default classes using method overloading? We need method overloading because if we have multiple arguments for add method and we have to create multiple methods in that case we will be confused which method to call to perform specific addition. Example: class   PrintOverloading1 {      public   void  show( char  c)     {           System . out .println(c);     }      public   void  show( char  c,  int  number)      {           System . out .println(c +  " " + number);     }    public   void  show( char  c,  String s )      {           System . out .println(c +  " " + s);     } } class   demo1 {     public   static   void  main( String  args[])    {         PrintOverloading1 obj  =  new   PrintOv
Read more

Design Patterns -- part 1

Design patterns are the best practices used by Developers while working on project. These give design level solutions for recurring problems that software engineers come across often. This helps developers to tackle these problems and design a solution well using patterns. These patterns help other developers so that they do not need to waste time in those problems which were faced by those developers.  What is   Gang Of Four (GOF)? There is a band called Gang Of Four (band) but here we will not be talking about band. We will talk about the authors of Gang of Four design patterns. In 1994, four authors Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides published a book titled Design Patterns - Elements of Reusable Object-Oriented Software Source:  Wikipedia Patterns are formalized  best practices  that the programmer can use to solve common problems when designing an application or system. Object-oriented  design patterns typically show relationships and  interactions
Read more

Access Modifiers in java

Access Modifiers in Java Access to classes is controlled using Access Modifiers aka ( Access Specifiers, Visibility Specifiers ) in java. These are used to regulate access to classes, fields and methods in java. Using access modifiers you can control the access of variables, methods with in a class. Java provides number of access modifiers to control the access for class as well as the fields, methods and constructors in your classes. We have 4 types of access modifiers in java which are explained below:- Default: Visible to the package, the default. No modifiers are needed, no keyword is required. Private: Visible to the class only. Public: Visible to the world. Protected: Visible to the package and all subclasses. Default: We do not have any default specifier in Java. It provides Default specifier which is used where no access modifier is present. Using this you can access class, methods or fields which belongs to same package, but not from outside
Read more