Configurazione di base di IntelliJ

1. Panoramica

Un buon IDE è importante per la produttività degli sviluppatori. IntelliJ è attualmente uno dei principali IDE e supporta molti linguaggi di programmazione.

In questo tutorial, inizieremo con alcune delle configurazioni di base in IntelliJ, concentrandoci sul linguaggio di programmazione Java. Elencheremo anche le scorciatoie più comuni in IntelliJ per aumentare la produttività degli sviluppatori.

2. Installazione di IntelliJ

Innanzitutto, dobbiamo scaricare e installare IntelliJ per la nostra piattaforma. Per le funzionalità che esamineremo, l'edizione Ultimate o Community andrà benissimo.

3. Configurazione di base del progetto in IntelliJ

3.1. Configurazione di JDK

IntelliJ è scritto in Java e viene fornito con un JRE impacchettato per l'esecuzione dell'IDE.

Tuttavia, dovremo configurare IntelliJ con un JDK per eseguire qualsiasi sviluppo Java. Può essere configurato globalmente o per progetto.

Per prima cosa, vediamo come configurare un JDK globale utilizzando l' opzione Switch IDE Boot JDK :

Il modo più semplice per trovare l'opzione Switch IDE Boot JDK è dalla procedura guidata "Trova azione".

Possiamo accedervi dal menu Aiuto o digitando Ctrl + Maiusc + A o Cmd + Maiusc + A.Di solito, elencherà ogni JDK installato e ci permetterà di scegliere quello desiderato.

Successivamente, creeremo un nuovo progetto Java.

3.2. Creazione di un progetto Java

Per creare un nuovo progetto Java, apriamo la procedura guidata Nuovo progetto da File-> Nuovo-> Progetto :

Successivamente, selezioneremo Java per creare un semplice progetto Java.

Inoltre, questa finestra ci consente di configurare un JDK specifico del progetto, se lo desideriamo.

Nella schermata successiva, IntelliJ fornisce progetti modello come Hello World come punto di partenza, ma selezioniamo semplicemente Fine e inizia.

Ora che abbiamo una struttura di progetto di base, possiamo aggiungere una classe Java selezionando la cartella src e quindi facendo clic con il pulsante destro del mouse o digitando Alt + Inserisci . Selezioneremo Java Class da questo menu e otterremo una finestra di dialogo in cui possiamo dargli un nome:

3.3. Configurazione delle librerie

Un progetto Java di solito dipende da molte librerie esterne o di terze parti. E mentre Maven e Gradle sono i tipici go-to per gestirlo, diamo un'occhiata a come farlo in modo nativo in IntelliJ.

Supponiamo di voler utilizzare l' API StringUtils dalla libreria commons-lang3 .

Come le impostazioni JDK, possiamo anche configurare le librerie a livello globale e di progetto. Le biblioteche globali sono condivise da tutti i progetti. Sia le librerie globali che quelle specifiche del progetto possono essere aggiunte accedendo alla finestra di dialogo Struttura del progetto ( File-> Struttura del progetto ) .

Per aggiungere la libreria, dobbiamo prima scaricarla. Normalmente, la fonte comune per qualsiasi libreria esterna è il repository Maven. Quindi, IntelliJ ci consente di scaricarlo direttamente da qualsiasi repository Maven preconfigurato. E, naturalmente, se nessun repository è configurato, cercherà in Maven Central.

IntelliJ scaricherà ora commons-lang3.jar in una cartella specificata. Insieme a ciò, lo aggiunge anche al classpath del progetto.

Ovviamente, ricorda che l' aggiunta di una libreria in questo modo è specifica di IntelliJ e non è portabile come le opzioni più robuste . È conveniente, tuttavia, per progetti semplici.

Nella prossima sezione, useremo questa libreria ed eseguiremo un semplice programma Java.

4. Esecuzione o debug di un'applicazione

4.1. Configurazioni di esecuzione / debug

