Qualcuno può fornire un esempio di come funziona l'opzione javac?

Question

Al prompt dei comandi della shell, se si digita javac -help, mi viene indicato che l'opzione -implicit specifica "... se generare o meno file di classe per file con riferimenti impliciti". Ci sono due opzioni che vanno con -implicit:none o class.

In primo luogo, qual è la differenza tra l'utilizzo di -implicit:none e non l'utilizzo dell'opzione - implicit?

In secondo luogo, riguardo al titolo della mia domanda, speravo che un esempio fornito mi avrebbe aiutato a capire che cosa fosse un file implicitamente referenziato. Molte grazie.

Answer 1

Lo avete descritto abbastanza bene nello Java documentation.

La risposta alla tua prima domanda è abbastanza semplice. Non utilizzare l'opzione -implicit è quasi come utilizzare -implicit:class (che è il valore predefinito dell'opzione), ma in modo esplicito utilizzando l'opzione si sopprimono certo avvertimento:

Il compilatore potrebbe non scoprire il bisogno di alcune informazioni di tipo fino al termine dell'elaborazione dell'annotazione. Quando le informazioni sul tipo sono state trovate in un file sorgente e non è stata specificata l'opzione -implicit, il compilatore avvisa che il file è in fase di compilazione senza essere sottoposto all'elaborazione di annotazione senza il . Per disabilitare l'avviso, specificare nella riga di comando (in modo che sia soggetto all'elaborazione dell'annotazione ) o utilizzare l'opzione -implicit per specificare se per tali file di origine devono essere generati o meno file di classe.

Ora la tua seconda domanda. Come la documentazione afferma:

Per compilare un file sorgente, il compilatore spesso ha bisogno di informazioni su un tipo , ma la definizione di tipo non è nei file di origine specificati riga di comando. Il compilatore richiede informazioni sul tipo per ogni classe o interfaccia utilizzata, estesa o implementata nel file di origine. Questo include classi e interfacce non esplicitamente menzionate nel file di origine , ma che forniscono informazioni tramite ereditarietà.

Ad esempio, quando si crea una sottoclasse java.applet.Applet, sei anche utilizzando le classi degli antenati di Applet: java.awt.Panel, java.awt.Container, java.awt.Component e java.lang.Object.

Abbiamo tre classi in tre file: Main, ImplicitClass, BaseImplicitClass.

Main.java:

public class Main { 
    public static void main(String[] args) { 
     ImplicitClass ec = new ImplicitClass(); 
     System.out.println(ec.getClass()); 
    } 
} 

ImplicitClass.java:

public class ImplicitClass extends BaseImplicitClass { 
} 

BaseImplicitClass.java:

public class BaseImplicitClass { 
} 

Quando li compilazione da linea di comando in questo modo: si creano

javac -cp . -implicit:class Main.java 

o

javac -cp . Main.java 

tutti i tre file * .class.

quando si compila lo

javac -cp . -implicit:none Main.java 

solo si crea Main.class.

Quando si compila si sono creati

javac -cp . -implicit:none Main.java ImplicitClass.java 

due file * .class, Main.class e ImplicitClass.class (la ImplicitClass ora è diventato esplicito perché è stato esplicitamente passato al compilatore), ma non BaseImplicitClass.class come questa classe è necessario, ma è implicito.