Installation von IntelliJ, Java und Git
←
→
Transkription von Seiteninhalten
Wenn Ihr Browser die Seite nicht korrekt rendert, bitte, lesen Sie den Inhalt der Seite unten
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.
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 srcmit 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 srcausgewä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.
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 mainim 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.
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.
Nun können wir unter Project das neu erstellte SDK auswählen:
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 Adressehttps://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
