De acuerdo, puede ser una pregunta poco convincente, pero todos usan estas cosas de manera diferente. ¿Cuáles son algunos de los mejores ahorradores de tiempo para este IDE?

Tom

No olvide Ctrl+ Shift+ L, que muestra una lista de todas las combinaciones de atajos de teclado (en caso de que olvide alguno de los enumerados aquí).

Ctrl-2 algo

Parece que nadie mencionó Ctrl-2 L (asignar a una nueva variable local) y Ctrl-2 F (asignar a un nuevo campo), estos han cambiado la forma en que escribo el código.

Anteriormente, estaba escribiendo, digamos (| es la ubicación del cursor):

Display display = new |

y luego presioné Ctrl-Space para completar la llamada al constructor. Ahora escribo:

new Display()|

y presione Ctrl-2 L, lo que da como resultado:

Display display = new Display()|

Esto realmente acelera las cosas. (Ctrl-2 F hace lo mismo, pero asigna a un nuevo campo en lugar de una nueva variable).

Otro buen atajo es Ctrl-2 R: renombrar en el archivo. Es mucho más rápido que cambiar el nombre de la refactorización (Alt-Shift-R) cuando se cambia el nombre de cosas como variables locales.

De hecho, fui a la página de preferencias de personalización de Keys y asigné todo tipo de arreglos rápidos adicionales a Ctrl-2-algo. Por ejemplo, ahora presiono Ctrl-2 J para dividir / unir la declaración de variable, Ctrl-2 C para extraer una clase interna en el nivel superior, Ctrl-2 T para agregar declaraciones throws a la función, etc. Hay toneladas de asignaciones rápidas arreglos, elija sus favoritos y asígnelos a los atajos Ctrl-2.

Plantillas

Otro de mis favoritos en mi plantilla "npe", definido como:

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

Esto me permite agregar rápidamente verificaciones de argumentos nulos al comienzo de cada función (especialmente aquellas que simplemente guardan el argumento en un campo o lo agregan a una colección, especialmente constructores), lo cual es excelente para detectar errores temprano.

Vea más plantillas útiles en www.tarantsov.com/eclipse/templates/ . No los enumeraré todos aquí porque hay muchos y porque a menudo agrego nuevos.

Terminación

Algunos trucos para completar el código:

• soporte de caso de camello mencionado en otra respuesta: escriba cTM, obtenga currentTimeMillis
• constructor predeterminado: en la declaración de clase sin constructor predeterminado presione Ctrl-Espacio, la primera opción será crear uno
• sobrecarga: en la declaración de clase, comience a escribir el nombre de un método que puede sobrecargar, Ctrl-Espacio, elija uno
• creación de getter / setter: escriba "get", Ctrl-Espacio, elija un getter para crear; lo mismo con "is" y "set"

Asignar a un campo nuevo

Así es como agrego campos.

1. Si aún no tiene constructores, agregue uno. (Ctrl-Espacio en cualquier lugar de una declaración de clase, elija la primera propuesta).

2. Agregue un argumento (| es la posición del cursor):

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

3. Presione Ctrl-1, elija "asignar a un nuevo campo". Usted obtiene:

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

4. Agregue una verificación de puntero nulo si corresponde (consulte la plantilla "npe" anterior):

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

   Presione Ctrl-Espacio, obtenga:

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

¡Un gran ahorro de tiempo!

ctrl-shift-r y su compañero, ctrl-shift-t, para abrir un recurso o tipo, respectivamente. Los recursos incluyen todos los archivos de sus proyectos abiertos (incluidos los archivos que no son de Java) y los tipos incluyen los tipos de Java en sus proyectos o en una biblioteca incluida en los proyectos.

Crtl+ 1es mi favorito. Las soluciones rápidas para los garabatos rojos.

También se encuentra en el menú Editar -> Solución rápida.

Ctrl+ Shift+ Opara organizar las importaciones, lo que las formateará muy bien, eliminará las importaciones innecesarias y agregará las importaciones faltantes.

Ctrl-J inicia una búsqueda incremental.

Presiona Ctrl-J, luego comienza a escribir. Utilice arriba / abajo para buscar instancias anteriores / siguientes de lo que escribió.

Ctrl-Shift-J busca hacia atrás.

Escriba 'syso' y luego presione Ctrl+ Spacepara expandirlo a System.out.println ().

Tres prácticos.

CTRL+ 3muestra una lista de escritura anticipada de cualquier comando de menú.