Prima di eseguire il nostro programma Java, aggiungiamo del codice alla classe che abbiamo aggiunto in precedenza. Useremo semplicemente la libreria aggiunta e chiameremo StringUtils.reverse () per invertire qualsiasi testo dato come argomento del programma:

System.out.println(StringUtils.reverse(args[0]));

Ora, ci sono 2 approcci per eseguire questo metodo principale in IntelliJ. In primo luogo, possiamo semplicemente eseguire Ctrl + Maiusc + F10 o Control + Maiusc + R / D dalla classe principale. IntelliJ creerà quindi una configurazione Run temporanea.

Tuttavia, poiché dobbiamo passare una stringa alla nostra applicazione StringReversal come argomento del programma (la parte args [0] ), una configurazione di esecuzione temporanea non funzionerà.

Quindi, possiamo creare una configurazione Run / Debug permanente .

Lo faremo utilizzando la finestra " Modifica configurazioni " dalla barra di navigazione Esegui ( Esegui-> Modifica configurazioni ):

Qui, specifichiamo il nome della nostra classe da eseguire in Main Class. È necessario disporre di un metodo principale affinché funzioni.

Passeremo anche una stringa - " baeldung " , in questo caso - come argomento del programma alla nostra applicazione.

E, sebbene non lo dimostreremo qui, possiamo anche configurare le opzioni JVM e le variabili di ambiente per la nostra applicazione.

Contrariamente alle configurazioni di esecuzione temporanea , IntelliJ salva questa configurazione e ci consente di eseguirla in qualsiasi momento con un clic di un pulsante.

4.2. Debug di un'applicazione Java

IntelliJ ha un ottimo supporto per il debug di molte lingue. Eseguiamo il debug della nostra utilità di inversione di stringa come esempio.

Come con la maggior parte degli IDE, possiamo aggiungere un punto di interruzione su qualsiasi riga della nostra classe dall'editor facendo clic sul pannello laterale:

Ora possiamo eseguire il debug della classe facendo clic sull'icona di debug dalla configurazione Esegui / Debug.

In questo caso, il programma è sospeso alla riga 9 come mostrato sopra, permettendoci di ispezionare lo stack di thread, ispezionare variabili o persino valutare espressioni ( Alt + F8 o Opzione / Alt + F8 ) .

A questo punto, possiamo sia Step Into ( F7 ) il metodo StringUtils.reverse () , Step Over ( F8 ) la riga o Resume Program ( F9 ), che significa eseguire fino al punto di interruzione successivo o fino alla fine dell'applicazione.

Di solito, la maggior parte degli IDE consente agli utenti di contrassegnare una riga in una classe Java come punto di interruzione come abbiamo appena usato. Inoltre, IntelliJ ci consente di configurare più di semplici punti di interruzione di riga. Possiamo anche fare:

  • Punto di interruzione temporaneo - Un punto di interruzione di riga che viene eseguito una sola volta
  • Punto di interruzione eccezione: un punto di interruzione su qualsiasi classe di eccezione in Java. Il debugger si fermerà quando l'eccezione sta per essere generata
  • Punto di interruzione del metodo: viene eseguito quando si entra o si esce da un metodo
  • Punto di interruzione del campo - E uno che viene eseguito quando un campo viene modificato

Anche un punto di interruzione può avere una logica condizionale.

Possiamo visualizzare e configurare tutti i punti di interruzione in un progetto nella finestra di dialogo Punti di interruzione Esegui-> Visualizza punti di interruzione ( Ctrl + Maiusc + F8 o Cmd + Maiusc + F8 ).

4.3. Manufatti di costruzione

Ora che abbiamo testato, debug e risolto tutti i problemi, siamo pronti per spedire la nostra applicazione. Pertanto, dobbiamo creare file binari distribuibili per la nostra applicazione.

Possiamo creare automaticamente file binari .jar distribuibili in IntelliJ.

