Grundlegende IntelliJ-Konfiguration

1. Übersicht

Eine gute IDE ist wichtig für die Entwicklerproduktivität. IntelliJ ist derzeit eine der führenden IDEs und unterstützt viele Programmiersprachen.

In diesem Tutorial beginnen wir mit einigen Grundkonfigurationen in IntelliJ, wobei der Schwerpunkt auf der Programmiersprache Java liegt. Wir werden auch die häufigsten Verknüpfungen in IntelliJ auflisten, um die Entwicklerproduktivität zu steigern.

2. IntelliJ installieren

Zuerst müssen wir IntelliJ für unsere Plattform herunterladen und installieren. Für die Funktionen, auf die wir noch eingehen werden, ist entweder die Ultimate- oder die Community-Edition hervorragend geeignet.

3. Grundlegende Projektkonfiguration in IntelliJ

3.1. JDK konfigurieren

IntelliJ ist in Java geschrieben und wird mit einer gepackten JRE zum Ausführen der IDE geliefert.

Allerdings müssen wir IntelliJ mit einem JDK konfigurieren jede Java - Entwicklung zu tun. Es kann entweder global oder pro Projekt konfiguriert werden.

Lassen Sie uns zunächst sehen, wie Sie ein globales JDK mithilfe der Option Switch IDE Boot JDK konfigurieren :

Der einfachste Weg, um die Option Switch IDE Boot JDK zu finden, ist der Assistent „Find Action“.

Sie können dies über das Hilfemenü oder durch Eingabe von Strg + Umschalt + A oder Befehlstaste + Umschalt + A erreichen.Normalerweise werden alle installierten JDKs aufgelistet und wir können das gewünschte auswählen.

Als nächstes erstellen wir ein neues Java-Projekt.

3.2. Erstellen eines Java-Projekts

Um ein neues Java - Projekt zu erstellen, lassen Sie sich das bringt neue Projekt - Assistenten von File-> New-> Projekt :

Als nächstes wählen wir Java aus, um ein einfaches Java-Projekt zu erstellen.

Darüber hinaus können wir in diesem Fenster ein projektspezifisches JDK konfigurieren, wenn wir möchten.

Auf dem nächsten Bildschirm stellt IntelliJ Vorlagenprojekte wie Hello World als Ausgangspunkt bereit. Wählen Sie jedoch einfach Fertig stellen und legen Sie los.

Nachdem wir nun eine grundlegende Projektstruktur haben, können wir eine Java-Klasse hinzufügen, indem wir den Ordner src auswählen und dann entweder mit der rechten Maustaste klicken oder Alt + Einfügen eingeben . Wir werden Java Class aus diesem Menü auswählen und einen Dialog erhalten, in dem wir ihm einen Namen geben können:

3.3. Bibliotheken konfigurieren

Ein Java-Projekt hängt normalerweise von vielen externen Bibliotheken oder Bibliotheken von Drittanbietern ab. Und während Maven und Gradle die typischen Anlaufstellen für die Verwaltung sind, werfen wir einen Blick darauf, wie dies in IntelliJ nativ durchgeführt wird.

Angenommen , wir möchten die StringUtils- API aus der commons-lang3- Bibliothek verwenden.

Wie die JDK-Einstellungen können wir auch Bibliotheken auf globaler und Projektebene konfigurieren. Globale Bibliotheken werden von allen Projekten gemeinsam genutzt. Durch Aufrufen des Dialogfelds Projektstruktur ( Datei-> Projektstruktur ) können sowohl globale als auch projektspezifische Bibliotheken hinzugefügt werden .

Um die Bibliothek hinzuzufügen, müssen wir sie zuerst herunterladen. Normalerweise ist das Maven-Repository die gemeinsame Quelle für jede externe Bibliothek. Mit IntelliJ können wir es daher direkt von jedem vorkonfigurierten Maven-Repository herunterladen. Und wenn kein Repository konfiguriert ist, durchsucht es natürlich den Maven Central.

IntelliJ lädt jetzt die Datei commons-lang3.jar in einen angegebenen Ordner herunter . Gleichzeitig wird es dem Projektklassenpfad hinzugefügt.

Denken Sie natürlich daran, dass das Hinzufügen einer Bibliothek auf diese Weise IntelliJ-spezifisch und nicht so portabel ist wie robustere Optionen . Es ist jedoch praktisch für einfache Projekte.

