Coding mit Java

Coding mit Java

Heute möchte ich euch eine kurze Einführung in die Programmiersprache Java geben. Java ist eine objektorientierte Programmiersprache, was das bedeutet werde ich euch später erklären. Doch zuerst möchte ich euch mit grundlegenden Begriffen der Programmierung vertraut machen. Hierzu werde ich zunächst Allgemeines zu Programmiersprachen/Terminologie erläutern.

Syntax

Programmiersprachen haben eine Syntax, also eine Grammatik sowie auch Deutsch eine Grammatik hat. Also Regeln nach denen die Sprache funktioniert.
Somit bezeichnet man die Grammatik einer Programmiersprache als Syntax.

Quellcode/Sourcecode:

Als Quellcode bzw. Sourcecode bezeichnet man den Code, den man selbst schreibt und der dann vom Computer bzw. Compiler in Maschinensprache übersetzt und ausgeführt wird.

Compiler

Ein Compiler übersetzt den Sourcecode in Maschinesprache, damit der Computer das Programm versteht.

Schlüsselwörter

Schlüsselwörter sind reservierte Begriffe bzw. Signalworte in einer Programmiersprache. Das bedeutet, sie haben eine definierte Bedeutung und du kannst bzw. darfst sie in der Programmiersprache nicht anders als definiert benutzen. Beispiele für Schlüsselwörter sind z.B. private, int, double...

Variablen

Variablen sind Platzhalter, die Information abspeichern. Variablen werden erstellt, indem man einen passenden Datentyp und einen Namen für die Variable wählt.

Konventionen zur Benennung von Variablen:

Der Anfang einer Variable wird stets klein geschrieben und ist stets ein Buchstabe. Besteht der Variablenname aus mehreren Wörtern, so schreibt man den Anfang des ersten Wortes klein, den des zweiten groß usw.
Beispiel: nutzerEingabe Diese Schreibweise nennt man CamelCase, weil sie an Kamelhöcker erinnert.

Datentypen

Primitive versus komplexe Datentypen

Variablen, die einen primitiven Datentyp haben, können immer nur einen Wert auf einmal speichern.

Variablen, die einen komplexen Datentyp verwenden, können mehrere Zeichen speichern. Eine Zeichenkette (String) kann z.B. mehrere Werte vom Typ char (=Zeichen) speichern.

Datentypen dienen dazu, festzulegen was für Informationen in Variablen (Platzhaltern) abgespeichert werden können. Es gibt z.B. primitive Datentypen zu diesen zählen in Java byte, int, long, short, float, double, boolean und char.

Objektorientierung

Wie oben bereits erwähnt ist Java eine objektorientierte Programmiersprache. Objektorientierung ist ein Programmierparadigma.
In Java nutzt man Klassen als Schablonen für Objekte. Man kann in objektorientierten Programmiersprachen leichter programmieren als z.B. in prozeduralen Programmiersprachen.

OOP := objektorientierte Programmierung

OOP orientiert sich an der realen Welt bzw. ähnlich wie Objekte in der realen Welt kann man sich Objekte in der objektorientierten Programmierung vorstellen. Also Objekte mit Eigenschaften und/oder Funktionen.

Eine Klasse ist in der OOP eine Beschreibung bzw. Definition dieser Objekte. Eine Klasse kann man sich wie ein "Handbuch" zu diesen Objekten vorstellen. In Java können Klassen mehr als Objekte beschreiben.

Eine (Java-)Klasse besteht i.d.R. aus drei Dingen:

Instanzvariablen := Attribute := Member := bestimmen Eigenschaften des Objekts
Instanzmethoden := bestimmen Interaktionen mit Objekten
Konstruktoren := dienen zur Erzeugung der Objekte

Methoden

Methoden – auch Funktionen genannt – verwendet man in Programmiersprachen wie Java, wenn man Code mehrfach nutzen möchte. Methoden können einen Rückgabewert haben, der mit return zurückgegeben wird, müssen sie aber nicht. Der Rückgabewert gibt den Datentyp an, den der zurückgegebene Inhalt hat.
Eine Methode besteht aus dem Sichtbarkeitsmodifier (der gibt an, von wo aus im Programm man auf die Methode zugreifen kann), dem Rückgabetyp (wenn man nichts zurückgeben will ist das void, sonst ein anderer Datentyp), einem Methodennamen und zwei runden Klammern () und zwei geschweiften Klammern {}. In den {} stehen die Anweisungen, die ausgeführt werden (sollen). In den () Klammern können Parameter mitgegeben werden.

