Bearbeiten von „Variable und einfache Datentypen:Javakurs“

[[Category:Tutorial]]
[[Category:Java]]

[[JavaTutorial|Übersicht]]

== Theorie ==

Variable sind das Gedächtnis eines Programms. Da Java eine typisierte Sprache ist, hat jede Variable genau einen Typ und einen Wert.
Jede Variable muss deklariert werden.

'''Konvention:''' Variablen werden klein geschrieben.

Es gibt folgende einfache Datentypen:
{|
| Datentyp
| Bedeutung
| Literal (Beispiele)
|-
| int
| Ganzzahl, 32 Bit, mit Vorzeichen
| 42 -22 0 0x7fff 0772
|-
| long
| Ganzzahl, 64 Bit, mit Vorzeichen
| 123456789012L 0xa12345668L -98765643210123L
|-
| boolean
| Wahrheitswert, boolscher Wert
| true false
|-
| char
| 16-Bit Zeichen (Unicode)
| '?' '\n'
|-
| float
| Gleitkommazahl, 32 Bit, mit Vorzeichen
| 0.73 1.7E-22 0.0
|-
| double
| Gleitkommazahl, 64 Bit, mit Vorzeichen
| 0.73 1.7E-22 0.0
|-
| String
| Zeichenfolge, eigentlich kein einfacher Typ, aber eingebaut und oft benutzt...
| "Hallo liebe Leute"
|}

=== Syntax ===

<pre><nowiki><data_type> <name> [ = <expr> ] ';'
</nowiki></pre>

=== Beispiele ===
<pre>
int x;
int index = 0;
boolean again = true;
double pi = 3.14159265;
String language = "german";
</pre>

== Formatierte Ausgabe ==
Eine häufig genutzte Ausgabe von einfache Datentypen ist die Methode format() aus der Klasse String.
Der erste Parameter ist die Formatangabe: Das ist ein Text, angereichert mit Platzhaltern, die mit den folgenden Parametern ersetzt werden.
<pre>
String.format("Die erste Primzahl: %d pi: %f", 2, 3.14);
</pre>
{|
|Platzhalter
|Datentyp
|Bemerkung
|-
|%d
|int
|Dezimalzahl
|-
|%x
|int
|Hexadezimal
|-
|%f
|double
|Gleitpunktzahl ohne Exponent
|-
|%g
|double
|Gleitpunktzahl mit Exponent
|-
|%s
|String
|Zeichenfolge
|}
Zwischen % und datentypspezifischem Konvertierungszeichen können Formatierungsinformationen auftauchen:

Beispiele:
{|
|Formatierung
|Ausgabe
|Bemerkung
|-
| String.format("count: %3d", 2) 
| count:   2
| Mindestbreite 3, mit Leerzeichen aufgefüllt
|-
| String.format("count: %04d", 2)
| count: 0002
| Mindestbreite 4, mit '0' aufgefüllt
|-
| String.format("Volume: %10.3f", 777.3344);
| Volume:    777.334
| Gesamtbreite 10, 3 Dezimalstellen
|-
|String.format("Area: %.3g", 0.7773344E-12)
| Area: 7.77E-12    .
| 3 gueltige Ziffern
|-
|String.format("Text: %8.10s...", "abcdefghijklmnopqrst")
| Text: abcdefghij...
| Mindestlänge 8, Maximallänge 10, Blanks werden hinten angefügt (linksbündig)
|-
|String.format("Text: %-5s...", "abc")
| Text:   abc
| Mindestlänge 5, Blanks werden vorne angefügt, rechtsbündig
|}

== Beispielprogramme ==
=== Volumen und Fläche der Kugel ===
<pre>
double pi = 3.141592;
double radius = 1;

double area = radius*radius*pi*4;
double volume = radius*radius*radius*pi*4/3;

System.out.println(String.format("radius: %f area: %f volume: %f", radius, area, volume));
</pre>

=== Antennenausrichtung ===
* Ein Roboter fährt auf einer Geraden an einer Antenne im Abstand a vorbei.
* Der Roboter hat selber eine Antenne, die auf dies externe Antenne ausgerichtet werden soll
* Der Fahrweg hat eine Länge von s (von Anfang des Fahrweges bis Punkt P)
* Die Antennen-Ausrichtung soll alle s/100 berechnet werden
* Aufgabe: Berechne die Winkeländerungen der ersten 5 Schritte in einem Programm.
[[Datei:Antennenausgleich.png]]

Formeln:
* Winkel w0: tan w0 = Gegenkathete / Ankathete = a / s
* Winkel w1: tan w1 = a / (s - s/100)
* Winkel wn: tan wn = a / (s - n/100) wn = arctan (a / (s - n/100))
<pre>
package javakurs;
import java.lang.Math;
public class Lesson1 {
   public static void main(String[] args) {
	double a = 1;
	double s = 2;
	double w0 = Math.atan(a / s);
	double lastW = w0;
	int n = 1;
	double wN = Math.atan(a / (s - n / 100.0));
	System.out.println(String.format("1: Winkel: %f Diff: %f", wN, wN - lastW));
	lastW = wN;
	n = 2;
	wN = Math.atan(a / (s - n / 100.0));
	System.out.println(String.format("%d: Winkel: %f Diff: %f", n, wN, wN - lastW));
	lastW = wN;
	n = 3;
	wN = Math.atan(a / (s - n / 100.0));
	System.out.println(String.format("%d: Winkel: %f Diff: %f", n, wN, wN - lastW));
	lastW = wN;
	n = 4;
	wN = Math.atan(a / (s - n / 100.0));
	System.out.println(String.format("%d: Winkel: %f Diff: %f", n, wN, wN - lastW));
	lastW = wN;
	n = 5;
	wN = Math.atan(a / (s - n / 100.0));
	System.out.println(String.format("%d: Winkel: %f Diff: %f", n, wN, wN - lastW));
   }
}
</pre>
Hinweis: 
* Für die mathematischen Funktionen brauchen wir einen zusätzlichen Import (Zeile 2): import java.lang.Math;
* Die Funktion arcus tangens von x wird so aufgerufen: Math.atan(x)

=== Hausaufgabe ===
* Ein Fensterputzerroboter besteht aus einem Teleskoparm, der mit 2 Motoren von links nach rechts und zurück bewegt wird. 
* Der erste Motor steuert die Länge des Teleskoparmes, der zweite den Winkel.
* Der Weg des Putzarms wird in gleich große 100 Teilschritte zerlegt.
* Stelle Formeln auf, die für jeden Schritt den Längenunterschied des Teleskopstabes und den Differenzwinkel berechnen.
* Berechne die Werte für die ersten 5 Schritte.

Hinweis: Die Quadratwurzel berechnet die Methode Math.sqrt().

[[Datei:Putzroboter.png]]