Im nächsten Abschnitt werden wir diese Bibliothek verwenden und ein einfaches Java-Programm ausführen.

4. Ausführen oder Debuggen einer Anwendung

4.1. Konfigurationen ausführen / debuggen

Bevor wir unser Java-Programm ausführen, fügen wir der zuvor hinzugefügten Klasse Code hinzu. Wir verwenden einfach die hinzugefügte Bibliothek und rufen StringUtils.reverse () auf, um den als Programmargument angegebenen Text umzukehren:

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

Nun gibt es zwei Ansätze, um diese Hauptmethode in IntelliJ auszuführen. Erstens können wir einfach Strg + Umschalt + F10 oder Strg + Umschalt + R / D aus der Hauptklasse ausführen . IntelliJ erstellt dann eine temporäre Ausführungskonfiguration.

Da wir jedoch einen String als Programmargument an unsere StringReversal- Anwendung übergeben müssen (der Teil args [0] ), funktioniert eine temporäre Ausführungskonfiguration nicht.

So können wir eine permanente Run / Debug-Konfiguration erstellen .

Wir tun dies über das Fenster " Konfigurationen bearbeiten " in der Navigationsleiste ausführen ( Ausführen-> Konfigurationen bearbeiten ):

Hier geben wir den Namen unserer Klasse an, die in der Hauptklasse ausgeführt werden soll. Es muss eine Hauptmethode geben, damit dies funktioniert.

Wir passieren auch einen String -baeldung, in diesem Fall - als Programmargument für unsere Anwendung.

Auch wenn wir dies hier nicht vorführen, können wir auch JVM-Optionen und Umgebungsvariablen für unsere Anwendung konfigurieren.

Im Gegensatz zu temporären Ausführungskonfigurationen speichert IntelliJ diese Konfiguration und ermöglicht es uns, sie jederzeit mit einem Klick auf eine Schaltfläche auszuführen.

4.2. Debuggen einer Java-Anwendung

IntelliJ bietet hervorragende Unterstützung für das Debuggen vieler Sprachen. Lassen Sie uns debuggen unsere String Reversal - Dienstprogramm als Beispiel.

Wie bei den meisten IDEs können wir im Editor einen Haltepunkt in einer beliebigen Zeile unserer Klasse hinzufügen, indem wir auf das Seitenfenster klicken:

Jetzt können wir die Klasse debuggen, indem wir in der Run / Debug-Konfiguration auf das Debug-Symbol klicken.

In diesem Fall wird das Programm wie oben gezeigt in Zeile 9 angehalten, sodass wir den Thread-Stapel überprüfen, Variablen überprüfen oder sogar Ausdrücke auswerten können ( Alt + F8 oder Option / Alt + F8 ) .

An diesem Punkt können wir entweder Step Into ( F7 ) , um die StringUtils.reverse () Methode , Step Over ( F8 ) , um die Zeile oder Fortsetzen Programm ( F9 ), was bedeutet , laufen , bis entweder zum nächsten Haltepunkt oder bis zum Ende der Anwendung.

Normalerweise erlauben die meisten IDEs den Benutzern, eine Zeile in einer Java-Klasse als Haltepunkt zu markieren, wie wir es gerade verwendet haben. Darüber hinaus können wir mit IntelliJ mehr als nur Leitungsunterbrechungspunkte konfigurieren. Wir können auch:

  • Temporärer Haltepunkt - Ein Zeilenumbruchpunkt, der nur einmal ausgeführt wird
  • Ausnahme-Haltepunkt - Ein Haltepunkt für eine Ausnahmeklasse in Java. Der Debugger wird angehalten, wenn diese Ausnahme ausgelöst wird
  • Methoden-Haltepunkt - Ein Punkt, der beim Eingeben oder Beenden einer Methode ausgeführt wird
  • Feld-Haltepunkt - Und einer, der ausgeführt wird, wenn ein Feld geändert wird

Ein Haltepunkt kann auch eine bedingte Logik haben.

Wir können alle Haltepunkte in einem Projekt im Dialogfeld Haltepunkte Run-> Haltepunkte anzeigen anzeigen ( Strg + Umschalt + F8 oder Cmd + Umschalt + F8 ).

4.3. Artefakte bauen