• CTRL-SHIFT-g: encuentra usos del método o campo debajo del cursor, absolutamente necesarios para comprender el código
• CTRL-F6: navega entre la lista de ventanas del editor abiertas, si solo lo escribes una vez y lo sueltas, puedes volver a la ventana del editor anterior, hacer esto sucesivamente es una buena manera de saltar hacia adelante y hacia atrás
• CTRL-t: en una clase o método le mostrará la jerarquía de tipos, muy útil para encontrar implementaciones de un método de interfaz, por ejemplo

Al hacer clic en el tipo de retorno en la declaración de un método, se resaltan todos los puntos de salida del método.

por ejemplo:

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

al hacer clic en anular se resaltará la devolución en la línea 4 y el cierre } en la línea 7.

Actualización : incluso funciona con bloques try {} catch. Si coloca el cursor en la excepción en el bloque de captura y eclipse resaltará los métodos probables que pueden generar esa excepción.

La finalización de código admite CamelCase, por ejemplo, al escribir CWARse mostrará un resultado para ClassWithAReallyLongName. Empiece a utilizar esta función y nunca volverá a escribir otro nombre de clase largo.

(Partes copiadas de otra respuesta porque creo que las respuestas con solo una pista / consejo son las mejores para la encuesta)

Alt-Flecha arriba mueve la selección actual hacia arriba una línea, Alt-Flecha abajo la mueve hacia abajo. También uso Alt-Shift-Up / Down Arrow todo el tiempo. Ctrl-K y Ctrl-Shift-K son bastante útiles para encontrar la aparición siguiente / anterior de la selección actual (o la última búsqueda, si no se selecciona nada).

Hay una opción para colocar la llave de apertura y un punto y coma automágicamente en la posición "correcta". Tendrá que habilitar esto - Elija Ventana / Preferencias y escriba "brace" en el cuadro de búsqueda - debería ser fácilmente localizable (no hay eclipse en esta computadora). El efecto:

• Escribir un punto y coma en cualquier lugar de la línea lo colocará al final de la línea (como en word / openoffice: retroceso si desea tenerlo en el lugar original)
• Escribir una llave de apertura cuando está dentro de otro par de llaves la colocará al final de esta línea, como en este ejemplo

("|" es el cursor):

if(i==0|)

escribir "{" ahora resultará en

