14 minutos de leitura
Autor(a)
Alex é instrutor e desenvolvedor e possui experiência em Java, Kotlin, Android. Atualmente cria conteúdo no canal https://www.youtube.com/@AlexFelipeDev.
Fique por dentro de conteúdos, insights e oportunidades do universo tech. Receba novidades e lançamentos direto no seu e-mail.
Durante o desenvolvimento de um projeto, é muito comum usarmos IDEs para facilitar todo o processo de build do projeto, seja para a realização de compilação de arquivos ou a execução da aplicação.
Hoje veremos alguns truques e dicas do Intellij IDEA que faz parte de uma das mais famosas e poderosas IDEs do mundo Java.
Observação: Vale lembrar que o IntelliJ em sua versão Ultimate, trata-se de uma ferramenta paga que possue um Trial de 30 dias. Entrentato, existe também a versão free que é justamente a versão Community (comunidade). Se tiver interesse em saber a diferença entre as versões, consulte o site da própria Jetbrains. Caso não tenha o IntelliJ instalado, você pode seguir esse tutorial de instalação da própria Jetbrains ou utilizar o Toolbox que é um gerenciador de pacotes da Jetbrains, com ele é possível instalar todos os produtos facilmente.
Avalie este artigo
Todos os exemplos que veremos no post serão baseados na versão Community, pois dessa forma você não vai precisar baixar a trial apenas para testar.
Além disso, irei considerar um projeto Java simples para um estoque, portanto, todos os exemplos serão voltados para esse projeto. Caso não tenha nenhum projeto, peço que crie um, nesse link tem um tutorial explicando os passos. Preparado? Bora começar então.
Um dos grandes primeiros passos com o IntelliJ é ajustar os atalhos, no caso, o keymap. Nesse instante você deve estar pensando:
"Então os atalhos não vem configurados?"
Sim, os atalhos já vem configurados, porém, dependendo da plataforma pode ser uma configuração diferente da padrão!
Ao ajustar o keymap, você verá diversas alternativas referenciando ferramentas como Eclipse IDE ou NetBeans. Quando eu comecei a aprender o IntelliJ eu estava acostumado a usar o Eclipse IDE, portanto, optei em usar o keymap Eclipse.
Alguns atalhos funcionam de forma parecida com os comportamentos do Eclipse, entretanto, durante o meu tempo de adaptação, haviam outros que só funcionavam conforme os atalhos padrões do IntelliJ, portanto, tive que me adaptar.
Nesse processo de adaptação (durou meses), decidi parar de usar os atalhos do Eclipse e migrei para os padrões do IntelliJ (Default), a princípio parecia contra-intuitivo, mas conforme fui treinando fui me acostumando...
Atualmente já estou bem acostumado com os atalhos do IntelliJ e me sinto produtivo, portanto, não sinto falta dos atalhos do Eclipse! Em outras palavras, não desanime logo de cara caso não se sentir produtivo, o aumento da produtividade vai surgir conforme for praticando!
Por experiência própria, recomendo para todos os devs que estão tentando migrar de uma outra IDE para o IntelliJ fazer o mesmo, ou seja, evite o uso de atalhos de uma ferramenta que já está acostumado, tente se adaptar praticando aos poucos com os atalhos padrões, conforme for praticando, perceberá que já se acostumou!
Agora que fizemos o overview sobre os atalhos, vamos configurar o keymap. Portanto, no IntelliJ, vá no menu File > Settings:
Dentro do Settings, filtre por keymap:
Observe que por padrão, no meu computador, veio o Default for XWin, nesse caso eu vou ajustar para apenas Default justamente por ter acostumado com atalhos padrões do próprio IntelliJ, em seguida clique em OK.
Fique à vontade em configurar o que desejar, porém, lembre-se que todas as dicas do posts serão baseadas nos atalhos do keymap default.
Chega de explicações e vamos colocar a mão na massa! Primeiro vamos fazer uso do projeto que criamos. No meu caso eu criei um projeto Java chamado estoque e vou me basear nele para os exemplos a seguir.
Sendo assim, qual é o nosso primeiro passo em um projeto Java? criar uma classe, certo? Portanto, vamos criar uma classe para rodar o método main(). Para isso, selecione o src e use o atalho Alt + Insert:
Observe que é um projeto Java simples, ou seja, apenas temos uma estrutura básica com o nome do projeto, diretório e arquivos do próprio IntelliJ. Além disso veja que temos o src que é justamente onde os arquivos fonte ficarão.
Esse atalho reflete justamente na ação Generate (no contexto atual New) do IntelliJ que tem como objetivo criar algo.
Veja que ele apresenta como primeira opção uma classe do Java, pois ele acredita que seja a opção mais adequada nesse contexto, portanto clique ou tecle o Enter na opção Java Class. Em seguida dê o nome Main, pois será a classe para executar o nosso programa:
Observe que o padrão do IntelliJ é sempre deixar um comentário indicando o autor e a data de criação do arquivo.
Aprendemos a criar uma classe apenas com um único atalho, mas agora, você pode estar pensando:
"Alex, é muito legal fazer isso com um atalho, mas se você não me falasse, como eu saberia?"
O IntelliJ fornece um documento de referência aos atalhos baseados no keymap configurado, esse documento é conhecido como Keymap References. Para vizualizá-lo, vá no menu Help > Keymap References:
Veja que ele apresenta um documento em PDF que faz referência ao keymap tanto para Windows, Linux ou Mac OS. Ou seja, quando tiver curiosidade de algum atalho específico sempre veja o do seu sistema operacional.
DICA: Existem pessoas que preferem imprimir esse PDF e deixar no lado para consultá-lo durante a aprendizagem. Pessoalmente prefiro o digital justamente para usar o famoso Ctrl + F (find) e encontrar rapidamente o atalho que busco, seja pelo nome ou pelo próprio atalho.
Além disso, o keymap faz referência ao último keymap configurado, portanto, caso mudar o keymap, lembre-se de pedir a Keymap References novamente.
Recomendações: Considerando que existem os atalhos padrões para cada plataforma recomendo que sempre avalie quais atalhos "default" fazem mais sentido pra você. Por exemplo, desenvolvedores que utilizam Mac OS preferem os atalhos padrões para Mac, pois são mais intuitivos. E claro, mantenha-se utilizando sempre o keymap reference para te auxiliar.
Agora que sabemos como buscar um atalho, vamos prosseguir com o nosso exemplo.
De acordo com o que temos agora, queremos de fato executar a nossa classe Main, certo? Para isso precisamos implementar o método main(). A princípio você deve estar pensando:
"Bom preciso apenas escrever o método
public static void
Pois é, no IntelliJ é mais simples do que parece, basta apenas digitar as iniciais da assinatura do método main() que ele já sugere e faz o resto pra gente:
Então teclamos o Enter e temos o seguinte resultado:
Simples, concorda? Legal, mas, geralmente, para testarmos se a nossa classe está funcionando adicionamos um System.out.prinln() junto da mensagem, porém, veja o tanto que a gente tá escrevendo apenas com essa chamada!
Nem precisa falar que tem atalho, né? Digite sout e veja o IntelliJ completando assim como ele fez no método main():
Então temos o seguinte resultado:
Até o momento conseguimos criar uma classe e adicionar um método main() junto com o método de impressão sem muito esforço, mas como podemos fazer para executar o método main()?
A princípio pensamos em clicar no botão de play localizado no menu Run > Run... que serve justamente pra isso.
Entretanto, a ideia do uso de uma IDE, principalmente do IntelliJ, é fazer com que o uso do mouse seja raro ou inexistente justamente para aumentar a produtividade.
Sendo assim, para executarmos a nossa aplicação, basta apenas usar o atalho Ctrl + Shift + F10.
Antes de executar deixe uma mensagem no
System.out.println(), eu deixei "Rodando a aplicação estoque"
Na parte de baixo vai aparecer a saída conforme o exemplo abaixo:
Veja que é apresentado também o local do Java que o IntelliJ usou para executar, como também o status code de finalização do programa.
Após rodar uma vez, as próximas vezes podem ser executadas apenas com o atalho Shift + F10.
Conseguimos executar o nosso programa, porém, já que estamos tratando de um projeto de estoque, precisamos de fato criar uma classe modelo que represente um produto do estoque,certo? Sendo assim, vamos fazer isso!
Inicialmente, você deve estar pensando:
"Bom, precisamos clicar em src, criar o pacote model, e depois, criar a classe. E tudo isso usando o atalho Alt + Insert"
De fato poderíamos seguir exatamente como foi descrito em cima, porém, sem o uso do mouse!
Em outras palavras, podemos usar o atalho Alt + Home (tecla que vai para o início de um tempo ou página) para navegar no projeto por meio da barra de navegação:
Observe que a classe Main está selecionada na barra, isso significa que qualquer ação que tomarmos enquanto ela estiver selecionada, será refletida nela. Portanto, navegue até o diretório src com as setas, nesse caso com a seta para esquerda.
Em seguida, utilize novamente o New com o atalho Alt + Insert, porém, dessa vez crie um pacote, para isso, logo depois do atalho, digite "package", veja como fica:
Teclando o Enter, dê o nome do pacote com o valor "model" e veja que chegamos ao seguinte resultado:
Agora, para criar a classe Produto faça o mesmo, utilize a navegação pela barra, deixe a seleção no pacote model e use o New (Alt + Enter).
Agora que temos a classe Produto precisamos adicionar os atributos, portanto vamos considerar os atributos abaixo:
public class Produto {
private String nome;
private double valor;
private int quantidade;
}
Legal, mas veja que agora teremos um trabalhinho para adicionar os métodos de acesso aos atributos, isto é, os getters e setters.
Mas como já sabemos, as IDEs estão aí para salvar as nossas vidas, portanto, é mais simples do que fazer na mão, basta apenas usar o atalho Alt + Insert novamente que ele vai abrir as opções Generate:
Note que ele já possui algumas opções de geração de código automático. Nesse caso, basta apenas selecionar a opção Getter and Setter que ele vai abrir uma janela para selecionarmos os campos que queremos adicionar os métodos de acesso:
Então, basta apenas selecionar todos os campos pressionando o Shift e navegando com as setas pra baixo ou pra cima. Selecionando os atributos desejados, basta apenas teclar o Enter ou clicar em OK:
Agora que temos a classe produto, precisamos de fato usá-la na nossa classe Main.
Sendo assim, vamos até a classe Main, porém ao invés de tentar por meio do mouse, ou então, por meio da navegação pela barra, vamos acessá-la diretamente da classe Produto!
Para isso utilize o atalho Ctrl + N que permite acessarmos uma classe disponível dentro do nosso projeto:
Então basta apenas teclar Enter que ele vai até a classe Main!
Além das opções de gerar código que o IntelliJ nos propõe, também temos a possibilidade de tomar ações conforme as sugestões da IDE. Por exemplo, dentro do método main() faça a instância da classe Produto:
public class Main {
public static void main(String args) {
System.out.println("Rodando a aplicação estoque");
new Produto();
}
}
Agora que temos uma instância precisamos de um objeto. A princípio bastaria apenas escrevermos algo como Produto produto =, certo?
Porém, podemos fazer isso de uma maneira mais fácil. Com o cursor em cima do new utilize o atalho Alt + Enter, veja que ele vai aparecer a opção Introduce local variable que vai atribuir a instância para o objeto do tipo Produto automaticamente:
public class Main {
public static void main(String args) {
System.out.println("Rodando a aplicação estoque");
Produto produto = new Produto();
}
}
Note que inicialmente o IntelliJ sugere o uso do nome produto, pois por padrão ele utiliza o nome da instância, mas nada impede de você editar conforme desejar :)
O atalho Alt + Enter é utilizado diversas vezes quando estamos dentro do código, é por meio dele que o IntelliJ nos sugere as dicas de possíveis ações baseando-se no local ao qual o cursor está, ou seja, já que ele estava no new ele sugeriu a introdução da variável, se fosse um erro de compilação, provavelmente, ele sugeriria outras opções.
Legal, temos o objeto, mas como podemos de fato criar um produto que tenha o nome de "refrigerante", valor "5.00" e quantidade "10"? Atualmente, precisamos utilizar todos os setters...
Uma abordagem mais objetiva seria criar de fato um construtor personalizado que já recebesse esses parâmetros, mas como podemos fazer isso no IntelliJ?
A princípio, bastaria irmos para classe Produto com o Ctrl + N e depois usar o Generate com o atalho Alt + Insert.
De fato funciona, porém, já que temos ambas as classes abertas, temos a capacidade de alternar entre elas de um modo mais simples. Basta apenas usar o atalho Ctrl + Tab:
Em seguida, basta apenas usar o Generate com o Alt + Insert e escolher a opção Constructor e fazer o mesmo procedimento que fizemos no getters e setters, isto é, selecionando todos os atributos e clicando em OK:
public class Produto {
private String nome;
private double valor;
private int quantidade;
public Produto(String nome, double valor, int quantidade) {
this.nome = nome;
this.valor = valor;
this.quantidade = quantidade;
}
// getters e setters
}
Agora basta voltar para a classe Main com o Alt + Tab novamente e chamar o objeto com o construtor personalizado:
public class Main {
public static void main(String args) {
System.out.println("Rodando a aplicação estoque");
Produto produto = new Produto("refrigerante", 5.00, 10);
}
}
Por enquanto conseguimos pegar os principais conceitos do uso do IntelliJ no dia a dia, ou seja, atalhos para criar algo novo Alt + Insert como também o de sugestões Alt + Enter.
Entretanto, se quisermos realizar alguma tipo de ação na qual um desses atalhos não resolvem ainda assim continua sendo um mistério, afinal, são muitos atalhos que ainda não conhecemos.
Sendo assim, o IntelliJ disponibiliza o atalho Ctrl + Shift + A que permite realizarmos qualquer ação dentro da IDE! Isso mesmo, quer testar? Vamos lá.
Vamos tentar buscar por keymap:
Veja que ele até apresenta alternativa para o Keymap References
Agora vamos tentar por generate:
Olha só que bacana ele também permite usar o Generate por meio desse atalho! Além disso, observe que ele até mostra o atalho que ativa essa funcionalidade da IDE que é justamente o Alt + Insert :)
Em outras palavras essa funcionalidade é conhecida como find action, ou na tradução, encontrar ação, portanto, podemos até mesmo criar um projeto apenas com esse atalho. A única coisa que ele vai exigir é um pouco do conhecimento de inglês para facilitar o uso.
Nesse post vimos como o IntelliJ facilita a nossa vida durante o desenvolvimento de um projeto, entretanto, vimos apenas a parte básica na qual permite criar arquivos e navegar no projeto.
Vimos também como podemos usar o template de código para facilitar a implementação de códigos comuns, como é o caso do método main() ou o System.out.println().
Além disso, aprendemos a gerar códigos comuns dentro de uma classe com o Generate e vimos que o IntelliJ também nos sugeres possíveis ações dependendo do contexto.
Por fim, vimos que temos a possibilidade de usar qualquer funcionalidade com apenas um único atalho! Bacana, né?
Quer aprender mais técnicas da IDE para aumentar a sua produtividade em projetos Java? Então não perca tempo e veja o curso de IntelliJ IDEA na Alura.
Nele você vai aprender desde os conceitos mais básicos, conforme vimos nesse artigo, como também, técnicas que são bem eficientes em qualquer projeto Java, seja na busca, navegação, refatoração entre outras.
A java.net.SocketException Broken Pipe
Ler mais
Aprender duas linguagens de programação ao mesmo tempo?
Ler mais
REST: Conceito e fundamentos
Ler mais