Nachdem wir alle Probleme getestet, getestet und behoben haben, können wir unsere Anwendung ausliefern. Daher müssen wir bereitstellbare Binärdateien für unsere Anwendung erstellen.

Wir können bereitstellbare .jar-Binärdateien in IntelliJ automatisch erstellen.

Zunächst müssen wir in der Projektstruktur ( Strg + Alt + Umschalt + S oder Cmd +; ) ein neues Artefakt deklarieren.

Wir wählen "Artefakte" und klicken dann auf das Pluszeichen.

Als Nächstes wählen wir ein JAR-Artefakt aus und fügen Abhängigkeiten in die JAR ein:

Als Nächstes kehren wir zum Dialogfeld " Konfiguration ausführen / debuggen " zurück.

Dort müssen wir im Fenster "Vor dem Start" eine Aufgabe zum Erstellen von Artefakten hinzufügen. Infolgedessen wird bei jeder Ausführung unserer Run / Debug-Konfiguration eine neue ausführbare JAR- Datei für unsere Anwendung erstellt.

Auch hier ist das Erstellen von Artefakten nicht IDE-unabhängig. Dieser Mechanismus ist spezifisch für IntelliJ. Ein Build-Management-Tool könnte ein besserer Ansatz sein, ähnlich dem, was wir für das Abhängigkeitsmanagement besprochen haben.

5. Allgemeine Verknüpfungen in IntelliJ

Die Verknüpfungen sind sehr nützlich, um die Produktivität der Entwickler zu steigern. Das Folgende ist ein kurzer Spickzettel für die häufigsten.

5.1. Navigation

  • Suchklasse - Strg + N / Cmd + O.
  • Alle Dateien durchsuchen - Double Shift
  • Letzte Dateien - Strg + E / Cmd + E.
  • Zwischen Dateien wechseln - Strg + Tab / Cmd + Tab
  • Typhierarchie - Strg + H / Strg + H.
  • Anrufhierarchie - Strg + Alt + H / Strg + Alt + H.
  • Popup der Dateistruktur - Strg + F12 / Befehl + F12 (listet alle Methoden und Felder auf)
  • Zur Deklaration gehen - Strg + B / Cmd + b
  • Gehen Sie zu den Implementierungen - Strg + Alt + B / Befehlstaste + Alt + B.
  • Projektstruktur anzeigen - Strg + Alt + Umschalt + S / Cmd +;

5.2. Editor

  • Code-Vervollständigung - Strg + Leertaste / Strg + Leertaste
  • Methodenparameterinfo - Strg + P / Cmd + P.
  • Informationen zur Methoden- / Klassendokumentation - Strg + Q / Strg + J.
  • Code neu formatieren - Strg + Alt + L / Cmd + Alt + L.
  • Importe optimieren - Strg + Alt + O / Strg + Alt + O.
  • Doppelte Zeile - Strg + D / Befehl + D.
  • Zeile löschen - Strg + Y / Befehlstaste + Löschen
  • Codeauswahl - Strg + W / Alt + Auf
  • Schnelle Aktionen anzeigen - Alt + Enter / Alt + Return
  • System.out.println - Sout + Strg + Enter / Sout +Strg + Leertaste
  • public static void main - psvm + Strg + Enter / psvm +Strg + Leertaste
  • System.out.println für den Rückgabewert einer Methode - methodName (). Sout [Enter]
  • Weisen Sie der lokalen Variablen - methodName () den Rückgabewert der Methode zu . Var [Enter]

5.3. Refactoring

  • Klasse / Methode umbenennen - Umschalt + F6
  • Extraktionsmethode - Strg + Alt + M / Befehlstaste + Alt + M.
  • Variable extrahieren - Strg + Alt + V / Cmd + Alt + V.
  • Feld extrahieren - Strg + Alt + F / Befehlstaste + Alt + F.
  • Konstante extrahieren - Strg + Alt + C / Cmd + Alt + C.
  • Parameter extrahieren - Strg + Alt + P / Cmd + Alt + P.

6. Fazit

In diesem Artikel haben wir uns einige grundlegende Konfigurationen in IntelliJ angesehen.

Als Beispiel haben wir ein Java-Projekt erstellt, Bibliotheken hinzugefügt, es debuggt und ein Artefakt erstellt, alles in IntelliJ.

Zuletzt haben wir uns Verknüpfungen für einige allgemeine Aktionen angesehen.