Java "astratto come" metodo con il corpo

Question

vi sono le seguenti classi:

public abstract class Super 
{ 
    public abstract void run(); 
} 

public class Sub1 extends Super 
{ 
    @Override 
    public void run() 
    { 
     System.out.println("Method called"); 
     System.out.println("Sub1 called"); 
    } 
} 

public class Sub2 extends Super 
{ 
    @Override 
    public void run() 
    { 
     System.out.println("Method called"); 
     System.out.println("Sub2 called"); 
    } 
} 

come posso evitare che devo scrivere il "System.out.println (" metodo chiamato ");" due volte?

Grazie per le risposte

CalibeR.50

Answer 1

Portare la funzionalità comune nella superclasse e definire un altro metodo astratto, per il quale le sottoclassi definiranno la propria implementazione.

public abstract class Super { 
    public void run() { 
     System.out.println("Method called"); 
     printMessage(); 
    } 
    abstract void printMessage(); 
} 

public class Sub1 extends Super { 
    @Override 
    void printMessage() { 
     System.out.println("Sub1 called"); 
    } 
} 

public class Sub2 extends Super { 
    @Override 
    void printMessage() { 
     System.out.println("Sub2 called"); 
    } 
} 

In questo modo è possibile evitare la duplicazione di chiamare il metodo comune della superclasse due volte.

Answer 2

Se si desidera che tutti sottoclassi ad avere un comportamento identico, quindi la tecnica corretta sarebbe quella di codificare il metodo solo nelle superclasse, permettendo alle sottoclassi di ereditare esso . Ma ciò eliminerebbe la necessità che la tua superclasse fosse astratta in questo caso, poiché implementerebbe il suo unico metodo.

Answer 3

Si può mettere run() implementazione nella classe astratta:

// Super is still an abstract class 
public abstract class Super 
{ 
    // While method run is not an abstract method: 
    public void run() 
    { 
     System.out.println("Method called"); 
    } 
} 

public class Sub1 extends Super 
{ 
    // There's no need of declaring run() here unless you want to change its behaviour 
} 

public class Sub2 extends Super 
{ 
} 

Nella versione modificata della tua domanda, si può semplicemente utilizzare una realizzazione corsa ereditato

// Super is still abstract 
public abstract class Super 
{ 
    // But method run is not abstract 
    public void run() 
    { 
     System.out.println("Method called"); 
    } 
} 

public class Sub1 extends Super 
{ 
    @Override 
    public void run() 
    { 
     super.run(); // <- call Super.run() that prints "Method called" 
     System.out.println("Sub1 called"); 
    } 
} 

public class Sub2 extends Super 
{ 
    @Override 
    public void run() 
    { 
     super.run(); 
     System.out.println("Sub2 called"); 
    } 
} 

Answer 4

È possibile inserire il codice comune nel metodo super-classe e chiamarlo dai metodi della sub-classe.

public abstract class Super 
{ 
    public abstract void run(); 
    // code common to both the sub classes implemented 
    public void print() { 
    System.out.println("Method called"); 
    } 
} 

public class Sub1 extends Super 
{ 
    @Override 
    public void run() 
    { 
    print(); 
    System.out.println("Sub1 called"); 
    // sub class specific code here 
    } 
} 

public class Sub2 extends Super 
{ 
    @Override 
    public void run() 
    { 
     print(); 
     System.out.println("Sub2 called"); 
     // sub class specific code here 
    } 
} 

Answer 5

utilizzare il "modello Template Method":

public class Super 
{ 
    public void template() { 
     System.out.println("Method called"); 
     run(); 
    } 

    public abstract void run(); 
} 

public class Sub1 extends Super 
{ 
    @Override 
    public void run() // out called before run 
    { 

    } 
} 

public class Sub2 extends Super 
{ 
    @Override 
    public void run() // out called before run 
    { 

    } 
} 

Aditionally è possibile effettuare run protetto.

Answer 6

Se parte dell'implementazione di run() è comune a Sub1 e Sub2, suggerisco di utilizzare semplicemente l'ereditarietà e l'esecuzione dell'override nelle sottoclassi. Ecco l'esempio di codice:

public abstract class Super 
{ 
    public void run() { 
     // Code shared by all subclasses 
     System.out.println("Method called"); 
    } 

} 

public class Sub1 extends Super 
{ 
    @Override 
    public void run() 
    { 
     super.run(); 
     System.out.println("Sub1 called"); 
    } 
} 

public class Sub2 extends Super 
{ 
    @Override 
    public void run() 
    { 
     super.run(); 
     System.out.println("Sub2 called"); 
    } 
} 

Il trucco è che la classe Super può essere definita abstract, mentre l'attuazione metodi. Se si dispone di sottoclassi che non richiedono il codice condiviso, è possibile ignorare run() senza il codice super.run() e modificarlo.