Va bene, può essere una domanda sciocca, ma tutti usano queste cose in modo diverso. Quali sono alcuni dei migliori risparmi di tempo disponibili per questo IDE.

Tom

Non dimenticare Ctrl+ Shift+ L, che mostra un elenco di tutte le combinazioni di scorciatoie da tastiera (nel caso in cui dimentichi qualcuna di quelle elencate qui).

Ctrl-2 qualcosa

Sembra che nessuno abbia menzionato Ctrl-2 L (assegna a una nuova variabile locale) e Ctrl-2 F (assegna a un nuovo campo), questi hanno cambiato il modo in cui scrivo il codice.

In precedenza, stavo digitando, ad esempio (| è la posizione del cursore):

Display display = new |

e poi ho premuto Ctrl-Spazio per completare la chiamata al costruttore. Adesso digito:

new Display()|

e premi Ctrl-2 L, che si traduce in:

Display display = new Display()|

Questo accelera davvero le cose. (Ctrl-2 F fa lo stesso, ma assegna a un nuovo campo piuttosto che a una nuova variabile.)

Un'altra buona scorciatoia è Ctrl-2 R: rinomina nel file. È molto più veloce del rinominare il refactoring (Alt-Shift-R) quando si rinominano cose come le variabili locali.

In realtà sono andato alla pagina delle preferenze di personalizzazione dei tasti e ho assegnato tutti i tipi di correzioni rapide aggiuntive a Ctrl-2-qualcosa. Ad esempio, ora premo Ctrl-2 J per dividere / unire la dichiarazione della variabile, Ctrl-2 C per estrarre una classe interna nel livello superiore, Ctrl-2 T per aggiungere la dichiarazione di lanci alla funzione, ecc. Ci sono tonnellate di rapidamente assegnabili correzioni, scegli i tuoi preferiti e assegnali alle scorciatoie Ctrl-2.

Modelli

Un altro dei miei preferiti nel mio modello "npe", definito come:

if (${arg:localVar} == null)
    throw new ${exception:link(NullPointerException,IllegalArgumentException)}("${arg:localVar} is null");

Ciò mi consente di aggiungere rapidamente controlli di argomenti nulli all'inizio di ogni funzione (specialmente quelli che si limitano a salvare l'argomento in un campo o aggiungerlo a una raccolta, in particolare i costruttori), il che è ottimo per rilevare i bug in anticipo.

Vedi modelli più utili su www.tarantsov.com/eclipse/templates/ . Non li elencherò tutti qui perché ce ne sono molti e perché spesso ne aggiungo di nuovi.

Completamento

Alcuni trucchi per il completamento del codice:

• supporto per il caso del cammello menzionato in un'altra risposta: digita cTM, ottieni currentTimeMillis
• costruttore predefinito: nella dichiarazione di classe senza costruttore predefinito premere Ctrl-Spazio, la prima scelta sarà crearne uno
• sovraccarico: nella dichiarazione della classe inizia a digitare il nome di un metodo che puoi sovraccaricare, Ctrl-Spazio, sceglierne uno
• creazione getter / setter: digita "get", Ctrl-Space, scegli un getter da creare; lo stesso con "è" e "set"

Assegna a un nuovo campo

Ecco come aggiungo i campi.

1. Se non hai ancora costruttori, aggiungine uno. (Ctrl-Spazio ovunque in una dichiarazione di classe, scegli la prima proposta.)

2. Aggiungi un argomento (| è la posizione del cursore):

   public class MyClass {
       public MyClass(int something|) {
       }
   }
   

3. Premi Ctrl-1, scegli "Assegna a un nuovo campo". Ottieni:

   public class MyClass {
       private final Object something;
       public MyClass(Object something) {
           this.something = something;
       }
   }
   

4. Aggiungi un controllo del puntatore nullo se appropriato (vedi il modello "npe" sopra):

   public class MyClass {
       private final Object something;
       public MyClass(Object something) {
           npe|
           this.something = something;
       }
   }
   

   Premi Ctrl-Spazio, ottieni:

   public class MyClass {
       private final Object something;
       public MyClass(Object something) {
           if (something == null)
               throw new NullPointerException("something is null");
           this.something = something;
       }
   }
   

Un grande risparmio di tempo!

ctrl-shift-r e il suo compagno, ctrl-shift-t, per aprire rispettivamente una risorsa o un tipo. Le risorse includono tutti i file nei progetti aperti (inclusi i file non java) e i tipi includono i tipi java nei progetti o in una libreria inclusa nei progetti.

Crtl+ 1è il mio preferito. Le soluzioni rapide per gli scarabocchi rossi.

Si trova anche nel menu Modifica -> Correzione rapida.

Ctrl+ Shift+ Oper organizzare le importazioni, che le formatterà bene, rimuoverà le importazioni non necessarie e aggiungerà le importazioni mancanti.

