Modo automatizzato per estrarre interfacce da una classe Java

Question

Ho una raccolta di classi concrete che definiscono un'API e vorrei estrarre l'interfaccia di queste classi (ovvero: essenzialmente la gerarchia di tipi e metodi pubblici) dal implementazione effettiva dell'API.

Così, per esempio, se una delle classi pubbliche API è

public class Foo extends Bar { 
    /* some fields which I don't care about */ 

    public void method() { 
    /* implementation here */ 
    } 

    public void otherMethod() { 
    /* implementation goes here */ 
    } 

    /* some non public methods which I don't care about */ 

} 

desidero penetrare un'interfaccia e un'implementazione

cioè

public interface FooInterface extends BarInterface { 
    public void method(); 
    public void otherMethod() 
} 

public class Foo implements FooInterface { 
    /* etc etc */ 
} 

e

C'è uno strumento che posso usare per fare questa separazione in modo automatico, o sono andando a dover rollare il mio programma per fare il lavoro? Deve essere uno strumento che richiede interazione minima.

Answer 1

Ho trovato la soluzione!

Eclipse, ha il supporto per il refactoring degli script, gli script sono in xml ma non molto amichevoli ma ho comunque generato gli script che fanno eseguire a Eclipse tutti i refactoring.

Per i dettagli di refactoring sceneggiatura eclissi, look here e utilizzare Eclipse per generare un paio di esempi per voi in modo da sapere ciò che lo script dovrebbe essere simile

Answer 2

Molti IDE, come IntelliJ, hanno un comando "Extract Interface" che svolge una refactoring per voi: http://www.jetbrains.com/idea/features/refactoring.html#Extract_Interface

Answer 3

Sono abbastanza sicuro che si dovrà rotolare il proprio strumento per fare questo lavoro; non è qualcosa che molti sviluppatori userebbero, e chi lo ha usato non lo userebbe spesso. L'interfaccia di estrazione, per essere eseguita correttamente, richiede davvero l'intelligenza (il vero tipo) che la guida. Uno strumento che estraeva ciecamente tutti gli elementi protetti pubblici & e ha costruito ciecamente una gerarchia di interfacce per rispecchiare una gerarchia di implementazione, è tutt'altro che intelligente e il prodotto finale non sarebbe bello. Sviluppare l'intelligenza (artificiale) per prendere buone decisioni su cosa includere e cosa portare avanti - sarebbe uno strumento utile, ma confesso inimmaginabilmente difficile per me. Ciò che gli IDE attuali offrono - assistenza guidata - è probabilmente il miglior compromesso. Tirati su; è sempre meno noioso di fare ogni passo a mano!

Answer 4

javap, uno strumento nel JDK, ti porterà la maggior parte di ciò che si volere. Tuttavia, sii pronto a non gestire correttamente alcune cose - scusa, dimentico cosa, forse annotazioni, classi interne, qualcosa del genere.

Se l'incorporamento javap nel proprietario di Java app avrebbe aiutato, si può fare qualcosa di simile:

import sun.tools.javap.Main; 
... 
    void javap(String className) throws IOException 
    { 
     bos = new ByteArrayOutputStream(); 
     ourOut = new PrintStream(bos); 

     PrintStream oldOut = System.out; 
     System.setOut(ourOut); 

     String[] params = new String[] {"-public", className}; 
     Main.main(params); 

     System.setOut(oldOut); 

     String str = bos.toString(); 
    } 

Ciò richiede l'tools.jar Sun JDK nel classpath.