Man könnte eine Methode zum Addieren zweier Ganzzahlen schreiben und das Ergebnis zurückgeben:

Public int addiere(int x, int y){

int summe=x+y;

return summe;
}

In dieser Methode ist public der Sichtbarkeitsmodifizierer, der festlegt von wo aus auf die Methode zugegriffen werden kann.

int ist der Rückgabetyp – hier eine Ganzzahl, da wir die Summer zweier Ganzzahlen mit return zurückgeben.
addiere ist der Methodenname, über diesen kann man die Methode aufrufen. x und y sind zwei Parameter, jeweils vom Typ int, die der Methode beim Aufruf übergeben werden müssen.

Im Methodenrumpf, also innerhalb der geschweiften Klammern {} stehen die Anweisungen, die beim Aufruf der Methode ausgeführt werden sollen. Hier wird eine Variable summe vom Typ int angelegt (also deklariert) und durch die Summe der beiden Parameter x und y initialisiert. Zum Schluss wird die Summe bzw. der Wert, der in der Variable summe gespeichert wurde, an die Methode, die die Methode addieren aufgerufen hat, zurückgegeben.

Arrays in Java

In Java (und anderen Programmiersprachen wie C#) sind Arrays Datenstrukturen und werden auch Felder genannt. Arrays können unterschiedlich viele Dimensionen haben, d.h. z.B. nur eine Spalte und mehrere Zeilen, mehrere Zeilen und Spalten etc. Grundsätzlich kann man Arrays beliebig vieler Dimensionen in Java erstellen. Du kannst dir Arrays vereinfacht vorstellen wie eine Tabelle mit unterschiedlich vielen Spalten und Zeilen, wenn es zweidimensional ist, ist es mehr diemensional kannst du es dir wie eine Art Würfel vorstellen – nur damit du ein grobes Bild hast.

Wie auch Variablen hat jedes Array einen Datentyp.

Ein Array vom Typ Integer deklariert man in Java so: int[] ArrayName = AnzahlDerElemente; oder wenn man es direkt befüllen möchte int[] ArrayName = {1,2,4,7}; Statt int kann man auch boolean[] schreiben, dann erhält man ein Array, das boolesche Werte annehmen kann. Boolesche Werte sind true und false (wahr und falsch).

Kontrollstrukturen in Java

Kontrollstrukturen dienen dazu, den Programmablauf zu steuern bzw. zu „kontrollieren“. In Java gibt es mehrere Kontrollstrukturen, die in Anweisungen, Schleifen und Kontrolltransferanweisungen unterteilt werden.

if-Anweisung

Die if-Anweisung (if=falls) dient dazu zu überprüfen, ob eine Bedingung erfüllt ist oder nicht. Je nachdem, ob die Bedingung erfüllt ist, wird ein bestimmter Befehl ausgeführt, oder – wenn die Bedingung nicht erfüllt ist – wird er nicht ausgeführt. Um mehrere Bedingungen zu prüfen, bzw. einen Befehl auszuführen, wenn die Bedingung nicht erfüllt ist, gibt es else if und else.

if = falls

else = ansonsten

else if = sonst wenn

switch-Anweisung

Bei der switch-Anweisung definiert man eine Variable, deren Wert man prüft. Je nach Wert wird eine bestimmte Anweisung ausgeführt. Man kann auch eine Anweisung definieren, die immer dann ausgeführt wird, wenn die Variable keinen der genannten Werte annimmt. Die Variable, die man prüft, muss vom Typ char, int, byte oder short sein und auf Gleichheit prüfen.
int alter;
switch (alter) {
case 10: {
System.out.println(“Ich bin 10“);
break;
}
case 16: {
System.out.println(“Ich bin 16 – ab jetzt darf ich Bier und Wein trinken :)“);
break;
}
case 18: {
System.out.println(“Ich bin 18 – ab jetzt darf ich hier trinken was ich will!!!“);
break;
}
default: {
System.out.println(“Ihr Alter bringt nichts besonderes mit sich.“);
break;
}
}

Schleifen/Loops

