Sitzung: Jeden Freitag in der Vorlesungszeit ab 16 Uhr c. t. im MAR 0.005. In der vorlesungsfreien Zeit unregelmäßig (Jemensch da?). Macht mit!

Javakurs2006/Uebungsaufgaben: Unterschied zwischen den Versionen

(Punkt mit Polarkoordinaten)
 
(54 dazwischenliegende Versionen von 8 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
= Variablen =
+
Weitere Wiederholungsaufgaben gibt es [http://www.javaranch.com/cattledrive.jsp|bei der Java Ranch]
== Variablendeklaration und Initialisierung ==
+
 
 +
== Variablen ==
 +
* Das gleiche Thema im Buch [http://www.galileocomputing.de/openbook/javainsel5/javainsel02_002.htm#Rxx747java02002040000A91F032100 Java ist auch eine Insel]
 +
=== Variablendeklaration und Initialisierung ===
 
  <nowiki>
 
  <nowiki>
 
class Beispiel {
 
class Beispiel {
Zeile 30: Zeile 33:
 
Erkläre deine Meinung einem Tutor.
 
Erkläre deine Meinung einem Tutor.
  
== Selber Deklarationen und Definitionen durchführen ==
+
=== Selber Deklarationen und Definitionen durchführen ===
 
  <nowiki>
 
  <nowiki>
 
class Beispiel {
 
class Beispiel {
Zeile 41: Zeile 44:
 
// addiere fünf zu dem Wert
 
// addiere fünf zu dem Wert
  
// System.out.println("7 erwartet: " + birnen);
+
// System.out.println("8 erwartet: " + birnen);
 
// deklariere eine Variable "aepfel" und weise ihr den Wert fünf zu
 
// deklariere eine Variable "aepfel" und weise ihr den Wert fünf zu
  
Zeile 54: Zeile 57:
 
</nowiki>
 
</nowiki>
  
 
+
=== Zuweisung an Variablen ===
== Zuweisung an Variablen ==
 
 
  <nowiki>
 
  <nowiki>
 
class Beispiel {
 
class Beispiel {
Zeile 71: Zeile 73:
 
</nowiki>
 
</nowiki>
  
Überlege dir was dieses Code-Fragment ausgeben würde.
+
Überlege dir, was dieses Code-Fragment ausgeben würde.
Führe es aus und vergleiche die Resultate. (Kopiere den Beispiel-Code in eine Datei, Kompiliere sie und füre sie aus)
+
Führe es aus und vergleiche die Resultate: Kopiere hierfür den Beispiel-Code in eine Datei, kompiliere sie und führe sie aus.
 
* Was sind die Unterschiede?
 
* Was sind die Unterschiede?
 
* Warum?
 
* Warum?
Erkläre einem Tutor zu welchem Schluss du gekommen bist und frage ihn ob du Recht hast.
+
Erkläre einem Tutor, zu welchem Schluss du gekommen bist und frage ihn, ob du Recht hast.
  
== Variablen ändern ihre Werte ==
+
=== Variablen ändern ihre Werte ===
 
  <nowiki>
 
  <nowiki>
 
class Test {
 
class Test {
Zeile 97: Zeile 99:
 
</nowiki>
 
</nowiki>
  
Überlege dir was dieser Code ausgeben würde.
+
Überlege dir, was dieser Code ausgeben würde.
 
Schreibe ihn in eine Datei, kompiliere ihn und führe ihn aus.
 
Schreibe ihn in eine Datei, kompiliere ihn und führe ihn aus.
 
* Was gibt er tatsächlich aus?
 
* Was gibt er tatsächlich aus?
* Gibt es unterschiede?
+
* Gibt es Unterschiede?
  
== Formatierung ==
+
=== Formatierung und Namen ===
Wieso haben wir das Beispiel  nach den geschweiften Klammern eingerückt und die Variablen so gestellt wie wir es gestellt haben und nicht so:
+
Wieso haben wir die Code-Beispiele nach den geschweiften Klammern eingerückt und die Variablen so benannt, wie wir es taten und nicht so:
 
  <nowiki>
 
  <nowiki>
 
class _{static long _
 
class _{static long _
Zeile 111: Zeile 113:
 
-1,_(__, ___-1)) ;  }
 
-1,_(__, ___-1)) ;  }
 
static  {int _=2 ,___
 
static  {int _=2 ,___
= 2;System.out.print(
+
== 2;System.out.print(
 
"a("+_+’,’+___+ ")="+
 
"a("+_+’,’+___+ ")="+
 
_ (_,  ___) ) ;System
 
_ (_,  ___) ) ;System
Zeile 150: Zeile 152:
 
Nenne mindestens einen Grund und erkläre ihn deinem Tutor.
 
Nenne mindestens einen Grund und erkläre ihn deinem Tutor.
  
== Variablen mit verschiedenen Typen zuweisen ==
+
=== Variablen mit verschiedenen Typen zuweisen ===
 
  <nowiki>
 
  <nowiki>
 
class Test {
 
class Test {
Zeile 159: Zeile 161:
 
</nowiki>
 
</nowiki>
  
= if =
+
== if ==
== Einfache if-Bedingung ==
+
=== Einfache if-Bedingung ===
Überlege dir was das folgende Code-Fragment macht.
+
Überlege dir, was das folgende Code-Fragment macht.
 
Führe es aus und vergleiche mit deinen Erwartungen.  
 
Führe es aus und vergleiche mit deinen Erwartungen.  
  
(Kopiere den Beispiel-Code in eine Datei, Kompiliere sie und füre sie aus)
+
(Kopiere den Beispiel-Code in eine Datei, kompiliere sie und führe sie aus)
 
* Was sind die Unterschiede?
 
* Was sind die Unterschiede?
 
* Warum?
 
* Warum?
Erkläre einem Tutor zu welchem Schluss du gekommen bist und frage ihn ob du Recht hast.
+
Erkläre einem Tutor, zu welchem Schluss du gekommen bist und frage ihn, ob du Recht hast.
 
  <nowiki>
 
  <nowiki>
 
public class If_Uebung1 {
 
public class If_Uebung1 {
Zeile 178: Zeile 180:
  
 
         /*  
 
         /*  
         * wir erzeugen uns hier eine Zufallszahl im
+
         * Wir erzeugen uns hier eine Zufallszahl im
 
         * Bereich 1-6. Warum funktioniert das so?
 
         * Bereich 1-6. Warum funktioniert das so?
 
         * Math.random ist eine statische Funktion im  
 
         * Math.random ist eine statische Funktion im  
         * Math-Paket, dass und eine double-Zahl, die kleiner
+
         * Math-Paket, die uns eine double-Zahl kleiner
         * als 1.0 aber groesser oder gleich 0 ist.
+
         * als 1.0, aber groesser oder gleich 0 liefert.
         * Mit 6 multipliziert und um eins erhöht erhalten wir
+
         * Mit 6 multipliziert und um Eins erhöht erhalten wir
 
         * Zahlen von 1.0 bis 6.99999...
 
         * Zahlen von 1.0 bis 6.99999...
 
         * Durch das Umwandeln in int werden die Nachkommastellen abgeschnitten
 
         * Durch das Umwandeln in int werden die Nachkommastellen abgeschnitten
Zeile 208: Zeile 210:
 
  </nowiki>
 
  </nowiki>
  
== if-else-Konstrukt ==
+
=== if-else-Konstrukt ===
Überlege dir was das folgende Code-Fragment macht.
+
Überlege dir, was das folgende Code-Fragment macht.
 
Führe es aus und vergleiche mit deinen Erwartungen.  
 
Führe es aus und vergleiche mit deinen Erwartungen.  
  
(Kopiere den Beispiel-Code in eine Datei, Kompiliere sie und füre sie aus)
+
(Kopiere den Beispiel-Code in eine Datei, kompiliere sie und führe sie aus)
 
* Was sind die Unterschiede?
 
* Was sind die Unterschiede?
 
* Warum?
 
* Warum?
Erkläre einem Tutor zu welchem Schluss du gekommen bist und frage ihn ob du Recht hast.
+
Erkläre einem Tutor, zu welchem Schluss du gekommen bist und frage ihn, ob du Recht hast.
  
 
  <nowiki>
 
  <nowiki>
Zeile 233: Zeile 235:
 
  </nowiki>
 
  </nowiki>
  
== Mehrere if-Bedingungen ==
+
=== Mehrere if-Bedingungen ===
Überlege dir was das folgende Code-Fragment macht.
+
Überlege dir, was das folgende Code-Fragment macht.
 
Führe es aus und vergleiche mit deinen Erwartungen.  
 
Führe es aus und vergleiche mit deinen Erwartungen.  
  
(Kopiere den Beispiel-Code in eine Datei, Kompiliere sie und füre sie aus)
+
(Kopiere den Beispiel-Code in eine Datei, kompiliere sie und führe sie aus)
* Was sind die Unterschiede?
+
 
* Warum?
+
Was macht das Programm für verschiedene Werte von ''wert''?.  
Erkläre einem Tutor zu welchem Schluss du gekommen bist und frage ihn ob du Recht hast.
 
  
 +
Welche If-Abfragen sind unnötig, weil man die Ausgaben in else-Zweige von bereits vorhandenen schreiben könnte?
 
  <nowiki>
 
  <nowiki>
public class If_Uebung3 {
+
public class If_Uebung3 {  
 
 
    /*
 
    * Eure Aufgabe:
 
    * Schaut Euch das Programm an und überlegt, was fuer verschiedene
 
    * Werte passiert.
 
    * Welche If-Abfragen sind unnötig, weil man die Ausgaben in else-Zweige von
 
    * bereits vorhandenen schreiben könnte?
 
    */
 
   
 
 
     public static void main(String[] args) {
 
     public static void main(String[] args) {
 
          
 
          
Zeile 284: Zeile 277:
 
  </nowiki>
 
  </nowiki>
  
= for =
+
== while ==
== for-Schleifen zum Zählen ==
+
=== Einfache Schleife ===
 +
Schreibe eine Schleife die unendlich oft "Hallo Welt!" ausgibt.
 +
 
 +
=== Begrenzte Schleifen ===
 +
* Schreibe eine for-Schleife, die 10 mal "Hallo Welt!!" ausgibt.
 +
* Verändere diese Schleife, so dass sie abwechselnd "Hallo Welt!" und "Ich bin im Javakurs!" ausgibt
 +
** Es gibt zwei Möglichkeiten das zu realisieren - finde die andere.
 +
 
 +
=== einfache while-Schleife ===
 +
Überlege dir, was das folgende Code-Fragment macht. Welche Zahlen werden ausgegeben?
 +
Führe es aus und vergleiche mit deinen Erwartungen.
 +
 
 +
(Kopiere den Beispiel-Code in eine Datei, kompiliere sie und führe sie aus)
 +
 
 +
<nowiki>
 +
public class While_Uebung1 {
 +
 
 +
    public static void main(String[] args) {
 +
 
 +
        int x=10;
 +
        while (x>0){
 +
            System.out.println(" x=" + x);  // Anhaengen von x an den String
 +
            x=x-1;
 +
        }
 +
    }
 +
}
 +
</nowiki>
 +
 
 +
== for ==
 +
=== for-Schleifen zum Zählen ===
 +
Überlege dir, was das folgende Code-Fragment macht. Welche Zahlen werden ausgegeben?
 +
Führe es aus und vergleiche mit deinen Erwartungen.
 +
 
 +
(Kopiere den Beispiel-Code in eine Datei, kompiliere sie und führe sie aus)
 +
 
 +
 
 
  <nowiki>
 
  <nowiki>
 
public class For_Uebung1 {
 
public class For_Uebung1 {
    /*
 
    * Eure Aufgabe:
 
    *  Schaut Euch dieses Programm an und überlegt, welche Zahlen
 
    *  es ausgeben wird.
 
    *  Anschliessend kompiliert das Programm, führt es aus und überprüft
 
    *  Eure Vermutungen.
 
    * 
 
    */
 
 
 
     public static void main(String[] args) {
 
     public static void main(String[] args) {
  
Zeile 306: Zeile 325:
  
 
         System.out.println("zweite for Schleife:");
 
         System.out.println("zweite for Schleife:");
         for (int i = 1; i <= 10; i = i + 2) {
+
         for (int i = 1; i <== 10; i = i + 2) {
 
             System.out.print(" " + i);
 
             System.out.print(" " + i);
 
         }
 
         }
Zeile 312: Zeile 331:
  
 
         System.out.println("dritte for Schleife:");
 
         System.out.println("dritte for Schleife:");
         for (int i = 1; i <= 10; i = i * 2) {
+
         for (int i = 1; i <== 10; i = i * 2) {
 
             System.out.print(" " + i);
 
             System.out.print(" " + i);
 
         }
 
         }
Zeile 322: Zeile 341:
 
  </nowiki>
 
  </nowiki>
  
== for-Schleife und if-Bedingung ==
+
=== for-Schleife und if-Bedingung ===
 
  <nowiki>
 
  <nowiki>
 
public class ForIf_Uebung {
 
public class ForIf_Uebung {
Zeile 338: Zeile 357:
 
  </nowiki>
 
  </nowiki>
  
= while =
+
== Methoden ==
== einfache while-Schleife ==
+
=== Argumente ===
 
  <nowiki>
 
  <nowiki>
 +
class Beispiel {
 +
public static void main(String [] ignored) {
 +
ausgabe(1, "Martin");
 +
ausgabe("Arthur", 2);
 +
ausgabe(3, "Florian");
 +
ausgabe("Robert", 4);
 +
}
  
public class While_Uebung1 {
+
static void ausgabe(int i, String string) {
 +
System.out.println(i + ": " + string);
 +
}
 +
}
 +
</nowiki>
  
    public static void main(String[] args) {
+
* Überlege was dieses Beispiel ausgibt.
 +
* Probiere es aus und erkläre den Unterschied. (Wenn Fehler auftreten, erkläre wieso)
 +
* Erkläre das einem Tutor
  
        int x=10;
+
=== Was tut das? ===
        while (x>0){
+
Überlege dir, was das folgenden Code-Fragmente machen. Welche Zahlen werden ausgegeben?
            System.out.println(" x=" + x);  // Anhaengen von x an den String
+
Führe sie aus und vergleiche mit deinen Erwartungen.
            x=x-1;
 
        }
 
    }
 
}
 
</nowiki>
 
  
= Methoden =
+
(Kopiere den Beispiel-Code in eine Datei, kompiliere sie und führe sie aus)
== Was tut das? ==
 
  
 +
<nowiki>
 
//file: Methoden1.java
 
//file: Methoden1.java
 
class Methoden1 {
 
class Methoden1 {
Zeile 368: Zeile 395:
 
     }
 
     }
 
}
 
}
 +
  
 
//file: Methoden2.java
 
//file: Methoden2.java
Zeile 379: Zeile 407:
 
     }
 
     }
 
}
 
}
 +
  
 
//file: Methoden3.java
 
//file: Methoden3.java
Zeile 407: Zeile 436:
 
     }
 
     }
 
}
 
}
 +
</nowiki>
  
== Tue selbst etwas! ==
+
=== Selbst einige Methoden schreiben! ===
 +
Im Folgenden wollen wir einige (mathematische)-Methoden programmieren.
  
Die folgende Aufgabe ist eine Schritt-für-Schritt Anleitung. Sie soll euch die Möglickeit geben einmal genau angeleitet zu sehen, wie man an eine Aufgabe herangehen könnte.
+
* Lege eine neue Klasse "MatheAufgabe" an.
 +
* Füge eine <code>public static void main(String[] arguments)</code> Methode hinzu.
 +
* Deklariere innerhalb der <code>main</code>-Methode eine <code>double</code>-Variable.
 +
* Belege diese Variable dem Wert <code>5/3</code> und gib den Inhalt der Variable auf dem Bildschirm aus.
 +
* Schreibe nun eine Methode <code>public static double add(double x, double y)</code>, die die Summe der beiden übergebenen Zahlen <code>x</code> und <code>y</code> zurückgibt.
 +
** Teste deine Methode mit verschiedenen Eingaben wie z.B.
 +
<nowiki>
 +
System.out.println(" 1.0 + 2.0 = " + add ( 1.0 , 2.0 ) );
 +
double x = 5.0;
 +
System.out.println( " " + x + " + 2.0 = " + add ( x , 2.0) );
 +
System.out.println( " 2.0 + " + x + " = " + add ( 2.0 , x) );
 +
x = add ( x , 2.0);
 +
System.out.println( x);
 +
</nowiki>
 +
* Schreibe nun eine Methode <code>sub</code>, welche die Differenz zweier übergebener Werte zurückgibt.
 +
** Teste deine Methode wie eben!
 +
** Überprüfe, ob x == (x - y ) + y gilt! (natürlich mit deinen <code>sub</code> und <code>add</code>-Modthoden)
 +
* Schreibe nun eine <code>mul</code>-Methode.
 +
** Benutze dazu nicht den operator *. Rufe statt dessen deine add-Methode auf.
 +
** Teste deine Methode wie eben!
 +
* Schreibe nun eine <code>public static double pow ( double basis, int exponent)</code>, die <code>basis</code> hoch <code>exponent</code> zurückgibt. <code>pow(2,3)</code> wurde z.B. 2^3=8 zurückgeben.
 +
** Benutze auch hier weder *, noch Math.pow(). Nutze statt dessen deine gerade geschriebene mul-Methode.
 +
** Teste deine Methode wie gehabt!
 +
**: Was liefert deine Methode wenn der Exponent 0 ist?
 +
**: Was liefert deine Methode wenn der Exponent negativ ist?
  
Zuerst stellen wir einen denkbaren Aufgabentext vor, der später ausreichen müsste um selbst ein Programm zu schreiben.
+
== Arrays (eindimensional und n-dimensional) ==
 
+
=== Eindimensionale Arrays ===
Aufgabe: Erstelle ein Modul, das die mathematischen Operationen Addition, Subtraktion, und Potenzieren jeweils in einer Methode anbieten. Probiere deine Methoden in der main-Methode aus.
 
 
 
//TODO: Schritt für Schritt Anleitung, wie, in welcher Reihenfolge und wo genau welche Methode implementiert werden soll. Voraussetzung: Verständnis von Schleifen. Rudimentäres Verständnis von Methoden.
 
 
 
= Arrays (eindimensional und n-dimensional) =
 
== Eindimensionale Arrays ==
 
 
Folgendes Array-Konstrukt wird initialisiert
 
Folgendes Array-Konstrukt wird initialisiert
 
  <nowiki>
 
  <nowiki>
Zeile 470: Zeile 519:
  
  
== Zweidimensionale Arrays ==
+
=== Zweidimensionale Arrays ===
 
Folgendes Array-Konstrukt wird initialisiert
 
Folgendes Array-Konstrukt wird initialisiert
 
  <nowiki>
 
  <nowiki>
Zeile 491: Zeile 540:
  
  
== Dreidimensionale Arrays ==
+
=== Dreidimensionale Arrays ===
 
Folgendes Array-Konstrukt wird initialisiert
 
Folgendes Array-Konstrukt wird initialisiert
 
  <nowiki>
 
  <nowiki>
Zeile 518: Zeile 567:
  
  
= Klassen =
+
[[Kategorie:Java]]
 
+
[[Kategorie:Java_Aufgaben]]
== einfache Datenklasse ==
 
 
 
manchmal braucht man neue Datentypen, zum Beispiel um eine Farbe oder einen Punkt abzuspeichern und
 
damit arbeiten zu können.
 
 
 
Die kann dann wie folgt aussehen:
 
 
 
=== eine Punktklasse ===
 
<nowiki>
 
class Punkt{
 
int x;
 
int y;
 
}
 
</nowiki>
 
 
 
=== eine Farbenklasse ===
 
<nowiki>
 
class Farbe{
 
double rotanteil;
 
double gruenanteil;
 
double blauanteil;
 
}
 
</nowiki>
 
 
 
 
 
Diese beiden Klassen kann man so schon tatsächlich verwenden. Allerdings sind sie alles andere
 
als Objektorientiert. Sie sind simple Datencontainer und wenn man sie verwenden will muss man alles über ihren
 
internen Aufbau wissen, wie folgendes Programm zeigt:
 
 
 
 
 
<nowiki>
 
class PundF{
 
 
 
    public static void main(String[] args){
 
   
 
        Farbe farbe1 = new Farbe();
 
 
 
        farbe1.rotanteil = 0.5;
 
        farbe1.blauanteil = 0.5;
 
        farbe1.gruenanteil = 0.5;
 
 
 
        Punkt p = new Punkt();
 
 
 
        p.x=123;
 
        p.y=321;
 
    }
 
 
 
}
 
</nowiki>
 
 
 
 
 
Das ist nicht sehr praktisch, weil man sich vorstellen kann, dass man die implementierung,
 
also den internen Aufbau z.B. des Punktes, ändern muss. Vielleicht verwendet man statt der
 
kartesischen Koordinaten nun Polarkoordinaten, oder man muss die Farben in einem anderen
 
Farbraum speichern.
 
 
 
 
 
Damit jemand, der diese Klassen benutzt, sich nicht darum kuemmern braucht, wie die Daten intern gespeichert werden,
 
benutzt man zum Zugriff auf die Daten sogenannte getter und setter Methoden:
 
 
 
 
 
 
 
=== getter und setter ===
 
 
 
Man kann die Punktklasse nun wie folgt erweitern:
 
 
 
<nowiki>
 
class Punkt{
 
  private int x;
 
  private int y;
 
 
 
  public int getX(){
 
    return this.x;
 
  }
 
  public int getY(){
 
    return this.y;
 
  }
 
 
 
  public void setX(int arg){
 
    this.x = arg;
 
  }
 
  public void setY(int arg){
 
    this.y = arg;
 
  }
 
 
 
}
 
</nowiki>
 
 
 
Huch - was soll denn dieses ganze private und public ploetzlich?!
 
 
 
Eigentlich ist das relativ einfach. Die Daten haben wir private deklariert, dass heisst wir dürfen nur
 
noch innerhalb unserer Klasse darauf zugreifen. Damit wird verhindert, dass jemand von aussen versucht
 
direkt auf die x-Koordinate zuzugreifen, die ja vielleicht irgendwann gar nicht mehr direkt vorhanden ist,
 
wenn wir Polarkoordinaten verwenden:
 
 
 
 
 
=== Punkt mit Polarkoordinaten ===
 
 
 
<nowiki>
 
class Punkt{
 
  private double length;
 
  private double angle;
 
 
 
  public int getX(){
 
    return ...
 
  }
 
  public int getY(){
 
    return ...
 
  }
 
 
 
  public void setX(int arg){
 
    this.length = ...
 
  }
 
  public void setY(int arg){
 
    this.angle = ...
 
  }
 
 
 
}
 
</nowiki>
 
 
 
 
 
Der Vorteil: Alle anderen Programmteile und Klassen koennen wie bisher mit Hilfe der Getter und Setter
 
an die X und Y-Koordinaten kommen, obwohl intern nur Polarkoordinaten vorliegen. Dieses Beispiel
 
ist nicht vollständig, die Mathematik wurde absichtlich weggelassen um Verwirrung zu verhindern ;)
 
[Ausserdem braucht man fuer die Überführung in Polarkoordinaten immer x und y Werte, hat den Sonderfall,
 
dass x nicht 0 sein darf, etc...]
 

Aktuelle Version vom 26. Oktober 2012, 15:15 Uhr

Weitere Wiederholungsaufgaben gibt es der Java Ranch

Variablen

Variablendeklaration und Initialisierung

class Beispiel {
	public static void main(String [] ignored) {
		int aWholeNumber;
		double notAWholeNumber;
		String aString;

		aWholeNumber = 0;
		notAWholeNumber = 0.0;
		aString = "";
		System.out.println(aWholeNumber);
		System.out.println(notAWholeNumber);
		System.out.println(aString);

		int anotherWholeNumber = 0;
		double anotherNotSoWholeNumber = 0;
		String anotherString = "";
		System.out.println(anotherWholeNumber);
		System.out.println(anotherNotSoWholeNumber);
		System.out.println(anotherString);
	}
}

  • An welcher Stelle im Programm wird die Variable aWholeNumber definiert?
  • An welcher Stelle im Programm wird die Variable aWholeNumber initialisiert?

Beantworte diese Fragen auch für die Variablen: notAWholeNumber, aString, anotherWholeNumber, anotherNotSoWholeNumber, anotherString

Erkläre deine Meinung einem Tutor.

Selber Deklarationen und Definitionen durchführen

class Beispiel {
	public static void main(String [] ignored) {
		// deklariere eine Variable "birnen"  vom Typ int
		
		// weise ihr den Wert drei zu

//		System.out.println("3 erwartet: " + birnen);
		// addiere fünf zu dem Wert

//		System.out.println("8 erwartet: " + birnen);
		// deklariere eine Variable "aepfel" und weise ihr den Wert fünf zu

//		System.out.println("5 erwartet: " + aepfel);
		// subtrahiere zwei von dem Wert

//		System.out.println("3 erwartet: " + aepfel);

		
	}
}

Zuweisung an Variablen

class Beispiel {
	public static void main(String [] ignored) {
		System.out.println(0);
		int zero = 0;
		System.out.println(zero);
		int one = 1;
		int whatsThis = zero;
		System.out.println(whatsThis);
		whatsThis = one;
		System.out.println(whatsThis);
	}
}

Überlege dir, was dieses Code-Fragment ausgeben würde. Führe es aus und vergleiche die Resultate: Kopiere hierfür den Beispiel-Code in eine Datei, kompiliere sie und führe sie aus.

  • Was sind die Unterschiede?
  • Warum?

Erkläre einem Tutor, zu welchem Schluss du gekommen bist und frage ihn, ob du Recht hast.

Variablen ändern ihre Werte

class Test {
	public static void main(String [] ignored) {
		int number = 1;
		System.out.println(number);
		number = 1;
		System.out.println(number);
		number = 2;
		System.out.println(number);
		number = 3;
		System.out.println(number);
		number = 1;
		System.out.println(number);
		number = 17;
		System.out.println(number);
	}
}

Überlege dir, was dieser Code ausgeben würde. Schreibe ihn in eine Datei, kompiliere ihn und führe ihn aus.

  • Was gibt er tatsächlich aus?
  • Gibt es Unterschiede?

Formatierung und Namen

Wieso haben wir die Code-Beispiele nach den geschweiften Klammern eingerückt und die Variablen so benannt, wie wir es taten und nicht so:

class _{static long _
(long __,long  ___) {
return __==0 ?___+ 1:
___==0?_(__-1,1):_(__
-1,_(__, ___-1)) ;  }
static  {int _=2 ,___
== 2;System.out.print(
"a("+_+’,’+___+ ")="+
_ (_,  ___) ) ;System
.exit(1);}}//(C) Ulli

Nenne mindestens einen Grund und erkläre ihn deinem Tutor.

Etwas weniger Extrem, wieso haben wir unser zweites Beispiel nicht so gestellt?

class Beispiel {public static void main
	(String [] ignored) {
	System.out.println(0); int zero = 0;
			System.out.println(zero);
		int one = 1;
		int whatsThis = zero;
			System.out.
		println(whatsThis);
	whatsThis = one;		System.out.println(whatsThis)
;}}

Nenne mindestens einen Grund und erkläre ihn deinem Tutor.

Wieso haben wir unser zweites Beispiel nicht so gestellt?

class b {
	public static void main(String [] i) {
		System.out.println(0);
		int a = 0;
		System.out.println(a);
		int b = 1;
		int c = a;
		System.out.println(c);
		c = b;
		System.out.println(c);
	}
}

Nenne mindestens einen Grund und erkläre ihn deinem Tutor.

Variablen mit verschiedenen Typen zuweisen

class Test {
	public static void main(String [] ignored) {
		
	}
}

if

Einfache if-Bedingung

Überlege dir, was das folgende Code-Fragment macht. Führe es aus und vergleiche mit deinen Erwartungen.

(Kopiere den Beispiel-Code in eine Datei, kompiliere sie und führe sie aus)

  • Was sind die Unterschiede?
  • Warum?

Erkläre einem Tutor, zu welchem Schluss du gekommen bist und frage ihn, ob du Recht hast.

public class If_Uebung1 {
    /* Eure Aufgabe:
     * Versucht nachzuvollziehen, was dieses Programm macht 
     * und schaut Euch den Code an.
     */

    public static void main(String[] args) {

        /* 
         * Wir erzeugen uns hier eine Zufallszahl im
         * Bereich 1-6. Warum funktioniert das so?
         * Math.random ist eine statische Funktion im 
         * Math-Paket, die uns eine double-Zahl kleiner
         * als 1.0, aber groesser oder gleich 0 liefert.
         * Mit 6 multipliziert und um Eins erhöht erhalten wir
         * Zahlen von 1.0 bis 6.99999...
         * Durch das Umwandeln in int werden die Nachkommastellen abgeschnitten
         * und wir erhalten ein int von 1 bis 6.
         */
        int wuerfelzahl = (int) (1 + (6 * Math.random()));

        /*
         * Zur Kontrolle geben wir das Ergebnis aus 
         */
        System.out.println("Der Würfel hat " + wuerfelzahl + " ergeben.");

        /*
         * Ist das Ergebnis groesser als 3 ?
         */
        if (wuerfelzahl > 3) {
            // Wenn ja gib diesen Text aus:
            System.out.println("mehr als 3!");
        }

    }

}
 

if-else-Konstrukt

Überlege dir, was das folgende Code-Fragment macht. Führe es aus und vergleiche mit deinen Erwartungen.

(Kopiere den Beispiel-Code in eine Datei, kompiliere sie und führe sie aus)

  • Was sind die Unterschiede?
  • Warum?

Erkläre einem Tutor, zu welchem Schluss du gekommen bist und frage ihn, ob du Recht hast.

public class If_Uebung2 {

    public static void main (String[] args){

        int x=10;
        if (x>5) {
             System.out.println("x ist groesser als 5"); 
        } else {
             System.out.println("x ist kleiner/gleich 5");
        }

    }
}
 

Mehrere if-Bedingungen

Überlege dir, was das folgende Code-Fragment macht. Führe es aus und vergleiche mit deinen Erwartungen.

(Kopiere den Beispiel-Code in eine Datei, kompiliere sie und führe sie aus)

Was macht das Programm für verschiedene Werte von wert?.

Welche If-Abfragen sind unnötig, weil man die Ausgaben in else-Zweige von bereits vorhandenen schreiben könnte?

public class If_Uebung3 {    
    public static void main(String[] args) {
        
        int wert;
        
        wert = 5;
        
        if (wert<5){
            System.out.println("Der Wert ist echt kleiner 5.");
        }
        
        if (wert>5){
            System.out.println("Der Wert ist echt groesser 5.");
        }
        
        if (wert==5){
            System.out.println("Der Wert ist gleich 5");
        }
        
        if (wert>=5){
            System.out.println("Der Wert ist groesser oder gleich 5");
        }
        
        if (wert<=5){
            System.out.println("Der Wert ist kleiner oder gleich 5");
        }
        
    }

}
 

while

Einfache Schleife

Schreibe eine Schleife die unendlich oft "Hallo Welt!" ausgibt.

Begrenzte Schleifen

  • Schreibe eine for-Schleife, die 10 mal "Hallo Welt!!" ausgibt.
  • Verändere diese Schleife, so dass sie abwechselnd "Hallo Welt!" und "Ich bin im Javakurs!" ausgibt
    • Es gibt zwei Möglichkeiten das zu realisieren - finde die andere.

einfache while-Schleife

Überlege dir, was das folgende Code-Fragment macht. Welche Zahlen werden ausgegeben? Führe es aus und vergleiche mit deinen Erwartungen.

(Kopiere den Beispiel-Code in eine Datei, kompiliere sie und führe sie aus)

public class While_Uebung1 {

    public static void main(String[] args) {

        int x=10;
        while (x>0){
            System.out.println(" x=" + x);  // Anhaengen von x an den String
            x=x-1;
        }
    }
}

for

for-Schleifen zum Zählen

Überlege dir, was das folgende Code-Fragment macht. Welche Zahlen werden ausgegeben? Führe es aus und vergleiche mit deinen Erwartungen.

(Kopiere den Beispiel-Code in eine Datei, kompiliere sie und führe sie aus)


public class For_Uebung1 {
    public static void main(String[] args) {

        System.out.println("erste for Schleife:");
        for (int i = 1; i <= 10; i = i + 1) {
            System.out.print(" " + i);
        }
        System.out.println(); // Zeilenumbruch

        System.out.println("zweite for Schleife:");
        for (int i = 1; i <== 10; i = i + 2) {
            System.out.print(" " + i);
        }
        System.out.println(); // Zeilenumbruch

        System.out.println("dritte for Schleife:");
        for (int i = 1; i <== 10; i = i * 2) {
            System.out.print(" " + i);
        }
        System.out.println(); // Zeilenumbruch

    }

}
 

for-Schleife und if-Bedingung

public class ForIf_Uebung {
    
    // Welche Zahlen gibt dieses Programm aus ?
    
    public static void main(String[] args) {
        for (int i=1;i<10;i++){
            if ((i % 2)==0){ // % ist der Modulo-Operator 
                System.out.println("Die Zahl "+i+" ist gerade.");
            }
        }
    }
}
 

Methoden

Argumente

class Beispiel {
	public static void main(String [] ignored) {
		ausgabe(1, "Martin");
		ausgabe("Arthur", 2);
		ausgabe(3, "Florian");
		ausgabe("Robert", 4);
	}

	static void ausgabe(int i, String string) {
		System.out.println(i + ": " + string);
	}
}

  • Überlege was dieses Beispiel ausgibt.
  • Probiere es aus und erkläre den Unterschied. (Wenn Fehler auftreten, erkläre wieso)
  • Erkläre das einem Tutor

Was tut das?

Überlege dir, was das folgenden Code-Fragmente machen. Welche Zahlen werden ausgegeben? Führe sie aus und vergleiche mit deinen Erwartungen.

(Kopiere den Beispiel-Code in eine Datei, kompiliere sie und führe sie aus)

//file: Methoden1.java
class Methoden1 {
    public static void main (String[] arguments) {
        System.out.println( gibMirNeZahl() );
    }
    
    public static double gibMirNeZahl() {
        return 15.3;
    }
}


//file: Methoden2.java
class Methoden3 {
    public static void main (String[] arguments) {
        System.out.println( mathematik(1, 2) );
    }
    
    public static boolean mathematik(int argument1, int argument2) {
        return (argument1 + 5) < (argument2 * 2);
    }
}


//file: Methoden3.java
class Methoden3 {
    public static void main (String[] arguments) {
        System.out.println( mathematik(1, 2) );
        System.out.println( mathematik(1, 5) );
        System.out.println( mathematik(3, 4) );
    }
    
    public static boolean mathematik(int argument1, int argument2) {
        return (argument1 + 5) < (argument2 * 2);
    }
}

//file: Methoden4.java
class Methoden4 {
    public static void main (String[] arguments) {
        int eineZahl = 2;
        System.out.println( mathematik(4, eineZahl) );
        eineZahl = 5;
        System.out.println( mathematik(2, eineZahl) );
        System.out.println( mathematik(eineZahl, 4) );
    }
    
    public static boolean mathematik(int argument1, int argument2) {
        return (argument1 + 5) < (argument2 * 2);
    }
}

Selbst einige Methoden schreiben!

Im Folgenden wollen wir einige (mathematische)-Methoden programmieren.

  • Lege eine neue Klasse "MatheAufgabe" an.
  • Füge eine public static void main(String[] arguments) Methode hinzu.
  • Deklariere innerhalb der main-Methode eine double-Variable.
  • Belege diese Variable dem Wert 5/3 und gib den Inhalt der Variable auf dem Bildschirm aus.
  • Schreibe nun eine Methode public static double add(double x, double y), die die Summe der beiden übergebenen Zahlen x und y zurückgibt.
    • Teste deine Methode mit verschiedenen Eingaben wie z.B.
System.out.println(" 1.0 + 2.0 = " + add ( 1.0 , 2.0 ) );
double x = 5.0;
System.out.println( " " + x + " + 2.0 = " + add ( x , 2.0) );
System.out.println( " 2.0 + " + x + " = " + add ( 2.0 , x) );
x = add ( x , 2.0);
System.out.println( x);

  • Schreibe nun eine Methode sub, welche die Differenz zweier übergebener Werte zurückgibt.
    • Teste deine Methode wie eben!
    • Überprüfe, ob x == (x - y ) + y gilt! (natürlich mit deinen sub und add-Modthoden)
  • Schreibe nun eine mul-Methode.
    • Benutze dazu nicht den operator *. Rufe statt dessen deine add-Methode auf.
    • Teste deine Methode wie eben!
  • Schreibe nun eine public static double pow ( double basis, int exponent), die basis hoch exponent zurückgibt. pow(2,3) wurde z.B. 2^3=8 zurückgeben.
    • Benutze auch hier weder *, noch Math.pow(). Nutze statt dessen deine gerade geschriebene mul-Methode.
    • Teste deine Methode wie gehabt!
      Was liefert deine Methode wenn der Exponent 0 ist?
      Was liefert deine Methode wenn der Exponent negativ ist?

Arrays (eindimensional und n-dimensional)

Eindimensionale Arrays

Folgendes Array-Konstrukt wird initialisiert

int[] meinArray1 = new int[5];
meinArray1[0] = 0;
meinArray1[1] = 1;
meinArray1[2] = 2;
meinArray1[3] = 3;
meinArray1[4] = 4;

int[] meinArray2 = new int[3];
meinArray2[0] = 0;
meinArray2[1] = 1;
meinArray2[2] = 2;


Was geben die folgenden "system.out.println" jeweils aus? Vergleiche die Ausgabe mit Deinem Ergebnis.

1.1.

System.out.println(meinArray1.length);

1.2.

System.out.println(meinArray2.length);

1.3.

System.out.println("Ergebnis:"+meinArray1[1]);

1.4.

System.out.println("Ergebnis:"+meinArray2[1]);

1.5.

System.out.println("Ergebnis:"+meinArray1[4]);

1.6.

System.out.println("Ergebnis:"+meinArray2[4]);

1.7.

System.out.println(meinArray1.length-1);

1.8.

System.out.println(meinArray2.length-1);

1.9.

System.out.println("Ergebnis:"+meinArray1[0]);

1.10.

System.out.println("Ergebnis:"+meinArray2[0]);


Zweidimensionale Arrays

Folgendes Array-Konstrukt wird initialisiert

int[][] meinArray3 = new int[2][3];
meinArray3[0][0] = 1;
meinArray3[1][1] = 2;
meinArray3[0][2] = 1;
meinArray3[1][0] = 2;
meinArray3[0][1] = 1;
meinArray3[1][2] = 2;

Was geben die folgenden "system.out.println" jeweils aus? Vergleiche die Ausgabe mit Deinem Ergebnis.

Tipp: Aus der Mathematik kennst Du Matrizen. Ihre Größe wird mit (n x m) angegeben.

System.out.println(meinArray3[0][0]+meinArray3[0][1]+meinArray3[0][2]);
System.out.println(meinArray3[1][0]+meinArray3[1][1]+meinArray3[1][2]);


Dreidimensionale Arrays

Folgendes Array-Konstrukt wird initialisiert

int[][][] meinArray3D = new int[2][2][2];
meinArray3D[0][0][0] = 1;
meinArray3D[0][1][1] = 2;
meinArray3D[0][1][0] = 2;
meinArray3D[0][0][1] = 1;

meinArray3D[1][0][0] = 3;
meinArray3D[1][1][1] = 4;
meinArray3D[1][1][0] = 4;
meinArray3D[1][0][1] = 3;

Was geben die folgenden "system.out.println" jeweils aus? Vergleiche die Ausgabe mit Deinem Ergebnis.

Tipp: Aus der Mathematik kennst Du mehrdimensionale Obejekte.

System.out.println(meinArray3D[0][0][0]+meinArray3D[0][0][1]);
System.out.println(meinArray3D[0][1][0]+meinArray3D[0][1][1]);
System.out.println(meinArray3D[1][0][0]+meinArray3D[1][0][1]);
System.out.println(meinArray3D[1][1][0]+meinArray3D[1][1][1]);