Cómo sobrescribir un método en Java, pero aún tiene una funcionalidad parcial del método principal

Question

Esta pregunta se realizó durante la entrevista de trabajo, Desarrollo Java, posición del estudiante.

interface SomeInterface { 
    public void execute(); 
} 

class A implements SomeInterface { 
    public void execute() {...} 
} 

La pregunta es: ¿se le pidió

Nueva desarrollador para crear una clase que amplíe la clase A, y crear método denominado Execute, este método va a hacer alguna cosa. Cómo deberíamos reescribir el código anterior para tener un "proceso de inicio" de salida cuando se llama al método Execute (por supuesto, la impresión no debe hacerse en la clase B).

class B extends A { 
    public void execute() { 
     //some code goes here 
    } 
} 

Sé que se puede hacer con dos funciones y una de ellas es abstracta. Aconsejar ...

Answer 1

Este es un ejemplo del template pattern. La superclase abstracta Clase A impone la estructura de procesamiento al hacer las partes "estándar" - en este caso, algo de impresión - y luego invoca las implementaciones concretas de la subclase de hacer el procesamiento real/concreto:

abstract class A implements someIterface { 
    public void Execute() { 
     System.out.println("start process"): 
     doExecute(); 
    } 

    protected abstract void doExecute(); 
} 

class B extends A { 
    protected void doExecute() { 
     // some code goes here 
    } 
} 

Sería ser más usual para:

• El método a ser llamado execute en lugar de Execute
• La interfaz de ser llamado SomeInterface en lugar de someInterface
• La interfaz para tener el método execute

Answer 2

Perdón.

soy principalmente un desarrollador .NET así que no se sever demasiado conmigo, pero en realidad me intentaron una sniplet en C# e hizo algo como esto:

datos de entrada tenemos

interface SomeInterface 
{ 
    void execute(); 
} 

public class A : SomeInterface 
{ 
    public void execute() { 
     Console.WriteLine("Start process"); 
    } 
} 


public class B : A { 

    public void execute() { 
     Console.WriteLine("Execute B"); 
    } 
} 

La cosa es que (y esto debe trabajo en Java también), que si escribo un código, como esto:

SomeInterface inter = new B(); 
inter.execute(); 

se imprimirá a lo solicitado y esperado "Iniciar proceso", se llama a causar inter.exexute se implementa la versión (tan presente en A) incluso si real tipo es B.

Espero que esto ayude.

Answer 3

super llama a la funcionalidad de su clase principal.

public class Test 
{ 
    public static void main(String[] args) 
    { 
     B b = new B(); 
     b.execute(); 
    } 
} 

interface Foo 
{ 
    public void execute(); 
} 

class A implements Foo 
{ 
    public void execute() 
    { 
     System.out.println("from class A"); 
    } 
} 

class B extends A 
{ 
    public void execute() 
    { 
     super.execute(); 
     System.out.println("from class B"); 
    } 
} 

La salida de este código es

from class A 
from class B