Schleifen ermöglichen es bestimmte Anweisungen mehrmals hintereinander auszuführen oder z.B. über Arrays zu iterieren. Das heißt über alle Elemente zu schauen, die in dem Array enthalten sind bzw. zu schauen, was für Elemente im Array enthalten sind und diese ggf. zu verändern, zu löschen etc.
In Java gibt es verschiedene Schleifen, die hier kurz vorgestellt werden.

while-Schleife

Eine while-Schleife ist eine kopfgesteuerte Schleife, d.h. die Schleife wird nur ausgeführt, wenn die Bedingung bereits zu Beginn erfüllt ist.
int faktor1 = 0;
int faktor2= 3;
int ergebnis;
while (faktor1< faktor2)
{ergebnis = faktor1 * faktor2;
faktor1=faktor1+1;
}

do-while-Schleife

Eine do-while-Schleife ist eine fußgesteuerte Schleife, sie wird mindestens einmal ausgeführt und dann wird die Bedingung geprüft. Ist die Bedingung nach einer Ausführung der Schleife erfüllt, wird die Schleife erneut ausgeführt, sonst nicht.
int faktor1 = 0;
int faktor2 = 3;
int ergebnis;
do
{ergebnis = faktor1 *faktor2;
faktor1 = faktor1 +1;
}
while (faktor1< faktor2);

for-Schleife

Bei einer for-Schleife legt man eine Zählvariable fest sowie eine Durchlaufbedingung. Die Zählvariable wird nach jedem Durchgang erhöht oder erniedrigt bzw. ihr Wert wird verändert.

Beispiel:

for(int i=0; i<10;i++){
System.out.println( ́ ́i beträgt aktuell: ́ ́ + i);
}

for each-Schleife

Eine for each-Schleife eignet sich um jedes Element einer Datenstruktur anzuschauen, z.B. jedes Element eines Arrays.

Beispiel:

int[] array= {1,4,3,5,6, 7,8};
for( int k : array){
System.out.println(k);
}

Kontrolltransferanweisungen

In Java gibt es die beiden Kontrolltransferanweisungen break und continue. Diese dienen dazu Schleifendurchläufe abzubrechen. Während bei continue nur der aktuelle Schleifendurchlauf abgebrochen wird und die Bedingung erneut geprüft wird und ein neuer Schleifendurchlauf gestartet wird, wird die Schleife bei break abgebrochen und verlassen und der Code, der nach der Schleife steht, ausgeführt.

Das war es erst einmal zur Theorie, im folgenden Teil wird es etwas praktischer und ihr werdet zwei kleine Programme schreiben, vorher solltet ihr aber entweder einen Entwicklungsumgebung (Eclipse oder Intellij z.B.) installieren oder einen online-Java-Editor öffnen. (Links stehen unten.)

Schnupperkurs

Du benötigst vorab eine Entwicklungsumgebung, eine Installationsanleitung findest du unter: https://de.wikibooks.org/wiki/Java_Standard:_Einrichten_der_Programmierumgebung Du kannst dir alternativ auch Youtube-Videos zum Thema Java JDK und IDE anschauen. Wenn du für dieses Tutorial nichts installieren möchtest, kannst du auch einen online Editor verwenden, z.B. https://www.tutorialspoint.com/compile_java_online.php Wenn du die Entwicklungsumgebung heruntergeladen und installiert hast, z.B. Eclipse, musst du einen neuen Workspace und dann ein neues Projekt anlegen, um deinen Code in der Entwicklungsumgebung schreiben zu können. Hier findest du dafür eine Anleitung: https://mein-javablog.de/java-projekt-eclipse-anlegen/ Du musst auch eine neue Klasse anlegen.
Traditionell schreibt man als erstes ein Hallo-Welt-Programm, d.h. ein Programm, dass Hallo Welt bzw. Hello World ausgibt.
Wenn deine Klasse erstellt wurde, brauchst du eine Main-Methode, in die du den Code für die Ausgabe von Hallo Welt schreibst.
Du schreibst: System.out.println(‘‘Hallo Welt‘‘);
System.out.println() ist der Befehl für das Ausgeben einer Zeile auf der Konsole. ‘‘ ‘‘ gibt an, dass zwischen den Anführungszeichen Text steht, der ausgegeben werden soll. ; zeigt an, dass der Befehl zuende ist.