Ctrl-J avvia una ricerca incrementale.

Premi Ctrl-J, quindi inizia a digitare. Usa su / giù per trovare istanze precedenti / successive di ciò che hai digitato.

Ctrl-Shift-J ricerca all'indietro.

Digita "syso", quindi premi Ctrl+ Spaceper espanderlo in System.out.println ().

Molto utile.

CTRL+ 3fa apparire un elenco in anticipo di tutti i comandi di menu.

• CTRL-SHIFT-g: trova gli utilizzi del metodo o del campo sotto il cursore, assolutamente necessari per la comprensione del codice
• CTRL-F6: naviga tra l'elenco delle finestre dell'editor aperte, se lo digiti una sola volta e lasci andare torni alla finestra dell'editor precedente, farlo successivamente è un bel modo per saltare avanti e indietro
• CTRL-t: su una classe o metodo ti mostrerà la gerarchia dei tipi, molto utile per trovare implementazioni di un metodo di interfaccia ad esempio

Facendo clic sul tipo restituito nella dichiarazione di un metodo vengono evidenziati tutti i punti di uscita del metodo.

per esempio:

1: public void foo()
2: {
3:   somecode();
4:    if ( blah ) return;
5:
6:    bar();
7: }

cliccando su void si evidenzierà il ritorno sulla riga 4 e la chiusura } sulla riga 7.

Aggiornamento : funziona anche per provare {} blocchi di cattura. Se metti il ​​cursore su un'eccezione nel blocco catch ed eclipse evidenzierà i probabili metodi che potrebbero generare quell'eccezione.

Il completamento del codice supporta CamelCase, ad esempio, la digitazione CWARmostrerà un risultato per ClassWithAReallyLongName. Inizia a utilizzare questa funzione e non digiterai mai più un altro nome di classe lungo.

(parti copiate da un'altra risposta perché penso che le risposte con solo un suggerimento / suggerimento siano le migliori per il sondaggio)

Alt-Freccia su sposta la selezione corrente su di una linea, Alt-Freccia giù la sposta verso il basso. Uso sempre Alt-Maiuscole-Freccia su / giù. Ctrl-K e Ctrl-Maiusc-K sono abbastanza utili, trovando l'occorrenza successiva / precedente della selezione corrente (o l'ultima Trova, se non è selezionato nulla).

C'è un'opzione per posizionare automaticamente la parentesi graffa di apertura e un punto e virgola nella posizione "corretta". Dovrai abilitarlo - Scegli Finestra / Preferenze e digita "parentesi graffa" nella casella di ricerca - dovrebbe essere facilmente individuabile (nessuna eclissi su questo computer). L'effetto:

• Digitare un punto e virgola in qualsiasi punto della riga lo posizionerà alla fine di questa riga (come in word / openoffice: Backspace se desideri averlo nella posizione originale)
• Digitando una parentesi graffa di apertura quando sei appena dentro un altro paio di parentesi graffe la posizionerà alla fine di questa riga, come in questo esempio

("|" è il cursore):

if(i==0|)

digitando "{" ora si otterrà

