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

 
 
(73 dazwischenliegende Versionen von 10 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
−
== If ==
+
Weitere Wiederholungsaufgaben gibt es [http://www.javaranch.com/cattledrive.jsp|bei der Java Ranch]
  
−
=== 1. ===
+
== 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>
 +
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);
 +
}
 +
}
 +
</nowiki>
 +
* 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 ===
 +
<nowiki>
 +
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);
 +
 
 +
 +
}
 +
}
 +
</nowiki>
 +
 
 +
=== Zuweisung an Variablen ===
 +
<nowiki>
 +
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);
 +
}
 +
}
 +
</nowiki>
 +
 
 +
Ü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 ===
 +
<nowiki>
 +
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);
 +
}
 +
}
 +
</nowiki>
 +
 
 +
Ü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:
 +
<nowiki>
 +
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
 +
</nowiki>
 +
Nenne mindestens einen Grund und erkläre ihn deinem Tutor.
 +
 
 +
Etwas weniger Extrem, wieso haben wir unser zweites Beispiel nicht so gestellt?
 +
<nowiki>
 +
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)
 +
;}}
 +
</nowiki>
 +
Nenne mindestens einen Grund und erkläre ihn deinem Tutor.
 +
 
 +
Wieso haben wir unser zweites Beispiel nicht so gestellt?
 +
<nowiki>
 +
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);
 +
}
 +
}
 +
</nowiki>
 +
Nenne mindestens einen Grund und erkläre ihn deinem Tutor.
 +
 
 +
=== Variablen mit verschiedenen Typen zuweisen ===
 +
<nowiki>
 +
class Test {
 +
public static void main(String [] ignored) {
 +
 +
}
 +
}
 +
</nowiki>
 +
 
 +
== 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.
 
  <nowiki>
 
  <nowiki>
 
public class If_Uebung1 {
 
public class If_Uebung1 {
Zeile 12: 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 42: Zeile 210:
 
  </nowiki>
 
  </nowiki>
  
−
=== 2. ===
+
=== 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.
  
 
  <nowiki>
 
  <nowiki>
 
public class If_Uebung2 {
 
public class If_Uebung2 {
  
−
     /*
+
     public static void main (String[] args){
−
    * Eure Aufgabe:
+
 
−
    * Schaut Euch das Programm an und überlegt, was fuer verschiedene
+
        int x=10;
−
    * Werte passiert.  
+
        if (x>5) {
−
    * Welche If-Abfragen sind unnötig, weil man die Ausgaben in else-Zweige von  
+
            System.out.println("x ist groesser als 5");
−
    * bereits vorhandenen schreiben könnte?
+
        } else {
−
    */
+
            System.out.println("x ist kleiner/gleich 5");
−
   
+
        }
 +
 
 +
    }
 +
}
 +
</nowiki>
 +
 
 +
=== 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?
 +
<nowiki>
 +
public class If_Uebung3 {   
 
     public static void main(String[] args) {
 
     public static void main(String[] args) {
 
          
 
          
Zeile 86: Zeile 277:
 
  </nowiki>
 
  </nowiki>
  
 +
== 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)
 +
 +
<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)
  
−
== For ==
 
  
−
=== 1. ===
 
 
  <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 110: 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 116: 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 126: Zeile 341:
 
  </nowiki>
 
  </nowiki>
  
−
=== 2. ===
+
=== for-Schleife und if-Bedingung ===
−
 
 
−
 
 
 
  <nowiki>
 
  <nowiki>
 
public class ForIf_Uebung {
 
public class ForIf_Uebung {
Zeile 143: Zeile 356:
 
}
 
}
 
  </nowiki>
 
  </nowiki>
 +
 +
== Methoden ==
 +
=== Argumente ===
 +
<nowiki>
 +
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);
 +
}
 +
}
 +
</nowiki>
 +
 +
* Ü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)
 +
 +
<nowiki>
 +
//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);
 +
    }
 +
}
 +
</nowiki>
 +
 +
=== Selbst einige Methoden schreiben! ===
 +
Im Folgenden wollen wir einige (mathematische)-Methoden programmieren.
 +
 +
* 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?
 +
 +
== Arrays (eindimensional und n-dimensional) ==
 +
=== Eindimensionale Arrays ===
 +
Folgendes Array-Konstrukt wird initialisiert
 +
<nowiki>
 +
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;
 +
</nowiki>
 +
 +
 +
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
 +
<nowiki>
 +
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;
 +
</nowiki>
 +
 +
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
 +
<nowiki>
 +
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;
 +
</nowiki>
 +
 +
Was geben die folgenden "system.out.println" jeweils aus?
 +
Vergleiche die Ausgabe mit Deinem Ergebnis.
 +
 +
Tipp: Aus der Mathematik kennst Du mehrdimensionale Obejekte.
 +
<nowiki>
 +
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]);
 +
</nowiki>
 +
 +
 +
[[Kategorie:Java]]
 +
[[Kategorie:Java_Aufgaben]]

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]);
Abgerufen von „https://wiki.freitagsrunde.org/index.php?title=Javakurs2006/Uebungsaufgaben&oldid=19453“