Tudo bem, pode ser uma pergunta idiota, mas todo mundo usa essas coisas de forma diferente. Quais são algumas das melhores economias de tempo para este IDE.

Tom

Não se esqueça de Ctrl+ Shift+ L, que exibe uma lista de todas as combinações de atalhos de teclado (apenas no caso de você esquecer qualquer uma das listadas aqui).

Ctrl-2 alguma coisa

Parece que ninguém mencionou Ctrl-2 L (atribuir a uma nova variável local) e Ctrl-2 F (atribuir a um novo campo), estes mudaram a forma como escrevo código.

Anteriormente, eu estava digitando, digamos (| é a localização do cursor):

Display display = new |

e pressionei Ctrl-Espaço para completar a chamada do construtor. Agora eu digito:

new Display()|

e pressione Ctrl-2 L, o que resulta em:

Display display = new Display()|

Isso realmente acelera as coisas. (Ctrl-2 F faz o mesmo, mas atribui a um novo campo em vez de uma nova variável.)

Outro bom atalho é Ctrl-2 R: renomear no arquivo. É muito mais rápido do que renomear a refatoração (Alt-Shift-R) ao renomear coisas como variáveis ​​locais.

Na verdade, fui para a página de preferências de personalização de teclas e atribuí todos os tipos de correções rápidas adicionais para Ctrl-2-alguma coisa. Por exemplo, agora pressiono Ctrl-2 J para dividir / juntar a declaração de variável, Ctrl-2 C para extrair uma classe interna para o nível superior, Ctrl-2 T para adicionar a declaração de projeções à função, etc. Existem toneladas de atribuições rápidas correções, escolha seus favoritos e atribua-os aos atalhos Ctrl-2.

Modelos

Outro favorito meu em meu modelo “npe”, definido como:

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

Isso me permite adicionar rapidamente verificações de argumento nulo no início de cada função (especialmente aquelas que simplesmente salvam o argumento em um campo ou o adicionam a uma coleção, especialmente construtores), o que é ótimo para detectar bugs antecipadamente.

Veja mais modelos úteis em www.tarantsov.com/eclipse/templates/ . Não vou listá-los todos aqui porque são muitos e porque costumo adicionar novos.

Conclusão

Alguns truques para completar o código:

• suporte de caixa de camelo mencionado em outra resposta: digite cTM, obtenha currentTimeMillis
• construtor padrão: na declaração de classe sem nenhum construtor padrão pressione Ctrl-Espaço, a primeira escolha será criar um
• sobrecarregando: na declaração da classe comece a digitar o nome de um método que você pode sobrecarregar, Ctrl-Espaço, escolha um
• criação de getter / setter: digite “get”, Ctrl-Espaço, escolha um getter para criar; o mesmo com "é" e "definido"

Atribuir a um novo campo

É assim que adiciono campos.

1. Se você ainda não tem construtores, adicione um. (Ctrl-Espaço em qualquer lugar em uma declaração de classe, escolha a primeira proposta.)

2. Adicione um argumento (| é a posição do cursor):

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

3. Pressione Ctrl-1, escolha “atribuir a um novo campo”. Você obtém:

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

4. Adicione uma verificação de ponteiro nulo, se apropriado (consulte o modelo “npe” acima):

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

   Pressione Ctrl-Espaço para obter:

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

Uma grande economia de tempo!

ctrl-shift-r e seu amigo, ctrl-shift-t, para abrir um recurso ou tipo, respectivamente. Os recursos incluem todos os arquivos em seus projetos abertos (incluindo arquivos não-java) e os tipos incluem tipos de java em seus projetos ou em uma biblioteca incluída nos projetos.

Crtl+ 1é meu favorito. As soluções rápidas para os rabiscos vermelhos.

Ele também está localizado no menu Editar -> Correção rápida.

Ctrl+ Shift+ Opara organizar as importações, o que irá formatá-las bem, remover importações desnecessárias e adicionar importações ausentes.

Ctrl-J inicia uma busca incremental.

Pressione Ctrl-J e comece a digitar. Use cima / baixo para encontrar instâncias anteriores / próximas do que você digitou.

Ctrl-Shift-J pesquisa para trás.

Digite 'syso' e pressione Ctrl+ Spacepara expandir para System.out.println ().

Muito útil.

CTRL+ 3traz uma lista de digitação antecipada de qualquer comando do menu.

