Programmieren I¶
Herzlich willkommen zur Programmieren I Veranstaltung! Wir werden unter Verwendung der Programmiersprache Java die wesentlichen Konzepte lernen, die für das Verständnis modernen Programmierens notwendig sind. Es sind keinerlei Vorkenntnisse erforderlich. Hier einige Tipps, damit Sie die Veranstaltung erfolgreich durchführen und Sie dabei auch Spaß haben:
- In diesem Skript sind bereits alle Inhalte des gesamten Semesters verfügbar. Der Grund dafür ist der, dass Sie sich das jeweilige Thema vorab selbständig erarbeiten können, indem Sie sich den jeweiligen Abschnitt bereits vor der jeweiligen Vorlesung anschauen. Ich empfehle Ihnen diese Vorgehensweise - sie hat sich bewährt!
- In den Übungen sollten Sie ruhig zusammenarbeiten. Es ist auch kein Problem, wenn Sie für das Bewältigen der Übungen etwas länger benötigen. Sollten Sie es gar nicht alleine schaffen, ist das auch kein Problem. Wichtig ist dann, dass Sie sich die Lösung anschauen und es erneut selbständig versuchen. Hören Sie nicht auf, bis Sie es geschafft haben! Sie müssen irgendwann in der Lage sein, alle Übungsaufgaben selbständig zu lösen.
- Sie können die Hausaufgaben gerne zu zweit oder im Team lösen. Achten Sie aber darauf, dass Sie Ihre gemeinsame Lösung vollständig verstanden haben und dass Sie sie danach auch alleine erstellen können. Sie können beim Lösen der Hausaufgaben beliebig kreativ sein! Die Aufgabenstellung gibt Ihnen Anhaltspunkte für eine eventuelle Lösung. Sie können es aber auch ganz anders machen!
- Die Klausurvorbereitung beginnt mit Beginn der Veranstaltung! Es ist nicht möglich, die Klausur am Ende des Semesters zu bestehen, wenn Sie nicht das ganze Semester über intensiv programmieren. Die Übungsaufgaben sind "kleine" Aufgaben, um das in der Vorlesung vermittelte Wissen direkt anzuwenden. Für die Lösung der Hausaufgaben ist bereits ein gewisses Abstraktionsniveau erforderlich, um zu erkennen, dass das in der Vorlesung vermittelte Wissen dafür ausreichend ist.
- Programmieren lernt man nur durch Programmieren! Sie müssen es tun. Das Lesen von Büchern oder das "Anschauen" von Code genügt nicht. Eine Sprache lernt man auch nur durch Sprechen. Sie müssen programmieren, programmieren, programmieren... (siehe auch hier)
- Lassen Sie sich durch Fehler nicht verunsichern, sondern analysieren Sie Ihre Fehler! Bis zur Klausur sollten Sie alle Fehler einmal gemacht haben. Wenn Sie sich überlegen, warum das jeweils ein Fehler war, dann werden Sie diesen Fehler nicht wiederholen und haben durch die Reflektion eine Menge gelernt. Fehler zu machen (und darüber zu reflektieren) gehört zu den besten Lernmethoden des Programmierens!
- Haben Sie Spaß! Je mehr Sie das Programmieren lernen, je mehr Spaß werden Sie haben. Sollte es Ihnen zwischendurch keinen Spaß mehr machen, geben Sie mir sofort Bescheid!
Viel Erfolg! Und viel Spaß!
Organisatorisches¶
Der Plan zur Durchführung der Veranstaltung ist derzeit wie folgt:
- Themen werden ausführlich in der Vorlesung vorgestellt und in diesem Skript beschrieben.
- Die neuen Themen werden stets vorab in diesem Skript hier veröffentlicht. Sie können sich also bereits vorab mit dem jeweiligen neuen Thema beschäftigen.
- Zusammen mit dem Skript (das neue Thema) werden sowohl die dazugehörige Übung als auch die dazugehörige Aufgabe hochgeladen.
- Die beiden Übungen am Dienstag (in der einen Woche) und am Montag in der folgenden Woche sind jeweils gleich (d.h. dort werden die gleichen Übungsaufgaben gelöst). Die Übungen behandeln den Stoff, der am Montag und Dienstag in der gleichen Woche besprochen wird.
- Sie können frei wählen, welche der beiden Übungen Sie besuchen. Sie können auch beliebig wöchentlich wechseln.
- Es wird ein Tutorium angeboten (Termin wird noch bekanntgegeben).
- Sollten Sie Wünsche haben, diesen Plan zu ändern, kommen Sie gerne auf mich zu.
Zur erfolgreichen Durchführung der Veranstaltung müssen Sie
- eine der Übungen durchgeführt haben (zu zweit) und (siehe dazu Wiki in Moodle)
- mir mind. 8 Lösungen Ihrer Übungen in den Übungszeiten präsentiert und
- die Klausur am Ende bestanden
haben.
Jede Woche gibt es zu jedem Thema Übungen, die wir in den Übungszeiten besprechen. Diese dienen der Anwendung und der Festigung der erlangten Kenntnisse. Die Übungen sind kleine Aufgaben, an denen Sie das neue Wissen anwenden sollen. Die Übungen dienen der Befähigung, die (größeren) Aufgaben lösen zu können.
Es gibt außerdem Aufgaben. Diese sind zu Ihrer eigenen Übung da. Es mag Ihnen vielleicht schwerfallen, die Aufgaben selbständig zu lösen. Sie sollten Sie jedoch irgendwann selbständig lösen können! Es hat sich gezeigt, dass die Studentinnen, die die Aufgaben irgendwann selbständig lösen konnten, die Klausur sicher bestehen. Damit Sie dies erfolgreich erledigen können, ist jeweils angegeben, welche Themen Sie dafür durcharbeiten müssen. Das Durcharbeiten der jeweiligen Themen entspricht meistens jeweils einem Wochenthema.
Am Ende des Semesters schreiben wir eine Klausur (am Rechner). Diese Klausur wird bewertet und entspricht der Note für "Programmieren 1". Probeklausuren (Klausuren aus den letzten Jahren) finden Sie hier.
Für die Kommunikation untereinander verwenden wir Slack (Channel #b11_prog1_ws2025_26). Dort können Sie alle inhaltlichen und organisatorischen Fragen stellen. Ich fände es gut, wenn eine Art internes Diskussionsforum entsteht. Es ist sehr gewünscht, dort Fragen zu stellen und noch mehr gewünscht, dass Sie sich diese gegenseitig beantworten. Damit wäre allen geholfen und wir können besser erkennen, wo noch Nachhol- bzw. Erläuterungsbedarf bei den meisten besteht. Bei Bedarf beantworten die Lehrenden die Fragen natürlich.
Planung¶
Nachfolgend der vorläufige Wochenplan (wird eventuell angepasst).
| Woche | Themen (Vorlesung) | Übung | Aufgabe | Abgabe Aufgabe bis | |
|---|---|---|---|---|---|
| 1. | 07.-11.10.2025 | Organisatorisches, Algorithmen und Erstes Programm | Übung 0 | - | - |
| 2. | 14.-18.10.2025 | Variablen und Datentypen | Übung 1 | - | - |
| 3. | 21.-25.10.2025 | Operatoren und Ausdrücke | Übung 2 | - | - |
| 4. | 28.-01.11.2025 | Methoden und Methodenstack | Übung 2a | - | - |
| 5. | 04.-08.11.2025 | Selektion (if) und Iteration (for) | Übung 3 | Aufgabe 1 | 22.11.2025 |
| 6. | 11.-15.11.2025 | Iteration (while) und Methodenstack | Übung 4 | Aufgabe 2 | 29.11.2025 |
| 7. | 18.-22.11.2025 | Klassen und Objekte, Konstruktoren, this | Übung 5 | Aufgabe 3 | 06.12.2025 |
| 8. | 25.-29.11.2025 | Eigene Datentypen, Rückgabe von Objekten und Leben der Objekte | Übung 6 | Aufgabe 4 | 13.12.2025 |
| 9. | 02.-06.12.2025 | Vererbung, Object und Polymorphie | Übung 7 | Aufgabe 5 | 20.12.2025 |
| 10. | 09.-13.12.2025 | Arrays | Übung 8 | Aufgabe 6 | 03.01.2026 |
| 11. | 16.-20.12.2025 | Algorithmen über Arrays | Übung 9 | Aufgabe 7 | 10.01.2026 |
| 12. | 06.-10.01.2026 | Sortieren von Arrays | Übung 10 | Aufgabe 8 | 17.01.2026 |
| 13. | 13.-17.01.2026 | Suchen in Arrays | Übung 11 | Probeklausuren | - |
| 14. | 20.-24.01.2026 | JavaDoc | Übung 12 | Probeklausuren | - |
| 15. | 27.-31.01.2026 | Wiederholung, Klausurvorbereitung | Probeklausuren | - | |
| 16. | 03.02.2026 09.45-11.30 Uhr | Klausur 1.PZ | - | - | |
| 16. | 24.03.2026 09.45-11.30 Uhr | Klausur 2.PZ | - | - |
Code aus der Vorlesung¶
Vorlesung String, print(), println()
package vorlesungen.vorl1014;
public class Vorlesung1014
{
public static void main(String[] args)
{
// hier kann ein Zeilenkommentar stehen
/*
* Blockkommentar
* in jeder Zeile
* kann irgendetwas
* stehen
*/
String wort; // Deklaration
wort = "Hallo!"; // Wertzuweisung
System.out.println(wort); // Ausgabe des Wertes von wort
wort = "FIW"; // neuer Wert
System.out.println(wort); // Ausgabe des (neuen) Wertes von wort
System.out.print("hallo1"); // kein Zeilenumbruch
System.out.println(); // nur Zeilenumbruch
System.out.println(); // Leerzeile
System.out.print("hallo2"); //
System.out.println();
System.out.println("hallo3"); // Ausgabe mit Zeilenumbruch
}
}
Variablen und Wertetypen
package vorlesungen.vorl1020;
public class Vorlesung1020
{
public static void main(String[] args)
{
// Deklaration
String wort; // Variable wort existiert
// Wertzuweisung
wort = "irgendein text";
System.out.println(wort);
wort = "fuenf";
// Lesen
System.out.println(wort);
System.out.println(wort);
// Datentyp int
int number;
// Wertzuweisung
number = 7; // erste Wertzuweisung - Initialisierung
// lesen
System.out.println(number);
// double
// Wertzuweisung und Initialisierung in einem Schritt
double number1 = 12.345;
// boolean
boolean bedingung = true; // oder bedingung = false;
System.out.println(bedingung);
bedingung = false;
System.out.println(bedingung);
// byte
byte kleineZahl = 127;
System.out.println(kleineZahl);
kleineZahl++;
System.out.println(kleineZahl);
//
int ganzGrosseZahlInt = 2147483647; // grosstmoeglicher int-Wert
System.out.println(ganzGrosseZahlInt);
long ganzGanzGrosseZahlLong = 2147483648L;
}
}
Konkatenation, Addition und Division
package vorlesungen.vorl1021;
public class Vorlesung1021
{
public static void main(String[] args)
{
char zeichen = 'a';
System.out.println(zeichen);
zeichen = 65;
System.out.println(zeichen);
zeichen = 'A';
System.out.println(zeichen);
zeichen = '\u00A9';
System.out.println(zeichen);
String zeichenkette = "Hallo " + "FIW" + "!";
System.out.println(zeichenkette);
String word1 = "eins ";
String word2 = "zwei";
String word3 = word1 + word2; // "eins zwei"
word1 = word1 + word2; // "eins zwei"
word2 = word1 + word2; // "eins zweizwei"
String wiederhole = "aktueller Wert von ";
System.out.println(word1);
System.out.println("aktueller Wert von word2 ist " + word2);
System.out.println(wiederhole + "word2 ist " + word2);
System.out.println("aktueller Wert von zeichen ist " + zeichen);
int number = 1234;
System.out.println("number = " + number);
int summand1 = 3;
int summand2 = 4;
int summe = summand1 + summand2;
System.out.println("summe = " + summe);
System.out.println(summand1 + " + " + summand2 + " = " + summe);
System.out.println(summand1 + summand2); // 7
System.out.println(summand1 + " + " + summand2 + " = " + summand1 + summand2);
System.out.println(summand1 + " + " + summand2 + " = " + (summand1 + summand2));
int number1 = 12;
int number2 = 4;
int product = number1 * number2; // 48
int quotient = number1 / number2; // 3
int sum = number1 + number2; // 16
int differenz = number1 - number2; // 8
System.out.println(number1 + " * " + number2 + " = " + number1 * number2);
System.out.println(number1 + " * " + number2 + " = " + product);
double nr1 = 5.0;
double nr2 = 2.0;
double pr = nr1 * nr2;
double qu = nr1 / nr2;
double su = nr1 + nr2;
double di = nr1 - nr2;
int zahl1 = 5;
int zahl2 = 2;
int ergebnis = zahl1 / zahl2; // Ergebnis ist 2
System.out.println("ergebnis : " + ergebnis );
double result = nr1 / nr2; // Ergebnis ist 2.5
System.out.println("result : " + result );
result = zahl1 / zahl2; // Ergebnis ist 2.0!!
System.out.println("result : " + result );
}
}
Ausdrücke, arithmetische Vergleichs- und logische Operatoren
package vorlesungen.vorl1027;
public class Vorlesung1027
{
public static void main(String[] args)
{
int nr1 = 21;
int nr2 = 5;
int nr3 = nr1; // nr3 = 21;
nr3 = nr1 + nr2; // nr3 = 21 + 5 = 26;
System.out.println(nr1 + " + " + nr2 + " = " + nr3);
nr3 = nr1 - nr2; // nr3 = 21 - 5 = 16;
System.out.println(nr1 + " - " + nr2 + " = " + nr3);
nr3 = nr1 * nr2; // nr3 = 21 * 5 = 105;
System.out.println(nr1 + " * " + nr2 + " = " + nr3);
// ganzzahlige Division!
nr3 = nr1 / nr2; // nr3 = 21 / 5 = 4;
System.out.println(nr1 + " / " + nr2 + " = " + nr3);
// Restwertoperator (Modulo-Operator)
nr3 = nr1 % nr2; // Restwert der Division
System.out.println(nr1 + " % " + nr2 + " = " + nr3);
double d1 = 21.0;
double d2 = 5.0;
// Gleitkommadivision
double d3 = d1 / d2;
System.out.println(d1 + " / " + d2 + " = " + d3);
System.out.println(21 / 5); // ganzzahlige Division
System.out.println(21.0 / 5); // Gleikommadivision
System.out.println(21 / 5.0); // Gleikommadivision
System.out.println(21.0 / 5.0); // Gleikommadivision
int zahl1 = 5;
int zahl2 = 4;
int zahl3 = 5;
boolean vergleich = 5 > 4;
System.out.println("5 > 4 = " + (5 > 4));
System.out.println(zahl1 + " > " + zahl2 + " = " + vergleich);
vergleich = 5 < 4;
System.out.println(zahl1 + " < " + zahl2 + " = " + vergleich);
vergleich = zahl1 <= zahl3; // kleiner oder gleich
System.out.println(zahl1 + " <= " + zahl3 + " = " + vergleich);
vergleich = zahl1 == zahl3; // gleich
System.out.println(zahl1 + " == " + zahl3 + " = " + vergleich);
vergleich = zahl1 == zahl2; // gleich
System.out.println(zahl1 + " == " + zahl2 + " = " + vergleich);
vergleich = zahl1 != zahl3; // ungleich
System.out.println(zahl1 + " != " + zahl3 + " = " + vergleich);
vergleich = zahl1 != zahl2; // ungleich
System.out.println(zahl1 + " != " + zahl2 + " = " + vergleich);
char c1 = 'A'; // ASCII-Code 65
char c2 = 'B'; // ASCII-Code 66
char c3 = 'a';
System.out.println(c1 < c2);
System.out.println(c3 > c1);
int c3ascii = c3;
System.out.println(c3ascii);
char c4 = 65; // siehe Uebung 1 - ASCII-Wert von 'A'
System.out.println(c4); // A
boolean operand1 = true;
boolean operand2 = true;
boolean operand3 = false;
boolean operand4 = false;
boolean result = operand1 && operand2;
System.out.println(operand1 + " && " + operand2 + " = " + result);
result = operand1 && operand3;
System.out.println(operand1 + " && " + operand3 + " = " + result);
result = operand1 || operand2;
System.out.println(operand1 + " || " + operand2 + " = " + result);
result = operand1 || operand3;
System.out.println(operand1 + " || " + operand3 + " = " + result);
boolean xor = (operand1 || operand2) && !(operand1 && operand2);
int z1 = 3;
int z2 = 4;
int z3 = 5;
boolean z1KleinerZ2KleinerZ3 = (z1 < z2) && (z2 < z3);
}
}
Dekrement, Inkrement, erste eigene Methode
package vorlesungen.vorl1028;
public class Vorlesung1028
{
public static void printSum(int summand1, int summand2)
{
int summe = summand1 + summand2;
System.out.println(summand1 + " + " + summand2 + " = " + summe);
}
public static void main(String[] args)
{
int x = 7;
System.out.println("x = " + x); // 7
x = x + 1; // x = 8;
System.out.println("x = " + x); // 8
x++; // x = x + 1;
System.out.println("x = " + x); // 9
++x; // x = x + 1;
System.out.println("x = " + x); // 10
x--; // x = x - 1;
System.out.println("x = " + x); // 9
--x; // x = x - 1;
System.out.println("x = " + x); // 8
x = x + 5;
x += 5;
x /= 3; // x = x / 3;
x *= 3; // x = x * 3;
x -= 3; // x = x - 3;
x %= 3; // x = x % 3;
int nr1 = 3;
int nr2 = 4;
System.out.println(nr1 + " + " + nr2 + " = " + (nr1 + nr2)); // Klammern notwendig!
System.out.println(nr1 + nr2 + " = " + nr1 + " + " + nr2); // nr1 + nr2 ist Summe
int summand1 = 7;
int summand2 = 10;
int summe = summand1 + summand2;
System.out.println(summand1 + " + " + summand2 + " = " + summe);
summand1 = -7;
summand2 = 107;
summe = summand1 + summand2;
System.out.println(summand1 + " + " + summand2 + " = " + summe);
summand1 = 17;
summand2 = -107;
summe = summand1 + summand2;
System.out.println(summand1 + " + " + summand2 + " = " + summe);
}
}
Methoden mit Rückgabe, Methodenaufrufe
package vorlesungen.vorl1103;
public class Vorlesung1103
{
public static void printSum(int summand1, int summand2)
{
//int summe = summand1 + summand2;
int summe = add(summand1, summand2);
System.out.println(summand1 + " + " + summand2 + " = " + summe);
}
public static int add(int summand1, int summand2)
{
int summe = summand1 + summand2;
return summe;
}
public static double multiply(double nr1, double nr2, double nr3)
{
double product = nr1 * nr2 * nr3;
return product;
}
public static boolean isLeapyear(int year)
{
boolean istDurch4Teilbar = year % 4 == 0;
boolean istDurch100Teilbar = year % 100 == 0;
boolean istDurch400Teilbar = year % 400 == 0;
boolean isLeapyear = (istDurch4Teilbar && !istDurch100Teilbar) || istDurch400Teilbar;
return isLeapyear;
}
public static void main(String[] args)
{
printSum(3,6);
printSum(17,4);
int summe = add(3,4); // 7
System.out.println(summe);
System.out.println(add(8,10));
int zahl1 = 17;
int zahl2 = 12;
System.out.println(zahl1 + " + " + zahl2 + " = " + add(zahl1, zahl2));
int doppelteSumme = 2 * add(17,4);
System.out.println(doppelteSumme);
double product = multiply(3.0, 4.0, 5.0);
System.out.println(product);
System.out.println("2025 : " + isLeapyear(2025));
System.out.println("2024 : " + isLeapyear(2024));
System.out.println("2000 : " + isLeapyear(2000));
System.out.println("2100 : " + isLeapyear(2100));
}
}
Methodenstack und Selektion
package vorlesungen.vorl1104;
public class Vorlesung1104
{
public static boolean areEqual(int nr1, int nr2)
{
return nr1 == nr2;
}
public static boolean isDivider(int number, int divider)
{
return number % divider == 0;
}
public static boolean isDividerButNotEqual(int number, int divider)
{
return isDivider(number, divider) && !areEqual(number, divider);
}
public static void main(String[] args)
{
System.out.println("------ areEqual()---------");
System.out.println(areEqual(123, 123));
System.out.println(areEqual(123, 124));
System.out.println(areEqual(123, -(-123)));
System.out.println("------ isDivider---------");
System.out.println(isDivider(16, 4));
System.out.println(isDivider(16, 5));
System.out.println("------ isDividerButNotEqual()---------");
int number1 = 16;
int number2 = 4;
System.out.println(isDividerButNotEqual(number1,number2));
System.out.println(isDividerButNotEqual(16,16));
System.out.println(isDividerButNotEqual(16,5));
System.out.println("------ Selektion ---------");
int nr1 = 4;
int nr2 = 3;
if(nr1 > nr2)
{
System.out.println(nr1 + " ist groesser als " + nr2);
}
else
{
System.out.println(nr1 + " ist nicht groesser als " + nr2);
}
if(nr1 % 2 == 0)
{
System.out.println(nr1 + " ist eine gerade Zahl.");
}
else
{
System.out.println(nr1 + " ist eine ungerade Zahl.");
}
if(isDivider(nr1,nr2))
{
System.out.println(nr2 + " ist Teiler von " + nr1);
}
else
{
System.out.println(nr2 + " ist kein Teiler von " + nr1);
}
}
}
for-Schleife
package vorlesungen.vorl1110;
public class Vorlesung1110
{
public static void printDivision(int nr1, int nr2)
{
if(nr2 != 0)
{
System.out.println(nr1 + "/" + nr2 + " = " + nr1/nr2);
}
else
{
System.out.println("Division durch 0 ist nicht definiert.");
}
}
public static int getQuotient(int nr1, int nr2)
{
return nr1 / nr2;
}
public static void main(String[] args)
{
System.out.println();
System.out.println("------------------ Selektion ------------------");
System.out.println();
printDivision(15, 5);
printDivision(15, 0);
int number = 17;
if(number % 2 == 0)
{
number = number / 2;
}
else
{
number = 3 * number + 1;
}
// das geht, aber wollen wir nicht :
if(number % 2 == 0)
number = number / 2;
else
number = 3 * number + 1;
int a = 3;
int b = 4;
int c = 5;
if(a < b)
{
if(a < c)
{
if(c < b)
{
System.out.println(a + " < " + c + " < " + b);
}
else
{
}
}
}
else // a >= b
{
}
int zahl1 = 3;
int zahl2 = 0;
if(zahl2 != 0)
{
System.out.println(zahl1 + "/" + zahl2 + " = " + getQuotient(zahl1,zahl2));
}
System.out.println();
System.out.println("------------------ Iteration ------------------");
System.out.println();
String output = "1";
int summe = 0;
for(int i = 1; i <= 10; i++)
{
summe = summe + i;
if(i>1)
{
output = output + " + " + i;
}
System.out.println(output + " = " + summe);
}
System.out.println(" Ende : " + summe);
for(int zeile = 0; zeile < 5; zeile++)
{
// Variable spalte gibt es noch gar nicht
for(int spalte = 0; spalte < 5; spalte++)
{
System.out.print("(" + zeile + ", " + spalte + ") ");
}
// Variable spalte gibt es nicht mehr
System.out.println();
}
}
}
verschachtelte for-Schleife
package vorlesungen.vorl1111;
public class Vorlesung1111
{
public static void printRectangle(int breite, int hoehe)
{
for(int zeile = 0; zeile < hoehe; zeile++)
{
/*
for(int col = 0; col < width; col++)
{
System.out.print("* ");
}
*/
printOneLine(breite, '*');
System.out.println();
}
}
public static void printTriangle(int hoehe, boolean rechts)
{
for(int zeile = 1; zeile <= hoehe; zeile++)
{
/*
for(int col = 0; col < width; col++)
{
System.out.print("* ");
}
*/
if(rechts)
{
printOneLine(hoehe - zeile, ' ');
}
printOneLine(zeile, '*');
System.out.println();
}
}
public static void printOneLine(int n, char c)
{
for(int i = 0; i < n; i++)
{
System.out.print(c + " ");
}
}
public static int fakultaet(int number)
{
int product = 1;
for(int factor = 1; factor <= number; factor++)
{
product = product * factor;
}
return product;
}
public static void printFakultaet(int n)
{
for(int nr = 1; nr <= n; nr++)
{
System.out.println(nr + "! = " + fakultaet(nr));
}
}
public static void main(String[] args)
{
int anzahlOft = 5;
for(int zeile = anzahlOft; zeile > 0; zeile--)
{
System.out.print("Zeile " + zeile + " : ");
for(int spalte = 1; spalte <= anzahlOft; spalte++)
{
System.out.print(spalte + " : hallo ");
}
System.out.println();
}
System.out.println();
printRectangle(6,4);
System.out.println();
printRectangle(5,8);
System.out.println();
for(int nr = 1; nr <= 10; nr++)
{
System.out.println(nr + "! = " + fakultaet(nr));
}
System.out.println();
printFakultaet(11);
System.out.println();
printOneLine(10, '*');
System.out.println();
System.out.println();
printTriangle(7, true);
System.out.println();
printTriangle(7, false);
}
}
while-Schleife
package vorlesungen.vorl1117;
public class Vorlesung1117
{
public static void berechneGGT(final int number1, final int number2)
{
int a = number1;
int b = number2;
if( a < 0 )
{
a = -a;
}
if( b < 0 )
{
b = -b;
}
if( a == 0)
{
System.out.println("ggT(" + number1 +"," + number2 + ") = " + b);
}
else // a != 0
{
if( b == 0)
{
System.out.println("ggT(" + number1 +"," + number2 + ") = " + a);
}
else // a != 0 && b != 0
{
while( a != b )
{
if(a > b)
{
a = a - b;
}
else
{
b = b - a;
}
}
System.out.println("ggT(" + number1 +"," + number2 + ") = " + a);
}
}
}
public static void printCollatz(int number)
{
int n = number;
if( n < 0 )
{
n = -n;
}
while( n > 1 )
{
System.out.print(n + " ");
if(n % 2 == 0)
{
n = n / 2;
}
else
{
n = n * 3 + 1;
}
}
System.out.println("1");
}
public static void main(String[] args)
{
berechneGGT(24, 18);
berechneGGT(-76, 12);
berechneGGT(24, -18);
berechneGGT(-76, 0);
berechneGGT(-76, 76);
printCollatz(27);
System.out.println();
printCollatz(5);
}
}
Klassen und Objekte - Adresse
package vorlesungen.vorl1118;
public class Vorlesung1118
{
public static void main(String[] args)
{
int a = 5;
int b = a;
a = 6;
System.out.println(b); // 5
Adresse campusWH = new Adresse("Wilhelminenhofstr.", 75, 12459, "Berlin" ); // Objekterzeugung
Adresse campusTA = new Adresse("Treskowallee", 8, 10435, "Berlin"); // Objekterzeugung
campusWH.printAdresse();
campusTA.printAdresse();
/*
* geht nicht mehr wegen private
campusWH.strasse = "Wilhelminenhofstr.";
campusWH.hausnummer = 75;
campusWH.ort = "Berlin";
campusWH.postleitzahl = 12459;
String adresseCampusWH = campusWH.getAdresse();
System.out.println(adresseCampusWH);
*/
/*
* geht nicht mehr wegen private
campusTA.strasse = "Treskowallee";
campusTA.hausnummer = 8;
campusTA.ort = "Berlin";
campusTA.postleitzahl = 10435;
System.out.println(campusTA.getAdresse());
*/
}
}
package vorlesungen.vorl1118;
public class Adresse
{
// Objektvariablen
private String strasse;
private int hausnummer;
private int postleitzahl;
private String ort;
// Konstruktor
public Adresse(String str, int nr, int plz, String wohnort)
{
strasse = str;
hausnummer = nr;
postleitzahl = plz;
ort = wohnort;
}
// Objektmethoden
private String getAdresse()
{
return strasse + " " + hausnummer
+ " in " + postleitzahl + " " + ort;
}
public void printAdresse()
{
System.out.println(getAdresse());
}
}
Klassen und Objekte - Point
package vorlesungen.vorl1124;
public class Vorlesung1124
{
public static void main(String[] args)
{
Point p1 = new Point(2,1);
Point p2 = new Point(-1,-2);
/*
p1.setX(3);
p1.setY(4);
*/
System.out.println("x = " + p1.getX());
System.out.println("y = " + p1.getY());
p1.print();
p2.print();
System.out.println();
System.out.println("p1 links von p2 ? " + p1.istLinks(p2));
System.out.println("p2 links von p1 ? " + p2.istLinks(p1));
System.out.println("p1 oberhalb von p2 ? " + p1.istOben(p2));
System.out.println("p2 oberhalb von p1 ? " + p2.istOben(p1));
}
}
package vorlesungen.vorl1124;
public class Point
{
// Objektvariablen
private int x;
private int y;
// Konstruktor
public Point(int pX, int pY)
{
x = pX;
y = pY;
}
/*
public void setX(int neuX)
{
x = neuX;
}
public void setY(int neuY)
{
y = neuY;
}
*/
public int getX()
{
return x;
}
public int getY()
{
return y;
}
public void print()
{
System.out.println("[ x = " + x + ", y = " + y + " ]");
}
public boolean istLinks(Point p)
{
return x < p.x;
}
public boolean istOben(Point p)
{
return y > p.y;
}
}
Klassen und Objekte - this und Person
package vorlesungen.vorl1125;
public class Vorlesung1125
{
public void etwas()
{
int p1 = 3;
int p2 = 4;
}
public static void main(String[] args)
{
Point p1 = new Point(3,4);
Point p2 = new Point(-2, -1);
Point p3 = p1;
p3.setX(5);
p1.print();
p3 = p2;
p2.setX(-3);
p3.print();
System.out.println("p1 links von p2 ? " + p1.istLinks(p2));
Point p4 = new Point(6,7);
Adresse wh = new Adresse("Wilhelminenhofstr.", 75, 12459, "Berlin");
Adresse ta = new Adresse("Treskowallee", 8, 10318, "Berlin");
Person max = new Person("Mustermann", "Max", wh);
Person maria = new Person("Musterfrau", "Maria", ta);
max.print();
maria.print();
Adresse maxAdresse = max.getAdresse();
maxAdresse.strasseUmbenennen("neue Strasse");
max.getAdresse().strasseUmbenennen("neue Strasse");
wh.printAdresse();
}
}
package vorlesungen.vorl1125;
public class Point
{
// Objektvariablen
private int x;
private int y;
// Konstruktor
public Point(int x, int y)
{
this.x = x;
this.y = y;
}
public void setX(int x)
{
this.x = x;
}
public void setY(int y)
{
this.y = y;
}
public int getX()
{
return this.x;
}
public int getY()
{
return this.y;
}
public void print()
{
System.out.println("[ x = " + this.getX() + ", y = " + this.getY() + " ]");
}
public boolean istLinks(Point p)
{
return this.x < p.x;
}
public boolean istOben(Point p)
{
return this.y > p.y;
}
}
package vorlesungen.vorl1125;
public class Adresse
{
// Objektvariablen
private String strasse;
private int hausnummer;
private int postleitzahl;
private String ort;
// Konstruktor
public Adresse(String strasse, int hausnummer, int plz, String wohnort)
{
this.strasse = strasse;
this.hausnummer = hausnummer;
this.postleitzahl = plz;
this.ort = wohnort;
}
// Objektmethoden
private String getAdresse()
{
return this.strasse + " " + this.hausnummer
+ " in " + this.postleitzahl + " " + this.ort;
}
public void printAdresse()
{
System.out.println(this.getAdresse());
}
public void strasseUmbenennen(String neuerStrassenname)
{
this.strasse = neuerStrassenname;
}
}
package vorlesungen.vorl1125;
import vorlesungen.vorl1118.Adresse;
public class Person
{
private String name;
private String vorname;
private Adresse adresse;
public Person(String name, String vorname, Adresse adresse)
{
this.name = name;
this.vorname = vorname;
this.adresse = adresse;
}
public void print()
{
System.out.print(this.vorname + " " + this.name + " wohnt in ");
this.adresse.printAdresse();
}
public Adresse getAdresse()
{
return this.adresse;
}
}
Klassen und Objekte - Circle
package vorlesungen.vorl1201;
public class Programmklasse
{
public static int add(int nr1, int nr2)
{
return nr1 + nr2;
}
public static int add(int nr1, int nr2, int nr3)
{
return nr1 + nr2 + nr3;
}
public static double add(double nr1, double nr2)
{
return nr1 + nr2;
}
public static void main(String[] args)
{
Circle c1 = new Circle(5.0);
Circle c2 = new Circle(2.5);
System.out.println("Radius von c1 : " + c1.getRadius());
System.out.println("Durchmesser von c1 " + c1.getDiameter());
System.out.println("Radius von c2 : " + c2.getRadius());
Circle c4 = c1.setNewCircleWithRadius(6.458);
System.out.println("Radius von c1 : " + c1.getRadius());
System.out.println("Durchmesser von c1 " + c1.getDiameter());
System.out.println("Radius von c4 : " + c4.getRadius());
System.out.println("Durchmesser von c4 " + c4.getDiameter());
c1.print();
c2.print();
System.out.println("PI = " + Math.PI);
System.out.println(MyMath.abs(-1));
Circle c3 = new Circle();
c3.print();
System.out.println(add(3,4));
System.out.println(add(3.0,4.0));
}
}
package vorlesungen.vorl1201;
public class Circle
{
// Objektvariable
private double radius;
// Konstruktor
public Circle(double radius)
{
this.radius = radius;
}
public Circle()
{
this.radius = 1.0;
}
public double getRadius()
{
return this.radius;
}
public double getDiameter()
{
return 2.0 * this.radius;
}
public Circle setNewCircleWithRadius(double radius)
{
return new Circle(radius);
}
public double getCircumference()
{
return Math.PI * this.getDiameter();
}
public double getArea()
{
return Math.PI * this.radius * this.radius;
}
public void print()
{
System.out.printf("%-14s : %7.2f %n", "Radius", this.radius);
System.out.printf("%-14s : %7.2f %n", "Durchmesser", this.getDiameter());
System.out.printf("%-14s : %7.2f %n", "Umfang", this.getCircumference());
System.out.printf("%-14s : %7.2f %n", "Flaecheninhalt", this.getArea());
System.out.println();
}
}
Vererbung - Viereck, Rechteck
package vorlesungen.vorl1202;
import vorlesungen.vorl1201.Circle;
public class Programmklasse
{
public static void main(String[] args)
{
System.out.printf("%n%n------- Circle ------------%n%n");
Circle c1 = new Circle();
Circle c2 = new Circle(2.0);
Circle c3 = new Circle(3.0);
c1.print();
c2.print();
c3.print();
System.out.println("c2 groesser als c1 ? " + c2.isBigger(c1));
System.out.printf("%n%n------- Viereck ------------%n%n");
Viereck v1 = new Viereck(10, 20, 30, 40);
Viereck v2 = new Viereck(15, 20, 25, 30);
// Viereck v1 = new Viereck();
// Viereck v2 = new Viereck();
v1.print();
v2.print();
// System.out.println("Flaecheninhalt des Vierecks : " +
// v1.flaecheninhalt());
Rechteck r1 = new Rechteck(12, 24);
r1.print();
System.out.println("Umfang des Rechtecks : " + r1.umfang());
System.out.println("Flaecheninhalt des Rechtecks : " +
r1.flaecheninhalt());
}
}
package vorlesungen.vorl1202;
public class Viereck
{
protected int a, b, c, d;
public Viereck(int a, int b, int c, int d)
{
this.a = a;
this.b = b;
this.c = c;
this.d = d;
}
public int umfang()
{
return this.a + this.b + this.c + this.d;
}
public void print()
{
System.out.println("a=" + this.a + ", b=" + this.b +
", c=" + this.c + ", d=" + this.d);
System.out.println("Umfang des Vierecks : " + this.umfang());
System.out.println();
}
}
package vorlesungen.vorl1202;
public class Rechteck extends Viereck
{
// private String farbe;
public Rechteck(int laenge, int breite)
{
super(laenge, breite, laenge, breite); // Aufruf des Konstruktors
// von Viereck
// this.farbe = farbe;
}
public int flaecheninhalt()
{
return this.a * this.b;
}
@Override
public void print()
{
System.out.println("a=" + this.a + ", b=" + this.b +
", c=" + this.c + ", d=" + this.d);
System.out.println("Umfang des Rechtecks : " + this.umfang());
System.out.println("Flaecheninhalt des Rechtecks : "
+ this.flaecheninhalt());
System.out.println();
}
}
package vorlesungen.vorl1201;
public class Circle
{
// Objektvariable
private double radius;
// Konstruktor
public Circle(double radius)
{
this.radius = radius;
}
public Circle()
{
this.radius = 1.0;
}
public double getRadius()
{
return this.radius;
}
public double getDiameter()
{
return 2.0 * this.radius;
}
public Circle setNewCircleWithRadius(double radius)
{
return new Circle(radius);
}
public double getCircumference()
{
return Math.PI * this.getDiameter();
}
public double getArea()
{
return Math.PI * this.radius * this.radius;
}
public void print()
{
System.out.printf("%-14s : %7.2f %n", "Radius", this.radius);
System.out.printf("%-14s : %7.2f %n", "Durchmesser", this.getDiameter());
System.out.printf("%-14s : %7.2f %n", "Umfang", this.getCircumference());
System.out.printf("%-14s : %7.2f %n", "Flaecheninhalt", this.getArea());
System.out.println();
}
public boolean isBigger(Circle c)
{
return this.radius > c.radius;
}
public double differenceRadius(Circle c)
{
return this.radius - c.radius;
}
}
Vererbung - Object
package vorlesungen.vorl1208;
public class Programmklasse
{
public static void main(String[] args)
{
System.out.printf("%n%n------- Objekte von Viereck erzeugen ------------%n%n");
Viereck v1 = new Viereck(10,20,30,40);
v1.print();
Viereck v2 = new Viereck(15,20,25,20);
v2.print();
System.out.printf("%n%n------- Objekte von Rechteck erzeugen ------------%n%n");
Rechteck r1 = new Rechteck(10, 20);
r1.print();
Rechteck r2 = new Rechteck(20, 30);
r2.print();
System.out.printf("%n%n------- Objekte von Quadrat erzeugen ------------%n%n");
Quadrat q1 = new Quadrat(25);
q1.print();
System.out.println(q1.umfang());
System.out.println(q1.flaecheninhalt());
System.out.printf("%n%n------- Object ------------%n%n");
//System.out.println(q1.getClass());
Viereck v3 = new Viereck(5,6,7,8);
Viereck v4 = new Rechteck(11, 12);
Viereck v5 = new Quadrat(13);
System.out.println(v3.getClass());
System.out.println(v4.getClass());
System.out.println(v5.getClass());
if(v5 instanceof Quadrat)
{
System.out.println("v5 ist Quadrat");
}
if(v5 instanceof Rechteck)
{
System.out.println("v5 ist Rechteck");
}
if(v5 instanceof Viereck)
{
System.out.println("v5 ist Viereck");
}
if(v5 instanceof Object)
{
System.out.println("v5 ist Object");
}
System.out.println("v4");
if(v4 instanceof Quadrat)
{
System.out.println("v4 ist Quadrat");
}
else
{
System.out.println("v4 ist kein Quadrat");
}
if(v4 instanceof Rechteck)
{
System.out.println("v4 ist Rechteck");
}
if(v4 instanceof Viereck)
{
System.out.println("v4 ist Viereck");
}
if(v4 instanceof Object)
{
System.out.println("v4 ist Object");
}
Rechteck r4 = (Rechteck)v4;
System.out.println(r4.flaecheninhalt());
}
}
package vorlesungen.vorl1208;
public class Viereck
{
protected int a, b, c, d;
public Viereck(int a, int b, int c, int d)
{
this.a = a;
this.b = b;
this.c = c;
this.d = d;
}
public int umfang()
{
return this.a + this.b + this.c + this.d;
}
public void print()
{
System.out.println("a=" + this.a + ", b=" + this.b +
", c=" + this.c + ", d=" + this.d);
System.out.println("Umfang des Vierecks : " + this.umfang());
System.out.println();
}
}
package vorlesungen.vorl1208;
public class Rechteck extends Viereck
{
public Rechteck(int laenge, int breite)
{
super(laenge, breite, laenge, breite); // Aufruf des Konstruktors
// von Viereck
}
public int flaecheninhalt()
{
return this.a * this.b;
}
@Override
public void print()
{
System.out.println("Laenge=" + this.a + ", Breite=" + this.b +
" ( c=" + this.c + ", d=" + this.d +" ) ");
System.out.println("Umfang des Rechtecks : " + this.umfang());
System.out.println("Flaecheninhalt des Rechtecks : "
+ this.flaecheninhalt());
System.out.println();
}
}
package vorlesungen.vorl1208;
public class Quadrat extends Rechteck
{
public Quadrat(int seite)
{
super(seite, seite);
}
@Override
public void print()
{
System.out.println("Seitenlaenge : " + this.a
+ " ("+ this.b + ", " + this.c + ", " + this.d + ")");
System.out.println("Umfang des Quadrates : " + this.umfang());
System.out.println("Flaecheninhalt des Quadrates : " + this.flaecheninhalt());
System.out.println();
}
}
toString() und equals()
package vorlesungen.vorl1209;
public class Programmklasse
{
public static void main(String[] args)
{
System.out.printf("%n%n------- Objekte von Viereck erzeugen ------------%n%n");
Viereck v1 = new Viereck(10,20,30,40);
v1.print();
Viereck v2 = new Viereck(10,20,30,40);
v2.print();
Object o1 = new Viereck(11, 12, 13, 14);
Object o2 = o1;
System.out.println(o1.toString());
System.out.println(o1);
Viereck v5 = (Viereck)o1;
System.out.println(v1.toString());
System.out.println(v2.toString());
System.out.println(v1); // v1.toString()
System.out.println(v2); // v2.toString()
System.out.println(5);
System.out.println(5.5);
System.out.println("v1 == v2 ? " + (v1 == v2)); // false
System.out.println("v1.equals(v2) ? " + v1.equals(v2));
Viereck v3 = v1;
System.out.println("v1 == v3 ? " + (v1 == v3));
System.out.println("v5 == o1 ? " + (v5 == o1));
}
}
package vorlesungen.vorl1209;
public class Viereck
{
protected int a, b, c, d;
public Viereck(int a, int b, int c, int d)
{
this.a = a;
this.b = b;
this.c = c;
this.d = d;
}
public int umfang()
{
return this.a + this.b + this.c + this.d;
}
public void print()
{
System.out.println("a=" + this.a + ", b=" + this.b +
", c=" + this.c + ", d=" + this.d);
System.out.println("Umfang des Vierecks : " + this.umfang());
System.out.println();
}
@Override
public String toString()
{
return "[ a=" + this.a + ", b=" + this.b + ", c="
+ this.c + ", d=" + this.d + " ]";
}
@Override
public boolean equals(Object o)
{
if(o == null) return false;
if(this == o) return true;
if(this.getClass() != o.getClass()) return false;
// o ist vom Typ Viereck
// jetzt der eigentliche Vergleich
Viereck other = (Viereck)o;
return this.a == other.a &&
this.b == other.b &&
this.c == other.c &&
this.d == other.d;
}
}
Code aus Tutorium¶
FilledRhombus
package tutorium.tutorium1124;
public class Tutorium1124
{
public static void printNSpaces(int n)
{
for(int i = 0; i < n; i++)
{
System.out.print(" ");
}
}
public static void printNStars(int n)
{
for(int i = 0; i < n; i++)
{
System.out.print("*");
}
}
public static void printPyramid(int upperHalf)
{
for(int row = 0; row < upperHalf; row++)
{
printNSpaces(upperHalf - row);
printNStars(2*row + 1);
System.out.println();
}
}
public static void printLowerHalf(int lowerHalf)
{
for(int row = lowerHalf - 1; row >= 0; row-- )
{
printNSpaces(lowerHalf - row);
printNStars(2 * row + 1);
System.out.println();
}
}
public static void printMiddleLine(int upperHalf)
{
printNStars(2 * upperHalf + 1);
System.out.println();
}
public static void printFilledRhombus(int upperHalf)
{
printPyramid(upperHalf);
printMiddleLine(upperHalf);
printLowerHalf(upperHalf);
}
public static void main(String[] args)
{
printPyramid(5);
System.out.println();
printPyramid(11);
System.out.println();
printPyramid(1);
System.out.println();
int upperHalf = 5;
for(int row = 1; row <= upperHalf; row++)
{
printNSpaces(row);
printNStars(2 * (upperHalf - row) + 1);
System.out.println();
}
System.out.println();
printFilledRhombus(5);
System.out.println();
printFilledRhombus(11);
System.out.println();
printFilledRhombus(1);
System.out.println();
}
}
FilledRhombus und UnfilledRhombus
package tutorium.tutorium1124;
public class Tutorium1124
{
public static void printNSpaces(int n)
{
for(int i = 0; i < n; i++)
{
System.out.print(" ");
}
}
public static void printNStarsFilled(int n)
{
for(int i = 0; i < n; i++)
{
System.out.print("*");
}
}
public static void printNStarsUnfilled(int n)
{
if(n==1)
{
System.out.print("*");
}
else
{
System.out.print("*");
for(int i = 0; i < n-2; i++)
{
System.out.print(" ");
}
System.out.print("*");
}
}
public static void printUpperHalfFilled(int upperHalf)
{
for(int row = 0; row < upperHalf; row++)
{
printNSpaces(upperHalf - row);
printNStarsFilled(2*row + 1);
System.out.println();
}
}
public static void printUpperHalfUnfilled(int upperHalf)
{
for(int row = 0; row < upperHalf; row++)
{
printNSpaces(upperHalf - row);
printNStarsUnfilled(2*row + 1);
System.out.println();
}
}
public static void printLowerHalfFilled(int lowerHalf)
{
for(int row = lowerHalf - 1; row >= 0; row-- )
{
printNSpaces(lowerHalf - row);
printNStarsFilled(2 * row + 1);
System.out.println();
}
}
public static void printLowerHalfUnfilled(int lowerHalf)
{
for(int row = lowerHalf - 1; row >= 0; row-- )
{
printNSpaces(lowerHalf - row);
printNStarsUnfilled(2 * row + 1);
System.out.println();
}
}
public static void printMiddleLineFilled(int upperHalf)
{
printNStarsFilled(2 * upperHalf + 1);
System.out.println();
}
public static void printMiddleLineUnfilled(int upperHalf)
{
printNStarsUnfilled(2 * upperHalf + 1);
System.out.println();
}
public static void printFilledRhombus(int upperHalf)
{
printUpperHalfFilled(upperHalf);
printMiddleLineFilled(upperHalf);
printLowerHalfFilled(upperHalf);
}
public static void printUnfilledRhombus(int upperHalf)
{
printUpperHalfUnfilled(upperHalf);
printMiddleLineUnfilled(upperHalf);
printLowerHalfUnfilled(upperHalf);
}
public static void main(String[] args)
{
printFilledRhombus(5);
System.out.println();
printFilledRhombus(11);
System.out.println();
printFilledRhombus(1);
System.out.println();
printUnfilledRhombus(5);
System.out.println();
printUnfilledRhombus(11);
System.out.println();
printUnfilledRhombus(1);
System.out.println();
}
}
Selektion und Iteration
package tutorium.tutorium1201;
public class Tutorium1201
{
public static void printNChars(int n, char c)
{
for(int i = 0; i < n; i++)
{
System.out.print(c);
}
System.out.println();
}
public static void main(String[] args)
{
int a = 5;
for(int b = 4; b <= 6; b++)
{
if(a < b)
{
// wenn die Bedingung (a < b) true
System.out.println(a + " ist kleiner als " + b);
}
else // nicht a < b
{
if(a > b)
{
// wenn die Beding false ist
System.out.println(a + " ist groesser als " + b);
}
else
{
System.out.println(a + " ist gleich " + b);
}
}
}
for(int i = 0; i < 5; i++)
{
System.out.println("i = " + i);
}
for(int i = 1; i <= 10; i++)
{
printNChars(i, '+');
}
for(int i = 1; i <= 5; i++)
{
System.out.print(" i = " + i + " : ");
for(int j = 0; j < i; j++)
{
System.out.print("[ j = " + j + " ] ");
}
System.out.println();
}
}
}
while und Referenzen
package tutorium.tutorium1208;
public class Tutorium1208
{
public static int lengthOfNumber(int number)
{
int merkeZahl = number;
if(merkeZahl < 0)
{
merkeZahl = -merkeZahl;
}
if(merkeZahl==0)
{
return 1;
}
int counter = 0;
while(merkeZahl > 0)
{
merkeZahl = merkeZahl/10;
counter++;
}
return counter;
}
public static void main(String[] args)
{
int number = 0;
System.out.println(lengthOfNumber(number));
Circle c1 = new Circle(5.0);
c1.print();
Circle c2 = c1.changeRadius(-1.5);
c1.print();
c2.print();
Circle c3 = c1;
c3.print();
int i = 1;
int i1 = 0;
i1 = changeI(i);
System.out.println("i = " + i);
System.out.println("i1 = " + i1);
O o1 = new O(1);
o1.print(); // i = 1
o1.changeI(0);
o1.print(); // i = 0
O o2 = o1;
o2.print(); // i = 0
}
public static int changeI(int i)
{
i++;
int i1 = i;
return i1;
}
}
package tutorium.tutorium1208;
public class Circle
{
private double radius;
public Circle(double radius)
{
this.radius = radius;
}
public Circle changeRadius(double diffRadius)
{
double newRadius = this.radius + diffRadius;
return new Circle(newRadius);
}
public void print()
{
System.out.println("Radius = " + this.radius);
}
}
Hinweise zur Klausur¶
- Es stehen immer ein Mac-Labor (z.B. 624) und ein Windows-Labor (z.B. 625) zur Verfügung.
- Wenn die Klausur auf 9:45 Uhr angesetzt ist, werden die Aufgabenblätter ca. 9:35 Uhr ausgeteilt, so dass um ca. 9:40 Uhr mit dem Programmieren begonnen werden kann. Seien Sie am besten spätestens eine halbe Stunde vor dem offiziellen Beginn in dem Labor Ihrer Wahl.
- Sie können sich vorab schon ein Package
klausurerstellen und darin eineProgrammklassemitmain-Methode. Probieren Sie auch schonmal mindestens eine Ausgabe auf die Konsole, damit Sie wissen, ob alles funktioniert. - Sie können sich in Ihren Workspace gerne allen Ihren Code importieren, den Sie im Laufe des Semesters erzeugt haben (üben Sie den Import dann am besten vorher - Sie können sich nicht sicher sein, dass Sie an dem Rechner die Klausur schreiben können, an dem Sie den Import geübt haben).
- Sie dürfen beliebig viele selbstbeschriebene Seiten mit in die Klausur bringen.
- Es ist nicht gestattet:
- den eigenen Rechner zu verwenden (gar nicht mitbringen oder auspacken)
- das Handy zu verwenden (gar nicht mitbringen oder auspacken)
- im Web zu browsen
- Kommunikation mit anderen oder mit KI-Tools
- Wichtig!
- Mit Teilnahme an der Klausur gestatten Sie uns, nachträglich die Access-Logs der Rechner im Labor zu überprüfen!
- Bereits geöffnete Programme oder Tabs (selbst, wenn Sie unbenutzt sind), die eine Kommunikation mit anderen (z.B. E-Mail, Chats, KI, ...) ermöglichen, führen zum Ausschluss aus der Klausur.
- Sollte sich herausstellen, dass 2 Labore nicht genügen, weichen wir auf ein drittes Labor aus (Windows). Deswegen ist es wichtig, dass Sie spätestens eine halbe Stunde vor Beginn vor Ort sind.
- Bitte beachten Sie auch, dass wir nicht beim Hochladen der Lösung in Moodle unterstützen können. Das haben Sie für die Aufgaben genügend geübt. Wichtig ist, dass Sie wissen, wo Ihr workspace auf dem Rechner ist, damit Sie von dort aus hochladen können.