Installation von IntelliJ, Java und Git

Die Seite wird erstellt Julie Reichert
 
WEITER LESEN
Installation von IntelliJ, Java und Git
Installation von IntelliJ, Java und Git
Im Kurs PPL benötigen wir eine Entwicklungsumgebung, in der Java-Programme geschrieben
werden. Wir empfehlen IntelliJ, welches sich durch einen grossen Funktionsumfang und eine
einfache Bedienung auszeichnet. Hier folgt nun eine Anleitung, wie IntelliJ installiert werden
kann. IntelliJ ist ein Programm, welches uns erlaubt, einfach Java-Programme zu schreiben.
Zusätzlich werden noch das sogenannte Java Development Kit (JDK) und Git benötigt, welche
separat installiert werden müssen.

Herunterladen und Installation vom JDK
Im Kurs benutzen wir Java 11. Dazu müssen wir das JDK passend zu Java 11 installieren. Dies
kann man unter
https://www.oracle.com/technetwork/java/javase/downloads/jdk11-downloads-5066655.html
herunterladen. Bitte wählen Sie die korrekte Version für Windows oder macOS aus und
installieren Sie sie. Falls Sie Linux benutzen, dann ist es besser, das JDK aus der Distribution
zu installieren.

Herunterladen von IntelliJ
IntelliJ kann unter folgender Adresse heruntergeladen werden:
https://www.jetbrains.com/idea/download/​. Bitte die ​Community​-Variante auswählen. Sie
enthält alle Funktionen, die für den Kurs benötigt werden. Als ETH-Student kann man jedoch
auch eine kostenlose Ultimate-Lizenz bekommen. Eine Anleitung findet man unter folgender
Adresse: ​https://www.jetbrains.com/student/​.

Eine genaue Anleitung ist bei IntelliJ selbst zu finden:
https://www.jetbrains.com/help/idea/install-and-set-up-intellij-idea.html

Installation von IntelliJ
Unter Windows und macOS kann man IntelliJ direkt installieren.

   1. IntelliJ fragt, ob es Settings importieren soll. Da IntelliJ vorher noch nie installiert war,
      einfach “Do not import settings” auswählen.
   2. Danach fragt IntelliJ nach dem Theme: Hier einfach das auswählen, welches Ihnen
      besser gefällt.
   3. Nun fragt IntelliJ, welche Plug-ins es installieren soll. Für den Kurs benötigen wir keine
      zusätzlichen Plug-ins, hier also einfach “Skip remaining and Set Default” auswählen.

Nun ist IntelliJ vollständig installiert und präsentiert einen Dialog, um ein Projekt auszuwählen.
Da es sich um einen neue Installation handelt, sollte die Liste leer sein.
Installation von IntelliJ, Java und Git
Ein erstes Projekt
Als erstes werden wir ein kleines Projekt erstellen, welches Ihnen IntelliJ näher bringen soll.
Dabei ist es nicht relevant, ob Sie schon Java-Kenntnisse haben.
Wir fangen beim Dialog an, der nach der Installation erscheint.

      1. Bitte “Create New Project” auswählen.
      2. Im neuen Dialog wählen wir nun “Java” aus. IntelliJ fragt nun nach zusätzlichen
         Libraries, aber wir wollen hier keine auswählen. Mit “Next” geht es weiter (Project SDK
         sollte schon vorkonfiguriert sein).
      3. Wir wollen ein leeres Projekt anlegen, deswegen wählen wir nichts unter “Create project
         from template” aus. Mit “Next” geht es weiter.
      4. Nun können wir dem Projekt einen Namen geben. Sie können diesen theoretisch frei
         wählen, praktisch ist es aber nützlich, nur Kleinbuchstaben und Unterstriche zu
         verwenden, bitte keine Leerzeichen; ein guter Name wäre z.B.
         installation_tutorial​        .
      5. Mit “Finish” erstellen wir nun das Projekt.