Insgesamt sollte dein Programm so aussehen:

public class KlassenName {
public static void main(String[] args){ System.out.println("Hallo Welt");
}
}

Hierbei steht public dafür, dass die Klasse bzw. die Methode öffentlich ist. class legt fest, dass eine Klasse beginnt. KlassenName ist der Name der Klasse, den kannst du weitgehend frei wählen. Static bedeutet, dass es sich um eine statische Methode handelt. Die main Methode gibt an wo der Programmeinstieg ist, deswegen steht diese Methode meist zu Beginn des Programms. Alles, was innerhalb der main-Methode steht wird von oben nach unten abgearbeitet. Das heißt der Code zwischen { nach public static void main(String[] args){ und der } nach System.out.println("Hallo Welt");

Achtung: Java ist case-sensitive, d.h. Groß- und Kleinschreibung ist wichtig und wird unterschieden. Klasse1 wäre etwas anderes als klasse1. Du kannst in dein Programm auch Kommentare einfügen. Kommentare dienen dazu, den Code zu erklären, ohne dass der Compiler (der ist für die Ausführung des Programms zuständig) die Kommentare interpretiert – der Compiler ignoriert Kommentare. Du kannst einzeilige Kommentare schreiben, indem du // schreibst und dann deinen Kommentar eingibst. Wenn du einen Kommentar schreiben willst, der über mehrere Zeilen geht, schreibst du


/* Kommentar
*über mehrere
* Zeilen */
/* leitet den Beginn des mehrzeiligen Kommentars ein und */ schließt ihn. Pro Zeile schreibt man, außer bei der ersten Zeile, die mit /* beginnt, am Anfang der Zeile *.


Du hast jetzt viele theoretische Grundlagen zu Java kennengelernt und ein erstes Mini-Programm geschrieben. Anhand eines kleinen Beispielprojekts werden wir die eben vorgestellten Grundlagen nun anwenden. Als erstes legst du ein neues Projekt an, indem du in Eclipse auf File und dann auf New und dann auf Project klickst. Du legst den Namen für dein Projekt fest: Wunschzettel Dann erstellst du über File new eine neue Klasse. Diese nennst du MeinWunschzettel. Wir schreiben hier ein Programm, indem ein Wunschzettel angelegt und mit deinem Budget abgeglichen wird. Hierfür benötigen wir den Wunschzettel, die Preise der gewünschten Produkte und ein Budget. Variablen dienen dazu Werte zu speichern. Variablen haben einen Datentyp, der festlegt, was für Werte in der Variablen gespeichert werden können, und einen Namen (Bezeichner). Der Name einer Variable sollte etwas über den Inhalt der Variable aussagen. Wie würdest du die Variablen für den Wunschzettel, die Preise und das Budget nennen? Damit es leichter ist, legen wir fest, dass wir drei Wünsche auf unserem Wunschzettel haben. Du kannst beliebig viele Wünsche theoretisch verwenden.

Nun brauchen wir einmal den Wunschzettel, dann brauchen wir die einzelnen Wünsche und deren Kosten und unser Budget.

Welche Datentypen würdest du diesen Variablen jeweils geben und welche Namen?

Ich nenne sie so: Wunschzettel vom Typ String, Wunsch1 (ein PC) vom Typ String, Wunsch2 (ein Buch) vom Typ String und Wunsch3 (ein Eis) vom Datentyp String. Für die Kosten bzw. die Preise erstelle ich jeweils eine Variable pro Wunsch vom Typ double. Für mein Budget erstelle ich auch eine Variable vom Typ double.

Eine Variable deklarierst du so: Datentyp Variablenname = Wert;

Double zeigt an, dass es Gleitkommazahlen sind. Anstelle des Kommas , verwendest du einen Punkt . in Java. Das heißt du schreibst anstatt 3,50 3.50.

Dein Code sollte bisher so aussehen:

public class MeinWunschzettel { //Beginn der Klasse MeinWunschzettel
public static void main(String[] args){ //Main-Methode-Beginn

String wunsch1 = "PC"; //Variable für den ersten Wunsch einen PC

String wunsch2 = "Buch"; // Variable für den zweiten Wunsch ein Buch
String wunsch3 = "Eis"; //Variable für den dritten Wunsch ein Eis
double eisPreis = 1.50;
/*damit man hier weiß, welches Produkt gemeint ist, habe ich EisPreis als *Variablennamen gewählt, natürlich geht auch Wunsch1Preis */
double PCPreis = 500.00; //vergleiche mit EisPreis-Variable
double buchPreis = 20.99; //vergleiche mit EisPreis-Variable
double budget = 750.00; //Variable für mein Budget

//Ausgabe des Wunschzettels:

System.out.println("Mein Wunschzettel:");
System.out.println(wunsch1);
System.out.println(wunsch2);
System.out.println(wunsch3);

/* Die Werte von Wunsch1, Wunsch2 und Wunsch3 werden hier vom Compiler dann ausgewertet * und ihre Werte (PC, Buch, Eis) werden ausgegeben */

}
}

