Diese Seite stellt nützliche Informationen, um das Arbeiten von Entwicklern so schnell und angenehm wie möglich zu gestalten, bereit. Benutze diese je nach Bedarf. Es kann eine gewisse Einarbeitungszeit brauchen, um sich an die Tastenkombinationen und anderen Optionen zu gewöhnen. Diese Seite kann dafür als eine Hilfe dafür genutzt werden.

WARNING

Tastenkombinationen im Text beziehen sich auf die Standardtastaturbelegung von IntelliJ IDEA, wenn nicht anders angegeben. Schaue unter Datei > Einstellungen > Tastaturbelegung nach oder suche woanders nach dieser Funktion, wenn du ein anderes Tastaturlayout verwendest.

Fortbewegung in Projekten

Manuell

IntelliJ bietet mehrere Möglichkeiten, sich im Projekt fortzubewegen. Falls die Quelldaten mit den ./gradlew genSources Befehlen oder über die Tasks > fabric > genSources Gradle Tasks im Gradle Fenster generiert wurden, können die Quelldaten von Minecraft, innerhalb des Projektfensters Externe Bibliotheken, manuell nachgeschlagen werden.

Die Quelldaten von Minecraft können mit dem Suchbegriff net.minecraft im Projektfensters Externe Bibliotheken gefunden werden. Wenn dein Projekt geteilte Quellen aus dem Online Template Modgenerator verwendet, gibt es zwei Quellen, wie durch den Namen (client/common) angegeben. Zusätzlich werden auch andere Quellen von Projekten, Bibliotheken und Abhängigkeiten, die über die Datei build.gradle importiert werden, verfügbar sein. Diese Methode wird häufig bei der Suche nach Assets, Tags und anderen Dateien verwendet.

Suchen

Durch zweimaliges Drücken von Shift öffnet sich ein Suchfenster. Dort kannst du nach den Dateien und Klassen deines Projekts suchen. Durch Aktivieren des Kontrollkästchens include non-project items oder durch zweimaliges Drücken von Shift wird nicht nur im eigenen Projekt gesucht, sondern auch in anderen, z. B. in den Externen Bibliotheken.

Du kannst auch die Tastenkombination ⌘/STRG+N zur Suche von Klassen und ⌘/STRG+Shift+N zur Suche aller Dateien nutzen.

Letzte Fenster

Ein weiteres nützliches Werkzeug in IntelliJ ist das Fenster Recent. Du kannst es mit der Tastenkombination ⌘/STRG+E öffnen. Dort kannst du zu den Dateien springen, die du bereits besucht hast, und Werkzeugfenster öffnen, z. B. das Fenster Struktur oder Lesezeichen.

Fortbewegung in Code

Zur Definition / Verwendung springen

Wenn du entweder die Definition oder Nutzung von Variablen, Methoden, Klassen oder anderen Dingen ansehen willst, kannst du ⌘/STRG+Linksklick / B oder Mittlere Maustate (drücken des Mausrads) auf deren Namen verwenden. Auf diese Weise vermeidest du langes Scrollen oder eine manuelle Suche nach einer Definition, die sich in einer anderen Datei befindet.

Du kannst außerdem ⌘/STRG+⌥/Shift+Linklsklick / B verwenden, um alle Implementationen einer Klasse oder eines Interfaces zu sehen.

Lesezeichen

Du kannst Codezeilen, Dateien oder sogar geöffnete Editor-Registerkarten mit Lesezeichen versehen. Besonders bei der Recherche von Quellcodes kann es helfen, Stellen zu markieren, die man in Zukunft schnell wiederfinden möchte.

Klicke entweder mit der rechten Maustaste auf eine Datei im Projektfenster, auf eine Registerkarte im Editor oder auf die Zeilennummer in einer Datei. Das Anlegen von Mnemonic Bookmarks ermöglicht es dur, schnell zu diesen Bookmarks zurück zu wechseln, indem du die Tastenkombination ⌘/STRG und die von dir gewählte Ziffer verwendest.

Es ist möglich, im Fenster Bookmarks mehrere Lesezeichenlisten gleichzeitig zu erstellen, wenn du sie trennen oder ordnen möchtest. Haltepunkte werden dort ebenfalls angezeigt.

Klassenstruktur

Klassen analysieren

Durch das Öffnen des Fensters Struktur (⌘/Alt+7) erhältst du einen Überblick über deine aktuell aktive Klasse. Du kannst sehen, welche Klassen und Enums sich in dieser Datei befinden, welche Methoden implementiert wurden und welche Felder und Variablen deklariert sind.

Manchmal kann es auch hilfreich sein, die Option Inherited oben in den Ansichtsoptionen zu aktivieren, wenn man nach potenziellen Methoden sucht, die man überschreiben kann.

Typenhierarchie einer Klasse

Indem du den Cursor auf einen Klassennamen setzt und ⌘/STRG+H drückst, kannst du ein neues Typenhierarchie-Fenster öffnen, das alle Eltern- und Kindklassen anzeigt.

