Questa pagina fornisce un po' di informazioni utili, per velocizzare e facilitare il workflow degli sviluppatori. Integrale nel tuo lavoro, se desideri. Potrebbe servire del tempo per imparare e abituarsi alle scorciatoie e alle altre opzioni. Puoi usare questa pagina come riferimento per questo.

WARNING

Le scorciatoie indicate si riferiscono alla mappatura di IntelliJ IDEA predefinita, se non specificato altrimenti. Fai riferimento alle impostazioni in File > Settings > Keymap o cerca per la funzionalità altrove se usi un layout di tastiera diverso.

Attraversare i Progetti

Manualmente

IntelliJ ha molti modi diversi di navigare i progetti. Se hai generato le fonti con i comandi ./gradlew genSources nel terminale o hai usato le operazioni Gradie Tasks > fabric > genSources nella finestra di Gradle, puoi aprire i file sorgente di Minecraft manualmente nelle Librerie Esterne della Schermata del Progetto.

Il codice sorgente di Minecraft si può trovare se cerchi net.minecraft nella schermata External Libraries della finestra del progetto. Se il tuo progetto usa sorgenti suddivise dal Generatore di Mod Modello online, troverai due sorgenti, indicate dal nome (client/common). Inoltre altre sorgenti di progetti, librerie e dipendenze, importate con il file build.gradle, saranno anche disponibili. Questo metodo si usa spesso mentre si cercano media, tag e altri file.

Ricerca

Premere Maiusc due volte apre una finestra Cerca. Lì puoi cercare i file e le classe del tuo progetto. Attivando la casella di controllo include non-project items o premendo Maiusc due volte di nuovo, la ricerca non includerà solo il tuo progetto, ma anche altri, come le Librerie Esterne.

Puoi anche usare le scorciatoie ⌘/CTRL+N per cercare classi e ⌘/CTRL+Maiusc+N per cercare in tutti i file.

Finestra Recenti

Un altro strumento utile in IntelliJ è la finestra Recent. Puoi aprirla con la scorciatoia ⌘/CTRL+E. Lì puoi saltare ai file che hai già visitato, e aprire finestre degli strumenti, come Struttura o Preferiti.

Navigare il Codice

Salta alla Definizione / Utilizzo

Se devi controllare la definizione o gli utilizzi di variabili, metodi, classi e altre cose, puoi premere ⌘/CTRL+Clic Sinistro / B o clicca il Pulsante Centrale del Mouse (la rotellina) sul nome. Così eviterai lunghe sessioni di scorrimento o una ricerca manuale della definizione che troveresti in un altro file.

Puoi anche usare ⌘/CTRL+⌥/Maiusc+Clic Sinistro / B per vedere tutte le implementazioni di una classe o di un'interfaccia.

Preferiti

Puoi aggiungere linee di codice, file o anche schede aperte dell'Editor ai preferiti. Specialmente se cerchi nel codice sorgente, aiuta a segnare posizioni che vuoi ritrovare velocemente nel futuro.

Clicca con il tasto destro un file nella finestra Project, una scheda dell'editor o il numero di una linea in un file. Creare Preferiti Mnemonici ti permette di passare velocemente a quei preferiti con le scorciatoie appropriate, ⌘/CTRL e il numero che hai scelto.

È possibile creare più liste di preferiti nella finestra Preferiti contemporaneamente se vuoi separarli o ordinarli. Breakpoints verranno inoltre mostrati qui.

Analizzare le Classi

Struttura di una Classe

Aprendo la finestra Structure (⌘/Alt+7) otterrai una panoramica della classe attualmente attiva. Puoi vedere quali Classi e quali Enum si trovano in quel file, quali metodi sono stati implementati e quali attributi e variabili sono dichiarate.

A volte può essere utile attivare anche l'opzione Inherited in cima alle opzioni Visualizza, quando si cercano metodi specifici di cui fare override.

Gerarchia dei Tipi di una Classe

Posizionando il cursore sul nome di una classe e premendo ⌘/CTRL+H puoi aprire una nuova finestra Type Hierarchy, che mostra tutte le classi genitore e figlie.

Utilità del Codice

Completamento del Codice

Il completamento del codice dovrebbe essere attivo in maniera predefinita. Otterrai consigli mentre scrivi il tuo codice in automatico. Se l'hai per errore chiuso o hai spostato il cursore ad un altro punto, puoi usare ⌘/CTRL+Spazio per riaprirli nuovamente.

Per esempio, usando espressioni lambda, puoi scriverli velocemente usando questo metodo.

Generazione del Codice

