Java- Overloading / Chapter - 6 / OOP's Concept

Overloading:-

1. Two methods are said to be overloaded method if and only if ,both methods having same name but different arguments types.
2. In old language like C method overloading concept is not available hence ,we can't declare multiple methods with same name but different arguments types.
3. But in Java , we can declare multiple methods with same name but different arguments types.Such type of methods are called overloaded method. This overloading feature of java reduces the complexity of programming.                                                                                                                                        example:
   
   
   class Test
   {
            public void m1( )
            {
                System.out.println( "no - arguments m1() method");
            }
              public void m1( int   x)

             {

                System.out.println( "integer - arguments m1() method");

             }

             public void m1( double y)

             {

                System.out.println( "double - arguments  m1() method");

              }
          public static void main( String [ ] args)
           {
                     Test    t   =   new    Test( );
                      t.m1( );
                      t.m1(20 );
                      t.m1(20.5);
             }
   }
   
   
   Output is:
   
   no -arguments m1() method
   integer - arguments m1() method
   double -arguments  m1() method                                                                                                                                                                                                                                                                     
4. In Overloading method resolution is always takes care by compiler based on the reference type hence overloading is also known as compile-time polymorphism or static polymorphism.

example:-

class Year

{

}

class Semester  extends Year

{

}

class Test

{

public void m1(Year   y)

{

            System.out.println( "Year class");

}

public void m1(Semester   s)

{

            System.out.println( "Semester class ");

}

 public static void main(String args[ ])

   {

       Test      t     =      new  Test( );

        Year     y   =        new   Year( );

         t.m1(y);                  ...............(1)

         Semester    s   =   new   Semester( );

         t.m1(s);             ..................(2)

          Year     y   =        new   Semester( );

                       t.m1( y);  ...............(3)

  }

}

Output of    ......(1)

Year class

Output of    ......(2)

Semester    class

Output of    ......(3)

Year class

               Important Loop Holes In Overloading

Case 1.  Automatic promotion in overloading:-

• While resolving overloaded method if exact match method is not available then we won't get any compile time error immediately.         
• First it will promote  argument to the next level and check whether the matched method is available or not.  If matched method is available it will be considered.
• If the matched method is not available then compiler promotes arguments once again to the next level, this process will be continued until all possible promotion. 
• Still if the matched method is not available then finally we will get compile - time error.
• These following are the all possible promotions in overloading.                                                                                                                                                                                                                                                                  

example:-

class Test

{

        

        public void m1( int   x)

          {

             System.out.println( "integer - arguments m1() method");

          }

          public void m1( float  y)

          {

             System.out.println( "float - arguments  m1() method");

           }

       public static void main( String [ ] args)

        {

                  Test    t   =   new    Test( );

                   t.m1(10 );

                   t.m1(10.5f );

                   t.m1('a');

                   t.m1(10L);

          }

}

Output is:

integer - arguments m1() method

float -arguments  m1() method   

integer - arguments m1() method 

float - arguments m1() method   

Case 2. Precedence of child class is high compared to parent class:-

• While resolving overloaded methods compiler will always gives the precedence for child type argument then compared with parent type argument.

example:-

class Test

{

        public  void  m1(String   s)

        {

             System.out.println("String Version");

        }

        public void  m1(Object  o)

       {

            System.out.println("Object Version");

        }

      public static void  main(String args [ ])

      {

               Test     t     =   new     Test( );

                t.m1("javabychetan")

                t.m1( new Object( ));

                t.m1( null);

       }

}

Output is:-

String Version

Object Version

String Version

Case 3. Normal method gets High Priority than var-arg Method:-

• In general var-arg method gets least priority.
• If no other method matched then var-arg method will be executed.

example:-

class Test

{

        public  void  m1(int  i)

        {

             System.out.println("general method called ");

        }

        public void  m1(int...  i)

       {

            System.out.println("var-arg method called ");

        }

      public static void  main(String args [ ])

      {

               Test     t     =   new     Test( );

                t.m1( )

                t.m1( 10,20);

                t.m1( 10);

       }

}

Output is:-

var-arg method called 

var-arg method called 

general method called