Intellij Idea - Guida rapida
IntelliJ è uno degli ambienti di sviluppo integrato (IDE) più potenti e popolari per Java. È sviluppato e mantenuto daJetBrainse disponibile come community e ultimate edition. Questo IDE ricco di funzionalità consente uno sviluppo rapido e aiuta a migliorare la qualità del codice.
Cos'è IDE e i suoi vantaggi?
IDE è l'acronimo di Integrated Development Environment. È una combinazione di più strumenti, che rendono il processo di sviluppo del software più semplice, robusto e meno soggetto a errori. Ha i seguenti vantaggi rispetto all'editor di testo normale:
Integrazione con strumenti utili come compilatore, debugger, sistema di controllo della versione, strumenti di compilazione, vari framework, profiler di applicazioni e così via.
Supporta la navigazione del codice, il completamento del codice, il refactoring del codice e le funzionalità di generazione del codice che potenziano il processo di sviluppo.
Supporta test di unità, test di integrazione e copertura del codice tramite plug-in.
Fornisce un ricco set di plug-in da migliorare IDE funzionalità ulteriormente.
Caratteristiche di IntelliJ
IntelliJ IDEA ha alcune funzionalità di completamento del codice Java estremamente produttive. Il suo algoritmo predittivo può presumere con precisione ciò che un programmatore sta tentando di digitare e lo completa per lui, anche se non conosce il nome esatto di una particolare classe, membro o qualsiasi altra risorsa.
Intuizione profonda
IntelliJ IDEA capisce davvero e ha un deep insight nel tuo codice, così come il contesto del programmatore, che lo rende così unico tra gli altri IDE Java.
Smart code completion- Supporta il completamento del codice basato sul contesto. Fornisce un elenco dei simboli più rilevanti applicabili nel contesto corrente.
Chain code completion - È una funzionalità di completamento del codice avanzata che elenca i simboli applicabili accessibili tramite metodi o getter nel contesto corrente.
Static member's completion - Consente di utilizzare metodi o costanti statici e aggiunge automaticamente le istruzioni di importazione richieste per evitare errori di compilazione.
Detecting duplicates - Trova al volo i frammenti di codice duplicati e fornisce notifiche / suggerimenti all'utente.
Inspections and quick-fixes- Ogni volta che IntelliJ rileva che stai per commettere un errore, viene visualizzata una piccola notifica di lampadina sulla stessa riga. Facendo clic su di esso viene visualizzato l'elenco dei suggerimenti.
Sviluppatore Ergonomics
IntelliJ IDEA è progettato intorno al principio di codifica secondo cui agli sviluppatori dovrebbe essere consentito di scrivere codici con la minor distrazione possibile. Ecco perché in questo caso l'editor è l'unica cosa visibile sullo schermo, con scorciatoie dedicate per tutte le altre funzioni non correlate alla codifica.
Editor-centric environment - I pop-up rapidi aiutano a controllare informazioni aggiuntive senza lasciare il contesto corrente.
Shortcuts for everything - IntelliJ IDEA dispone di scorciatoie da tastiera per quasi tutto, inclusa la selezione rapida e il passaggio tra le finestre degli strumenti e molto altro.
Inline debugger- Il debugger in linea consente di eseguire il debug dell'applicazione nello stesso IDE. Rende il processo di sviluppo e debug senza soluzione di continuità.
Strumenti per sviluppatori incorporati
Per aiutare gli sviluppatori a organizzare il loro flusso di lavoro, IntelliJ IDEA offre loro un fantastico set di strumenti, che comprende un decompilatore, supporto Docker, visualizzatore bytecode, FTP e molti altri strumenti -
Version control - IntelliJ supporta la maggior parte dei più diffusi sistemi di controllo delle versioni come Git, Subversion, Mercurial, CVS, Perforce e TFS.
Build tools - IntelliJ supporta Java e altri strumenti di compilazione come Maven, Gradle, Ant, Gant, SBT, NPM, Webpack, Grunt e Gulp.
Test runner and code coverage- IntelliJ IDEA consente di eseguire facilmente i test di unità. L'IDE include test runner e strumenti di copertura per i principali framework di test, inclusi JUnit, TestNG, Spock, Cucumber, ScalaTest, spec2 e Karma.
Decompiler- IntelliJ viene fornito con un decompilatore integrato per le classi Java. Quando vuoi dare un'occhiata all'interno di una libreria di cui non hai il codice sorgente, puoi farlo senza utilizzare plug-in di terze parti.
Terminal- IntelliJ fornisce un terminale integrato. A seconda della piattaforma, puoi lavorare con il prompt della riga di comando, come PowerShell o Bash.
Database tools- IntelliJ fornisce strumenti di database, che consentono di connettersi a database live; eseguire query; sfoglia e aggiorna i dati; e persino gestire i tuoi schemi in un'interfaccia visiva dall'IDE stesso.
Application server- IntelliJ supporta i principali server delle applicazioni: Tomcat, JBoss, WebSphere, WebLogic, Glassfish e molti altri. Puoi distribuire le tue risorse sui server delle applicazioni ed eseguire il debug delle applicazioni distribuite nello stesso IDE.
Docker support - Tramite un plug-in separato, IntelliJ fornisce una finestra degli strumenti dedicata che consente di connettersi alle macchine Docker in esecuzione in locale.
Confronto tra Ultimate e Community Edition
La Ultimate Edition è progettata per assistere nello sviluppo web e aziendale, mentre la Community Edition è progettata per JVM e Android Development. Consideriamo alcuni punti importanti che ci aiuteranno a capire il confronto tra le due edizioni:
| Caratteristica | Ultima edizione | Edizione comunitaria |
|---|---|---|
| Licenza | Commerciale | Open source, Apache 2.0. per lo sviluppo commerciale. |
| Java, Kotlin, Groovy, Scala | Supportato | Supportato |
| Sviluppo Android | Supportato | Supportato |
| Maven, Gradle, SBT | Supportato | Supportato |
| Git, SVN, Mercurial, CVS | Supportato | Supportato |
| Rilevamento di duplicati | Supportato | Non supportato |
| Perforce, TFS | Supportato | Non supportato |
| JavaScript, TypeScript | Supportato | Non supportato |
| Java EE, Spring, GWT, Vaadin, Play, Grails, altri framework | Supportato | Non supportato |
| Strumenti database, SQL | Supportato | Non supportato |
In questo capitolo capiremo come installare e configurare IntelliJ IDEA. Il primo passo del processo inizia con la scelta dell'edizione. In base alle tue esigenze, puoi scaricare la community o l'edizione definitiva. Come suggerisce il nome, la community edition è assolutamente gratuita e possiamo usarla anche per lo sviluppo commerciale. Tuttavia, l'edizione definitiva è una versione a pagamento e possiamo valutarla liberamente30 giorni.
Installazione su Windows
IntelliJ è compatibile con quasi tutte le versioni di Windows precedenti al 2003. Un elenco completo sarà: Windows 10/8/7 / Vista / 2003 / XP. Si consiglia di chiudere tutte le altre applicazioni prima di installare IntelliJ su Windows.
Requisiti di sistema
Si consigliano almeno 2 GB di capacità RAM per prestazioni senza interruzioni.
Per una migliore visualizzazione, si consiglia la risoluzione dello schermo 1024x768.
Minimo 300 MB di spazio su disco per l'installazione e 1 GB aggiuntivo per la cache.
Download e installazione
Downloading - Puoi scaricare il programma di installazione di Windows dal loro sito Web ufficiale.
Installation- Cominciamo con l'installazione seguita dai passaggi di configurazione. L'installazione di IntelliJ è simile ad altri pacchetti software. Basta fare doppio clic sul programma di installazione e seguire le istruzioni sullo schermo per completare il processo di installazione.
Installazione su Linux
Per l'installazione di IntelliJ su piattaforme Linux, è necessario notare che un JDK a 32 bit non è in bundle, quindi si consiglia un sistema a 64 bit.
Requisiti di sistema
Ambiente desktop GNOME, KDE o XFCE
Si consigliano almeno 2 GB di RAM per un utilizzo senza interruzioni
300 MB di spazio su disco per l'installazione e 1 GB aggiuntivo per le cache
Per una migliore visualizzazione, si consiglia la risoluzione dello schermo 1024x768
Download e installazione
Downloading - Puoi scaricare IntelliJ per Linux dal loro sito web ufficiale.
Installation- Abbiamo scaricato il bundle tar.gz. Nota che nel nostro caso il nome del bundle era ideaIC-2017.2.5.tar.gz. Può cambiare con l'edizione / versione. Utilizza il nome del bundle appropriato.
First extract it using following command:
$ tar xvf ideaIC-2017.2.5.tar.gz It will create new directory with idea-IC-172.4343.14 name. Now change directory to idea-IC-172.4343.14/bin/ and execute idea.sh shell script as shown below: $ cd idea-IC-172.4343.14/bin/
$ ./idea.sh
Follow on-screen instructions to complete installation procedure.Configurare IntelliJ
I passaggi di configurazione sono simili su entrambe le piattaforme. Per iniziare la configurazione, avvia l'applicazione IntelliJ. Facoltativamente, puoiimportla configurazione esistente da questa procedura guidata. Fare clic sul pulsante Avanti per continuare.
Step1- Se stai utilizzando l'edizione definitiva, verrà visualizzata una finestra di attivazione della licenza. Selezionare l'opzione Valuta gratuitamente e fare clic sul pulsante Valuta come mostrato nell'immagine seguente.
Step 2- Accetta il contratto di licenza per procedere e segui le istruzioni sullo schermo per avviare IntelliJ. Vedrai la schermata di benvenuto di IntelliJ.
Step 3- Ora è il momento di configurare il Java Development Kit (di seguito, lo chiameremo JDK) con IntelliJ. Se JDK non è già installato, segui le istruzioni come qui .
Nella schermata di benvenuto, fare clic su "configura"
Seleziona "impostazioni predefinite del progetto" dall'elenco a discesa
Seleziona l'opzione "struttura del progetto"
Seleziona l'opzione "SDK" dal menu "Impostazioni piattaforma".
Fare clic sull'icona "più" e selezionare l'opzione "JDK".
Seleziona la home directory di JDK e segui le istruzioni sullo schermo.
In questo capitolo, acquisiremo maggiore familiarità con IntelliJ IDEA. Per discutere i vantaggi e le funzionalità di qualsiasi strumento, è necessario avere familiarità con tale strumento e IntelliJ non fa eccezione.
Questo capitolo offre una panoramica di IntelliJ. Il capitolo inizia con una discussione sugli elementi visivi di IDE, le impostazioni di configurazione e termina infine con la discussione della JVM e delle proprietà della piattaforma.
Elementi visivi
Una delle cose importanti di IDE sono i suoi elementi visivi. Identificare e comprendere gli elementi visivi ti consente di agire in un filequickere modo più semplice. Lo screenshot seguente e le etichette su di esso mostrano l'interfaccia principale di IntelliJ.
Menu bar - La barra dei menu fornisce opzioni per creare nuovi progetti e altre azioni importanti relative a progetti come refactoring del codice, build, esecuzione, debug, opzioni di controllo della versione e così via.
Tool bar- La barra degli strumenti fornisce scorciatoie per compilare, eseguire il debug ed eseguire le opzioni. Puoi personalizzarlo in base alle tue esigenze.
Navigation bar- La barra di navigazione consente una navigazione più semplice all'interno di un progetto. Questa funzione è utile con l'aumentare della base di codice.
Tools tab- La scheda Strumenti viene visualizzata su entrambi i lati della finestra principale. Da qui puoi accedere a strumenti importanti come i database; Maven / Ant costruisce e così via.
Project perspective - La finestra della prospettiva del progetto mostra vari elementi di progetti come pacchetti, moduli, classi, librerie esterne e così via.
Editor window- Questo è un luogo in cui lo sviluppatore trascorre la maggior parte del suo tempo. La finestra dell'editor consente di modificare / scrivere codice con l'evidenziazione della sintassi e altre funzioni utili.
Nella parte inferiore della finestra principale è presente un file statusbarra, che mostra alcuni attributi aggiuntivi sul file, come il suo formato e il tipo di codifica. Fornisce inoltre l'opzione per attivare o disattivare l'attributo di sola lettura del file corrente. Puoi anche gestire il livello di ispezione da qui.
Lavorare con i plug-in
I plug-in aiutano a estendere le funzionalità di IntelliJ. Fornisce un gran numero di plug-in che vanno dai database, al controllo delle versioni, alla creazione di profili e l'elenco potrebbe continuare.
Passaggi per gestire i plug-in
Segui questi passaggi per gestire i plug-in:
Vai al menu File → Impostazioni.
Seleziona la scheda Plugin nel riquadro di sinistra.
Questa finestra elenca tutti i plug-in installati. C'è una casella di controllo sul lato destro di ogni nome di plug-in. La selezione di questa casella di controllo abilita / disabilita i plug-in.
Il repository di plug-in online IntelliJ è disponibile qui. Per aggiungere / rimuovere il repository di plug-in, fare clic sul pulsante Sfoglia repository e fornirà un modo per eseguire le operazioni necessarie.
Inoltre, consente l'installazione offline di plug-in. Per questo, scarica il plug-in e seleziona Installa plug-in dal pulsante del disco e vai al percorso di download.
Per eseguire altre azioni sui plug-in come la disinstallazione, l'aggiornamento e l'ordinamento, fare clic con il pulsante destro del mouse su qualsiasi plug-in. Mostrerà un menu a discesa da cui è possibile selezionare una delle azioni.
Lavorare con le impostazioni
Questa sezione fornisce alcuni importanti suggerimenti per gestire le impostazioni. Ti consente di importare, esportare e condividere le impostazioni di IntelliJ.
Impostazioni di esportazione
Permette di esportare le impostazioni correnti come file jar.
Vai a File → Impostazioni di esportazione.
Le finestre delle impostazioni di esportazione elencano le impostazioni disponibili relative a UI, debugger, SDK e altre.
Fornisce una casella di controllo per la selezione. Al termine della selezione, fare clic sul pulsante OK per salvare le impostazioni sul disco locale.
Impostazioni di importazione
Consente di importare le impostazioni memorizzate nel file jar.
- Vai a File → Importa impostazioni.
- Seleziona il vaso Impostazioni navigando nella struttura delle cartelle
- Fare clic sul pulsante OK.
Impostazioni di condivisione
IntelliJ IDEA ti consente di condividere le tue impostazioni IDE tra istanze diverse. Ciò è particolarmente utile quando si desidera applicare le stesse impostazioni all'interno di un team o di un'organizzazione. Il prerequisito per questo è abilitare ilSettings Repositorycollegare. È installato e abilitato per impostazione predefinita.
Per garantire il suo status -
- Vai a File → Impostazioni → Plugin
- Plug-in del repository delle impostazioni di ricerca
Possiamo memorizzare le impostazioni correnti su GitHub / Bitbucket e applicarle su altre istanze. Per memorizzare l'impostazione corrente -
Vai a File → Repository delle impostazioni.
Digita l'URL del repository Git nella finestra di dialogo URL upstream.
Fare clic sul pulsante Sovrascrivi telecomando.
Per applicare le stesse impostazioni ad altre istanze, fare clic sul pulsante Sovrascrivi locale.
Configurazione delle opzioni JVM e delle proprietà della piattaforma
Possiamo configurare le opzioni JVM accedendo al file Help → Edit Custom VM Optionsmenù. Di seguito sono riportate alcune importanti opzioni JVM che possiamo impostare.
–server - Permette la selezione della VM Java HotSpot Server
-Xms<size>- Imposta la dimensione heap Java iniziale. Il valore predefinito è 128 MB.
-Xmx<size>- Imposta la dimensione massima dell'heap Java. Il valore predefinito è 750 MB.
-Xss<size> - Imposta la dimensione dello stack del thread Java.
–XX - Consente di impostare l'algoritmo GC e altre proprietà.
È ora di fare un'esperienza pratica con IntelliJ. In questo capitolo creeremo il nostro primo progetto Java. Scriveremo ed eseguiremo il tradizionaleHello Worldprogramma. Questo capitolo spiega la compilazione e l'esecuzione dell'applicazione Java.
Crea progetto
Per qualsiasi cosa relativa allo sviluppo, uno sviluppatore deve creare un nuovo progetto con IntelliJ. Seguiamo questi passaggi per creare un progetto:
Avvia IntelliJ.
Vai a File → New → Project menù.
Selezionare il progetto Java e l'SDK appropriato e fare clic sul pulsante Avanti.
Se desideri creare una classe Java con il metodo principale, seleziona Crea progetto dalla casella di controllo del modello.
Seleziona l'app della riga di comando dalla finestra di dialogo mostrata di seguito e continua.
Immettere il nome del progetto e il percorso della directory.
Fare clic sul pulsante Fine.
Crea pacchetto
Un pacchetto viene creato nel progetto Java e può essere creato separatamente o contemporaneamente alla creazione di una classe. Seguiamo questi passaggi per creare un pacchetto:
Vai alla prospettiva del progetto.
Fare clic con il pulsante destro del mouse su Project, selezionare il file New->Module opzione.
La finestra del nuovo modulo sarà simile al nuovo progetto. Selezionare l'opzione Java e l'SDK appropriato e fare clic sul pulsante Avanti.
Immettere il nome del modulo.
Fare clic sul pulsante Fine.
Crea classe Java
In questa sezione impareremo come creare una classe Java. Una classe Java può essere creata sotto un modulo Java. Segui questi passaggi per creare un modulo:
Vai alla prospettiva del progetto.
Espandi Progetto e seleziona il file src directory dal modulo.
Fare clic destro su di esso; seleziona ilNew->Java Opzione di classe.
Immettere il nome della classe nella finestra di dialogo e fare clic sul pulsante OK.
Si aprirà la finestra dell'Editor con la dichiarazione della classe.
Esegui l'applicazione Java
Vedremo ora come eseguire un'applicazione Java. Segui questi passaggi e guarda come funziona:
Scriviamo un semplice codice, che stamperà un messaggio sulla console. Immettere il codice seguente nella finestra dell'editor:
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World !!!");
}
}Vai al menu Esegui e seleziona l'opzione Esegui.
Seleziona il nome della classe e fai clic su Esegui.
Se non ci sono errori di compilazione, verrà visualizzato l'output nella parte inferiore della finestra.
I primi quattro capitoli di questo tutorial sono stati progettati per fornire ai principianti una panoramica di livello base di IntelliJ. Questa sezione approfondisce IntelliJ e discute di più sui progetti, il suo formato e altre cose.
Capire i progetti
Un progetto è un'applicazione o un software su cui stai lavorando. Può contenere più moduli, classi, librerie, configurazioni e così via. È l'elemento più in alto nella gerarchia.
Moduli di comprensione
I moduli presentano un rung sotto "Project". Un modulo è un'entità separata che può essere compilata, sottoposta a debug ed eseguita indipendentemente da altri moduli. Un singolo progetto può contenere più moduli. Puoi aggiungere o rimuovere moduli da un progetto in qualsiasi momento.
Oltre a questo, possiamo anche importare i moduli esistenti. Segui questi passaggi per importare i moduli esistenti:
- Vai a File → Struttura del progetto.
- Seleziona i moduli e fai clic sull'icona più.
- Mostrerà l'opzione per importare il modulo.
Capire le cartelle
Content rootè una cartella che contiene tutti i file che compongono il tuo modulo. Un modulo può avere più di una cartella di contenuti. Le cartelle sono classificate nei seguenti tipi:
Sources - Assegnando questa categoria alla cartella, istruiamo IntelliJ che questa e la sua sottocartella contengono il codice sorgente java e devono essere compilate come parte del processo di compilazione.
Tests- Assegnando questa categoria alla cartella, indichiamo a IntelliJ che è la posizione per gli unit test. Questa cartella può accedere alle classi dalla cartella Sources.
Resources- Rappresenta vari file di risorse utilizzati nel progetto, ad esempio immagini, XML e file di proprietà. Durante il processo di compilazione, il contenuto di questa cartella viene copiato così com'è nella cartella di output.
Excluded- I contenuti della cartella esclusa non verranno indicizzati da IntelliJ. Ciò significa che IntelliJ non fornirà il suggerimento per il completamento del codice e altri suggerimenti. Ad esempio, la directory di output e la directory di destinazione sono escluse per impostazione predefinita.
Test resources - Questo è simile alle risorse e utilizzato per gli unit test.
Capire le biblioteche
La libreria è una raccolta di classi diverse. La libreria consente il riutilizzo del codice. In Java, la libreria può essere racchiusa in ZIP, Jar o semplicemente cartella. Possiamo definire le biblioteche a tre diversi livelli. I livelli sono: globale, progetto e livello modulo.
Global level - Condiviso da tutti i progetti.
Project level - Condiviso da tutti i moduli del progetto.
Module level - Condiviso dalle classi di quei moduli.
Comprensione delle sfaccettature
Le sfaccettature sono le estensioni dei moduli. Aggiungono il supporto ai framework e alle tecnologie. Quando un facet viene aggiunto a un modulo, IntelliJ lo identifica aggiunge il supporto. Ad esempio, suggerimenti e aiuto nell'editor, nuovi strumenti nella barra delle finestre, download delle dipendenze e così via. Puoi aggiungere sfaccettature dal fileFile → Project Structure finestra come mostrato di seguito -
Artefatti
Gli artefatti sono l'output di un progetto. Può essere un semplice file JAR, un'applicazione Java EE o un'applicazione Java EJB. Se utilizziamo strumenti di compilazione esterni come Gradle o Maven, IntelliJ aggiungerà automaticamente gli artefatti. Gli artefatti possono essere creati accedendo al fileFile → Project Structure come mostrato di seguito -
Importazione del progetto esistente
In questa sezione capiremo come importare un progetto esistente. Possiamo importare un progetto in due modi:
- Importalo dalla sorgente esistente
- Importalo dal modello di build.
Al momento, supporta gli strumenti di compilazione Gradle e Maven. Per importare il progetto -
- Navigando su File → Nuovo → Progetto dalla sorgente esistente.
- Seleziona la directory del progetto esistente, pom.xml di Maven o lo script di build di Gradle.
- Fare clic sul pulsante OK.
Formati del progetto
IntelliJ supporta due tipi di formato di progetto uno è directory-based e altro è file-based. Il formato basato su directory è più recente, consigliato. Per impostazione predefinita, IntelliJ crea un formato di progetto basato su directory. È possibile selezionare il formato del progetto durante la creazione di un nuovo progetto. Nella nuova finestra del progetto basta fare clic su più impostazioni come mostrato nell'immagine sottostante -
Formato progetto basato su directory
Questo formato aiuta a creare una cartella di idee nel progetto e a mantenere tutti i file di configurazione all'interno di quella cartella. Le impostazioni sono raggruppate nei file xml. Ad esempio, creeràmisc.xml, modules.xml, workspace.xmle così via. Lo screenshot seguente ti aiuterà a capire come funziona -
Formato progetto basato su file
Creerà due file di progetto con ..ipr e wprestensioni. Il file ipr conterrà le impostazioni specifiche del progetto e il file wpr conterrà le impostazioni specifiche dell'area di lavoro.
Per convertire un progetto basato su file in un progetto basato su directory, vai al File → Save as a Directory-Based format.
Formato del progetto basato su directory e su file
Rispetto al formato di progetto basato su file, il formato di progetto basato su directory memorizza le impostazioni in una cartella separata con nomi significativi. Altre differenze sono:
Le impostazioni correlate che vengono archiviate in un singolo file ne facilitano la gestione nel formato di progetto basato su directory.
Se la cartella contiene la sottocartella dell'idea, IntelliJ riconosce quel progetto. Per questo motivo, non è necessario selezionare esplicitamente il progetto ipr.
Il formato del progetto basato su directory suddivide le impostazioni in più file, quindi è più facile selezionare un tipo particolare di impostazione da memorizzare nel sistema di controllo della versione.
L'editor è l'area in cui uno sviluppatore trascorre la maggior parte del suo tempo. Padroneggiare l'editor è il primo passo per migliorare la produttività di qualsiasi risorsa. Questo capitolo discute gli elementi visivi dell'editor, le azioni dell'editor più comuni eSonarLint plug-in, che fornisce il controllo dei pelucchi.
Elementi visivi dell'editor
IntelliJ ha molte disposizioni che includono elementi visivi progettati per assistere gli sviluppatori nella navigazione e nella comprensione dello stato reale della loro codifica.
Esaminiamo ora le diverse disposizioni:
Area di grondaia
L'area di rilegatura dell'editor si trova sul lato sinistro dell'IDE, come mostrato nell'immagine seguente:
Etichette
Ora capiremo come funzionano le etichette. La schermata sopra è contrassegnata da numeri. Vedremo ora cosa devono mostrare i numeri:
Qui possiamo vedere i numeri di riga insieme ad altre opzioni utili. Se osservi attentamente appena prima del nome della classe e del metodo principale c'è un piccolo triangolo verde. Fornisce l'opzione per eseguire, eseguire il debug ed eseguire l'applicazione con copertura. Basta fare clic sull'icona del triangolo e fornirà le opzioni.
È possibile vedere il piccolo simbolo più alla riga numero 6. Questa è la funzionalità di raggruppamento del codice. Se fai clic su quell'icona, verrà aperta. La piegatura del codice può essere eseguita a livello di classe, metodo, ciclo e altri blocchi.
Ai numeri di riga 11 e 14, ci sono 2 frecce che puntano l'una verso l'altra. Il marcatore rappresenta la posizione iniziale e finale del metodo. Se fai clic su una freccia, eseguirà l'azione di piegatura su quel blocco di codice. L'area Grondaia mostrerà vari simboli quando vengono eseguite determinate azioni; per esempio, mostrerà i simboli per i punti di interruzione, le annotazioni Java.
Barra di stato
Nella parte inferiore della finestra dell'Editor, c'è una barra di stato, che mostra le informazioni sul file corrente e lo stato del progetto.
Nella prima immagine, 16: 1 rappresenta rispettivamente il numero di riga corrente e il numero di colonna.
Il prossimo è il separatore di riga, per UNIX e mac OS è \ ne per Windows è \ r.
UTF-8 rappresenta la codifica del file.
Il prossimo è il file lockicona. Possiamo attivare l'attributo di sola lettura del file facendo clic su di esso.
Alla fine, c'è un simbolo con la faccia di un uomo. Permette di gestire il livello di ispezione del codice.
Quando digitiamo codice in Editor, IntelliJ ispeziona il codice on the flye mostra suggerimenti / suggerimenti. Possiamo decidere il livello di ispezione da qui. Ad esempio, possiamo disabilitarlo completamente o consentire l'ispezione solo per la sintassi e così via.
Da qui possiamo anche abilitare la modalità Risparmio energetico, che disabiliterà l'analisi del codice in background e altri processi in background.
La barra di stato mostra anche le informazioni sulle azioni del progetto. Ad esempio, la seconda immagine mostra le informazioni sulla compilazione del progetto.
Graffi
IntelliJ fornisce un editor temporaneo. È possibile creare testo o parti di codice senza modificare la struttura del progetto corrente. Fornisce due tipi di file temporanei:
File gratta
Sono funzionali, eseguibili e eseguibili. Per creare un file di lavoro:
Vai a File → New → Scratch file.
Seleziona la lingua che preferisci.
Creerà un file nella cartella IntelliJ-Installation-Directory \ config \ scratches.
Buffer antigraffio
Viene utilizzato solo per creare testo. Per creare un buffer di memoria virtuale:
Premi Ctrl + Maiusc + A o fai clic sull'icona Cerca ovunque
Apparirà una finestra di dialogo.
Immettere il nuovo testo del buffer di memoria virtuale in quella casella e premere Invio.
Si aprirà il buffer di memoria virtuale nella finestra dell'editor.
Come i file di memoria virtuale, scratch buffers sono inoltre archiviati nella cartella IntelliJ-Installation-Directory \ config \ scratches.
Barra di scorrimento
La barra di scorrimento evidenzia avvisi / messaggi di errore / indicatori TODO dal codice. Ad esempio, il metodo sayHello () e sayGoodBye () non viene mai utilizzato; quindi, la barra di scorrimento mostra loro un indicatore giallo.
Alla riga numero 8, c'è il commento TODO, la barra di scorrimento lo evidenzia usando l'indicatore blu. Gli errori vengono evidenziati utilizzando un pennarello rosso.
Azioni dell'editor
In questa sezione, discuteremo le azioni dell'Editor in IntelliJ.
Cerca e sostituisci
Per cercare del testo nel file corrente -
Vai al file nella finestra dell'Editor e premi Ctrl + F.
Mostrerà la casella di testo, digita il testo da cercare lì.
Puoi fornire varie opzioni qui: corrispondenza con distinzione tra maiuscole e minuscole, corrispondenza esatta, espressione regolare e così via.
È possibile eseguire l'operazione di ricerca a un livello molto granulare. Ad esempio, la ricerca può essere eseguita a livello di progetto, modulo o directory -
premi il Ctrl+Shift+F combinazione di tasti.
Apparirà una nuova finestra; da qui è possibile selezionare il livello appropriato.
Per eseguire un'azione di sostituzione nel file corrente:
premi il Ctrl+R combinazione di tasti.
Apparirà una finestra di dialogo, inserire qui il testo da sostituire.
Questa operazione consente di sostituire una singola corrispondenza, tutte le corrispondenze o saltare la corrispondenza corrente.
Per eseguire l'azione di sostituzione a livello granulare:
premi il Shift+Ctrl+R combinazione di tasti.
Ti consentirà di sostituire il testo in progetto, modulo, directory e altri ambiti.
Modalità di selezione delle colonne
Per abilitare la selezione della modalità colonna, tenere premuto il tasto Altdurante la selezione del testo. Per abilitare la modalità di selezione delle colonne su base permanente, selezionareEdit → Column selection mode.
Cronologia degli appunti
Quando copiamo del testo, va nella cronologia degli appunti. IntelliJ mantiene la cronologia degli appunti. Per visualizzare questa cronologia, premere il pulsanteCtrl+Shift+Vcombinazione di tasti. È possibile selezionare il contenuto da incollare da questa finestra.
Completamento del codice
IntelliJ ispeziona il file code on the flye fornisce un accurato completamento del codice. Ad esempio, quando digito la parolasay - suggerisce sayHello() e sayGoodBye() metodi.
Il completamento del codice suggerisce attributi di classe e metodi di classe mentre si lavora con gli oggetti di classe.
Generazione di codice
IntelliJ fornisce un modo per generare codice utile come costruttore, getter, setter, metodo toString (), metodi di override e così via. Segui questi passaggi per generare il clic con il pulsante destro del mouse nella finestra dell'editor.
Seleziona il Generate opzione.
Elencherà i metodi per i quali è possibile generare il codice.
Ispezione del codice
Abbiamo già visto che IntelliJ identifica errori di sintassi, messaggi di avviso e marcatori TODO. Oltre a questo, suggerisce il miglioramento del codice, identifica il codice morto, l'ottimizzazione del codice. Ad esempio, nel codice fornito di seguito, il valore di flag è sempre vero. Quindi ilelse parte non verrà mai eseguita.
boolean flag = true;
if (flag == true) {
System.out.println("Value of flag is true");
} else {
System.out.println("Value of flag is false");
}IntelliJ lo identifica e suggerisce di rimuovere questo blocco di codice.
Confronto di file e cartelle
Segui questi passaggi per confrontare file e cartelle:
Tenere il Ctrl chiave e selezionare i file da confrontare dalla prospettiva del progetto.
Fai clic destro su di esso e seleziona il file Compare Files opzione.
Si aprirà la finestra Confronta in cui sono evidenziate le modifiche.
Puoi anche applicare le modifiche da un file a un altro. Se osservi, ci sono due indicatori di freccia evidenziati in rosso. Fare clic su di essi per applicare le modifiche da un altro file. stampaCtrl+Z per annullare le modifiche.
Allo stesso modo, per confrontare le cartelle, seleziona le cartelle dalla prospettiva del progetto invece dei file.
Ottenere aiuto
È utile se ottieni facilmente dettagli sul codice. Come la descrizione del metodo, il suo tipo restituito, il tipo di argomenti e il numero di argomenti - IntelliJ può fornire questi dettagli nella stessa finestra dell'Editor.
Documentazione in linea
Come suggerisce il nome, IntelliJ può accedere alla documentazione estraendola dal codice. Se fornisci Java Docs per il tuo codice, IntelliJ può mostrare la guida al riguardo. Per accedere alla documentazione in linea, fai clic con il mouse sul nome del metodo e premi il tastoCtrl+Q combinazione di tasti.
Visualizzazione della definizione
Per visualizzare la definizione, passare il mouse sul nome del metodo e premere il tasto Ctrl+Shift+I combinazione di tasti.
Mostra utilizzo
Per visualizzare l'utilizzo del metodo, fare clic sulla dichiarazione / definizione del metodo e premere il tasto Alt+Ctrl+F7 combinazione di tasti.
Visualizza parametri
Per visualizzare i parametri del metodo, digitare il nome del metodo e premere il tasto Ctrl+P combinazione di tasti.
Codice Linting
Il linting è un processo in cui lo strumento lint analizza i codici sorgente e segnala potenziali problemi relativi allo standard di codifica. Aiuta a migliorare la qualità del codice. IntelliJ supporta il plug-in SonarLint che limita il codice.
Informazioni su SonarLint
Una volta installato e abilitato il plug-in SonarLint, inizierà ad analizzare il codice automaticamente quando aprirai un file nella finestra dell'Editor. Segnalerà problemi nel pannello SonarLint. Ne discuteremo di più in questa sezione.
SonarLint supporta i linguaggi di programmazione più diffusi come Java, JavaScript, PHP e Python.
Installazione
Segui questi passaggi per installare SonarLint -
Scarica SonarLint da qui .
Vai a File → Settings → Select plugins.
Clicca sul Install plugin from disk pulsante.
Seguire l'installazione sullo schermo per completare la procedura di installazione.
Analisi del codice
Una volta installato e abilitato il plug-in, inizierà l'analisi code on the fly. Segnalerà problemi nel pannello SonarLint. Segui questi passaggi per visualizzare i problemi del file corrente:
Fare clic sulla scheda File corrente.
Segnalerà problemi come variabili locali non utilizzate, attributi di classe non utilizzati, registrazione dei messaggi e così via.
Per saperne di più sul problema, fare clic sul problema dal pannello SolarLint.
Nella parte destra della finestra, mostrerà la sua gravità come Maggiore, Minore e così via.
Fai un'analisi del codice temporale
Se non ti senti a tuo agio con l'analisi del codice al volo, puoi disabilitarlo ed eseguire un'analisi del codice temporale una volta che sei pronto con il codice. Segui questi passaggi per disabilitare l'analisi del codice al volo:
Vai a File → Settings → Other Setting → SonarLint General impostazioni
Deseleziona Automatically Trigger Analysis casella di controllo dalla scheda delle impostazioni.
Clicca su Apply seguito da Ok pulsante.
In questo capitolo apprenderemo il refactoring del codice e come funziona in IntelliJ. Il refactoring del codice è la ristrutturazione del codice senza modificarne la funzionalità e l'usabilità. Il refactoring del codice può essere eseguito per migliorare la leggibilità e le prestazioni del codice o per rimuovere funzionalità inutilizzate / duplicate. IntelliJ fornisce un ottimo supporto per il refactoring del codice. Questo capitolo discute varie azioni di refactoring del codice.
Rinominare
Le azioni di ridenominazione possono essere utilizzate per rinominare metodi, i suoi parametri, attributi di classe, variabili locali e così via. Creiamo la seguente classe in IntelliJ.
public class Employee {
private String name;
private String address;
private int age;
public Employee() {
this("Jarvis", "Palo Alto", 35);
}
public Employee(String name, String address, int age) {
this.name = name;
this.address = address;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Employee{" +
"name='" + name + '\'' +
", address='" + address + '\'' +
", age=" + age +
'}';
}
public static void main(String args[]) {
Employee e = new Employee();
System.out.println(e);
}
}Ora rinominiamo Employee classe a Person. Questa azione apporterà modifiche nei costruttori e inmain() metodo -
Seleziona parola dipendente
Vai a Refactor → Rename e rinominalo con Persona.
Sostituisci duplicati di codice
Questa è una delle potenti azioni di refactoring. IntelliJ identifica i duplicati del codice e lo sostituisce con il codice appropriato. Introduciamo la duplicazione del codice e lo rifattorizziamo. Digita il seguente codice nell'Editor:
public class Employee {
private String name;
private String address;
private int age;
public Employee() {
this("Jarvis", "Palo Alto", 35);
}
public Employee(String name, String address, int age) {
this.name = name;
this.address = address;
this.age = age;
}
public void setData(String name, String address, int age) {
this.name = name;
this.address = address;
this.age = age;
}
public void showEmployeeDetail() {
System.out.println("Name = " + name + ", Address = " + address + ", Age = " + age);
}
public static void main(String args[]) {
Employee e = new Employee();
e.showEmployeeDetail();
}
}In questo esempio, Employee (String name, String address, int età) costruttore e public void setData (nome stringa, indirizzo stringa, intetà) sono esattamente identici. Dopo il refactoring, il costruttore Employee (String name, String address, int age) viene modificato come segue:
public Employee(String name, String address, int age) {
setData(name, address, age);
}Per sostituire i duplicati -
Vai a Refactor → Trova e sostituisci duplicati di codice.
Seleziona l'ambito del refactoring e segui i passaggi sullo schermo per completare l'azione.
Copia refactoring
In questa sezione capiremo come copiare una classe in un'altra. Copiamo la classe Employee nella classe Person. Possiamo copiarlo nel modulo esistente o in uno nuovo. IntelliJ eseguirà le modifiche richieste a seconda di esso. Segui questi passaggi per eseguire il refactoring della copia:
Vai a Refactor → Copy, aprirà la finestra di dialogo.
Immettere il nuovo nome e il pacchetto di destinazione.
Fare clic sul pulsante OK e farà il necessario.
Spostare il refactoring
Il refactoring di spostamento è simile alla copia ma invece di fare un'altra copia sposta il codice in un pacchetto diverso o lo rende come classe interna di un'altra classe.
Segui questi passaggi per eseguire il refactoring dello spostamento:
Vai a, Refactoring → Sposta.
Apparirà una nuova finestra.
Seleziona una delle opzioni in base alla tua scelta e fai clic su Refactor.
Eliminazione sicura
L'azione di eliminazione sicura eliminerà l'oggetto solo quando non è referenziato in alcun punto del progetto. L'obiettivo per questa opzione può essere classe, interfaccia, metodo, campo o parametro.
Vediamolo in azione. Digita il codice seguente nell'editor:
public class HelloWorld {
static void sayHello() {
System.out.println("Hello, World !!!");
}
public static void main(String[] args) {
sayHello();
}
}Segui questi passaggi per eseguire l'azione di eliminazione sicura:
Seleziona il sayHello() metodo.
Fai clic destro su di esso e seleziona il file Refactor → Safe Delete opzione.
Poiché viene utilizzato il metodo sayHello (), verrà visualizzato un errore come nella schermata seguente:
Cambia firma
L'azione modifica la firma del metodo. Può modificare il nome del metodo, i suoi parametri, i tipi, i valori di ritorno e così via. Prendiamo un metodo dall'esempio sopra e cambiamo la sua firma.
Segui questi passaggi per eseguire l'azione Modifica firma:
Seleziona il metodo.
Fare clic con il tasto destro su di esso e selezionare l'azione Refactoring → Modifica firma
Apparirà una nuova finestra in cui potrai eseguire le azioni precedenti.
Nella parte inferiore della finestra, mostra l'anteprima della nuova firma.
Digitare Migration
La migrazione del tipo cambia il tipo del simbolo. Questo simbolo può essere un parametro del metodo o un attributo di classe. Consideriamo il seguente metodo prima di eseguire l'azione richiesta:
static void sayHello(String name) {
System.out.println(name);
}Segui questi passaggi per eseguire la migrazione del tipo:
Seleziona il tipo di dati "String".
Fai clic destro su di esso e seleziona Refactor → Type migration.
Immettere il tipo di dati richiesto nella casella di testo data.
Scegli l'ambito e fai clic sul pulsante Refactoring.
IntelliJ offre diversi modi per creare la configurazione. Questo capitolo discute le opzioni per creare una configurazione temporanea e permanente. Discute anche il metodo per condividere la configurazione tra altri utenti.
Crea configurazione temporanea
La configurazione temporanea viene creata quando si esegue o si esegue il debug di una classe Java o di uno scenario di test. Considera i seguenti passaggi per capire come funziona:
- Crea una classe Java.
- Fai clic destro su di esso e seleziona l'opzione Esegui.
- Dopo la prima esecuzione, la configurazione temporanea viene aggiunta al menu di esecuzione.
Crea configurazione permanente
La configurazione temporanea può essere convertita in configurazione permanente salvandola con IntelliJ. Per salvare la configurazione, fare clic suSave Configuration opzione dal menu Esegui -
È inoltre possibile modificare la configurazione esistente modificandola.
Crea nuova configurazione
In questa sezione capiremo come creare una nuova configurazione. Segui questi passaggi per creare una nuova configurazione:
Vai a Esegui → Modifica configurazione.
Fare clic sul pulsante Più per aggiungere una nuova configurazione.
Seleziona Applicazione dall'elenco a discesa.
Creerà una configurazione senza nome.
Configuralo in base alle tue esigenze e fai clic sul pulsante OK.
Questa configurazione salvata sarà accessibile dal menu Esegui insieme ad altre configurazioni.
Condivisione della configurazione
Segui questi passaggi per condividere la configurazione con altri:
Vai al file Run → Edit Configurazione.
Seleziona la configurazione dal riquadro di sinistra e fai clic sulla casella di controllo Condividi.
Memorizzerà la configurazione su disco.
Se viene utilizzato il formato basato su directory, salverà la configurazione in un file separato in runConfigurationcartella. Altrimenti, memorizzerà la configurazione nel file.ipr file.
Esegui configurazione
Per eseguire un progetto con una configurazione specifica:
Seleziona la configurazione dal menu Esegui.
Esegui il progetto come mostrato nello screenshot seguente:
IntelliJ fornisce un modo per creare e creare pacchetti di pacchetti Java. Supporta strumenti di compilazione esterni come Maven e Gradle. Questo capitolo discute di questi strumenti di compilazione.
Creazione del progetto Maven
Segui questi passaggi per creare un progetto Maven:
Navigare verso File → Project.
Seleziona l'opzione Maven e fai clic sul pulsante Avanti.
Nella finestra del nuovo progetto inserisci tutorialspoint.com come GroupId e HelloWorld come ArtifactId.
Nella nuova finestra, aprirà il file pom.xml.
Dobbiamo aggiungere proprietà a questo file; il file pom.xml finale dovrebbe assomigliare a questo -
<?xml version = "1.0" encoding = "UTF-8"?>
<project xmlns = "http://maven.apache.org/POM/4.0.0"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.tutorialspoing</groupId>
<artifactId>HelloWorld</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>
</project>Ora, creiamo una classe Java all'interno di src/main/javadirectory del progetto Maven. Segui questi passaggi per creare la classe:
Accedi alla directory src / main / java.
Fai clic destro su di esso e seleziona New → Java Class.
Segui questi passaggi per compilare questa classe usando Maven -
Vai a Esegui → Modifica configurazione.
Fare clic sull'icona più verde e selezionare l'opzione Maven dal menu a discesa.
Immettere il nome del progetto come Maven-Package.
Fornisci pacchetto come riga di comando.
Fare clic sul pulsante OK.
Vai a Esegui e seleziona il file Maven-Package opzione.
Inizierà a costruire il pacchetto. Dopo aver creato con successo il pacchetto, vedrai il seguente risultato:
Crea progetto Gradle
In questa sezione impareremo come creare un progetto Gradle -
Navigare verso File → Project e seleziona Gradle.
Fare clic sul pulsante Avanti.
Nella finestra del nuovo progetto, inserisci tutorialspoint come GroupId e HelloWorld come ArtifactId.
Fare clic sul pulsante Avanti, verificare i dettagli del progetto e fare clic sul pulsante Fine.
Segui le istruzioni sullo schermo per completare il processo.
Apri il buildl.gradle file e scrivi Hello task come mostrato nello screenshot sopra.
Per compilare questa attività, vai al file Run → Build-Gradle opzione.
I test unitari svolgono un ruolo importante nello sviluppo del software. IntelliJ supporta vari framework di unit test come JUnit, TestNG, Spock e molti altri. In questo capitolo useremo JUnit3.
Crea test unitario
In questa sezione impareremo come creare uno Unit Test. Segui questi passaggi per creare il test:
Seleziona il Navigate → Test opzione.
Apparirà una finestra di dialogo in cui devi selezionare Create New Test.
Segui le istruzioni sullo schermo per continuare -
Fornisci i dettagli sul test come libreria di test, dettagli della classe, setUp, metodi di tearDown e così via.
Fare clic sul pulsante OK per continuare.
Verrà creata una classe di prova. Inizialmente potrebbe non riuscire a risolvere alcuni simboli. Spostare il cursore sulla riga di errore, verrà visualizzato il simbolo del suggerimento.
Seleziona l'opzione appropriata dal menu a discesa. Abbiamo selezionato ilAdd library ‘junit.jar!’ to classpath opzione -
È possibile aggiungere logica all'interno di ogni test in base alle proprie esigenze aziendali. L'ho tenuto vuoto per semplicità.
Esegui test unitario
Segui questi passaggi per eseguire lo unit test:
Seleziona la classe di unit test dalla finestra Editor.
Vai al menu Esegui e seleziona l'opzione Esegui.
Verrà generato il seguente risultato
Il debugger semplifica notevolmente il debug delle applicazioni. Usando il debugger, possiamo interrompere l'esecuzione del programma a un certo punto, ispezionare le variabili, entrare in funzione e fare molte cose. IntelliJ fornisce un debugger Java integrato.
Punti di interruzione
Il punto di interruzione consente di interrompere l'esecuzione del programma in un determinato punto. I punti di interruzione possono essere impostati passando il mouse sull'area di rilegatura dell'Editor e facendo clic su di essa.
I punti di interruzione sono indicati utilizzando i simboli del cerchio rosso. Considera il punto di interruzione impostato alla riga 3.
Considera i seguenti passaggi per capire di più su come funzionano i punti di interruzione:
Fare clic con il tasto destro sul simbolo del cerchio rosso.
Seleziona il More opzioni.
Per rimuovere il punto di interruzione è sufficiente fare clic sullo stesso simbolo.
Segui questi passaggi per avviare il debugger:
- Vai al menu Esegui.
- Seleziona l'opzione Debug.
Entra
Durante il debug, se viene rilevata una funzione e viene selezionato un passaggio all'azione, il debugger interromperà l'esecuzione del programma in ogni punto di quella funzione come se il debug fosse abilitato per quella funzione.
Ad esempio, quando l'esecuzione del programma raggiunge la riga 9 e se selezioniamo il passaggio in azione, interrompe l'esecuzione su ciascuna riga del sayGoodBye() funzione.
Uscire
L'azione Step out è esattamente l'opposto di Step in action. Ad esempio, se esegui l'azione di uscita con lo scenario precedente, il debugger tornerà dal filesayGoodBye() metodo e inizia l'esecuzione dalla riga 10.
Scavalcare
L'azione Step over non entra invece in funzione, salterà alla riga di codice successiva. Ad esempio, se ti trovi alla riga 9 ed esegui l'azione di passaggio, si sposterà l'esecuzione alla riga 10.
Riprendi il programma
L'azione Riprendi programma continuerà l'esecuzione del programma ignorando tutti i punti di interruzione.
Interrompi l'azione
L'azione Stop aiuta a fermare il debugger.
Entra in modo intelligente
Durante il debug, a volte possiamo raggiungere una riga di codice che chiama diversi metodi. Quando si esegue il debug di queste righe di codice, il debugger in genere ci consente di utilizzarestep intoe ci conduce attraverso tutte le funzioni figlio e poi di nuovo alla funzione genitore. Tuttavia, cosa succederebbe se volessimo solo entrare in una funzione figlio? Con Smart step-into, ci permette di scegliere la funzione in cui entrare.
Ora, creiamo una classe Java con la seguente riga di codice:
public class HelloWorld {
public static void main(String[] args) {
allFunctions();
}
static void allFunctions() {
System.out.println(function1() + " " + function2() + " " + function3());
}
static String function1() {
return "function1";
}
static String function2() {
return "function2";
}
static String function3() {
return "function3";
}
}Nel codice sopra, allFunctions()chiama altre 3 funzioni. Impostiamo il punto di interruzione in questa funzione. Segui questi passaggi per eseguire un passaggio intelligente in:
- Vai a correre
- Seleziona Smart Step into.
- Seleziona la funzione figlio per andare.
Ispezione delle variabili
Durante il debug, IntelliJ mostra il valore della variabile nella finestra dell'editor stessa. Possiamo anche visualizzare le stesse informazioni nella finestra Debug.
Valuta l'espressione
Valuta espressione consente di valutare l'espressione al volo. Segui questi passaggi per eseguire questa azione:
Avvia l'applicazione nel debugger
Navigare verso Run->Evaluate espressione.
Inserisci espressione. Nell'esempio riportato di seguito, il valore corrente della variabile "i" è 0; quindi, l'espressione "i> 100" restituirà false
Profiler fornisce informazioni dettagliate sulla tua applicazione come la CPU, la memoria e l'utilizzo dell'heap. Fornisce inoltre dettagli sui thread dell'applicazione. Questo capitolo discute l'utilizzo dello strumento VisualVM per la creazione di profili di applicazioni Java. Può profilare entità come CPU e heap.
Si consiglia ai lettori di questo tutorial di acquisire familiarità con i concetti del profiler dell'applicazione.
introduzione
VisualVM è uno strumento visivo che integra strumenti JDK e offre potenti funzionalità di profiling. Consente di generare e analizzare i dati dell'heap, rintracciare le perdite di memoria, monitorare il garbage collector ed eseguire la profilazione della memoria e della CPU.
Benefici
Interfaccia visiva per applicazioni Java locali e remote in esecuzione su JVM.
Monitoraggio dell'utilizzo della memoria dell'applicazione e del comportamento di runtime dell'applicazione.
Monitoraggio dei thread dell'applicazione
Analizzando le allocazioni di memoria a diverse applicazioni.
Thread dump: molto utili in caso di deadlock e race condition.
Dump dell'heap: molto utile per analizzare l'allocazione della memoria dell'heap.
Configurazione
In questa sezione, impareremo i passaggi eseguiti per configurare VisualVM. I passaggi sono i seguenti:
Scaricalo da qui .
Estrai il file zip.
Vai al file etc / visualvm.conf e aggiungi la seguente riga in questo file:
visualvm_jdkhome=<path of JDK>Se il tuo JDK è installato in C:\Program Files\Java\jdk-9.0.1 directory quindi dovrebbe assomigliare a questo -
visualvm_jdkhome="C:\Program Files\Java\jdk-9.0.1"Applicazione di monitoraggio
Vediamo ora come monitorare l'applicazione. Considera i seguenti passaggi per capire lo stesso:
- Fare doppio clic sul file visualvm.exe.
- Seleziona l'applicazione dal riquadro sinistro.
- Seleziona la scheda Monitor.
Verrai indirizzato a una finestra in cui otterrai i dettagli su CPU, Heap, Classi e thread. Per essere specifici con l'utilizzo, passa il mouse su qualsiasi grafico. Possiamo vedere l'utilizzo di Heap nello screenshot qui sopra.
Approfondimenti sui thread
L'applicazione Java può contenere più thread di esecuzione. Per saperne di più sui thread, seleziona la scheda Thread di una particolare applicazione. Fornirà varie statistiche sui thread come il numero di thread live e thread daemon. I diversi stati del thread sono Running, Sleeping, Waiting, Park e Monitor.
Applicazione di campionamento
VisualVM supporta CPU, campionamento della memoria e rilevamento di perdite di memoria. Per l'applicazione di esempio, selezionare l'applicazione e scegliere la scheda di esempio -
Campionamento della CPU
Per il campionamento della CPU, fare clic sul pulsante CPU come mostrato nella seguente schermata:
Profilazione della memoria
Per la profilazione della memoria, fare clic sul pulsante Memoria come mostrato nella seguente schermata -
Perdite di memoria
Si verifica una perdita di memoria quando un'applicazione, durante l'esecuzione, riempie lentamente l'heap con oggetti che non vengono eliminati automaticamente dal programma.
Se un oggetto che non viene utilizzato dal programma non viene eliminato, rimane in memoria e il GC non può recuperare il suo spazio. Se il numero di byte e il numero di istanze nella tua applicazione dovessero aumentare costantemente e in modo significativo nel tuo programma al punto da consumare tutto lo spazio, ciò può essere un'indicazione di una perdita di memoria.
Applicazione di profilazione
In questa sezione impareremo come creare il profilo di un'applicazione. Per creare il profilo di un'applicazione, selezionare l'applicazione dal riquadro di sinistra e fare clic sulla scheda del profilo -
Profilazione della CPU
Per eseguire la profilazione della CPU, fare clic sul pulsante CPU come mostrato nello screenshot qui sotto -
Profilazione della memoria
Per eseguire la profilazione della CPU, fare clic sul pulsante CPU come mostrato nello screenshot qui sotto -
IntelliJ supporta vari sistemi di controllo della versione come Git, Subversion, Mercurial, CVS, GitHub e TFS. È possibile eseguire un'azione relativa al controllo della versione dall'IDE stesso.
In questo capitolo, discuteremo di Git e Subversion (di seguito denominati SVN). Partiamo dal presupposto che il lettore abbia familiarità con lo strumento Git e SVN e la sua terminologia.
Idiota
In questa sezione impareremo come lavorare con Git.
Clone
Per clonare un repository Git esistente:
Passa a File-> Nuovo-> Progetto da Controllo versione-> Git.
Immettere l'URL del repository, la directory principale e il nome della directory.
Fare clic sul pulsante clona per continuare.
Dopo aver eseguito con successo i passaggi precedenti, il repository verrà clonato.
Tenere traccia delle modifiche
Git terrà traccia delle modifiche apportate nel repository. Modifichiamo qualsiasi file dal repository e confrontalo con il repository.
Passa a VCS → Git → Confronta con l'ultima versione del repository.
Il passaggio precedente aprirà la finestra delle differenze.
Puoi vedere che c'è una nuova linea sul lato destro con il colore di sfondo verde.
Git lo mostra in verde poiché abbiamo aggiunto nuovi contenuti. Se rimuoviamo qualsiasi contenuto, verrà visualizzato in rosso
Ripristina le modifiche locali
Segui questi passaggi per annullare le modifiche locali:
Vai al file VCS → Git → Revert opzione.
Chiederà conferma e rimuoverà le modifiche.
Aggiungi file al repository
Per aggiungere file al repository, vai a VCS → Git → Add option. Questa azione è simile agit add azione.
Effettua modifiche
L'operazione Commit creerà il commit locale. È simile al filegit commitazione. Per eseguire il commit -
Vai al file VCS → Git → Commit File opzione.
Seleziona i file di cui eseguire il commit.
Immettere il messaggio di commit e fare clic sul pulsante Commit.
Esegui il push delle modifiche al repository remoto
L'azione Push invierà le modifiche locali al repository remoto. Per spingere le modifiche -
Vai al file VCS → Git → Push opzione.
Apparirà una finestra. Qui puoi vedere i comitt da spingere.
Verificare il commit e fare clic sul pulsante Push per pubblicare le modifiche.
Visualizza la cronologia o i registri
Per visualizzare la cronologia, vai al file VCS → Git → Show history option. Questa azione è simile agit logcomando. Mostrerà la storia come segue:
Ricevi aggiornamenti
Segui questi passaggi per recuperare gli aggiornamenti dal repository:
Vai al file VCS → Git → Pull opzione.
Seleziona l'opzione in base alle tue esigenze.
Fare clic sul pulsante Pull.
Aggiungi un progetto esistente a Git
Per aggiungere un progetto esistente in Git -
Navigare verso VCS → Import into Version Control → Create Git repository.
Seleziona il progetto sfogliando la directory.
Fare clic sul pulsante OK.
Sovversione
In questa sezione, capiremo come funziona Subversion in IntelliJ. Consideriamo alcune azioni importanti per capirlo.
Check-out
Per effettuare il checkout del repository SVN -
Navigare verso File → New → Project from Version Control → Subversion.
Immettere l'URL del repository.
Clicca sul OK pulsante.
Tenere traccia delle modifiche
SVN terrà traccia delle modifiche apportate nel repository. Modifichiamo qualsiasi file dal repository e confrontalo con il repository -
Passa a VCS-> Subversion-> Confronta con l'ultima versione del repository
Puoi vedere che c'è una nuova linea sul lato destro con il colore di sfondo verde.
SVN lo mostra con sfondo verde per indicare l'aggiunta di nuovi contenuti. Se rimuoviamo qualsiasi contenuto, verrà visualizzato in rosso.
Ripristina le modifiche locali
Segui questi passaggi per ripristinare le modifiche locali che hai apportato:
Vai al file VCS → Subversion → Revert opzione.
Chiederà conferma e rimuoverà le modifiche.
Applica le modifiche al repository remoto
Segui questi passaggi per salvare le modifiche nel repository remoto:
Navigare verso VCS → Subversion → Commit Files opzione.
Apparirà una nuova finestra. Qui puoi vedere i file da salvare nel repository remoto.
Verifica i file e fai clic sul pulsante Conferma per pubblicare le modifiche.
Visualizza la cronologia o i registri
Per visualizzare la cronologia, vai al file VCS → Subverion → Show historyopzione. Questa opzione è simile asvn logcomando. Mostrerà la storia come segue:
Operazione di aggiornamento
Per recuperare le ultime modifiche, vai a VCS → Subversion → Update File/Update Folder opzione.
Aggiungi un progetto esistente a Subversion
Segui questi passaggi per aggiungere un progetto esistente in SVN -
Navigare verso VCS → Import into Version Control → Import into Subverion.
Immettere l'URL del repository e fare clic sul pulsante Importa -
IntelliJ fornisce uno strumento di database che consente di eseguire operazioni relative al database dall'IDE stesso. Supporta tutti i principali database come MySQL, Oracle, Postgress, SQL server e molti altri. In questo capitolo, discuteremo di come IntelliJ supporta il database MySQL.
Partiamo dal presupposto che il lettore abbia familiarità con i concetti del database e che gli strumenti dei database richiesti siano installati e configurati sul sistema.
Crea database
Per cominciare, creeremo un database - test_db. Esegui il seguente comando nel prompt dei comandi:
Connetti al database
Segui questi passaggi per connetterti a un database:
Navigare verso View → Tool Windows → Database.
Fare clic sull'icona più verde e selezionare Origine dati → MySQL.
Immettere l'indirizzo host e fare clic sul pulsante Test connessione.
Se tutto va bene, verrà visualizzato Riuscito come mostrato nell'immagine sopra.
Fare clic sul pulsante OK per salvare la connessione.
Crea tabella
Segui questi passaggi per creare una nuova tabella:
Fare clic con il pulsante destro del mouse sul riquadro del database e selezionare lo schema.
Seleziona il New → Table opzione
Apparirà una nuova finestra. Definisci la tabella con colonne, tipi e così via.
Fare clic sul pulsante Esegui
Fare clic sul pulsante Esegui
Inserisci dati
Segui questi passaggi per inserire i dati:
- Seleziona tabella dal riquadro del database.
- Si aprirà la tabella nella nuova finestra.
- Fare clic sull'icona più per inserire una nuova riga.
- Fare clic sul pulsante Invia per rendere permanenti le modifiche.
Recupera dati
Per recuperare i dati, fare doppio clic su student_table dal riquadro del database. Mostrerà i dati della tabella in una nuova finestra.
Per assicurarti che i dati siano inseriti nella tabella, apri il prompt dei comandi ed esegui i seguenti comandi:
NetBeans è un altro popolare IDE Java. Se sei un utente corrente di NetBeans e desideri migrare da esso a IntelliJ, questo servirà come un buon punto di partenza.
Questo capitolo discute l'importazione di progetti NetBeans in IntelliJ, la sua terminologia equivalente a NetBeans, scorciatoie popolari e domande frequenti.
Importa progetto NetBeans
In questa sezione, impareremo come importare il progetto NetBeans. Segui questi passaggi per importare il progetto:
Passa a File → Nuovo → Progetto da sorgenti esistenti
Seleziona la directory del tuo progetto NetBeans.
Quando si apre la procedura guidata Importa progetto, selezionare l'opzione Crea progetto da origini esistenti.
Segui le istruzioni sullo schermo per continuare.
Terminologia IntelliJ vsNetBeans
La tabella seguente mette a confronto la terminologia di IntelliJ e NetBeans:
| IntelliJ | NetBeans |
|---|---|
| Modulo | Progetto |
| Biblioteca globale | Biblioteca globale |
| Libreria dei moduli | Libreria del progetto |
| Dipendenza dal modulo | Dipendenza dal progetto |
| Modulo SDK | SDK specifico del progetto |
Scorciatoie popolari
IntelliJ è un IDE incentrato sulla tastiera. Fornisce scorciatoie per la maggior parte delle azioni. La tabella seguente elenca alcune scorciatoie importanti:
| Azione | Scorciatoia |
|---|---|
| Esegui il programma Java | ctrl + maiusc + F10 |
| Organizza le importazioni | ctrl + alt + o |
| System.out.println () | Digita sout e premi ctrl + j |
| Elimina la riga corrente | ctrl + y |
| Ricerca | ctrl + maiusc + f |
| Genera getter e setter | alt + inserisci |
| Formatta il codice | ctrl + alt + l |
| Commenta il codice | ctrl + / |
| Vai alla riga | ctrl + g |
| Vai alla dichiarazione | ctrl + b |
| Rinominare | MAIUSC + F6 |
| Sposta le linee | ctrl + maiusc + su / giù |
Scorciatoie del debugger
La tabella seguente elenca alcune importanti scorciatoie del debugger:
| Azione di debug | Scorciatoia |
|---|---|
| Eseguire il debug di un programma | Maiusc + F9 |
| Scegli la configurazione ed esegui il debug | Maiusc + Alt + F9 |
| Scavalcare | F8 |
| Entra | F7 |
| Entra in modo intelligente | Maiusc + F7 |
| Uscire | Maiusc + F8 |
| Forza un passo | Maiusc + Alt + F8 |
| Forza entra | Maiusc + Alt + F7 |
| Riprendi il programma | F9 |
| Valuta l'espressione | Alt + F8 |
| Attiva / disattiva i punti di interruzione | Ctrl + F8 |
| Visualizza punti di interruzione | Ctrl + Maiusc + F8 |
FAQ e suggerimenti
In questa sezione, esamineremo alcune domande e suggerimenti con risposta frequente. Le domande frequenti e i suggerimenti sono i seguenti:
Posso utilizzare le associazioni di tasti NetBeans in IntelliJ IDEA?
Vai a File → Impostazioni e seleziona Mappa dei tasti.
Seleziona NetBeans dalla casella a discesa
La storia locale in IntelliJ IDEA è diversa da quella in NetBeans?
La storia locale in IntelliJ IDEA, generalmente, è più dettagliata. Qualunque cosa tu faccia con una directory, un file, una classe, un metodo o un campo o un blocco di codice si riflette nella tua cronologia locale. La cronologia locale include anche le operazioni VCS.
Posso abilitare la "compilazione al salvataggio" in IntelliJ IDEA?
- Vai a File → Impostazioni → Crea, Esecuzione, Distribuzione → Compilatore
- Seleziona l'opzione Crea progetto automaticamente.
- Fare clic sul pulsante OK.
Posso usare i plugin NetBeans in IntelliJ IDEA?
No, non puoi.
È possibile creare applicazioni RCP NetBeans con IntelliJ IDEA?
È possibile; tuttavia, non otterrai lo stesso tipo di supporto che ottieni con NetBeans (procedure guidate, azioni di menu, ecc.). Per maggiori dettagli, visita questo.
Eclipse è un altro popolare IDE Java. Se sei un utente corrente di Eclipse e desideri migrare da esso a IntelliJ, questo è un buon punto di partenza.
Questo capitolo discute come importare progetti Eclipse in IntelliJ, la sua terminologia equivalente a Eclipse, scorciatoie popolari e domande frequenti.
Importa progetto esistente
In questa sezione, discuteremo come importare un progetto esistente. Segui questi passaggi per importare il progetto:
Passa a File → Nuovo → Progetto da sorgenti esistenti.
Seleziona la directory del tuo progetto NetBeans.
Quando si apre la procedura guidata Importa progetto, selezionare l'opzione Crea progetto da origini esistenti.
Segui le istruzioni sullo schermo per continuare.
Terminologia IntelliJ vs Eclipse
La tabella seguente mette a confronto le terminologie di IntelliJ e NetBeans:
| IntelliJ | Eclisse |
|---|---|
| Progetto | Area di lavoro |
| Modulo | Progetto |
| Sfaccettatura | Sfaccettatura |
| Biblioteca | Biblioteca |
| SDK | JRE |
| Variabile di percorso | Variabile classpath |
Scorciatoie popolari
IntelliJ è un IDE incentrato sulla tastiera. Fornisce scorciatoie per la maggior parte delle azioni. La tabella seguente elenca alcune scorciatoie popolari:
| Azione | Scorciatoia |
|---|---|
| Esegui il programma Java | ctrl + maiusc + F10 |
| Organizza le importazioni | ctrl + alt + o |
| System.out.println () | Digita sout e premi ctrj + j |
| Elimina la riga corrente | ctrl + y |
| Ricerca | ctrl + maiusc + f |
| Genera getter e setter | alt + inserisci |
| Formatta il codice | ctrl + alt + l |
| Commenta il codice | ctrl + / |
| Vai alla riga | ctrl + g |
| Vai alla dichiarazione | ctrl + b |
| Rinominare | MAIUSC + F6 |
| Sposta le linee | ctrl + maiusc + su / giù |
Scorciatoie del debugger
La tabella seguente elenca le scorciatoie del debugger di uso comune:
| Azione di debug | Scorciatoia |
|---|---|
| Eseguire il debug di un programma | Maiusc + F9 |
| Scegli la configurazione ed esegui il debug | Maiusc + Alt + F9 |
| Scavalcare | F8 |
| Entra | F7 |
| Entra in modo intelligente | Maiusc + F7 |
| Uscire | Maiusc + F8 |
| Forza un passo | Maiusc + Alt + F8 |
| Forza entra | Maiusc + Alt + F7 |
| Riprendi il programma | F9 |
| Valuta l'espressione | Alt + F8 |
| Attiva / disattiva i punti di interruzione | Ctrl + F8 |
| Visualizza punti di interruzione | Ctrl + Maiusc + F8 |
FAQ e suggerimenti
In questa sezione, vedremo alcune domande e suggerimenti con risposta frequente. Le domande frequenti e i suggerimenti sono i seguenti:
Usa il compilatore Eclipse
Mentre Eclipse utilizza il proprio compilatore, IntelliJ IDEA utilizza il compilatore javac in bundle con il progetto JDK. Se vuoi usare il compilatore Eclipse -
Navigare verso File → Settings → Build, Execution, Deployment → Compiler → Java Compiler.
Selezionare il compilatore richiesto dal menu a discesa del compilatore utente.
Eclipse Keymap
Per gli utenti Eclipse che preferiscono non apprendere nuove scorciatoie, IntelliJ IDEA fornisce la mappa dei tasti Eclipse che imita da vicino le scorciatoie:
- Vai a File → Impostazioni → Opzione mappa dei tasti.
- Seleziona Eclipse dal menu a discesa Keymap.
Formattazione del codice
Per importare le impostazioni del formattatore Eclipse:
Navigare verso File → Settings → Editor → Code Style → Java.
Seleziona il Eclipse XML profilo.
Lavorare con gli strumenti di costruzione
Come Eclipse, IntelliJ non fornisce moduli visivi per la modifica dei file di configurazione Maven / Gradle.
Dopo aver importato / creato il tuo progetto Maven / Gradle, sei libero di modificare i suoi file pom.xml / build.gradle direttamente nell'editor di testo.