if(i==0) {|

Hippie expand / Word Complete, afaik inspirado en Emacs: autocompletará cualquier palabra en cualquier editor basándose en otras palabras en ese archivo. Autocompletar dentro de literales de cadena en código Java, en archivos xml, en todas partes.

Alt + /

Alt-Shift-R significa renombrar , no refactorizar. Refactorizar es un término más general (como lo define el libro ).

Sin embargo, es una de mis refactorizaciones favoritas. Otros incluyen:

• Alt-Shift-M : Método de extracción (cuando se selecciona un bloque de código o una expresión)

• Alt-Shift-L : Extraer variable local (cuando se selecciona una expresión)

Extraer variable local es especialmente útil cuando no recuerdo (o me molesto en escribir) el tipo de resultado de un método. Suponiendo que tiene un método JdbcTemplate createJdbcTemplate()en su clase, escriba un código como este:

void someQuery() {
    createJdbcTemplate()
}

Seleccione la expresión createJdbcTemplate(), haga clic en Alt-Shift-L, escriba el nombre de la variable y presione enter.

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

CTRL+ D- para borrar la línea actual

Absolutamente, Ctrl+ Qpara ir a la última ubicación de edición. Es muy útil justo después de haber sido interrumpido por teléfono, jefe u otros.

Ctrl+ Shift+ M: cambia un método estático o una referencia de atributo estático de una clase a una importación estática.

antes de

import X;

...
X.callSomething();

Después

import static X.callSomething;

...
callSomething();

Alt+ Shift+ UpFlecha hace una selección creciente. Alt+ Shift+ Downhace lo contrario.

Alt+ Upo Alt+ Downpara mover líneas

Nadie ha mencionado el mejor todavía. Haga clic en el nombre de una clase o método y presione Ctrl+ T.

Obtienes una jerarquía de tipos rápida. Para un nombre de clase, verá la jerarquía de clases completa. Para un nombre de método, obtienes la jerarquía que muestra superclases y subclases, con implementaciones de ese método que se distinguen de las menciones abstractas o clases que no mencionan el método.

Esto es enorme cuando se encuentra en una declaración de método abstracto y rápidamente desea ver dónde se implementa.

F3 ha sido mi favorito, abre la definición del elemento seleccionado.

Ctrl+ Shift+ Rtiene una característica interesante, puede usar solo las letras mayúsculas de camello de una clase al realizar la búsqueda (como escribir CWAR mostrará un resultado para ClassWithAReallyLongName).

Alt+ Shift+ W> Package Explorer hace la vida más fácil al navegar por proyectos grandes.

Un truco de método abreviado que no es de teclado es usar conjuntos de confirmación en su vista Equipo-> Sincronizar para organizar sus cambios antes de confirmar.

Establezca un conjunto de cambios como predeterminado, y todos los cambios que realice en los archivos se incluirán en ese conjunto, lo que facilitará ver lo que ha cambiado mientras trabajaba en un defecto / característica específico, y otros cambios que tuvo durante la prueba, etc.

CTRL + ESPACIO, para cualquier cosa, en cualquier lugar.

Genere getters y setters.

Crear constructores usando campos

Método de extracción ...

Refactor-> Cambiar nombre

CTRL + O para el esquema rápido. CTRL + O + CTRL + O para el esquema heredado.

F4 para mostrar una jerarquía de tipos

Abra la jerarquía de llamadas para mostrar desde dónde se llama a un método.

CTRL + MAYÚS + T para abrir un tipo de Java

CTRL + MAYÚS + R para abrir cualquier recurso.

ALT + izquierda o derecha para avanzar o retroceder a través de lugares de edición en sus documentos (navegación fácil)

Anule / implemente métodos si sabe que va a utilizar muchos métodos (de lo contrario, CTRL + ESPACIO es mejor para una selección de uno a la vez.

Refactor-> Extraer interfaz

Refactor-> Pull up

Refactor-> Empujar hacia abajo

CTRL + MAYÚS + O para organizar las importaciones (al escribir el nombre de la clase general, como Mapa, presionar CTRL + ESPACIO y luego seleccionar la clase apropiada lo importará directamente).

CTRL + MAYÚS + F para formatear (aunque el formateador integrado de Eclipse puede ser un poco loco para largas líneas de código)

EDITAR: Oh sí, algo de depuración:

F5: Entra (¡muéstrame los detalles!)

F6: Pasa (te creo, pasa a la siguiente parte ...)

F7: Sal (pensé que me importaba este método, pero resulta que no, ¡sácame de aquí!)

F8: Reanudar (ir hasta que se alcance el siguiente punto de interrupción)

CTRL + MAYÚS + I: inspeccionar una expresión. CTRL + MAYÚS + I + CTRL + MAYÚS + I: crea una expresión de observación en la expresión inspeccionada.

Puntos de interrupción condicionales: haga clic con el botón derecho en un punto de interrupción y puede establecer una condición que se produzca y que desencadene la interrupción de la ejecución del programa (la ayuda de contexto, con Ctrl + Espacio, está disponible aquí).

F11: depuración lanzada por última vez (aplicación)

CTRL + F11 - Ejecutar por última vez (aplicación)

Punto de interrupción en la excepción

Eclipse le permite establecer puntos de interrupción en función de dónde se produce una excepción.
Se accede a la opción a través de la "j!" texto alternativo http://help.eclipse.org/stable/topic/org.eclipse.jdt.doc.user/images/org.eclipse.jdt.debug.ui/elcl16/exc_catch.png icono en la ventana de depuración.

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

El tema de ayuda oficial " Agregar punto de interrupción de excepción de Java " tiene más información sobre esto.

• La opción de excepción no detectada es suspender la ejecución cuando se lanza una excepción del mismo tipo que el punto de interrupción en una ubicación no detectada.
• La opción de excepción detectada es suspender la ejecución cuando se lanza una excepción del mismo tipo que el punto de interrupción en una ubicación detectada.
• no olvide el punto de interrupción de excepción Suspender en subclase de esta excepción :
  para suspender la ejecución cuando se encuentran subclases del tipo de excepción.
  Por ejemplo, si un punto de interrupción de excepción paraRuntimeException se configura se suspenda en subclases, también se activará mediante unNullPointerException .

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

Ctrl+ Alt+ Hen un método para obtener la jerarquía de llamadas para él. Manera rápida de ver desde dónde se llama.

Ctrl+ Alt+ UPo Ctrl+ Alt+ DOWNpara copiar líneas

Alt+ Shift+ Rpara refactorizar y renombrar.

Aquí está mi colección de los atajos de teclado más útiles para 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

No tan oculto pero en mi opinión el mejor truco.

Asumiendo la configuración predeterminada (y no ha agregado nuevos fragmentos)

Resalte (o seleccione) un texto (cadena o variable) ... Presione Ctrl + Espacio. Presiona Fin + Enter. se activa el fragmento "sysout" que envuelve la selección como parámetro.

p.ej.

 "hello world!"

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

Me encanta tanto que he implementado un fragmento similar para Toast y Log.i () de Android ENORME ahorro de tiempo durante la depuración manual ...