Si può accedere velocemente al menu Generate con Alt+Ins (⌘ Comando+N su macOS) o andando su Code in cima e selezionando Generate. In un file Java, potrai generare costruttori, getter, setter, fare override o implementare metodi, e molto altro. Puoi generare accessori ed invocatori se hai installato Minecraft Development plugin

Inoltre puoi fare velocemente override di metodi con ⌘/CTRL+O e implementare metodi con ⌘/CTRL+I.

In un file di test Java, ti saranno fornite opzioni per generare metodi di test correlati, come segue:

Mostrare i Parametri

La visualizzazione dei parametri dovrebbe essere attiva in maniera predefinita. Otterrai automaticamente i tipi e i nomi dei parametri mentre scrivi il tuo codice. Se li hai per errore chiusi o hai spostato il cursore ad un altro punto, puoi usare ⌘/CTRL+P per riaprirli nuovamente.

Metodi e classi possono avere più implementazioni con parametri diversi, fenomeno detto Overloading. In questo modo puoi decidere quale implementazione vuoi usare, mentre scrivi la chiamata al metodo.

Refactoring

La riscrittura è il processo di ristrutturazione del codice senza cambiarne la funzionalità durante l'esecuzione. Rinonimare o eliminare in sicurezza parte del codice è un esempio di ciò, ma anche l'estrazione di codice in più metodi separati e l'introduzione di nuove variabili per parti di codice ripetute è detto "refactoring".

Tanti ambienti di sviluppo hanno una vasta gamma di strumenti per assistere questo processo. In intelliJ basta cliccare con il tasto destro file o parti del codice per accedere agli strumenti di refactoring disponibili.

È soprattutto utile abituarsi alla scorciatoia dello strumento di refactoring Rename, ovvero Maiusc+F6, poiché probabilmente rinonimerai molte cose nel futuro. Usando questa funzione, ogni occorrenza del codice rinonimato sarà rinonimata e la sua funzionalità rimarrà intatta.

