Question

Consider the following code:

    import java.io.*;
    import java.util.*;

    class parent{
      private static int static_count;
      final void static_display(){
       for(int i=0; i< 1000000; i++){
         Object obj = new Object();
       }
       System.out.println("Static method called"+static_count+"times");    
      }
      public void dynamic_display(){
        System.out.println("implemented in child");
      } 
    }

    class child extends parent{
      private static int dynamic_count;
      public void dynamic_display(){
        for(int i=0; i< 1000000; i++){
          Object obj = new Object();
        }
        System.out.println("dynamic method called"+dynamic_count+"times");    
      }
    }

    class sample{
      public static void main(String args[]){
      parent pnt= new parent();
      parent pnt2=new child();
      //static binding
      long startTime = System.nanoTime();
      pnt.static_display();
      long elapsedTime = System.nanoTime() - startTime;

      System.out.println("Total execution time for static binding in millis: "
            + elapsedTime/1000000);
      //dynamic binding
      long startTime2 = System.nanoTime();
      pnt2.dynamic_display();
      long elapsedTime2 = System.nanoTime() - startTime2;

      System.out.println("Total execution time for dynamic binding in millis: "
            + elapsedTime2/1000000);
     }
    }

When this code is executed i am getting the following answer,

    Static method called0times
    Total execution time for static binding in millis: 11
    dynamic method called0times
    Total execution time for dynamic binding in millis: 9

consider only the execution time in the result.i tried to find the time taken for statically and dynamically binnded method to execute.but according to my answer,dynamic binding is faster than static binding.how is this possible.am i wrong anywhere.

Answer 1

It looks as though all your tests do the runs in the same order, static then dynamic. The JVM may have decided to optimize your code, because of the amount of time it is running, part way through the static test. The static test would get all the cost of optimization, and some benefit. The dynamic code would get the benefit.

This is just one example of the sorts of issues you can hit with this sort of micro-benchmarking of Java code.

If you want meaningful results, take the real program you are working on and test in context. If the difference is too small to measure in actual use, it is too small to outweigh code clarity.