Code Vervollständigung

Code-Utility

Die Code-Vervollständigung sollte standardmäßig aktiviert sein. Du bekommst die Empfehlungen automatisch beim Schreiben deines Codes. Wenn du sie versehentlich geschlossen oder den Mauszeiger an eine neue Stelle bewegt hast, kannst du sie mit ⌘/STRG+Leertaste wieder öffnen.

Wenn du zum Beispiel Lambdas verwendest, kannst du sie mit dieser Methode schnell schreiben.

Code Generierung

Das Menü Generieren kannst du schnell durch Alt+Einfügen (⌘ Befehl+N auf Mac) aufgerufen werden oder indem du oben auf Code gehst und Generieren auswählst. In einer Java-Datei kannst du Konstruktoren, Getter, Setter, überschreibende oder implementierende Methoden und vieles mehr generrieren. Du kannst auch Accessors und Invokers erzeugen, wenn du das Minecraft Development Plugin installiert hast.

Zusätzlich kannst du Methoden mit ⌘/STRG+O überschreiben und mit ⌘/STRG+I implementieren.

In einer Java-Testdatei erhälst du Optionen, um die entsprechenden Testmethoden zu generieren, wie folgt:

Parameter anzeigen

Die Anzeige der Parameter sollte standardmäßig aktiviert sein. Du bekommst automatisch die Typen und Namen der Parameter, während du deinen Code schreibst. Wenn du sie versehentlich geschlossen oder den Cursor an eine neue Stelle bewegt hast, kannst du sie mit ⌘/STRG+P wieder öffnen.

Methoden und Klassen können mehrere Implementationen mit unterschiedlichen Parametern haben, was auch als Überladen bezeichnet wird. Auf diese Weise kannst du beim Schreiben des Methodenaufrufs entscheiden, welche Implementation du verwenden möchtest.

Refactoring

Refactoring ist der Prozess der Umstrukturierung von Code, ohne dessen Laufzeitfunktionalität zu verändern. Das sichere Umbenennen und Löschen von Teilen des Codes ist ein Teil davon, aber Dinge wie das Extrahieren von Teilen des Codes in separate Methoden und die Einführung neuer Variablen für wiederholte Code-Anweisungen werden auch als "Refactoring" bezeichnet.

Viele IDEs verfügen über ein umfangreiches Toolkit, das bei diesem Prozess hilft. In IntelliJ klicke einfach mit der rechten Maustaste auf Dateien oder Teile des Codes, um Zugriff auf die verfügbaren Refactoring-Tools zu erhalten.

Es ist besonders nützlich, sich an die Tastenkombination Shift+F6 zu gewöhnen, da du in der Zukunft wahrscheinlich viele Dinge umbenennen wirst. Mit dieser Funktion wird jedes Code-Vorkommen des umbenannten Codes umbenannt und bleibt funktionell gleich.

Du kannst den Code auch entsprechend deinem Codestil umformatieren. Wähle dazu den Code aus, den du neu formatieren möchtest (wenn nichts ausgewählt ist, wird die gesamte Datei neu formatiert) und drücke ⌘/STRG+⌥/ALT+L. Um zu ändern, wie IntelliJ Code formatiert, siehst du die Einstellungen unter Datei > Einstellungen > Editor > Codestil > Java.

Kontextaktionen

Mit Hilfe von Kontextaktionen können bestimmte Codeabschnitte kontextabhängig umgestaltet werden. Bewege dazu einfach den Mauszeiger auf den Bereich, den du überarbeiten möchtest, und drücke ⌥/ALT+Enter oder klicke Sie auf die Glühbirne auf der linken Seite. Es erscheint ein Popup-Fenster mit Kontextaktionen, die für den ausgewählten Code verwendet werden können.

Suchen und Ersetzen von Dateiinhalten

Manchmal sind einfachere Werkzeuge erforderlich, um Code-Vorkommen zu bearbeiten.

Tastenkombination	Funktion
⌘/STRG+F	Finde in der aktuellen Datei
⌘/STRG+R	Ersetze in der aktuellen Datei
⌘/STRG+Shift+F	Finde in einem größeren Bereich (kann spezifische Dateitypmaske einstellen)
⌘/STRG+Shift+R	Ersetze in einem größeren Bereich (kann spezifische Dateitypmaske einstellen)

Falls verwendet, ermöglichen alle diese Werkzeuge einen spezifischeren Mustervergleich durch Regex.

Andere nützliche Tastenkombinationen

Wenn du einen Text markierst und ⌘/STRG+Shift+↑ Nach oben / ↓ Nach unten verwendest, kannst du den markierten Text nach oben oder unten verschieben.

In IntelliJ ist die Tastenkombination für Redo nicht unbedingt die übliche ⌘/STRG+Y (Zeile löschen). Stattdessen kann es ⌘/STRG+Shift+Z sein. Du kannst dies in der Tastaturbelegung ändern.

