Method Overriding

[Joseph Sweet]

I would expect this code:

  
 
class CustomException extends Exception{

}
 
class SuperClassWithDifferentMethods{
  
  protected int field1 = 10;
  protected static int field2 = 20;   

  public void method1() {
  System.out.println("SuperClassWithDifferentMethods.method1()");
  }
  
  public final void method2(){
  System.out.println("SuperClassWithDifferentMethods.method2()");
  }

  private void method3() {
  System.out.println("SuperClassWithDifferentMethods.method3()");
  }
  
  private final void method4(){
  System.out.println("SuperClassWithDifferentMethods.method4()");
  }
  
  public static void method5() {
        System.out.println("SuperClassWithDifferentMethods.method5()");
  }
  
  public void method6() throws Exception {
  System.out.println("SuperClassWithDifferentMethods.method6()");
  }
  
  private void method7(){
  System.out.println("SuperClassWithDifferentMethods.method7()");
  }
  
  private void method8(int x){
  System.out.println("SuperClassWithDifferentMethods.method8()");
  }
  
  public static void method9() {
        System.out.println("SuperClassWithDifferentMethods.method9()");
  }
}
 
class OverridingClass extends SuperClassWithDifferentMethods {

  public int field1 = 30;
  public static int field2 = 40; 

  public void method1() {
  System.out.println("OverridingClass.method1()");
  }
  
  //We can't override a public final method
/*  public final void method2(){
  System.out.println("OverridingClass.method2()");
  }*/
 
  private void method3(){
  System.out.println("OverridingClass.method3()");
  }
  
  private final void method4(){
  System.out.println("OverridingClass.method4()");
  }
  
  public static void method5() {
        System.out.println("OverridingClass.method5()");
  }
  
  public void method6() throws CustomException{
  System.out.println("OverridingClass.method6()");
  }
  
  public void method7(){
  System.out.println("OverridingClass.method7()");
  }
  
  public void method8(final int x){
  System.out.println("OverridingClass.method8()");
  }
  
  //A static method cannot be overridden to be non-static instance method 
  /*public void method9() {
        System.out.println("OverridingClass.method9()");
  }*/
  
}
 
public class MethodOverridingDemo {
  
public static void main(String[] args) {
    OverridingClass oc1 = new OverridingClass();
    SuperClassWithDifferentMethods sc3 = new OverridingClass();
    oc1.method1();
    oc1.method2();
    
    
//    Since its private, the below 2 methods are not visible
/*    oc1.method3();
    oc1.method4();*/
    
    oc1.method5();
    try {
oc1.method6();
} catch (CustomException e) {
e.printStackTrace();
}
    oc1.method7();
    oc1.method8(100);
    System.out.println("oc1.field1 : "+oc1.field1);
    System.out.println("oc1.field2 : "+oc1.field2);
    System.out.println("sc3.field1 : "+sc3.field1);
    System.out.println("sc3.field2 : "+sc3.field2);
    sc3.method5();
   
    OverridingClass overClass = new OverridingClass();
        SuperClassWithDifferentMethods supClass = (SuperClassWithDifferentMethods)overClass;
        supClass.method5();                   
        supClass.method1();
 

}
}
 

....to produce the following output:

    
 
OverridingClass.method1()
SuperClassWithDifferentMethods.method2()
OverridingClass.method5()
OverridingClass.method6()
OverridingClass.method7()
OverridingClass.method8()
oc1.field1 : 30
oc1.field2 : 40
sc3.field1 : 10
sc3.field2 : 20
OverridingClass.method5()
SuperClassWithDifferentMethods.method5()
SuperClassWithDifferentMethod.method1()
 

But instead it produces:

    
 
OverridingClass.method1()
SuperClassWithDifferentMethods.method2()
OverridingClass.method5()
OverridingClass.method6()
OverridingClass.method7()
OverridingClass.method8()
oc1.field1 : 30
oc1.field2 : 40
sc3.field1 : 10
sc3.field2 : 20
SuperClassWithDifferentMethods.method5()
SuperClassWithDifferentMethods.method5()
OverridingClass.method1()
 

I was wrong in the output for the 1st & 3rd lines from the end.

Why???

I am following the following tutorial:

http://www.beginner-java-tutorial.com/java-method-overriding.html

Where they say:

The following distinction between invoking instance methods on an object and accessing fields of an object must be noted. When an instance method is invoked on an object using a reference, it is the class of the current object denoted by the reference, not the type of the reference, that determines which method implementation will be executed. When a field of an object is accessed using a reference, it is the type of the reference, not the class of the current object denoted by the reference, that determines which field will actually be accessed. This is demonstrated in the above program.

[Anton Uwe]

Because "public static void method5() {..." is static and there is no "overriding" of static methods, the call "sc3.method5();" is the same as "supClass.method5();", both will be replaced by "SuperClassWithDifferentMethods.method5();".

Because method1() is overridden, "supClass.method1();" will call method1() in OverridingClass. That's exactly what overriding means.

[Joseph Sweet]

But it does not match with what they said in the quote.

sc3 refers to OverridingClass (although sc3 is of the type SuperClassWithDifferentMethods).

Hence, according to the quote,

    
 
sc3.method5();
 

should have invoked the method5() that belongs OverridingClass (whether it is overridden or not) and produce:

    
 
OverridingClass.method5()
 

[ March 06, 2007: Message edited by: Joseph Sweet ]

[Anton Uwe]

Calling a static method the runtime type doesn't matter.
You have declared "SuperClassWithDifferentMethods sc3=...". The compiler will substitute your sc3.method5()-call with "SuperClassWithDifferentMethods.method5();".

Edit: Please note that static methods are not instance methods.
[ March 06, 2007: Message edited by: Anton Uwe ]