• CTRL-SHIFT-g: encontra usos do método ou campo sob o cursor, absolutamente necessários para compreender o código
• CTRL-F6: navegue entre a lista de janelas abertas do editor, se você apenas digitar uma vez e voltar para a janela anterior do editor, fazer isso sucessivamente é uma boa maneira de ir e voltar
• CTRL-t: em uma classe ou método irá mostrar a você a hierarquia de tipo, muito útil para encontrar implementações de um método de interface, por exemplo

Clicar no tipo de retorno na declaração de um método destaca todos os pontos de saída do método.

por exemplo:

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

clicar em void destacará o retorno na linha 4 e o fechamento } na linha 7.

Atualização : funciona até mesmo para blocos try {} catch. Se você colocar o cursor na exceção no bloco catch e o eclipse destacará os métodos prováveis ​​que podem lançar essa exceção.

O autocompletar de código suporta CamelCase, por exemplo, a digitação CWARmostrará um resultado para ClassWithAReallyLongName. Comece a usar este recurso e você nunca mais digitará outro nome de classe longo novamente.

(partes copiadas de outra resposta porque acho que as respostas com apenas uma dica / dica são melhores para a votação)

Alt-Seta para cima move a seleção atual para cima uma linha, Alt-Seta para baixo move para baixo. Eu também uso Alt-Shift-Up / Down Arrow o tempo todo. Ctrl-K e Ctrl-Shift-K são bastante úteis, encontrando a próxima ocorrência / anterior da seleção atual (ou a última Find, se nada estiver selecionado).

Há uma opção de colocar a chave de abertura e um ponto-e-vírgula automaticamente na posição "correta". Você terá que habilitar isso - Escolha Janela / Preferências e digite "chave" na caixa de pesquisa - deve ser facilmente localizável (sem eclipse neste computador). O efeito:

• Digitar um ponto-e-vírgula em qualquer lugar da linha o colocará neste final de linha (como em word / openoffice: Backspace se quiser colocá-lo no lugar original)
• Digitar uma chave de abertura quando você estiver dentro de outro par de chaves irá colocá-la no final desta linha - como neste exemplo

("|" é o cursor):

if(i==0|)

digitar "{" agora resultará em