Weitere Tastenkombinationen findest du in der IntelliJ-Dokumentation.

Kommentare

Guter Code sollte leicht lesbar und selbst-dokumentierend sein. Die Wahl aussagekräftiger Namen für Variablen, Klassen und Methoden kann sehr hilfreich sein, aber manchmal sind Kommentare notwendig, um Notizen zu hinterlassen oder vorübergehend Code zum Testen zu deaktivieren.

Um Code schneller auszukommentieren, kannst du einen Text markieren und die Tastenkombinationen ⌘/STRG+/ (Zeilenkommentar) und ⌘/STRG+⌥/Shift+/ (Blockkommentar) verwenden.

Jetzt kannst du den erforderlichen Code markieren (oder einfach den Mauszeiger darauf halten) und die Tastenkombinationen verwenden, um den Abschnitt auszukommentieren.

// 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*/);
}

Code-Faltung

In IntelliJ kannst du neben den Zeilennummern kleine Pfeil-Symbole sehen. Diese können verwendet werden, um Methoden, if-Anweisungen, Klassen und viele andere Dinge vorübergehend auszublenden, wenn du nicht aktiv an ihnen arbeitest. Um einen benutzerdefinierten Block zu erstellen, der eingeklappt werden kann, verwende die Kommentare region und endregion.

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

WARNING

Wenn du feststellst, dass du zu viele davon verwendest, solltest du deinen Code überarbeiten, um ihn lesbarer zu machen!

Den Formatierer deaktivieren

Kommentare können den Formatierer auch während der oben erwähnten Codeumstrukturierung deaktivieren, indem sie ein Codestück wie folgt umschließen:

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

Unterdrückung von Inspektionen

//noinspection Kommentare können außerdem auch dazu genutzt werden um Inspektionen und Warnungen zu unterdrücken. Sie sind funktionell identisch mit der Annotation @SuppressWarnings, jedoch ohne die Einschränkung, dass es sich um eine Annotation handelt, und können für Anweisungen verwendet werden.

// 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

Wenn du merkst, dass du zu viele Warnungen unterdrückst, solltest du deinen Code so umschreiben, dass er nicht so viele Warnungen erzeugt!

TODO und FIXME Notizen

Bei der Arbeit am Code kann es hilfreich sein, Notizen zu hinterlassen, was noch zu erledigen ist. Manchmal entdeckst du auch ein potenzielles Problem im Code, aber du willst nicht aufhören, dich auf das aktuelle Problem zu konzentrieren. Verwende in diesem Fall die Kommentare TODO oder FIXME.

IntelliJ behält sie im TODO-Fenster im Auge und kann dich benachrichtigen, wenn du Code committen willst, der diese Art von Kommentaren verwendet.

JavaDocs

Eine gute Möglichkeit, deinen Code zu dokumentieren, ist die Verwendung von JavaDoc. JavaDocs liefern nicht nur nützliche Informationen zur Implementation von Methoden und Klassen, sondern sind auch tief in IntelliJ integriert.

Wenn du mit dem Mauszeiger über Methoden- oder Klassennamen fährst, die mit JavaDoc-Kommentaren versehen sind, werden diese Informationen in deren Informationsfenster angezeigt.

Um zu beginnen, schreibe einfach /** über die Methoden- oder Klassendefinition und drücke die Eingabetaste. IntelliJ erzeugt automatisch Zeilen für den Rückgabewert und die Parameter, aber du kannst sie nach Belieben ändern. Es sind viele benutzerdefinierte Funktionen verfügbar, und du kannst bei Bedarf auch HTML verwenden.

Minecraft's ScreenHandler Klasse hat einige Beispiele. Um die Renderansicht umzuschalten, verwende die Stifttaste neben den Zeilennummern.

IntelliJ weiter optimieren

Es gibt noch viele weitere Abkürzungen und praktische kleine Tricks, die den Rahmen dieser Seite sprengen würden. Jetbrains hat viele gute Vorträge, Videos und Dokumentationsseiten darüber, wie du deinen Arbeitsbereich weiter anpassen kannst.

PostFix Vervollständigung

Verwende die PostFix Vervollständigung, um Code nach dem Schreiben schnell zu ändern. Häufig verwendete Beispiele sind .not, .if, .var, .null, .nn, .for, .fori, .return und .new. Neben den bereits vorhandenen kannst du in den Einstellungen von IntelliJ auch eigene erstellen.

Live-Vorlagen

Verwende Live-Vorlagen, um deinen eigenen Vorlagen-Code schneller zu generieren.

Mehr Tipps und Tricks

Anton Arhipov von Jetbrains hielt auch einen ausführlichen Vortrag über Regex Matching, Code Vervollständigung, Debugging und viele andere Themen in IntelliJ.

Für weitere Informationen, sieh dir Jetbrains Tips & Tricks Seite und IntelliJ's Dokumentation an. Die meisten ihrer Beiträge sind auch auf das Ökosystem von Fabric anwendbar.