Entonces, chicos, he estado jugando con la herencia y me he topado con este programa:

public class HelloWorld {
    static class A {
        void f() { System.out.println("A"); }
    }

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

    static class C {
        void func(B b) { b.f(); }
    }

    static class D extends C {
        void func(A a){ a.f(); }
    }

    public static void main(String args[]) {
        ( (new D())).func( (A) (new B()));
        A a =  new B();
        a.f();
        B b = new B();
        C c = new D();
        c.func(b);
    }
}

Entonces, ¿cómo es que aunque A y C se implementan exactamente de la misma manera en las últimas líneas, los métodos de A son anulados por B, pero los de C no son anulados por D? El programa imprime de la siguiente manera: B B B

1
zxzx28 24 feb. 2020 a las 18:33

2 respuestas

La mejor respuesta

Debido a que la definición de la función de Clase D es más general que C. La función de C toma el parámetro de tipo B, pero la función de D toma el parámetro de tipo A que es un padre de B. Es más general que una función definida en C.

static class D extends C {
    void func(A a){ 
        a.f(); 
    }
}

  B b = new B();
  C c = new D();
  c.func(b);

La variable c apunta al objeto de D, por lo que c.func (b) invoca el método definido en D. A es padre de B, por lo tanto, se llama al método de B. Igual que se llama usando la referencia de A como se muestra a continuación.

  A a =  new B();
  a.f();
2
Ravi Sharma 24 feb. 2020 a las 15:55

Esto se debe a que el método func en D no anula lo mismo de C que el cambio de firma.

static class C {
    void func(B b) { b.f(); }
}
static class D extends C {
    void func(B a){ a.f(); }
}

Esto dará como resultado una anulación del método.

0
Greedo 24 feb. 2020 a las 15:38