if(i==0) {|

Hippie expand / Word Complete, afaik inspirado no Emacs: irá autocompletar qualquer palavra em qualquer editor baseado em outras palavras naquele arquivo. Autocomplete dentro de literais String em código Java, em arquivos xml, em qualquer lugar.

Alt + /

Alt-Shift-R significa renomear , não refatorar. Refatoração é um termo mais geral (conforme definido pelo livro ).

No entanto, é uma das minhas refatorações favoritas. Outros incluem:

• Alt-Shift-M : Método de extração (quando um bloco de código ou uma expressão é selecionado)

• Alt-Shift-L : Extrair variável local (quando uma expressão é selecionada)

Extrair variável local é especialmente útil quando não me lembro (ou me incomodo em digitar) o tipo de resultado de um método. Supondo que você tenha um método JdbcTemplate createJdbcTemplate()em sua classe, escreva algum código como este:

void someQuery() {
    createJdbcTemplate()
}

Selecione a expressão createJdbcTemplate(), clique em Alt-Shift-L, digite o nome da variável e pressione Enter.

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

CTRL+ D- para deletar a linha atual

Com certeza, Ctrl+ Qpara ir para o último local de edição. É muito útil logo após ser interrompido por telefone, chefe ou outros.

Ctrl+ Shift+ M: muda um método estático ou referência de atributo estático de uma classe para uma importação estática.

Antes

import X;

...
X.callSomething();

Depois de

import static X.callSomething;

...
callSomething();

Alt+ Shift+ A Upseta faz a seleção escalonada. Alt+ Shift+ Downfaz o oposto.

Alt+ Upou Alt+ Downpara mover linhas

Ninguém mencionou o melhor ainda. Clique no nome de uma classe ou método e pressione Ctrl+ T.

Você obtém uma hierarquia de tipos rápida. Para um nome de classe, você vê toda a hierarquia de classes. Para um nome de método, você obtém a hierarquia que mostra superclasses e subclasses, com implementações desse método diferenciadas de menções abstratas ou classes que não mencionam o método.

Isso é enorme quando você está em uma declaração de método abstrato e deseja ver rapidamente onde ela está implementada.

F3 tem sido o meu favorito, abre a definição do item selecionado.

Ctrl+ Shift+ Rtem um recurso interessante, você pode usar apenas as letras maiúsculas de camelo de uma classe ao pesquisar (como digitar CWAR irá mostrar um resultado para ClassWithAReallyLongName).

Alt+ Shift+ W> Package Explorer torna a vida mais fácil ao navegar em grandes projetos.

Um truque de atalho sem teclado é usar conjuntos de confirmação em sua visão Equipe-> Sincronizar para organizar suas mudanças antes de enviar.

Defina um conjunto de alterações como o padrão e todas as alterações feitas nos arquivos serão colocadas nesse conjunto, tornando mais fácil ver o que você alterou enquanto trabalhava em um defeito / recurso específico e outras alterações que você teve durante o teste etc.

CTRL + ESPAÇO, para qualquer coisa, em qualquer lugar.

Gere getters e setters.

Crie construtores usando campos

Extrair Método ...

Refatorar-> Renomear

CTRL + O para um esboço rápido. CTRL + O + CTRL + O para o contorno herdado.

F4 para exibir uma hierarquia de tipo

Abra Hierarquia de chamada para exibir de onde um método é chamado.

CTRL + SHIFT + T para abrir um tipo Java

CTRL + SHIFT + R para abrir qualquer recurso.

ALT + esquerda ou direita para avançar ou retroceder na edição de lugares em seus documentos (navegação fácil)

Substitua / Implementar métodos se você sabe que vai usar vários métodos (caso contrário, CTRL + ESPAÇO é melhor para uma seleção de cada vez.

Refatorar-> Extrair Interface

Refatorar-> Pull up

Refatorar-> Empurrar para baixo

CTRL + SHIFT + O para organizar importações (ao digitar o nome geral da classe como Mapa, pressionar CTRL + ESPAÇO e selecionar a classe apropriada irá importá-la diretamente para você).

CTRL + SHIFT + F para formatação (embora o formatador embutido do Eclipse possa ser um pouco estúpido para longas linhas de código)

EDIT: Oh sim, alguma depuração:

F5: Entre (mostre-me os detalhes!)

F6: Avance (acredito em você, para a próxima parte ...)

F7: Saia (pensei que me importava com este método, mas descobri que não, tire-me daqui!)

F8: Retomar (vá até o próximo ponto de interrupção ser alcançado)

CTRL + SHIFT + I: inspecionar uma expressão. CTRL + SHIFT + I + CTRL + SHIFT + I: cria uma expressão de observação na expressão inspecionada.

Pontos de interrupção condicionais: Clique com o botão direito em um ponto de interrupção e você pode definir uma condição que ocorre que desencadeia a interrupção da execução do programa (assistente de contexto, com Ctrl + Espaço, está disponível aqui!)

F11 - Última depuração iniciada (aplicativo)

CTRL + F11 - Executar pela última vez (aplicativo)

Ponto de interrupção na exceção

O Eclipse permite definir pontos de interrupção com base em onde ocorre uma exceção.
Você acessa a opção por meio do "j!" alt text ícone http://help.eclipse.org/stable/topic/org.eclipse.jdt.doc.user/images/org.eclipse.jdt.debug.ui/elcl16/exc_catch.png na janela de depuração.

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

O tópico de ajuda oficial " Add Java Exception Breakpoint " tem mais sobre isso.

• A opção Uncaught Exception é suspender a execução quando uma exceção do mesmo tipo que o breakpoint é lançada em um local não capturado.
• A opção Caught Exception é suspender a execução quando uma exceção do mesmo tipo que o ponto de interrupção é lançada em um local detectado.
• não se esqueça da suspensão do ponto de interrupção da exceção na subclasse desta exceção :
  para suspender a execução quando forem encontradas subclasses do tipo de exceção.
  Por exemplo, se um ponto de interrupção de exceção para RuntimeExceptionfor configurado para suspender em subclasses, ele também será disparado por aNullPointerException .

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

Ctrl+ Alt+ Hem um método para obter a hierarquia de chamadas para ele. Maneira rápida de ver de onde ele é chamado.

Ctrl+ Alt+ UPou Ctrl+ Alt+ DOWNpara copiar linhas

Alt+ Shift+ Rpara refatorar e renomear.

Aqui está minha coleção dos atalhos de teclado mais úteis 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

Não tão escondido, mas OMI é o melhor truque.

Assumindo as configurações padrão (e você não adicionou novos snippets)

Destaque (ou selecione) um Texto (String ou Variável) ... Pressione Ctrl + Espaço. Pressione End + Enter. o snippet "sysout" é acionado, envolvendo a seleção como seu parâmetro.

por exemplo.

 "hello world!"

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

Eu amo tanto que implementei um trecho semelhante para Toast e Log.i () do Android. HUGE Time saver durante a depuração manual ....