if(i==0) {|

Hippie expand / Word Complete, afaik ispirato a Emacs: completerà automaticamente qualsiasi parola in qualsiasi editor in base ad altre parole in quel file. Completamento automatico all'interno di stringhe letterali nel codice Java, nei file xml, ovunque.

Alt + /

Alt-Shift-R sta per rinomina , non refactoring. Il refactoring è un termine più generale (come definito dal libro ).

Tuttavia, è uno dei miei refactoring preferiti. Altri includono:

• Alt-Maiusc-M : Metodo di estrazione (quando è selezionato un blocco di codice o un'espressione)

• Alt-Maiusc-L : Estrai variabile locale (quando un'espressione è selezionata)

Estrai variabile locale è particolarmente utile quando non ricordo (o mi preoccupo di digitare) il tipo di risultato di un metodo. Supponendo che tu abbia un metodo JdbcTemplate createJdbcTemplate()nella tua classe, scrivi un codice come questo:

void someQuery() {
    createJdbcTemplate()
}

Seleziona l'espressione createJdbcTemplate(), clicca Alt-Maiusc-L, digita il nome della variabile e premi Invio.

void someQuery() {
    JdbcTemplate myTemplate = createJdbcTemplate();
}

CTRL+ D- per eliminare la riga corrente

Assolutamente, Ctrl+ Qper andare all'ultima posizione di modifica. È molto utile subito dopo essere stato interrotto dal telefono, dal capo o da altri.

Ctrl+ Shift+ M: cambia un metodo statico o un riferimento ad attributo statico di una classe in un'importazione statica.

Prima

import X;

...
X.callSomething();

Dopo

import static X.callSomething;

...
callSomething();

Alt+ Shift+ La Upfreccia aumenta la selezione. Alt+ Shift+ Downfa l'opposto.

Alt+ Upo Alt+ Downper spostare le linee

Nessuno ha ancora menzionato il migliore. Fare clic sul nome di una classe o di un metodo e premere Ctrl+ T.

Ottieni una rapida gerarchia dei tipi. Per il nome di una classe vedi l'intera gerarchia di classi. Per un nome di metodo si ottiene la gerarchia che mostra le superclassi e le sottoclassi, con le implementazioni di quel metodo distinte dalle citazioni astratte o dalle classi che non menzionano il metodo.

Questo è enorme quando ti trovi in ​​una dichiarazione di metodo astratto e vuoi vedere rapidamente dove è implementato.

F3 è stato il mio preferito, apre la definizione per l'elemento selezionato.

Ctrl+ Shift+ Rha una caratteristica interessante, puoi usare solo le lettere maiuscole di cammello di una classe durante la ricerca (come digitare CWAR mostrerà un risultato per ClassWithAReallyLongName).

Alt+ Shift+ W> Package Explorer semplifica la vita durante la navigazione in grandi progetti.

Un trucco per le scorciatoie da tastiera consiste nell'usare i set di commit nella vista Team-> Synchronize per organizzare le modifiche prima di eseguire il commit.

Imposta un set di modifiche come predefinito e tutte le modifiche apportate ai file verranno inserite in quel set, rendendo più facile vedere cosa hai cambiato mentre lavoravi su uno specifico difetto / funzionalità e altre modifiche che hai avuto durante il test, ecc.

CTRL + SPAZIO, per qualsiasi cosa, ovunque.

Genera getter e setter.

Crea costruttori usando i campi

Metodo di estrazione ...

Refactoring-> Rinomina

CTRL + O per la struttura rapida. CTRL + O + CTRL + O per la struttura ereditata.

F4 per visualizzare una gerarchia di tipi

Aprire la gerarchia delle chiamate per visualizzare da dove viene chiamato un metodo.

CTRL + MAIUSC + T per aprire un tipo Java

CTRL + MAIUSC + R per aprire qualsiasi risorsa.

ALT + sinistra o destra per andare avanti o indietro nelle posizioni di modifica nei tuoi documenti (navigazione facile)

Sostituisci / implementa i metodi se sai che farai molti metodi (altrimenti, CTRL + SPAZIO è meglio per la selezione uno alla volta.

Refactoring-> Estrai interfaccia

Refactoring-> Pull up

Refactoring-> Push down

CTRL + MAIUSC + O per organizzare le importazioni (quando si digita il nome della classe generale come Mappa, premendo CTRL + SPAZIO e quindi selezionando la classe appropriata verrà importata direttamente per te).

CTRL + MAIUSC + F per la formattazione (sebbene il formattatore integrato di Eclipse possa essere un po 'braindead per lunghe righe di codice)

EDIT: Oh sì, alcuni debug:

F5: Entra (mostrami i dettagli!)

F6: Fai un passo avanti (ti credo, passa alla parte successiva ...)

F7: Esci (pensavo che mi interessasse questo metodo, ma si scopre che non è così, portami fuori di qui!)

F8: Riprendi (vai fino al raggiungimento del punto di interruzione successivo)

CTRL + MAIUSC + I: ispeziona un'espressione. CTRL + MAIUSC + I + CTRL + MAIUSC + I: crea un'espressione di controllo sull'espressione ispezionata.

Punti di interruzione condizionali: fai clic con il pulsante destro del mouse su un punto di interruzione e puoi impostare una condizione che si verifica che innesca l'interruzione dell'esecuzione del programma (l'assistente al contesto, con Ctrl + Spazio, è disponibile qui!)

F11 - Debug ultimo avvio (applicazione)

CTRL + F11 - Esegui ultimo avvio (applicazione)

Punto di interruzione su eccezione

Eclipse consente di impostare punti di interruzione in base a dove si verifica un'eccezione.
Si accede all'opzione tramite "j!" alt text http://help.eclipse.org/stable/topic/org.eclipse.jdt.doc.user/images/org.eclipse.jdt.debug.ui/elcl16/exc_catch.png icona nella finestra di debug.

testo alternativo http://blogs.bytecode.com.au/glen/2007/04/06/images/2007/AddExceptionWindow.png

L'argomento della guida ufficiale " Aggiungi punto di interruzione eccezione Java " contiene ulteriori informazioni su questo.

• L'opzione Eccezione non rilevata consiste nel sospendere l'esecuzione quando un'eccezione dello stesso tipo del punto di interruzione viene generata in una posizione non rilevata.
• L'opzione Eccezione rilevata consiste nel sospendere l'esecuzione quando un'eccezione dello stesso tipo del punto di interruzione viene generata in una posizione rilevata.
• non dimenticare la sospensione del punto di interruzione dell'eccezione sulla sottoclasse di questa eccezione :
  per sospendere l'esecuzione quando si incontrano sottoclassi del tipo di eccezione.
  Ad esempio, se un punto di interruzione dell'eccezione per RuntimeExceptionè configurato per la sospensione nelle sottoclassi, verrà attivato anche da un fileNullPointerException .

testo alternativo http://help.eclipse.org/stable/topic/org.eclipse.jdt.doc.user/reference/breakpoints/images/ref-breakpoint_suspendsubclass.PNG

Ctrl+ Alt+ Hsu un metodo per ottenere la gerarchia delle chiamate per esso. Modo veloce per vedere da dove viene chiamato.

Ctrl+ Alt+ UPo Ctrl+ Alt+ DOWNper copiare le righe

Alt+ Shift+ Rper refactoring e rinominare.

Ecco la mia raccolta delle scorciatoie da tastiera più utili per Eclipse 3:

Eclipse 3 Favorite Keyboard Shortcuts. 
by -=MaGGuS=-

Navigate:

•   Ctrl + Shift + L – Shows useful keyboard shortcuts in popup window 
•   Ctrl + H – Search.
•   Ctrl + K – Goes to next search match in a single file. Shift + Ctrl + K – goes to previous match.
•   F3 - Goes to ‘declaration’ of something. Same as Ctrl + Click.
•   Ctrl + Shift + G - Use this on a method name or variable. It will search for references in the code (all the code) to that item.
•   Ctrl + O – Shows outline view of the current class or interface.
•   Ctrl + T – Shows class hierarchy of the current class or interface. F4 – shows the same in separate tab.
•   Ctrl + Shift + T - Open Type. Search for any type globally in the workspace.
•   Ctrl + Shift + R – Open Resource. Search for any file inside workspace.
•   Ctrl + J – Incremental search. Similar to the search in firefox. It shows you results as you type. Shift + Ctrl +J - Reverse incremental search.
•   Ctrl + Q – Goes to the last edit location.
•   Ctrl + Left|Right – Go Back/Forward in history.
•   Ctrl + L – Go to line number.
•   Ctrl + E – This will give you a list of all the source code windows that are currently open. You can arrow up or down on the items to go to a tab.
•   Ctrl +PgUp|PgDown – Cycles through editor tabs.
•   Ctrl + Shift + Up|Down - Bounces you up and down through the methods in the source code.
•   Ctrl + F7 – Switches between panes (views).
•   Ctrl + ,|. – Go to the previous/next error. Great in combination with Ctrl + 1.
•   Ctrl + 1 on an error – Brings up suggestions for fixing the error. The suggestions can be clicked.
•   Ctrl + F4 – Close one source window.

Edit:

•   Ctrl + Space – Auto-completion.
•   Ctrl + / – Toggle comment selected lines.
•   Ctrl + Shift + /|\ – Block comment/uncomment selected lines.
•   Ctrl + Shift + F – Quickly ‘formats’ your java code based on your preferences set up under Window –> Preferences.
•   Ctrl + I – Correct indentations.
•   Alt + Up|Down – move the highlighted code up/down one line. If nothing is selected, selects the current line.
•   Ctrl + D – Delete row.
•   Alt + Shift + Up|Down|Left|Right – select increasing semantic units.
•   Ctrl + Shift + O – Organize Imports.
•   Alt + Shift + S – Brings up “Source” menu.
o   Shift + Alt + S, R – Generate getter/setter.
o   Shift + Alt + S, O – Generate constructor using fields.
o   Shift + Alt + S, C – Generate constructor from superclass.
•   Alt + Shift + T – Brings up “Refactor” menu.
•   Alt + Shift + J – Insert javadoc comment.
•   F2 – Display javadoc popup for current item. Shift + F2 – Display javadoc in external browser.

Run/Debug:

•   F11 / Ctrl + F11 – Execute/debug.
•   Ctrl + Shift +B – Toggle breakpoint.
•   When paused: F5 – Step into, F6 – Step over, F7 – Step out, F8 – Resume.
•   Ctrl + F2 – Terminate.

EOF

Non così nascosto ma IMO il miglior trucco.

Assumendo le impostazioni predefinite (e non hai aggiunto nuovi snippet)

Evidenzia (o seleziona) un testo (stringa o variabile) ... Premi Ctrl + Spazio. Premi Fine + Invio. viene attivato lo snippet "sysout" che avvolge la selezione come parametro.

per esempio.

 "hello world!"

becomes
System.out.println("hello world!");

Mi piace così tanto che ho implementato uno snippet simile per Toast e Log.i () di Android ENORME Risparmio di tempo durante il debug manuale ...