Héritage de la méthode principale

Question

Je souhaite définir une classe de base qui définit une méthode principale qui instancie la classe et exécute une méthode. Il y a quelques problèmes cependant. Voici la classe de base:

public abstract class Strategy 
{ 
    abstract void execute(SoccerRobot robot); 

    public static void main(String args) 
    { 
     Strategy s = new /*Not sure what to put here*/(); 
     s.execute(new SoccerRobot()) 
    } 
} 

Et voici un exemple classe dérivée:

public class UselessStrategy 
{ 
    void execute(SoccerRobot robot) 
    { 
     System.out.println("I'm useless") 
    } 
} 

Il définit d'une simple méthode execute, qui devrait être appelé dans une méthode principale lors de l'utilisation en tant que l'application principale . Cependant, pour ce faire, j'ai besoin d'instancier la classe dérivée à partir de la méthode principale de la classe de base. Ce qui ne semble pas possible. Je préférerais ne pas avoir à répéter la méthode principale pour chaque classe dérivée, car elle semble quelque peu déséquilibrée.

Existe-t-il une bonne façon de procéder?

Answer 1

Déplacer la principale méthode dans une classe à part. préoccupations distinctes
stratégie (le nom dit tout)
lanceur (assemblage de composants ensemble et déclenchement d'exécution)

public class Launcher 
{ 
    public static void main(String args) 
    { 
     Strategy s = new UselessStrategy(); 
      //OR Strategy s = CreateInstance(args[0]) ; 
      //OR equiv mechanism for Dependency Injection if you don't want to hardcode the derived strategy to use. 
     s.execute(new SoccerRobot()) 
    } 
} 

Answer 2

Vous ne pouvez pas instancier une classe abstraite, mais vous pouvez certainement instancier une classe dérivée à partir de la classe de base. Il suffit donc de supprimer abstraite de la définition de la classe

public class UselessStrategy 

et faire

Strategy s = new UselessStrategy(); 

Answer 3

méthodes statiques telles que le « principal », ne sont pas héritées, mais peuvent être appelés directement. Pour contourner ce problème, vous pouvez paramétrer le nom de classe comme argument à la méthode principale:

public static void main(String args) throws Exception 
{ 
    String className = (args.length > 0) ? args[0] : 'UselessStrategy'; 
    Strategy s = (Strategy) Class.forName(className).newInstance(); 
    s.execute(new SoccerRobot()) 
} 

Si Class.forName est impossible, le maintien d'une cartographie des noms de classe peuvent fournir une table de consultation, par le commentaire de Andreas_D:

private static Map<String, Class<? extends Strategy>> STRATEGY_NAME = 
    new HashMap<String, Class<? extends Strategy>>(); 

static { 
    STRATEGY_NAME.put("Useless", UselessStrategy.class); 
    STRATEGY_NAME.put("Better", BetterStrategy.class); 
} 

public static void main(String args[]) throws Exception { 
    String className = (args.length > 0) ? args[0] : null; 
    Class<? extends Strategy> klass = STRATEGY_NAME.get(className); 
    if (klass == null) klass = UselessStrategy.class; 
    Strategy s = klass.newInstance(); 
    s.execute(); 
} 

Des méthodes automatisées pour maintenir la cartographie pourraient être conçues, telles que l'utilisation de la réflexion, si le besoin s'en fait sentir.

Answer 4

D'où provient la principale méthode? S'il prend des arguments, alors vous pouvez décider d'une stratégie concrète basée sur ces arguments, instancier cette classe de stratégie et appeler la méthode execute dessus.

Answer 5

Je le repenserais.

Placez le code que vous souhaitez exécuter ailleurs, de préférence une méthode non statique, et appelez-le. main() ne devrait pas être utilisé de cette façon.

Je vous recommande de créer une classe Stratégie séparée au lieu de main.

Answer 6

Vous pouvez définir la classe dans un bloc statique de la sous-classe.

public abstract class Strategy 
{ 
    protected static Class<? extends Strategy> instanceClass; 

    abstract void execute(SoccerRobot robot); 

    public static void main(String args) 
    { 
     Strategy s = instanceClass.newInstance() 
     s.execute(new SoccerRobot()) 
    } 
} 

puis

public class UselessStrategy extends Strategy 
{ 
    static { 
     instanceClass = UselessStrategy.class; 
    } 

    void execute(SoccerRobot robot) 
    { 
     System.out.println("I'm useless") 
    } 
}