Nun ist das Projekt erstellt und wir können uns mit der Entwicklungsumgebung vertraut machen.
Auf der linken Seite sollte die Struktur des Projekts zu sehen sein.1 Im grossen grauen Bereich
werden wir Dateien bearbeiten können. Oben gibt es ein Menü, welches wir nun benutzen
werden.

      1. Wir wollen unser erstes kleines Programm erstellen. Dazu müssen wir in Java eine
         Klasse​ erstellen, die eine ​main​-Methode enthält (Es macht nichts, wenn Sie diese
         Begriffe noch nicht verstehen).
      2. Als erstes wählen wir den Ordner ​src​mit einem Einfachklick aus, so dass er
         hervorgehoben ist.
      3. Nun wählen wir File > New > Java Class aus. Dies öffnet einen Dialog, um eine Klasse
         zu erstellen. Bietet Ihnen IntelliJ diese Option nicht an, dann stellen Sie bitte sicher, dass
         sie wirklich den Ordner ​src​ausgewählt haben.
      4. Wir geben der Klasse einen Namen, z.B. ​Programm​       . Bei Kind muss Class ausgewählt
         sein. Weiter geht es mit OK.
      5. Jetzt sollte in IntelliJ eine Datei geöffnet worden sein, mit etwa folgendem Inhalt:
          public class ​Programm {
          }
      6. Wir wollen nun zwischen die Klammern { und } folgenden Text einfügen:
          public static void ​main(String[] args) {

1
    Falls nicht, kann man sie mit Alt+1 unter Windows/Linux und Command+1 unter macOS anzeigen.
Installation von IntelliJ, Java und Git
System.​out​.println(​"Hello, world!"​);
   }
   Das Programm sollte also folgendermassen aussehen:
   public class ​Programm {
     ​public static void ​main(String[] args) {
        System.​out.​ println(​"Hello, world!"​);
     }
   }
7. Nun wollen wir das Programm ausführen: Dazu klicken wir auf ​main​im Programm.
   Vorne in der Zeile erscheint eine Glühbirne. Darauf klicken wir und wählen Run
   “Programm.Main.” IntelliJ baut nun unser Programm und führt es aus.
8. Es sollte sich ein neues Fenster öffnen, in welchem etwa folgender Text zu sehen ist:
   /usr/lib/jvm/java-1.8.0-openjdk-amd64/bin/java …
   Hello!

   Process finished with exit code 0
9. Wir haben soeben unser erstes Programm geschrieben.
Installation von IntelliJ, Java und Git
Konfiguration von JDK in IntelliJ
Falls IntelliJ das vorher installierte JDK nicht findet, muss man es pro Projekt noch manuell
konfigurieren. Die folgenden Screenshots zeigen, wie man dies macht. Zuerst muss man die
Einstellungen des Projekts öffnen. Dazu klickt man auf das unten markierte Symbol:

Es öffnet sich ein neues Fenster. Auf der linken Seite wählen wir nun SDKs aus und erstellen
mit dem Plus-Symbol einen neuen Eintrag.
Installation von IntelliJ, Java und Git
Nun können wir unter Project das neu erstellte SDK auswählen:
Installation von IntelliJ, Java und Git
Integration mit Git
In diesem Kurs werden sie im praktischen Teil zwei Dinge lernen: Einerseits werden Sie ein
Projekt implementieren, andererseits müssen Sie dazu ein System zur Versionskontrolle
benutzen. Wir verwenden ​Git​. Jeder Student kann sich unter ​https://gitlab.ethz.ch/​ eigene
Projekte erstellen. Im Folgenden werden zunächst die Grundlagen von Git erklärt, und danach
wird eine praktische Anleitung für IntelliJ gegeben.

Git
Git ist ein verteiltes Versionskontrollsystem, welches man sowohl für kleine als auch grosse
Projekte benutzen kann. Es hilft dabei, Dateien eines Projektes und Änderungen daran zu
verwalten und zu koordinieren, besonders wenn mehrere Leute daran arbeiten.

Versionskontrollsysteme dienen dazu, die bei der Softwareentwicklung entstehenden
Entwicklungsstufen (Versionen), die Sie selbst oder andere, die mitarbeiten, erstellen,
übersichtlich zu machen; Lösungen für sich widersprechende Änderungen (Konflikte) zu finden;
sie ermöglichen, den Programmcode für eine neue oder eine Testversion zu bearbeiten, ohne
den vorhandenen, getesteten und funktionierenden Entwicklungsstand verändern zu müssen;
und sie erlauben, leicht wieder zum letzten funktionierenden Stand zurückzukehren, sollte sich
ein Fehler eingeschlichen haben - und dies sind nur die Basisfunktionen.

