2010-09-26 59 views

Respuesta

15

Si reemplaza un método padres en su hijo, los objetos secundarios siempre usarán la versión sustituida. Pero; puede usar la palabra clave super para llamar al método principal, dentro del cuerpo del método secundario.

public class PolyTest{ 
    public static void main(String args[]){ 
     new Child().foo(); 
    } 

} 
class Parent{ 
    public void foo(){ 
     System.out.println("I'm the parent."); 
    } 
} 

class Child extends Parent{ 
    @Override 
    public void foo(){ 
     //super.foo(); 
     System.out.println("I'm the child."); 
    } 
} 

Esto imprimiría:

Soy el niño.

de comentario la línea comentada y sería imprimir:

soy el padre.

Soy el niño.

Debe buscar el concepto de polimorfismo.

+0

muchas gracias –

2

Utilice la palabra clave super dentro del método reemplazado en la clase secundaria para usar el método de la clase padre. Sin embargo, solo puedes usar la palabra clave dentro del método reemplazado. El siguiente ejemplo ayudará.

public class Parent { 
    public int add(int m, int n){ 
     return m+n; 
    } 
} 


public class Child extends Parent{ 
    public int add(int m,int n,int o){ 
     return super.add(super.add(m, n),0); 
    } 

} 


public class SimpleInheritanceTest { 
    public static void main(String[] a){ 
     Child child = new Child(); 
     child.add(10, 11); 
    } 
} 

El método add en la clase del niño prevé super.add reutilizar la lógica de adición.

1

En primer lugar, es un mal diseño, si necesita algo así, es una buena idea refactorizar, p. cambiando el nombre del método. Java allows calling of overriden method using the "super" keyword, pero solo un nivel más arriba en la jerarquía, no estoy seguro, quizás Scala y algunos otros lenguajes JVM lo admitan para cualquier nivel.

+0

gracias también creo que es mejor ans ...... –

0

Supongamos que la jerarquía es C->B->A siendo A la clase base.

Creo que hay más para solucionar esto que cambiar el nombre de un método. Eso será trabajo pero ¿es eso una solución?

Una forma es refactorizar todas las funcionalidades comunes a B y C en D, y dejar que B y C hereden de D: (B,C)->D->A Ahora el método en B que ocultaba la implementación de A de C es específico de B y permanece allí. Esto permite que C invoque el método en A sin ningún tipo de hokery.

Cuestiones relacionadas