Puoi anche riformattare il codice secondo il tuo stile di codice. Per fare questo, seleziona il codice che vuoi riformattare (se non selezioni niente, l'intero file sarà riformattato) e premi ⌘/CTRL+⌥/ALT+L. Per cambiare il modo in cui IntelliJ formatta il codice, controlla le impostazioni presso File > Settings > Editor > Code Style > Java.

Azioni Contestuali

Le azioni contestuali permettono di effettuare refactoring di sezioni di codice specifiche in base al contesto. Per usarle, basta muovere il cursore sull'area di cui si vuol fare refactoring, e premere ⌥/ALT+Invio o cliccare la lampadina a sinistra. Ci sarà un popup che mostrerà azioni contestuali che si possono usare per il codice selezionato.

Trova e Sostituisci i Contenuti di un File

A volte sono necessari strumenti più semplici per modificare le occorrenze del codice.

Scorciatoie	Funzione
⌘/CTRL+F	Trova nel file corrente
⌘/CTRL+R	Sostituisci nel file corrente
⌘/CTRL+Maiusc+F	Trova in uno scope più grande (e imposta un filtro di tipo di file)
⌘/CTRL+Maiusc+R	Sostituisci in uno scope più grande (e imposta un filtro di tipo di file)

Quando ben sfruttati, tutti questi strumenti permettono una ricerca più specifica grazie alle Regex.

Altre Scorciatoie Utili

Selezionare del testo e usare ⌘/CTRL+Maiusc+↑ Su / ↓ Giù muoverà il codice selezionato in alto o in basso.

In IntelliJ, la scorciatoia per Ripeti potrebbe non essere quella solita, ovvero ⌘/CTRL+Y (Elimina Linea). Potrebbe invece essere ⌘/CTRL+Maiusc+Z. Puoi cambiarla in Keymap.

Per altre scorciatoie da tastiera, consulta la documentazione di IntelliJ.

Commenti

Il buon codice dovrebbe essere facilmente leggibile e dovrebbe documentarsi "da solo". Scegliere nomi espressivi per variabili, classi e metodi aiuta molto, ma a volte i commenti sono necessari per lasciare note o per disattivare codice temporaneamente a fini di testing.

Per commentare del codice velocemente, puoi selezionare del testo e usare le scorciatoie ⌘/CTRL+/ (commento linea) e ⌘/CTRL+⌥/Maiusc+/ (commento blocco).

Ora puoi evidenziare il codice necessario (o basta che il cursore sia sopra ad esso) e usare le scorciatoie per commentare una sezione.

// private static final int PROTECTION_BOOTS = 2;
private static final int PROTECTION_LEGGINGS = 5;
// private static final int PROTECTION_CHESTPLATE = 6;
private static final int PROTECTION_HELMET = 1;

/*
ModItems.initialize();
ModSounds.initializeSounds();
ModParticles.initialize();
*/

private static int secondsToTicks(float seconds) {
    return (int) (seconds * 20 /*+ 69*/);
}

Compressione del Codice

In IntelliJ, vicino ai numeri di linea, potresti vedere delle piccole freccie. Possono essere usate per comprimere temporaneamente metodi, istruzioni if, classi e molte altre cose su cui non stai lavorando attivamente. Per creare un blocco personalizzato che possa essere compresso, usa i commenti region e endregion.

// region collapse block name
    ModBlocks.initialize();
    ModBlockEntities.registerBlockEntityTypes();
    ModItems.initialize();
    ModSounds.initializeSounds();
    ModParticles.initialize();
// endregion

WARNING

Se noti che ne stai usando troppi, considera una riscrittura del codice per renderlo più leggibile!

Disattivare il Formattatore

Si possono inoltre usare dei commenti per disattivare il formattatore durante il refactoring del codice menzionato sopra, rinchiudendo una sezione di codice così:

//formatter:off (disable formatter)
    public static void disgustingMethod() { /* ew this code sucks */ }
//formatter:on (re-enable the formatter)

Sopprimere le Ispezioni

I commenti //noinspection possono essere usati per sopprimere ispezioni e avvisi. Funzionalmente sono identici all'annotazione @SuppressWarnings, ma non hanno la limitazione di essere un'annotazione e possono quindi essere usati per le istruzioni.

// below is bad code and IntelliJ knows that

@SuppressWarnings("rawtypes") // annotations can be used here
List list = new ArrayList();

//noinspection unchecked (annotations cannot be here so we use the comment)
this.processList((List<String>)list);

//noinspection rawtypes,unchecked,WriteOnlyObject (you can even suppress multiple!)
new ArrayList().add("bananas");

WARNING

Se noti che stai sopprimendo troppi avvisi, considera una riscrittura del codice per non produrne così tanti!

Note TODO e FIXME

Lavorando sul codice, può tornarti utile lasciare note su ciò che devi ancora completare. A volte potresti notare un problema nel codice, ma vuoi continuare a lavorare su ciò che stai facendo. In questi casi, usa i commenti TODO o FIXME.

IntelliJ terrà conto di essi nella finestra TODO e ti notificherà se stai per fare commit di codice che usa questo tipo di commento.

Javadocs

Un ottimo modo di documentare il tuo codice è usare i JavaDoc. I JavaDoc non solo forniscono informazioni utili per l'implementazione di metodi e classi, ma sono anche profondamente integrati in IntelliJ.

Passando il mouse sopra ai nomi di metodi o classi ai quali sono stati aggiunti commenti JavaDoc, essi mostreranno queste informazioni nella finestra apposita.

Per iniziare, ti basta scrivere /** sopra al metodo o alla definizione della classe e premere Invio. IntelliJ genererà automaticamente linee per il valore restituito e per i parametri, ma le puoi modificare come ti pare. Ci sono parecchie funzioni personalizzate disponibili e puoi addirittura usare HTML se ti serve.

La classe ScreenHandler di Minecraft ti mostra alcuni esempi. Per attivare o disattivare la finestra di rendering, usa il pulsante penna vicino ai numeri di linea.

Visualizzare il Bytecode

Visualizzare il bytecode è necessario se si scrivono mixin. Puoi vedere il bytecode di una classe proveniente da una libreria (per esempio le classi di Minecraft) aprendo la classe nell'editor, per poi selezionare Show Bytecode nel menu View.

Ottimizzare IntelliJ Ulteriormente

Ci sono parecchie altre scorciatoie e tanti trucchi utili, che però oltrepasserebbero gli obiettivi di questa pagina. Jetbrains ha tanti buoni discorsi, video e pagine di documentazione riguardo a come personalizzare il tuo ambiente di lavoro ancora di più.

Completamento PostFix

Usa il Completamento PostFix per alterare il codice velocemente dopo averlo scritto. Esempi spesso citati comprendono .not, .if, .var, .null, .nn, .for, .fori, .return e .new. Oltre a quelli già esistenti, puoi anche aggiungerne di tuoi nelle Impostazioni di IntelliJ.

Modelli Live

Usa i Modelli Live per generare il tuo codice ripetitivo personalizzato più velocemente.

Altri Trucchi

Anton Arhipov di Jetbrains ha anche tenuto un discorso approfondito riguardo a Corrispondenza Regex, Completamento di Codice, Debugging e molti altri argomenti legati a IntelliJ.

Per ulteriori informazioni, controlla il sito di Trucchi e Consigli di Jetbrains e la documentazione di IntelliJ. Tanti dei loro post possono essere applicati anche all'ecosistema Fabric.