In diesem Kurs entwickeln wir zu mehreren an einem Projekt, daher legen wir dieses auf einem
Server (z.B. bei der ETH auf Gitlab) ab. Üblicherweise werden Projekte so organisiert, dass eine
Hauptversion gepflegt wird, der sogenannte ​Master,​ und eine Anzahl von
Entwicklungsversionen, die ​Branches​, die bei einem bestimmten Versionsstand von diesem
Hauptstrang abgezweigt worden sind, z.B. um neue Funktionen oder andere grössere
Änderungen einzuführen, und die eventuell, wenn gewünscht, wieder in den Hauptzweig/Master
eingebaut, ​merged,​ werden.

Bei allen auch nur etwas grösseren Projekten sollten Sie so oder so ähnlich verfahren; da wir
hier aber nur ein sehr kleines Projekt bearbeiten werden, benutzen wir den Master-Strang direkt
zur Entwicklung.

Nun enthält der Master-Branch (kurz Master) unser aktuelles Projekt. Wenn wir jetzt daran
etwas ändern wollen, dann müssen wir eine Kopie davon bearbeiten, denn das Original liegt auf
dem Server, der keinen direkten Zugriff zur Bearbeitung erlaubt, er stellt eine durch Git
verwaltete Dateiablage (​repository)​ dar.

Wenn man nun an einem Git-Projekt arbeitet, dann muss man daher davon zuerst eine lokale
Kopie erstellen. Dies nennt man ​Clonen.​ Ein Clone holt das aktuelle Projekt vom Server, wählt
den Master-Branch aus und erstellt die Dateien daraus lokal. Dieser Vorgang ist nur einmal
nötig, wenn Sie ein Projekt auf einem Rechner bearbeiten möchten, auf dem es bisher noch
nicht vorlag.

Git speichert Änderungen nicht automatisch ab, sondern jeder Änderungsschritt muss von
Ihnen manuell abgeschlossen und damit in den Branch, der gerade bearbeitet wird, integriert
werden. Bei Git wird dieser Vorgang als ​Commit​ bezeichnet. Ein Commit beschreibt, wer wann
welche Änderungen gemacht hat, und wird zunächst lokal als Differenz zur vorherigen Version
gespeichert.

Best Practices

Es hat sich gezeigt, dass es empfehlenswert ist, möglichst in kleinen Schritten und oft zu
committen; das ist besser, als sich hinreissen zu lassen, grosse Änderungsblöcke mit vielen
verschiedenen Änderungen auf einmal zu committen: einmal lassen sich fehlerhafte
Änderungen leichter finden und beheben, wenn sie ihren eigenen separaten Commit haben, als
wenn ein grosser Block nach ihnen durchsucht werden muss; und auch die Koordination mit
Änderungen Ihrer Koautoren wird erleichtert, da sich widersprechende Änderungen einfacher
miteinander in Einklang gebracht werden können, wenn sie nur wenige Änderungen am
Programmcode umfassen.

Koordination

Alle Commits, die Sie ausführen, werden vorerst lokal gespeichert. Zur Zusammenarbeit mit
Ihren Koautoren müssen Ihre Änderungen in das Repository auf dem zentralen Server
übermittelt werden, damit sie dort für alle Beteiligten verfügbar sind. Bei Git heisst dieser
Vorgang ​Push​.

Umgekehrt bringt ein ​Pull​ ihre lokalen Projektdateien auf den Stand, der auf dem Server
vorliegt.

Üblicherweise beginnt die Arbeit mit einem Pull und endet mit einem Push. Bei Bedarf, wenn
Ihre Mitarbeitenden Änderungen gepusht haben, mit denen Sie weiterarbeiten möchten, pullen
Sie diese während Ihrer Arbeit am Projekt vom Server und pushen ihre Commits wieder, wenn
Sie einen Stand erreicht haben, mit dem Ihre Koautoren weiterarbeiten können/sollen.

Parallele Entwicklung
Wenn nun mehrere Personen an einem Projekt arbeiten, dann wird mit grosser
Wahrscheinlichkeit die Situation eintreten, dass parallel Änderungen am Projekt gemacht
werden. Dadurch kann es passieren, dass es nun mehrere unterschiedliche Kopien des
Projektes gibt, die sich leicht unterscheiden. Trotzdem wollen wir die Änderungen
zusammenführen und so eine Version haben, die alle Einzelmodifikationen enthält. Git erlaubt
es, mit einem ​Merge​ zwei Versionen zusammenzuführen. Im besten Fall passiert dies
vollständig automatisch, manchmal ist es jedoch erforderlich, dass ein Benutzer genau sagt, wie
etwas gemerged werden soll.