Nun kannst du deinen Wunschzettel ausgeben lassen, allerdings wird noch nicht geprüft, ob du dir deine Wünsche mit deinem verfügbaren Budget erfüllen kannst. Wie könntest du das lösen?

Versuch selbst eine Lösung zu finden, bevor du weiterliest.
Du hast vorhin bereits gelernt, dass es Methoden gibt und dass es z.B. if-else-Anweisungen gibt. Als erstes deklarierst du eine Variable für die Gesamtkosten deiner Wünsche. Anschließend verrechnest du diese mit deinem Budget und speicherst das Ergebnis in einer Variable. Achtung es gibt mehrere Möglichkeiten das zu lösen, wir versuchen es hier sehr simpel ohne viele Methoden.


public class MeinWunschzettel { //Beginn der Klasse MeinWunschzettel
public static void main(String[] args){ //Main-Methode-Beginn

String wunsch1 = "PC"; //Variable für den ersten Wunsch einen PC

String wunsch2 = "Buch"; // Variable für den zweiten Wunsch ein Buch
String wunsch3 = "Eis"; //Variable für den dritten Wunsch ein Eis
double eisPreis = 1.50;
/*damit man hier weiß, welches Produkt gemeint ist, habe ich eisPreis als
*Variablennamen gewählt, natürlich geht auch wunsch1Preis */
double PCPreis = 500.00; //vergleiche mit eisPreis-Variable
double buchPreis = 20.99; //vergleiche mit eisPreis-Variable
double budget = 750.00; //Variable für mein Budget

//Ausgabe des Wunschzettels:

System.out.println("Mein Wunschzettel:");
System.out.println(wunsch1);
System.out.println(wunsch2);
System.out.println(wunsch3);
/* Die Werte von wunsch1, wunsch2 und wunsch3 werden hier vom Compiler dann *ausgewertet und ihre Werte (PC, Buch, Eis) werden ausgegeben */ double summeWunschKosten = PCPreis + buchPreis + eisPreis; /*Aller Preis-Variablen werden *addiert und in der Variable summeWunschKosten abgespeichert.
*Du musst hier nur den Namen der Preis-Variablen angeben ohne Datentyp. Du kannst auch erst *die Variable deklarieren und ihr später einen Wert zuweisen. Die erste Wertzuweisung für eine Variable nennt man Initialisierung*/

//Differenz zwischen Budget und Kosten:

double budgetMinusKosten = budget - summeWunschKosten;

//Überprüfung, ob wir uns unsere Wünsche erfüllen können

if(budget >= budgetMinusKosten){
System.out.println("Juhu, wir können uns unsere Wünsche erfüllen.");
}else {
System.out.println("Schade, das Budget reicht noch nicht…");}
}
}

Nun hast du ein erstes kleines Programm in Java geschrieben, das einen Wunschzettel ausgibt und prüft, ob du dir deine Wünsche leisten kannst. Spiele hier ein bisschen rum, verwende andere Werte, mehr Wünsche etc. Sei kreativ, du kennst die Grundlagen, um erste Programme zu schreiben. Wenn du nicht weiterweißt hilft nachdenken oder googlen.

Du suchst hilfreiche Dokumente zum Thema?

Auf Studydrive findest du jede Menge Lernmaterialien, die dir bei der Kurs- oder Prüfungsvorbereitung helfen werden. Hier findest du Zusammenfassungen und Notizen, Lösungen zu vergangenen Prüfungen und Arbeitsblätter