Innanzitutto, nella struttura del progetto ( Ctrl + Alt + Maiusc + S o Cmd +; ), dobbiamo dichiarare un nuovo artefatto.

Selezioniamo "Artefatti" e quindi facciamo clic sul pulsante più.

Successivamente, selezioniamo un artefatto JAR e aggiungiamo anche dipendenze nel JAR:

Successivamente, torneremo alla nostra finestra di dialogo Configurazione esecuzione / debug .

Lì, dobbiamo aggiungere un'attività Build Artifact nella finestra Before Launch. Di conseguenza, un nuovo jar eseguibile viene creato per la nostra applicazione ogni volta che eseguiamo la nostra configurazione Run / Debug.

Ancora una volta, la creazione di artefatti non è indipendente dall'IDE. Questo meccanismo è specifico di IntelliJ. Uno strumento di gestione della compilazione potrebbe essere un approccio migliore, simile a quello che abbiamo discusso per la gestione delle dipendenze.

5. Scorciatoie comuni in IntelliJ

Le scorciatoie sono davvero utili per aumentare la produttività degli sviluppatori. Quello che segue è un breve cheat sheet per i più comuni.

5.1. Navigazione

  • Classe di ricerca - Ctrl + N / Cmd + O
  • Cerca in tutti i file - Doppio Maiusc
  • File recenti: Ctrl + E / Cmd + E
  • Passa da un file all'altro : Ctrl + Tab / Cmd + Tab
  • Gerarchia dei tipi: Ctrl + H / Control + H.
  • Gerarchia delle chiamate: Ctrl + Alt + H / Control + Alt + H
  • Popup della struttura dei file - Ctrl + F12 / Cmd + F12 (elenca tutti i metodi e i campi)
  • Vai alla dichiarazione - Ctrl + B / Cmd + b
  • Vai alle implementazioni - Ctrl + Alt + B / Cmd + Alt + B
  • Mostra struttura del progetto - Ctrl + Alt + Maiusc + S / Cmd +;

5.2. Editor

  • Completamento del codice: Ctrl + Spazio / Controllo + Spazio
  • Informazioni sui parametri del metodo - Ctrl + P / Cmd + P
  • Informazioni sulla documentazione di metodo / classe - Ctrl + Q / Control + J
  • Riformatta il codice - Ctrl + Alt + L / Cmd + Alt + L
  • Ottimizza le importazioni: Ctrl + Alt + O / Control + Alt + O
  • Riga duplicata - Ctrl + D / Cmd + D
  • Elimina riga: Ctrl + Y / Cmd + Canc
  • Selezione del codice: Ctrl + W / Alt + Su
  • Mostra azioni rapide - Alt + Invio / Alt + Invio
  • System.out.println - sout + Ctrl + Invio / sout + Control + Spazio
  • public static void main - psvm + Ctrl + Invio / psvm + Control + Spazio
  • System.out.println per il valore restituito da un metodo : methodName (). Sout [Invio]
  • Assegna il valore di ritorno del metodo alla variabile locale - methodName (). Var [Invio]

5.3. Refactoring

  • Rinomina classe / metodo: Maiusc + F6
  • Metodo di estrazione: Ctrl + Alt + M / Cmd + Alt + M
  • Estrai variabile: Ctrl + Alt + V / Cmd + Alt + V
  • Estrai campo - Ctrl + Alt + F / Cmd + Alt + F.
  • Estrai costante - Ctrl + Alt + C / Cmd + Alt + C
  • Estrai parametro - Ctrl + Alt + P / Cmd + Alt + P

6. Conclusione

In questo articolo, abbiamo esaminato alcune configurazioni di base in IntelliJ.

Ad esempio, abbiamo creato un progetto Java, aggiunto librerie, debuggato e creato un artefatto, tutto in IntelliJ.

Infine, abbiamo esaminato le scorciatoie per alcune azioni comuni.