Zuweisungen

Im Programm Kaffeetassen wurden einige Zuweisungen gemacht. Wir haben zum Beispiel der Klasse Tasse die Eigenschaften über Variablen zugewiesen. Dabei wurde festgelegt, dass eine Tasse die Eigenschaften: Farbe, Höhe, Durchmesser, Henkel, Aufdruck hat. Diese Eigenschaften wurden im Programm Kaffetassen zweimal Variablen zugewiesen, einmal im Konstruktor der Klasse Tasse und einmal im Konstruktor der Klasse Kaffeetassen. Zur Erinnerung:

Der Konstruktor von Tasse:


          class Tasse {
                 // Erst einmal wieder Platzhalter für die Werte
                 String farbe, henkel, aufdruck;
                 int hoehe, durchmesser;

                 /* Ich beschreibe meine Tasse:
                  * f ist die Farbe und vom Typ String
                  * h ist die Höhe und vom Typ int
                  * d ist der Durchmesser und auch vom Typ int
                  * he ist die Aussage ob die Tasse einen Henkel hat oder nicht und vom Typ String
                  * a ist der Aufdruck und ebenfalls vom Typ String
                  */

                 Tasse (String f, int h, int d, String he, String a) {
                         farbe = f;
                         hoehe = h;
                         durchmesser = d;
                         henkel = he;
                         aufdruck = a;
                 }

und im Konstruktor von Kaffeetassen:


               class Kaffeetassen {

                 /* Programm Kaffeetassen von Heiko Schmuck, im März 2011
                  * Das Programm beschreibt Kaffetassen und gibt die Beschreibung
                  * auf dem Bildschirm aus.
                  */

                 // Als erstes werden Platzhalter für unsere Tassen erzeugt
                 Tasse kikisweb, java, schalke, bayern, bvb;

                 // Kaffeetassen haben die Eigenschaften: Farbe, Höhe, Durchmesser, Henkel, Aufdruck
                 Kaffeetassen () {
                         kikisweb = new Tasse("Weiß", 10, 8, "Ja", "KIKISWEB");
                         java     = new Tasse("Schwarz", 10, 8, "Ja", "JAVA");
                         schalke  = new Tasse("Blau", 10, 8, "Ja", "SCHALKE");
                         bayern   = new Tasse("Rot", 10, 8, "Ja", "BAYERN");
                         bvb      = new Tasse("Gelb", 10, 8, "Nein", "BVB");

                 [...]


In beiden Fällen wird dem Programm zuerst mitgeteilt, welchen Datentyp die Variablen haben. Der Datentyp sagt dem Programm womit er es zu tun hat. In JAVA gibt es 8 Grundtypen die Daten aufnehmen können.
Für ganze Zahlen:

  • byte: Ganze Zahlen von -128 bis 127. Ein Byte entspricht den Zahlenwerten die mit 8 Bit dargestellt werden können.
  • short: Ganze Zahlen von -32786 bis 32767. Diese Zahlen können mit 16 Bit dargestellt werden.
  • int: Ganze Zahlen von -2147483648 bis 2147483647. Diese Zahlen können mit 32 Bit dargestellt werden.
  • long: Ganze Zahlen von -9223372036854775808 bis 9223372036854775807. Diese Zahlen können mit 64 Bit dargestellt werden.

Für Gleitkommazahlen, also Zahlen die nicht ganze Zahlen sind:

  • float: Zahlen von 3.4e-038 bis 3.4e+038. Das e-038 bzw. e+038 bedeutet, dass der vorhergehende Wert mit 10 hoch -38 bzw. 10 hoch 38 multipliziert werden muss.
  • double: Zahlen von 1.7e-308 bis 1.7e+308. Das e-308 bzw. e+308 bedeutet, dass der vorhergehende Wert mit 10 hoch -308 bzw. 10 hoch 308 multipliziert werden muss.

Für Zeichen und Boole'sche Werte:

  • char: Einzelne Buchstaben oder Ziffern.
  • boolean: Wahr(true) oder Falsch(false). Für logische Abfragen, ob ein Ausdruck Wahr ist.

Der Aufmerksame Leser hat gemerkt: String fehlt !! Wir haben nur den Datentyp char als Grundtyp zur Verfügung. Das liegt daran, dass String kein einfacher Datentyp mehr ist, sondern aus mehreren char besteht. Die Bezeichnung dafür ist Literal.
Achtung : Ein String wird immer in "..." eingeschlossen!!, damit das Programm den String von einer Variablen unterscheiden kann.

Also, wird mit:


                [...]
                String farbe, henkel, aufdruck;
                int hoehe, durchmesser;
                [...]

den Variablen farbe, henkel, aufdruck der Datentyp String und hoehe, durchmesser der Datentyp int zugewiesen.
Diese Variablen können die entsprechenden Werte aufnehmen. Aber, eben auch nur Werte, die den entsprechenden Typ haben. durchmesser könnte zum Beispiel keinen Wert wie "Ich bin eine Zahl" annehmen. Das Programm würde einen Fehler ausgeben.

Will man nun die Variablen mit einem Wert füllen, muss man der Variablen den Wert zuweisen. Am einfachsten geht das mit:


                 Variable = Wert;

also, zum Beispiel:


                durchmesser = 8;

oder


                farbe = "Weiß";

Einfach, oder? Was nutzt uns das jetzt? Nun, jetzt kann ich zum Beispiel, das Ergebnis einer Berechnung einer Variablen zuweisen und dann damit weiter rechnen. Ich möchte zum Beispiel erst ermitteln was 2 + 4 ergibt und dieses Ergebnis dann mit 6 multiplizieren. OK, kann man auch in einem Schritt machen, aber wir wollen ja was lernen.


                 // Erst einmal unsere Variablen. Das Ergebnis wird eine ganze Zahl und nicht größer als 32768,
                 // also benutzer wir den Typ int.
                 int ersterWert, zweiterWert, Ergebnis;

                 // Die Werte den Variablen Zuweisen
                 ersterWert = 2 + 4;
                 zweiterWert = 6;

                 // Jetzt berechne ich das Ergebnis
                 Ergebnis = ersterWert * zweiterWert;

In desem Beispiel ist das ganze noch überschaubar. In einem großen Programm kann man auf diese Weise komplizierte berechnungen in "Häppchen" aufteilen und dann zum Schluß in einem Ergebnis zusammenführen.

In JAVA können zum Rechnen folgende Operatoren benutzt werden:

  • Addieren: +
  • Subtrahieren: -
  • Multiplizieren: *
  • Dividieren:./
  • Restwert einer Division: %
  • Es gibt ein paar Zuweisungen die immer wieder benötigt werden. Programmierer sind normalerweise wirklich schreibfaule Gesellen, sodas man sich dafür Abkürzungen einfallen lassen hat.

  • Einen nummerischen Wert um 1 erhöhen geht auch mit Variable ++;
  • Einen nummerischen Wert um 1 verringern geht auch mit Variable --;
  • Einen nummerischen Wert um Wert erhöhen geht auch mit Variable += Wert;
  • Einen nummerischen Wert um Wert verringeren geht auch mit Variable -= Wert;
  • Einen nummerischen Wert mit Wert multiplizieren geht auch mit Variable *= Wert;
  • Einen nummerischen Wert durch Wert teilen geht auch mit Variable /= Wert;


  • Wobei Wert auch wieder eine Variable sein kann.

    Manchmal möchte man aber auch konstante Werte irgendwo ablegen, um nicht immer eine Zeichenfolge eingeben zu müssen. Die sogenannten Konstanten, werden wie eine Variable angelegt. Der Unterschied ist, dass wir definieren, dass sich diese Werte nicht ändern dürfen. Zum Beispiel kann man PI zum rechnen in einer Konstante ablegen.

    
                     static final double PI = 3,14;
    
    

    Mit static final geben wir an das sich der folgende Wert nicht ändern wird. Danach geben wir den Datentyp an, hier eine Kommazahl, also double. (Wer sich nicht mehr erinnnert was Datentypen sind - Guckst du oben.) Dann kommt der Bezeichner für unsere Konstante, dabei hat sich eingebürgert, dass Konstanten immer Groß geschrieben werden, also PI. Mit dem Gleichheitszeichen wird der Konstanten ein Wert zugewiesen. Fertig.
    Nun kann man im ganzen Programm auf PI zugreifen, zum Beispiel um eine Kreisfläche zu berechnen.

    
                     Kreisfläche = PI * (Radius * Radius)
    
    

    Weiter geht es mit Schleifen.

    Mit JAVA programmieren

    Als Entwicklungsumgebung benutze ich NetBeans 7.

    JAVA gibt es hier.