Versionsvergleich

Aus ProgrammingWiki

Vergleich: 2008-10-07T20:36:49+00:00 → 2011-01-10T19:41:55+00:00

<language>Java</language>
−
Java ist eine objektorientierte Programmiersprache. Selbst für einfachste Programme ist deshalb ein gewisses Grundgerüst in Form einer Klasse nötig. Um zunächst einfache Grundstrukturen von Java zu verstehen, wollen wir auf dieses Grundgerüst zunächst verzichten und nur einfache Java Methoden entwickeln. 
+
Mit diesem Online-Kurs sollen Grundlagen der Programmierung mit der Programmiersprache Java vermittelt werden. Er richtet sich an Lernende, die bislang keinerlei Programmierkenntnisse besitzen. Es werden nur mathematisches Grundverständnisse vorausgesetzt. 
+
== Was ist Java? ==
+
+
Java ist eine objektorientierte Programmiersprache die etwa 1996 in der Version 1.0 entwickelt wurde. Der Name Java wurde von den Entwicklern nach ihrer Lieblingskaffesorte benannt. Über die Jahre wurde die Sprache weiterentwickelt und wir verwenden heute Java 6 (1.6). 
+
+
Java Programme werden von einem Java-Compiler in sogenannten Java-Bytecode übersetzt. Dieser kann anschließend auf einer beliebigen Plattform mit Hilfe eines Java-Interpreters ausgeführt werden. Du kannst also ein Java Programm auf deinem Windows Computer entwickeln und es anschließend Freunden schicken, die vielleicht ein ganz anderes Betriebssystem wie du verwenden (etwa Linux oder MacOS).
+
== Datentypen ==
−
Java unterscheidet zwischen primitiven Datentypen (einfachen) und Objekten. Wir wollen uns zunächst den einfachen Typen zuwenden. Dazu zählen die folgenden:
+
Um Java Programme entwickeln zu können, müssen wir uns zunächst die Datentypen ansehen. Java unterscheidet zwischen primitiven Datentypen (einfachen) und Objekten/Klassen. Wir wollen uns zunächst auf die einfachen Typen beschränken. 
+
Um uns etwas mit dieser Schreibweise vertraut zu machen, wenden wir einfache Rechenoperatoren auf ganze und reelle Zahlen an. Es folgt ein interaktives Feld indem du experimentieren kannst. Im oberen Kästchen kannst du eine beliebige Gleichung eingeben. Mit einem Klick auf ''speichern & ausführen'' wird diese vom Java-Interpreter verarbeitet. Im zweiten Kästchen erscheint das Berechnungsergebnis.
+
+
''Zu beachten ist, dass reelle Zahlen mit Punkt (also 12.5 nicht 12,5) notiert werden.''
+
+
<run id="4ca984e280fd2">System.out.print(3*5-12.5);</run>
+
+
Wir haben mit Rechenzeichen und Zahlen gearbeitet ganz so, wie wir es von unserem Taschenrechner her kennen. Vielleicht hast du schon einmal versucht eine sehr sehr große Zahl mit dem Taschenrechner zu berechnen, wobei eine Fehlermeldung erschien. Es gibt also Grenzen wie groß eine Zahl sein darf - genau diese Grenzen legt der verwendete Datentyp fest. In nachfolgender Tabelle sind diese dargestellt. Jeder Typ (rot) besitzt einen genauen Wertebereich. 
+
<center>
{| style="text-align:center;border:solid grey 1px" cellpadding=3 cellspacing=0
|- style="background:#FFE466;"
! Typ     !! Byte !! Wertebereich  	 !!  Standardwert
|- style="background:#FFE466;"
−
| Boolische Datentypen || || ||
+
| ganze Zahlen || || ||
|-
−
| boolean || 1    || true,false          || false 
−
|- style="background:#FFE466;"
−
| Integer || || ||
+
| <span style="color:red">byte</span>    || 1    || -128 bis 127 || 0 
|-
−
| byte    || 1    || - 2<sup>07</sup> bis 2<sup>07</sup>-1 || 0 
+
| <span style="color:red">short</span>   || 2    || - 32768 bis 32767  || 0 
|-
−
| short   || 2    || - 2<sup>15</sup> bis 2<sup>15</sup>-1  || 0 
+
| <span style="color:red">int</span> 	  || 4    || - 2<sup>31</sup> bis 2<sup>31</sup>-1  || 0 
|-
−
| int 	  || 4    || - 2<sup>31</sup> bis 2<sup>31</sup>-1  || 0 
−
|-
−
| long 	  || 8    || - 2<sup>63</sup> bis 2<sup>63</sup>-1  || 0 
+
| <span style="color:red">long</span> 	  || 8    || - 2<sup>63</sup> bis 2<sup>63</sup>-1  || 0 
|- style="background:#FFE466;"
| Fließkommazahlen || || ||
|-
−
| float   || 4 	  || - 3.40282347 *10<sup>38</sup> bis 3.40282347 *10<sup>38</sup> || 0.0
+
| <span style="color:red">float</span>   || 4 	  || - 3.40282347 *10<sup>38</sup> bis 3.40282347 *10<sup>38</sup> || 0.0
|-
−
| double  || 8 	  || - 1.79769313486231570 *10<sup>308</sup> bis 1.79769313486231570 *10<sup>308</sup> || 0.0
+
| <span style="color:red">double</span>  || 8 	  || - 1.79769313486231570 *10<sup>308</sup> bis 1.79769313486231570 *10<sup>308</sup> || 0.0
|- style="background:#FFE466;"
+
| Wahrheitswert || || ||
+
|-
+
| <span style="color:red">boolean</span> || 1    || true,false          || false 
+
|- style="background:#FFE466;"
| Zeichen || || ||
|-
−
| char    || 2    ||  alle Unicode - Zeichen || \n0000
+
| <span style="color:red">char</span>    || 2    ||  alle Unicode - Zeichen || \n0000
|}
−
''Zu beachten ist, dass reelle Zahlen mit Punkt also 12.5 (nicht 12,5) notiert werden.''
</center>  	 	  	 
+
Geben wir eine Zahl ein, nimmt Java automatisch einen Datentyp an, der vom Wertebereich passt. Geben wir eine zu große Zahl an, werden wir eine Fehlermeldung erhalten. In der Tabelle sind alle primitiven Datentypen angegeben die Java kennt. Die Typen für Zeichen und Wahrheitswert werden wir erst später verwenden. 
−
Um uns etwas mit dieser Schreibweise vertraut zu machen, wenden wir einfache Rechenoperatoren auf ganze und reelle Zahlen an. Gib in das obere Kästchen eine Gleichung ein. Anschließend kannst du mit ''Eval'' diese vom Java-Interpreter ausführen lassen. Im zweiten Kästchen erscheint das Berechnungsergebnis.
+
Ein weiteren Datentyp ist ''String'', welcher Zeichenketten repräsentiert. Eine Zeichenkette wird in " eingeschlossen. ''String'' ist kein primitivenr Typ. Wir wollen ihn dennoch schon jetzt verwenden, ohne dessen genauen Definition zu kennen. Auch auf Zeichenketten kann der Operator "+" angewendet werden. Im Gegensatz zu arithmetischen Ausdrücken steht Plus hier für die Verkettung - durch Verkettung zweier Zeichenketten entsteht wieder eine neue Zeichenkette. Beispiel: "a"+"b" = "ab". 
−
<code rows="1">3*5-12.5</code>
−
<eval rows="1">3*5-12.5</eval>
+
<run id="4ca984e28109e">System.out.print("Hallo" + " " + "Welt");</run>
−
Ein weiteren Datentyp ist ''String'', welcher Zeichenketten repräsentiert. Eine Zeichenkette wird in " eingeschlossen. ''String'' ist kein primitivenr Typ. Wir wollen ihn dennoch schon jetzt verwenden ohne dessen genauen Definition zu kennen. Auch auf Zeichenketten kann der Operator "+" angewendet werden. Im Gegensatz zu arithmetischen Ausdrücken steht Plus hier für die Verkettung. 
−
−
<eval rows="1">"Hallo" + " " + "Welt"</eval>
−
Zeichenketten können auch mit anderen Datentypen verkettet werden:
−
<eval rows="1">"Pi ist " + 3.14</eval>
+
<run id="4ca984e28115d">System.out.print("Pi ist " + 3.14);</run>
−
Beachte, dass es sich bei 3.14 um eine Fließkommazahl handelt. Diese wird durch "+" automatisch in eine Zeichenkette "3.14" konvertiert und anschließend mit "Pi ist " verkettet. Was passiert wenn man etwa folgenden Ausdruck schreib: "2 mal Pi ist " + 3.14*2 ?
+
Beachte, dass es sich bei 3.14 um eine Fließkommazahl handelt. Diese wird durch "+" automatisch in eine Zeichenkette "3.14" konvertiert und anschließend mit "Pi ist " verkettet. Was passiert wenn man etwa folgenden Ausdruck schreib: "2 mal Pi ist " + (3.14*2)? Experimentiere etwas mit diesen Mischformen aus Rechnungen (in runden Klammern angeben) und Zeichenketten und versuche eine Vorschrift über die Berechnungsreihenfolge aufzustellen. 
== Methoden aufrufen und definieren ==
−
Um eine Methode aufzurufen verwenden wir den Methodennamen gefolgt von runden Klammern. Dies entspricht der Funktionsvorstellungen aus der Mathematik f(x). In diesem Fall ist x der Parameter zu dem uns die Funktion f einen Funktionswert berechnen soll. 
+
Um eine Methode aufzurufen verwenden wir den Methodennamen gefolgt von runden Klammern. Dies entspricht der Funktionsvorstellungen aus der Mathematik f(x). In diesem Fall ist x der Parameter, zu dem uns die Funktion f einen Funktionswert berechnen soll. 
−
Nehmen wir die Sinus Funktion sin(x). Wir wissen, dass für x eine Fließkommazahl angegeben wird (etwa Pi) und eine Fließkommazahl zurückgeliefert wird. Java bietet uns bereits eine fertige Methode sin(x) an, die wir verwenden können. Alle mathematischen Funktionen sind dabei in der Klasse ''Math'' definiert. Was genau eine Klasse ist, werden wir uns erst später genauer anschauen. 
+
Nehmen wir die Sinus Funktion sin(x). Wir wissen, dass für x eine Fließkommazahl angegeben wird (etwa Pi) und eine Fließkommazahl zurückgeliefert wird. Java bietet uns bereits eine fertige Methode sin(x) an, die wir verwenden können. Alle mathematischen Funktionen sind dabei in der Klasse ''Math'' definiert. Was genau unter einer Klasse zu verstehen ist, werden wir uns später genauer anschauen. 
−
<eval rows="1">Math.sin(1)</eval>
+
<run id="4ca984e2811d9">
+
Math.sin(1)
+
</run>
Hier haben wir die Methode ''sin(x)'' der Klasse ''Math'' verwendet. Experimentiere mit mit weiteren Funktionen wie ''cos(x)'', ''tan(x)'' oder ''sqrt(x)'' (Quadratwurzel).
−
Wir wollen uns nun eine eigene Funktion für Pi definieren. Es handelt sich dabei um eine null-stellige Funktion ''gibPi()''. Das ist auch klar, denn wir benötigen keinen Parameter ''gibPi(5)'' macht offensichtlich keinen Sinn. Es soll stets 3.14 als Funktionswert zurückgegeben werden. 
+
Wir wollen uns nun eine eigene Funktion ''gibPi()'' für Pi definieren. Es wird sich dabei um eine null-stellige Funktion handeln. Das ist auch klar, denn wir benötigen keinen Parameter ''gibPi(5)'' macht offensichtlich keinen Sinn. Es soll stets 3.14 (eine Fließkommazahl) als Funktionswert zurückgegeben werden. 
−
Um eine Methode zu definieren müssen wir zunächst den Rückgabetyp festlegen. Für unsere Methode ''gibPi()'' wählen wir den primitiven Datentyp ''double'' aus. Es handelt sich dabei um eine reelle Zahl. Anschließend müssen wir den Namen unserer Methode angeben. Diesen können wir beliebig wählen, wir müssen nur einige Regeln beachten. Ein Name darf zum Beispiel nicht mit einer Zahl beginnen oder Sonderzeichen enthalten.
+
Um eine Methode zu definieren müssen wir zunächst den Rückgabetyp festlegen. Wir haben laut der Typentabelle für Fließkommazahlen die Wahl zwischen ''float'' und ''double''. Wir sind großzügig und wählen für unsere Methode ''gibPi()'' den Datentyp ''double'' aus. Anschließend müssen wir den Namen unserer Methode angeben. Diesen können wir beliebig wählen, wir müssen nur einige Regeln beachten. Ein Name darf zum Beispiel nicht mit einer Zahl beginnen oder Sonderzeichen enthalten.
Schau dir den nachfolgen Quelltext genau an und versuche dessen Bedeutung zu erahnen: 
−
<code rows="3">
+
<code id="4ca984e280be3">
double gibPi () { 
  return 3.14; 
−
}</code>
+
}
+
</code>
−
Die geschweiften Klammern markieren den Begin und das Ende der Definition der Methode ''gibPi()''. Der Befehl ''return'' ist dafür verantwortlich unseren Wert 3.14 als Rückgabewert der Methode ''gibPi()'' zu setzen. Unsere Methode können wir nun genau wie f(x) aufrufen. Nachfolgendes Beispiel zeigt einen solchen Aufruf:
+
Die geschweiften Klammern markieren den Begin und das Ende der Beschreibung der Methode ''gibPi()''. Wenn wir später die Methode aufrufen werden die Befehle innerhalb der geschweiften Klammern nacheinander abgearbeitet. Bis der spezielle Befehel ''return'' das Ergebnis der Berechnungen zurückliefert. Der Rückgabewert der Methode ''gibPi()'' wird also auf 3.14 gesetzt. Unsere Methode können wir nun genau wie f(x) aufrufen, wie nachfolgendes Beispiel zeigt:
−
<eval rows="1">"Pi ist: " + gibPi() + " der Sinus von Pi ist: " + Math.sin(gibPi())</eval>
+
<run id="4ca984e281255">System.out.print("Pi ist: " + gibPi());</run>
−
Wie bei Math.sin(...) zu sehen, können wir auch den Rückgabewert unserer Methode wieder als Parameter einer anderen einsetzen. 
+
Wir können auch den Rückgabewert unserer Methode wieder als Parameter einer anderen einsetzen. 
−
Schlag im Internet den genauen Wert von Pi nach und ändere die Methode ''gibPi()'' so, dass etwa 8 Nachkommastellen ausgegeben werden - nicht nur 2. Der Sinus von Pi sollte ja bekanntlich 0 ergeben. Du wirst feststellen, dass wir zwar einen Wert sehr nah an 0 erhalten (beachte die Exponentialschreibweise wie E-9 am Ende der Zahl), jedoch auf Grund der Genauigkeit von ''double'' nur eine Näherung bekommen. 
+
<run id="4ca984e2812d2">System.out.print("Der Sinus von Pi ist: " + Math.sin( gibPi() ) );</run>
+
Schlag im Internet eine genauere Definition von Pi nach und ändere die Methode ''gibPi()'' so, dass etwa 8 Nachkommastellen ausgegeben werden - nicht nur zwei. Der Sinus von Pi sollte ja bekanntlich 0 ergeben. Du wirst feststellen, dass wir zwar einen Wert sehr nah an 0 erhalten (beachte die mögliche Exponentialschreibweise wie E-9 am Ende der Zahl), jedoch auf Grund der Genauigkeit von ''double'' nur eine Näherung bekommen.
+
== Methoden mit Parameter ==
−
Gehen wir nun einen Schritt weiter und definieren eine Methode mit Parameter. Betrachte zunächst die folgende Methode zur Kreisflächenberechnung und vergleiche sie mit unser null-stelligen ''gibPi()'' Methode.
+
Wir wollen nun einen Schritt weiter gehen und Parameter verwenden. Betrachte zunächst die folgende Methode zur Kreisflächenberechnung und vergleiche sie mit der null-stelligen ''gibPi()'' Methode.
−
<code rows="3">
+
<code id="4ca984e280cc1">
double KreisA (double radius) { 
−
  return radius*gibPi(); 
+
  return radius*radius*gibPi(); 
}
</code>
−
<eval rows="1">"Die Fläche eines Kreises mit r=3cm beträgt: " + KreisA(3) + "cm²"</eval>
+
<run id="4ca984e28137b">System.out.print("Die Fläche eines Kreises mit r=3cm beträgt: " + KreisA(3) + "cm²");</run>
−
Die Methode ''KreisA'' besitzt genau einen Parameter ''radius''. Dieser kann innerhalb der Methode (innerhalb der geschweiften Klammern) als eine Art Platzhalter verwendet werden. Ein Aufruf ''KreisA(5)'' berechnet demnach ''return 5*gibPi()''. 
+
Die Methode ''KreisA'' besitzt genau einen Parameter ''radius''. Dieser kann innerhalb der Methode (innerhalb der geschweiften Klammern) als eine Art Platzhalter verwendet werden. Ein Aufruf ''KreisA(5.0)'' berechnet demnach ''return 5.0*5.0*gibPi()''. 
''radius'' ist vom Datentyp ''double''. Damit erklären wir Java, dass wir als Parameter genau eine Fließkommazahl erwarten. Ein Aufruf wie ''KreisA("Hallo")'' würde also zu einem Fehler führen (versuch es einfach mal). 
Wenn wir mehr als einen Parameter benötigen, können wir diese durch Kommas getrennt hintereinander angeben. Wir definieren eine Methode zur Berechnung des Flächeninhalts eines Rechtecks:
−
<code rows="3">
+
<code id="4ca984e280e25">
double RechteckA (double a, double b) { 
  return a*b; 
−
}</code>
+
}
+
</code>
−
Als Parameter haben wir ''a'' und ''b'' definiert, denn bekanntlich benötigen wir zur Berechnung der Fläche die Kantenlängen des Rechtecks. Wenn wir diese Methode aufrufen müssen wir die Parameter wieder durch Kommas voneinander trennen: 
+
Als Parameter haben wir ''a'' und ''b'' verwendet, denn bekanntlich benötigen wir zur Berechnung der Fläche die Kantenlängen des Rechtecks. Wenn wir diese Methode aufrufen müssen wir die einzelnen Werte wieder durch Kommas voneinander trennen: 
−
<eval rows="1">"Die Fläche eines Rechtecks mit a=3.1 und b=5.7 ist: " + RechteckA(3.1,5.7) + "cm²"</eval>
+
+
<run id="4ca984e28140c">System.out.print("Die Fläche eines Rechtecks mit a=3.1 und b=5.7 ist: " + RechteckA(3.1,5.7) + "cm²");</run>
+
+
== Übung ==
+
Entwickle selbst eine Funktion zur Berechnung des Volumeninhalts eines Quaders. 
+
<code id="4ca984e280ec7">
+
double Quadervolumen (double x,double y,double z){
+
  // hier musst du etwas einfügen
+
}
+
</code>
+
+
+
<check>
+
 return ((int)Quadervolumen(3,4,4) == 48 && (int)Quadervolumen(2.0,7.5,3.0) == 45);
+
</check>