Questo documento contiene una descrizione delle modifiche più importanti apportate agli strumenti di sviluppo Java per il rilascio 3.1 di Eclipse a partire dalla versione 3.0. Il documento è suddiviso in diverse sezioni:
|
|
J2SE 5.0 |
Eclipse 3.1 include supporto completo per le nuove funzioni di J2SE 5.0 ("Tiger"). La conseguenza più importante della presenza di tale supporto, è che tutte le funzioni di J2SE 1.4, tra cui l'editazione, gli assistenti al codice, la compilazione, il debug, le correzioni rapide, i refactoring, le azioni relative all'origine, la ricerca, ecc., funzioneranno in modo simile con i nuovi tipi e la nuova sintassi di J2SE 5.0. Per sviluppare il codice compatibile con J2SE 5.0, sarà necessario un JRE (Java Runtime Environment) 5.0. Se Eclipse viene avviato per la prima volta, per impostazione predefinita verrà utilizzato un JRE 5.0. In caso contrario, per registrarsi con Eclipse, sarà necessario utilizzare la finestra JRE installati. È possibile aprire questa finestra dalle preferenze Java > JRE installati o dal collegamento Configura predefiniti... nella procedura guidata Nuovo progetto Java. |
|
|
Correzione rapida |
Una nuova correzione rapida consente di modificare le impostazioni di conformità quando si
tenta di inserire un costrutto 5.0 in un progetto 1.4. È richiesto un 1.5 JRE che può essere aggiunto dalla pagina delle
preferenze 'JRE installati'.
|
|
|
Supporto generici nelle procedure guidate Nuovo tipo |
Le procedure guidate Nuovo tipo supportano i tipi generici J2SE 5.0
in diversi campi:
|
|
|
Creazione di enumerazioni e annotazioni |
Con la procedura guidata Nuova Enumerazione o Annotazione è possibile
creare enumerazioni e annotazioni: |
|
|
Proposte di argomenti di tipo |
L'assistente al codice inserisce gli argomenti di tipo corretti durante il
completamento di un tipo nell'editor Java. Gli argomenti di tipo che non possono essere confusi con altri verranno
selezionati e mediante il tasto Tab è possibile spostarsi da un argomento al successivo.
In questo esempio viene inserito
Per verificare questa funzione, abilitare l'opzione Immettere i nomi di argomento nella pagina delle preferenze Java > Editor > Assistente al codice. |
|
|
Dichiarazione del parametro tipo che nasconde un'altra diagnosi di tipo |
Il compilatore Java può indicare che una dichiarazione del parametro tipo, sta
nascondendo un altro tipo.
|
|
|
Ridenominazione refactoring |
La ridenominazione refactoring è stata ampliata in modo da gestire la
ridenominazione dei parametri tipo. |
|
|
Refactoring Deduzione argomenti di tipo generico |
Con J2SE 5.0, il codice potrà utilizzare i generici per migliorare la leggibilità e la
protezione dei tipi statici. Il refactoring
> Deduci argomenti di tipo generico è un nuovo refactoring che consente
ai client di librerie di classi generiche, ad esempio il framework di raccolta Java, di migrare il proprio codice.
Il refactoring deduce i parametri dei tipi generici e rimuove i cast non necessari. Funziona per le singole unità di compilazione e per gli interi pacchetti e progetti Java. |
|
|
Correzioni rapide per i generici |
Per i tipi Java non risolti, è possibile ottenere una proposta per creare
un nuovo parametro tipo: |
|
|
Nuovi filtri per i risultati della ricerca per le ricerche di tipi parametrizzati |
Durante la ricerca di riferimento a un tipo parametrizzato, tipo
|
|
|
Completamento nelle annotazioni |
È supportato il completamento del codice in una singola annotazione del membro
o nel valore dell'attributo dell'annotazione.
|
|
|
Utilizzo del tipo di annotazione come diagnosi di superinterfaccia |
In J2SE 5.0, il linguaggio Java consente ad una classe di implementare
un tipo di annotazione. Tuttavia questa operazione è in genere sconsigliata. Il compilatore Java facoltativamente può indicare tale utilizzo.
|
|
|
Supporto per annotazione @SuppressWarnings |
È supportata l'annotazione J2SE 5.0 @SuppressWarnings. I nomi dei token di avviso riconosciuti sono:
"all", "boxing", "dep-ann", "deprecation", "incomplete-switch",
"hiding", "finally", "static-access", "nls", "serial",
"synthetic-access", "unqualified-field-access", "unchecked", "unused" e
"warningToken". Nell'esempio seguente il primo campo ha l'annotazione
@SuppressWarnings("deprecation") e non è riportato nessun avviso di elemento obsoleto. Il secondo campo non ha tag ed è riportato un avviso.
Tenere presente che una opzione del compilatore controlla se le annotazioni @SuppressWarnings sono attive o meno. Fare riferimento alla preferenza Java > Compilatore > Errori/Avvisi > Opzioni J2SE 5.0 > Abilita annotazioni '@SuppressWarnings' Per impostazione predefinita, i token di avviso non gestiti vengono segnalati da un avviso. Tale avviso può essere eliminato utilizzando l'annotazione @SuppressWarnings("warningToken"). |
|
|
Correzione rapida |
Gli avvisi che possono essere eliminati utilizzando un'annotazione
@SuppressWarning dispongono di una correzione rapida per eseguire l'operazione. Applicando la correzione rapida all'avviso locale non utilizzato il risultato ottenuto sarà: |
|
|
Diagnosi annotazione @Override mancante |
Il compilatore Java può indicare un metodo che sovrascrive un metodo di superclasse,
ma non ha un'annotazione @Override appropriata.
Le annotazioni @Override mancanti possono essere aggiunte utilizzando la Correzione rapida. |
|
|
Diagnosi annotazione @Deprecated mancante |
Il compilatore Java riconosce le annotazioni
@Deprecated e le tratta come il commenti doc
/** @deprecated */. Facoltativamente può indicare quei costrutti obsoleti a cui manca un'annotazione
@Deprecated appropriata (per incoraggiare l'utente ad ad utilizzare le annotazioni invece dei tag di commento doc).
|
|
|
Diagnosi istruzione di passaggio a enumerazione non completa |
Il compilatore Java può indicare le istruzioni di passaggio a enumerazioni
non complete
|
|
|
Diagnosi del compilatore per l'identificativo 'enum' |
Il compilatore Java è in grado di trovare ed indicare le ricorrenze in cui
'enum' è utilizzato come identificativo. 'enum' è un identificativo legale fino al livello origine
1.4, ma è una parola chiave riservata nell'origine 5.0. Abilitare questo avviso per anticipare problemi
nella migrazione dell'origine. Fare riferimento alla preferenza Java
> Compilatore > Conformità JDK > Disattiva identificativi definiti 'enum'.
|
|
|
Correzione rapida |
La correzione rapida supporta la creazione di costanti di enumerazione. Nell'esempio seguente, la costante BLUE manca dai colori dell'enumerazione |
|
|
Parametro boxing automatico |
I parametri proposti comprendono i parametri
di boxing e unboxing automatici: Nota: la preferenza Java > Editor > Assistente al codice > Immettere i nomi di argomento al completamento deve essere abilitata. |
|
|
Diagnosi di boxing |
La funzione di boxing automatico di J2SE 5.0 è molto potente ma può causare comportamenti
imprevisti soprattutto durante la trasmissione degli argomenti. Il compilatore introduce una diagnosi facoltativa
che indica quando vengono eseguite le operazioni di boxing e unboxing automatiche. Nel seguente esempio,
verrebbe richiamato foo(Integer)
se l'opzione di unboxing automatica non fosse eseguita. Dal momento che invece viene eseguita, viene richiamato
foo(int) .
|
|
|
Supporto per J2SE 5.0 nell'editor Java |
L'editor Java consente di colorare la sintassi per le nuove funzioni
di linguaggio di J2SE 5.0. Passare alla pagina delle preferenze Java > Editor
> Colorazione sintassi per modificare i colori o per abilitare la colorazione
semantica di variabili dei tipi, elementi
dell'annotazione e espressioni di boxing e unboxing automatiche:
|
|
|
Novità per il modello di ciclo |
Il modello foreach
inserisce un nuovo ciclo 'for' nel codice, proponendo variabili Iterable locali: |
|
|
Converti in avanzato per loop |
Un nuovo assistente rapido (Ctrl+1)
è in grado di convertire il vecchio stile per loop di matrici e raccolte nel nuovo loop migliorato per
J2SE 5.0:
La correzione rapida semplifica il loop in: |
|
|
Argomento varargs |
Il compilatore Java può indicare i richiami al metodo
varargs sospetti. Un ultimo argomento null non è riportato come matrice 1-element come previsto; aggiungendo un cast esplicito
l'intenzione del codice risulta più chiara.
Le impostazioni delle preferenze si trovano in Java > Compilatore > Errori/Avvisi > Opzioni di J2SE 5.0 > Corrispondenza tipo inesatta per gli argomenti vararg. |
|
|
Completamento che utilizza importazioni statiche |
Il completamento del codice nell'editor Java è in grado di elaborare
le importazioni statiche durante la deduzione dei completamenti sensibili al contesto.
|
|
|
Gruppi di importazione |
Per organizzare le importazioni statiche, creare gruppi per le importazioni e inserirle dove
desiderato. È possibile definire un gruppo 'others' per la raccolta di tutte le importazioni che non corrispondono
a nessun gruppo: La funzione del gruppo 'others' è disponibile anche per le importazioni non statiche. |
|
|
Supporto per |
È stato aggiunto supporto per il file di origine speciale
package-info.java, che consente di annotare e documentare i pacchetti. Tutti gli strumenti JDT (assistente al codice, selezione codice, ricerca, struttura, gerarchie di tipi
ecc.) possono essere utilizzati in questa unità di compilazione speciale.
I commenti doc interni a package-info.java vengono elaborati e vengono verificati la sintassi e i riferimenti nei tag di commento standard. |
|
|
Programma di formattazione codice per i costrutti J2SE 5.0 |
Il programma di formattazione codice supporta tutti i nuovi costrutti
di linguaggio di J2SE 5.0. Per i controlli di gestione, fare riferimento alla pagina delle preferenze:
Java > Stile codice > Programma di formattazione codice: |
|
|
Debug del codice di origine 5.0 |
È possibile eseguire e sottoporre a debug il codice di origine 5.0 con 1.5 JRE. Le valutazioni del debug Java supportano i costrutti di J2SE 5.0, i generici e i miglioramenti per i loop. |
|
|
Modifica della denominazione dei file di classe per i tipi interni locali |
Nella modalità di conformità 5.0, il compilatore Java
genera file di classe che si attengono alla convenzione di denominazione specificata in
JLS 13.1 (terza edizione) per i tipi interni di locale. Come conseguenza dell'esempio seguente, invece di generare
un file X$1$A.class , verrà generato il file X$1A.class .
|
|
|
|
Punti di controllo e |
Facendo doppio clic sul righello dell'editor Java, vengono creati dei punti di controllo sui campi e punti di interruzione delle voci del metodo sulle dichiarazioni del metodo. |
|
|
Blocchi e deadlock |
I blocchi di un thread e il blocco atteso da un thread possono essere visualizzati incorporati nella vista Debug mediante il menu Mostra controlli nel menu a discesa della vista Debug. I thread e i blocchi coinvolti in un deadlock vengono evidenziati in rosso. |
|
|
Tracce dello stack |
Per esplorare una traccia copiare una traccia dello stack nella Console di traccia stack Java e utilizzare i collegamenti ipertestuali, La Console di traccia stack Java può essere aperta dal menu a discesa Apri console nella vista Console. Le tracce di stack copiate possono essere formattate mediante l'associazione ai tasti standard Formatta. |
|
|
'toString()' incorporato |
Il valore toString()-computed di una variabile può essere visualizzato nella struttura della vista Variabili e nell'area dei dettagli. Il comando Programmi di formattazione dettagli Java... nel menu a discesa della vista viene utilizzato per configurare il funzionamento della funzione. |
|
|
Strutture logiche definite dall'utente |
Il debugger Java adesso consente di controllare gli elementi visualizzati nella vista Variabili per diversi tipi di oggetti. Ad esempio, è possibile visualizzare le raccolte come una semplice matrice di valori, invece dei dettagli relativi alla modalità di implementazione di tale oggetto particolare. Queste impostazione viene effettuata nella pagina delle preferenze
Java > Debug> Strutture logiche in cui si associa una classe specifica o un'interfaccia a una singola espressione
(ad esempio |
|
|
Modifica al valore delle variabili migliorata |
Il debugger Java adesso consente di modificare il valore delle variabili immettendo un'espressione nella finestra Modifica valore o nell'area dei dettagli della vista Variabili e scegliendo Salva. |
|
|
Trova variabile |
L'azione Trova variabile nella vista Variabili, consente di immettere il nome della variabile che si desidera ricercare. Durante la digitazione, nella vista Variabili viene selezionata la variabile visibile successiva che corrisponde al testo immesso. Anche la finestra Ricerca variabili mostra le variabili che corrispondono al testo immesso. |
|
|
Collegamenti Javadoc |
È adesso possibile associare un diverso percorso Javadoc a ciascun JAR nelle librerie JRE. |
|
|
|
Nuove impostazioni del compilatore |
Quando la verifica Javadoc è abilitata, è possibile configurarlo per
Queste impostazioni si trovano nella pagina delle preferenze Java > Compilatore > Javadoc. |
|
|
Assegnazione senza diagnosi degli effetti per espressioni postfix |
La diagnosi facoltativa per l'assegnazione senza effetti rileva
il caso in cui un'espressione postfix viene assegnata alla stessa variabile, ad esempio i = i++;
|
|
|
UID versione seriale |
Esiste una nuova diagnosi per il compilatore, facoltativa, per le classi
serializzabili a cui manca una dichiarazione di un campo Le impostazioni delle preferenze si trovano in Java > Compilatore > Errori/Avvisi > Problemi di programmazione potenziali |
|
|
Rilevamento di riferimenti a classi interne |
È possibile annotare librerie (e progetti) nel percorso di generazione
Java (Proprietà > Percorso di generazione Java > Librerie) per identificare qualsiasi pacchetto interno
che si desidera evitare di indicare come riferimento direttamente dal codice. Ad esempio, generalmente è sconsigliato
dipendere da qualsiasi pacchetto specifico del fornitore, ad esempio
com.ibm.* o com.sun.* , normalmente presenti nelle librerie J2SE. Le limitazioni all'accesso vengono espresse con una combinazione di regole di inclusione ed esclusione nelle voci del
percorso di generazione. La sintassi del modello segue l'annotazione degli insiemi di file Ant e corrisponde al percorso
del file di classe. Ad esempio, utilizzando il modello com/ibm/** come regola di esclusione,
l'accesso verrebbe limitato a tutte le classi nel pacchetto com.ibm e nei rispettivi sottopacchetti;
utilizzando il modello org/eclipse/**/internal/** come regola di esclusione, verrebbero rilevati tutte
le classi contenute nei pacchetti Eclipse. Quando si forniscono regole di inclusione, solo tutte le corrispondenze
vengono considerate corrette.
Le impostazioni delle preferenze Java > Compilatore > Errori/Avvisi > API obsolete e limitate consente di controllare se indicare come errori o avvisi i riferimenti erranti (per impostazione predefinita, i riferimenti proibiti sono errori e i riferimenti sconsigliati sono avvisi). |
|
|
Regole di accesso per le librerie e i progetti |
È possibile definire le regole di accesso nelle librerie
indicate come riferimento e nei progetto per consentire/proibire/sconsigliare esplicitamente l'accesso a tipi
specifici.
|
|
|
|
Icone di raggruppamento e didascalie migliorate |
Quando si raggruppano gli elementi Java, la riga rimanente nell'editor Java
contiene il nome dell'elemento. La prima riga di commento viene visualizzata per i commenti Javadoc raggruppati. Le nuove icone di raggruppamento visualizzate nell'editor Java sono diverse dagli indicatori di sovrascrittura e
di implementazione: |
|
|
Raggruppamento commento intestazione |
I commenti delle intestazioni e le istruzioni di copyright
nei file di origine Java possono essere raggruppati: |
|
|
Ricorrenze dei metodi ereditati |
L'editor Java può evidenziare tutte le dichiarazioni dei metodi
che implementano o sovrascrivono i metodi ereditati dal supertipo selezionato. Fare riferimento alle impostazioni delle preferenze Java > Editor
> Indicazione ricorrenze > Metodo che implementa un'interfaccia.
|
|
|
Menu rapido Nuova ricorrenza |
Nell'editor Java, premendo Ctrl+Maius+U è possibile
aprire un menu di scelta rapida che consente di ricercare le ricorrenze.
Nota: gli utenti che preferiscono il vecchio comportamento, possono riassegnare la sequenza di tasti precedente al comando "Ricerca tutte le ricorrenze nel file. |
|
|
Evidenziazione dei membri di classe obsoleti nell'editor Java |
I membri di classe obsoleti vengono contrassegnati dall'evidenziazione
avanzata: |
|
|
Riferimenti in Javadoc |
Eclipse adesso riconosce i riferimenti agli elementi Java
interni ai commenti doc (ad esempio, tag @see, @link,
@linkplain, @throws, @exception, @param o @value). In tal modo vengono abilitati
le descrizioni a comparsa e i collegamenti all'elemento Java indicato come riferimento.
|
|
|
Completamento delle parole migliorato |
Il completamento del codice Java delle parole non propone più automaticamente tutti
i tipi visibili nel percorso del completamento. Sarà necessario immettere il primo carattere del tipo per ottenere
una proposta di completamento.
|
|
|
Descrizione a comparsa per Javadoc |
Il Javadoc mostrato mediante Modifica > Mostra descrizione comandi (F2) viene visualizzato nel widget SWT Browser. |
|
|
Regolazione del rientro nello spostamento righe |
I comandi Sposta righe (Alt+Su/Giù) e Copia righe (Ctrl+Alt+Su/Giù) regolano automaticamente il rientro delle righe selezionate quando vengono spostate nell'editor Java. |
|
|
Editor file delle proprietà Java migliorato |
Gli editor per i file delle proprietà Java sono stati migliorati. Offrono
evidenziazione della sintassi, comportamento su doppio clic migliorato e preferenze per i tipi di carattere separate. I colori per l'evidenziazione della sintassi vengono regolati dalla pagina delle preferenze
Java > Editor dei file delle proprietà. Il controllo ortografico è disponibile ed è possibile utilizzare
la correzione rapida (Ctrl+1) per correggere eventuali errori di ortografia.
|
|
|
Utilizzo delle stringhe esternalizzate |
Quando ci si ferma su una chiave per una stringa esternalizzata nell'editor Java, viene mostrato
in un testo a comparsa il valore esternalizzato associato: Premere Ctrl+clic per passare direttamente alla voce nel file delle proprietà Java corrispondente: |
|
|
Passaggio dalla chiave delle proprietà nell'editor file delle proprietà al rispettivo riferimento |
Utilizzare Esplora > Apri (F3)
o Ctrl+clic per passare da una chiave delle proprietà nell'editor file delle proprietà al codice nel punto in
cui si fa riferimento alla chiave.
|
|
|
La procedura guidata Esternalizzazione stringhe supporta nuovi insiemi di messaggi |
La procedura guidata Esternalizzazione stringhe supporta il meccanismo di esternalizzazione
delle stringhe di Eclipse, una novità per questo rilascio: |
|
|
Nuova API per la creazione delle proposte di codice come nell'editor Java |
Implementazione di un editor per i linguaggi simili a Java. Creare le proprie proposte dell'assistente al codice simili a quelle dell'editor Java. Istanziare CompletionProposalCollector
per ottenere le stesse proposte dell'editor Java o assegnarlo a una sottoclasse per unire le proposte personalizzate. Utilizzare CompletionProposalLabelProvider
per ottenere le immagini e le etichette e ordinare le proposte utilizzando CompletionProposalComparator .
Pacchetto: |
|
|
|
Nuova finestra Apertura tipo |
La finestra Apertura tipo Java è stata migliorata in diversi modi:
I tipi mostrati nella finestra, adesso possono essere rilevati mediante una query nel motore di ricerca Java. In tal modo si risparmiano 4-6 MB in uno spazio di lavoro per lo sviluppo Eclipse normale rispetto ai precedenti approcci. |
|
|
Organizzazione dello spazio di lavoro con molti progetti |
Utilizzare Mostra > Insieme di lavoro nel menu della
vista Esplora pacchetti per abilitare una nuova modalità che mostra gli insiemi di lavoro
come elementi superiori. Questa modalità rende più facile gestire gli spazi di lavoro contenenti molti progetti.
Utilizzare Seleziona insiemi di lavoro nel menu della vista di Esplora pacchetti per configurare gli insiemi di lavoro da visualizzare. La finestra consente di creare nuovi insiemi di lavoro Java, definire gli insiemi visualizzati e in che ordine. Gli insiemi di lavoro possono anche essere redisposti direttamente in Esplora pacchetti utilizzando le funzioni di trascinamento e di copia e incolla. |
|
|
Pagina Cartella di origine migliorata per la procedura guidata Nuovo progetto Java |
Una pagina per la configurazione della cartella di origine consente di creare
i progetti da un'origine esistente. È possibile definire le voci della cartella di origine, le cartelle
di inclusione/esclusione direttamente nella struttura e verificare i risultati dell'azione eseguita immediatamente.
|
|
|
Condivisione impostazioni del progetto |
Ciascun progetto Java può avere impostazioni personalizzate per le opzioni del
compilatore e lo stile del codice. Tali impostazioni vengono archiviate nello stesso progetto e applicate automaricamente
quando il progetto viene caricato o aggiornato dal repository.
Modificando le impostazioni di un progetto Java attraverso l'UI tali modifiche vengono scritte in un file nella directory .settings. Il contenuto del file delle impostazioni è generato automaticamente e non è destinato ad una modifica diretta. |
|
|
Passaggio alle impostazioni specifiche del progetto |
La pagina delle preferenze per le impostazioni configurabili per i progetti
contiene un collegamento alla pagina delle preferenze del progetto.
|
|
|
Percorsi Javadoc memorizzati nel file .classpath |
I percorsi Javadoc collegati ai file JAR
e alle cartelle delle classi vengono archiviati nel file .classpath in modo che possano essere condivisi
con il team. All'avvio di 3.1, un'attività in background migrerà
tutti i percorsi archiviati in precedenza internamente al file .classpath.
I percorsi Javadoc sono utilizzati da 'Apri Javadoc esterno' (CTRL + F2) e dalla procedura guidata Javadoc. |
|
|
Tasti di accesso rapido per l'assistente e le correzioni rapidi. |
Alcuni degli assistenti rapidi più comuni come Rinomina in file e
Assegna alla locale possono essere richiamati direttamente con
Ctrl+2 R e Ctrl+2 L. Verificare la pagina delle preferenze per i tasti
per le correzioni rapide che supportano richiamo diretto.
|
|
|
Nuove correzioni rapide |
Per diverse opzioni del compilatore, sono state aggiunte nuove correzioni
rapide, ad esempio:
|
|
|
Nuovi assistenti rapidi |
All'editor Java sono stati aggiunti diversi assistenti rapidi (Ctrl+1):
|
|
|
Annulla/ripristina refactoring disponibile nel menu Modifica |
L'operazione di annulla/ripristina refactoring è adesso disponibile nel menu di testo ed è stata rimossa dalla barra dei menu generale. Inoltre adesso tali operazioni sono integrate nell'editor Java. Ad esempio, un refactoring attivato dall'editor, può essere annullato nell'editor semplicemente premendo Ctrl+Z. |
|
|
Regolazione visibilità dei membri |
I comandi di refactoring Sposta metodo, Sposta tipo di membro in un
nuovo file, Sposta membro statico, Sposta a un livello superiore e Sposta a un livello inferiore
modificano automaticamente la visibilità dei campi indicati come riferimento, dei tipi e dei metodi laddove sia necessario.
|
|
|
Refactoring Sposta metodo |
Il comando Refactoring > Sposta è stato modificato per supportare
meglio lo spostamento dei metodi di istanza. Le nuove funzioni includono:
|
|
|
Refactoring Utilizza supertipo dove possibile |
Il refactoring Utilizza supertipo dove possibile, è stato ampliato con una
preferenza che specifica se le ricorrenze dei tipi nelle espressioni instanceof devono essere aggiornate: |
|
|
Menu Percorso di generazione in Esplora pacchetti |
Il menu di scelta rapida di Esplora pacchetti Java contiene la nuova voce
'Percorso di generazione, che propone azioni sensibili al contesto per modificare il percorso di generazione di
un progetto Java.
È possibile aggiungere/rimuovere nuove cartelle di origine, archivi e librerie ed includere/escludere cartelle
e file da una cartella di origine: |
|
|
Nuovo profilo del programma di formattazione integrato Eclipse predefinito |
Anche se il profilo del programma di formattazione codice 3.0 predefinito di Eclipse si chiama Convenzioni Java, la formattazione di un file utilizzando questo profilo usa le schede per il rientro invece degli spazi. È stato aggiunto un nuovo profilo chiamato Eclipse che utilizza le schede per il rientro. Per utilizzare le impostazioni della convenzione Java, passare dal profilo del programma di formattazione alle Convenzioni Java mediante la pagina delle preferenze Java > Stile codice > Programma di formattazione. |
|
|
Modifica delle impostazioni di riga multipla in una volta sola |
Il programma di formattazione codice Java consente modificare le impostazioni
relative alle righe multiple in una volta selezionandole nella struttura e modificando le impostazioni: Le impostazioni del programma di formattazione codice si trovano nella pagina delle preferenze Java > Stile codice > Programma di formattazione. |
|
|
Impostazioni di rientro miste |
Le preferenze del programma di formattazione Java consentono di configurare la dimensione
delle schede indipendentemente dalla dimensione del rientro (vedere la scheda Rientro nel profilo
del programma di formattazione):
Ad esempio, impostare Dimensione scheda su 8 e Dimensione rientro su 4 per rientrare l'origine di quattro spazi. Se Criterio scheda viene impostato su Misto, ogni due unità di rientro verranno sostituite da un carattere di tabulazione. I profili del programma di formattazione possono essere configurati nella pagina delle preferenze Java > Stile codice > Programma di formattazione. |
|
|
Riesegui prima le verifiche non riuscite |
La vista JUnit contiene una nuova azione che consente di rieseguire
le verifiche non riuscite prima di qualsiasi altra verifica trasmessa.
|
|