Dies passiert, wenn es Änderungen gibt, die sich widersprechen. In diesem Fall muss der
Benutzer entscheiden, welche Änderung relevant ist oder manuell beide zusammenführen.

Installation von Git mit IntelliJ
Git muss zusätzlich zu IntelliJ und Java separat installiert werden. Eine vertiefte Anleitung
befindet sich bei IntelliJ: ​https://www.jetbrains.com/help/idea/using-git-integration.html​. Wir
geben hier eine kurze Anleitung, die für den Kurs genügen sollte.

Zuerst muss Git heruntergeladen und dann installiert werden. Laden Sie von
https://git-scm.com/downloads​ die richtige Version für Ihren Computer herunter. Wenn Sie Linux
benutzen, dann installieren Sie bevorzugt die Version aus der Distribution.

Ein erstes Projekt auschecken
Für den Anfang haben wir ein kleines Projekt vorbereitet, welches Sie auschecken können. Bitte
befolgen Sie die Anleitung, um eine eigene Kopie davon zu erstellen, diese zu clonen und dann
zu verändern.

   1. Zuerst muss eine private Kopie des Projekts erstellt werden, da nicht alle auf diesem
      Projekt arbeiten sollen. Dazu gehen Sie auf ​https://gitlab.ethz.ch/ppl19/getting-started
      und wählen ​Fork​ aus:

   2. Nun wählen Sie ihren eigenen Benutzer aus. Auf der nächsten Seite sollte die Nachricht
      erscheinen, dass das Projekt erfolgreich erstellt wurde: The project was successfully
      forked.
   3. Als nächstes starten wir IntelliJ und erstellen ein neues Projekt. Wenn schon ein Projekt
      in IntelliJ geöffnet ist, dann schliessen wir dieses vorher mit File > Close Project. Im
      Dialog wählen wir nun ​Check out from Version Control​ > ​Git​.
   4. Jetzt muss die Adresse des Projektes eingegeben werden. Diese finden wir auf Gitlab
      auf der Übersichtsseite unseres kopierten Projektes, welche wir wiederum in unserem
      persönlichen Bereich finden. Sie hat etwa die Adresse
https://gitlab.ethz.ch/​NETHZ/​ getting-started​. In der Mitte wählen wir HTTPS aus (wie
       oben gezeigt) und kopieren die Adresse und fügen sie in IntelliJ ein:

   5. Mit ​Clone​ erstellen wir nun eine lokale Kopie. IntelliJ wir nun nach einem Passwort
      fragen. Dort benötigen wir den ETH-Namen und das Passwort (nicht die
      E-Mail-Adresse.)
   6. Jetzt sollte IntelliJ das Projekt clonen und öffnen.

Damit haben wir das Projekt lokal kopiert und können nun daran weiterarbeiten.
Git in IntelliJ

Commit: Neue Versionen erstellen
Wenn wir nun Änderungen haben, die gespeichert werden sollen, dann können wir diese
committen. Dazu speichern wir alle geänderten Dateien ab und wählen im Menü von IntelliJ
VCS > Commit… aus. Es öffnet sich ein Dialog, in dem wir die geänderten Dateien auswählen
können. Zusätzlich können wir eine Nachricht schreiben und sollten diese nutzen, die Änderung
in Worten zu beschreiben. Im folgenden Beispiel wurde die Datei Programm.java geändert.

Anschliessend können wir die Änderungen committen. Wir haben die Möglichkeit, den Commit
zuerst nur lokal zu speichern oder ihn direkt zu veröffentlichen. Letzteres funktioniert allerdings
nur, wenn das Repository nicht zwischendurch geändert wurde. Daher ist es sinnvoll, hier nur
Commit auszuwählen und die Änderungen in einem zweiten Schritt zu veröffentlichen.
Push und Pull: Änderungen synchronisieren
Um die lokale Kopie des Repositories auf den aktuellen Stand zu bringen, müssen wir die
Änderungen mit ​Pull​ hereinholen. Dazu wählen wir in IntelliJ VCS > Update Project... aus. Es
öffnet sich ein Dialog, in welchem wir Update Type: Branch Default und Stash auswählen. Mit
Ok holt IntelliJ nun die aktuelle Version.

Wenn wir nun lokale Änderungen als Commit hatten, dann können wir diese mit VCS > Git >
Push veröffentlichen:

Hier wird nun nochmal angezeigt, welche Änderungen veröffentlicht werden und dass der
Master-Branch geändert wird. Mit Push wird dies dann ausgeführt.
Sie können auch lesen