Javakurs2006/Uebungsaufgaben - Versionsgeschichte

PaulG am 26. Oktober 2012 um 15:15 Uhr

2012-10-26T15:15:11Z

Bmay: Kategorisiert

2009-03-17T13:15:24Z

Kategorisiert

← Nächstältere Version		Version vom 17. März 2009, 13:15 Uhr
Zeile 568:		Zeile 568:
	= Klassen =		= Klassen =
	(todo)		(todo)

			[[Kategorie:Java]]
			[[Kategorie:Java_Aufgaben]]

130.149.17.39: /* Selbst einige Methoden schreiben! */

2007-04-11T08:48:29Z

Selbst einige Methoden schreiben!

Neue Seite

Weitere Wiederholungsaufgaben gibt es [http://www.javaranch.com/cattledrive.jsp|bei der Java Ranch]

= 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>
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!");
}

}

}
</nowiki>

== 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>
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");
}

}
}
</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) {

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");
}

}

}
</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)

<nowiki>
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

}

}
</nowiki>

== for-Schleife und if-Bedingung ==
<nowiki>
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.");
}
}
}
}
</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>

= Klassen =
(todo)

Kriber: /* Selbst einige Methoden schreiben! */

2006-04-05T16:09:06Z

Selbst einige Methoden schreiben!

← Nächstältere Version		Version vom 5. April 2006, 16:09 Uhr
Zeile 460:		Zeile 460:
	** Teste deine Methode wie eben!		** 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.		* 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 ~~ebend~~ geschriebene mul-Methode.		** Benutze auch hier weder *, noch Math.pow(). Nutze statt dessen deine gerade geschriebene mul-Methode.
	** Teste deine Methode wie gehabt!		** Teste deine Methode wie gehabt!
	**: Was liefert deine Methode wenn der Exponent 0 ist?		**: Was liefert deine Methode wenn der Exponent 0 ist?

192.168.23.194: /* Selbst einige Methoden schreiben! */

2006-04-05T16:06:13Z

Selbst einige Methoden schreiben!

← Nächstältere Version		Version vom 5. April 2006, 16:06 Uhr
Zeile 457:		Zeile 457:
	** Überprüfe, ob x == (x - y ) + y gilt! (natürlich mit deinen <code>sub</code> und <code>add</code>-Modthoden)		** Ü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.		* Schreibe nun eine <code>mul</code>-Methode.
			** Benutze dazu nicht den operator *. Rufe statt dessen deine add-Methode auf.
	** Teste deine Methode wie eben!		** 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.		* 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 ebend geschriebene mul-Methode.
	** Teste deine Methode wie gehabt!		** Teste deine Methode wie gehabt!
	**: Was liefert deine Methode wenn der Exponent 0 ist?		**: Was liefert deine Methode wenn der Exponent 0 ist?

130.149.17.39: /* Selber Deklarationen und Definitionen durchführen */

2006-04-05T11:11:30Z

Selber Deklarationen und Definitionen durchführen

← Nächstältere Version		Version vom 5. April 2006, 11:11 Uhr
Zeile 42:		Zeile 42:
	// 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 54:
	}		}
	</nowiki>		</nowiki>


	== Zuweisung an Variablen ==		== Zuweisung an Variablen ==

Mutax: Klassen ausgegliedert

2006-04-05T10:49:36Z

Klassen ausgegliedert

@@ Zeile 562: / Zeile 562: @@
 System.out.println(meinArray3D[1][1][0]+meinArray3D[1][1][1]);
 </nowiki>
 = Klassen =
+(todo)

192.168.23.119: /* Selbst einige Methoden schreiben! */

2006-04-05T10:01:14Z

Selbst einige Methoden schreiben!

← Nächstältere Version		Version vom 5. April 2006, 10:01 Uhr
Zeile 463:		Zeile 463:
	**: Was liefert deine Methode wenn der Exponent 0 ist?		**: Was liefert deine Methode wenn der Exponent 0 ist?
	**: Was liefert deine Methode wenn der Exponent negativ ist?		**: Was liefert deine Methode wenn der Exponent negativ ist?

	~~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.~~

	~~Zuerst stellen wir einen denkbaren Aufgabentext vor, der später ausreichen müsste, um selbst ein Programm zu schreiben.~~

	~~Aufgabe: Erstelle ein Modul, das die mathematischen Operationen Addition, Subtraktion, und Potenzieren jeweils in einer Methode anbietet. 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) =		= Arrays (eindimensional und n-dimensional) =

192.168.23.119: /* Selbst einige Methoden schreiben! */

2006-04-05T09:59:27Z

Selbst einige Methoden schreiben!

← Nächstältere Version		Version vom 5. April 2006, 09:59 Uhr
Zeile 459:		Zeile 459:
	* Schreibe nun eine <code>mul</code>-Methode.		* Schreibe nun eine <code>mul</code>-Methode.
	** Teste deine Methode wie eben!		** 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.
			** Teste deine Methode wie gehabt!
			**: Was liefert deine Methode wenn der Exponent 0 ist?
			**: Was liefert deine Methode wenn der Exponent negativ ist?

	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.		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.

192.168.23.119: /* Selbst einige Methoden schreiben! */

2006-04-05T09:52:28Z

Selbst einige Methoden schreiben!

← Nächstältere Version		Version vom 5. April 2006, 09:52 Uhr
Zeile 438:		Zeile 438:

	== Selbst einige Methoden schreiben! ==		== Selbst einige Methoden schreiben! ==
	Im ~~folgenden~~ wollen wir einige (mathematische)-Methoden programmieren.		Im Folgenden wollen wir einige (mathematische)-Methoden programmieren.

	* Lege eine neue Klasse "MatheAufgabe" an.		* Lege eine neue Klasse "MatheAufgabe" an.
	* Füge eine <code>public static void main(Strings[] arguments)</code> Methode hinzu.		* Füge eine <code>public static void main(Strings[] arguments)</code> Methode hinzu.
	* Deklariere ~~inerhalb~~ der <code>main</code>-Methode eine <code>double</code>-Variable		* 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		* 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 ~~bieden~~ übergebenen Zahlen <code>x</code> und <code>y</code> zurückgibt.		* 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.		** Teste deine Methode mit verschiedenen Eingaben wie z.B.
	<nowiki>		<nowiki>
Zeile 454:		Zeile 454:
	System.out.println( x);		System.out.println( x);
	</nowiki>		</nowiki>
	* Schreibe nun eine Methode <code>sub</code>, ~~die~~ die Differenz zweier übergebener Werte zurückgibt.		* Schreibe nun eine Methode <code>sub</code>, welche die Differenz zweier übergebener Werte zurückgibt.
	** Teste deine Methode wie eben!		** 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)		** Ü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		* Schreibe nun eine <code>mul</code>-Methode.
	** Teste deine Methode wie eben!		** Teste deine Methode wie eben!