Surcharge vs. Redéfinition

Soit    les    classes   

class A {
    public void f(int n) {
        System.out.println("A.f appelee avec " + n);
    }

    public void f(char c) {
        System.out.println("A.f appelee avec " + c);
    }
};

class B extends A {
    public void f(int n) {
        System.out.println("B.f appelee avec " + n);
    }

}

où  A contient une méthode surchargée, et  B  une   sous  classe   de   A qui redéfinit  l'une des méthodes surchargées de A.

1) Tester dans une méthode main() dans une classe Test les appels suivants:

	A a = new A();
	a.f(5);
	a.f('W');	

2) Rajouter maintenant les lignes suivantes et refaire le test.

	B b = new B();
	a = b;
	a.f(5);
	a.f('W');	

Constater le polymorphisme. (Résultat cette fois de a.f(5) est "B.f appelee avec 5".)

3) Reprogrammer les classes A et B comme suit (sans surcharge de f()):

class A {
    public void f() {
        System.out.println("f de A appelee ");
    }
};

class B extends A {
    public void f() {
        System.out.println("f de B appelee ");
    }
};  

On définit maintenant la classe X suivante (où on reporte la surcharge)

 class X {
    public static void g(A a){
        System.out.println("g(A) appelee");
    }
    public static void g(B b){
        System.out.println("g(B) appelee");
    }
}

Tester les appels suivants:

{
    A a = new A();
    a.f();
    X.g(a);
    B b = new B();
    b.f();
    X.g(b);
}

et vérifier  le résultat (normal).

4) Tester maintenant les appels

{
  A a = new B();
  a.f(); 
  X.g(a);	
}

Commenter.

Réponse :

Résultat  "f de B appelee":  Redéfinition (override) de f. Appel résolu à l'éxecution (java)

Résultat  "X.g(A) appelee":   Surcharge (overload) de g. Appel résolu à la compilation (javac)