Variablen

Einleitung

Variablen sind in der objektorientierten Programmierung von großer Bedeutung. Durch diese können die unterschiedlichen Eigenschaften von Objekten einer Klasse beschrieben werden.

Die drei Gesichter von Variablen

Folgendes Beispiel verdeutlicht die unterschiedlichen Typen von Variablen:

public class MeineKlasse
  {
      private int einAttribut;

      public int Methode1(int einParameter)
      {
          int eineVariable;
          eineVariable = einAttribut+einParameter;
          return eineVariable;
      }

      public void Methode2()
      {
          // Hier existiert nur noch das Attribut einAttribut.
          // Die lokale Variable eineVariable und der Parameter
          // ein Parameter kann nicht mehr verwendet werden!
      }
  }

  class Fahrzeug{
    ...
    public Fahrzeug(){
      String typ="VW";
      String farbe="schwarz";
      int baujahr = 2018;
      String standort = "Erkelenz"
    }
  }

Programmierung mit BlueJ

Ein neuen Editor

Nach dem Start von BlueJ erscheint eine Aufforderung zur Erstellung eines neuen Projekts. Lege dies auf deinem Stick an. Anschließend sollte folgende Oberfläche erscheinen:

Die wichtigsten Bereiche / Knöpfe:

• New Class legt eine neue Klasse an.
• Compile übersetzt alle Klassen in ausführbaren Code - sofern der Compiler keine Fehler findet. Dies geschieht auch automatisch beim Speichern des Quelltextes.
• Im Bereich für Klassen werden die einzeln Klassen deines Projekts als Rechteck aufgeführt. In späteren Projekten können das einige Klassen sein und BlueJ zeigt deren Abhängigkeiten an.
• Im Bereich für Objekte erscheinen die erstellten Objekte als rote Rechtecke. Per Rechtsklick kannst du Methoden dieser Objekte aufrufen und diese somit einfach testen.

Ein erster, kleiner Taschenrechner mit BlueJ

Grundgerüst und Addition

Alte bzw. einfache Taschenrechner funktionieren anders als die aktuellen Taschenrechner.

Es gibt eine aktuell im Speicher befindliche Zahl. Für diese können dann weitere Rechenoperationen (+,-,*,/) aufgerufen werden und die Zahl im Speicher wird mit einer weiteren Zahl verrechnet.

Solch einen einfachen Taschenrechner wollen wir mit BlueJ implementieren. Nach Erstellung einer neuen Klasse in BlueJ erscheint ein Grundgerüst einer Klasse in Java. Hier ist bereits ein Attribut x deklariert und initialisiert sowie der Konstruktor Taschenrechner und eine Beispielmethode sampleMethod implementiert worden. Im Normalfall kann man die Beispielmethode löschen.

/**
* Write a description of class Taschenrechner here.
*
* @author (your name)
* @version (a version number or a date)
*/
public class Taschenrechner
{
   // instance variables - replace the example below with your own
   private int x;

   /**
    * Constructor for objects of class Taschenrechner
    */
   public Taschenrechner()
   {
       // initialise instance variables
       x = 0;
   }

   /**
    * An example of a method - replace this comment with your own
    *
    * @param  y  a sample parameter for a method
    * @return    the sum of x and y
    */
   public int sampleMethod(int y)
   {
       // put your code here
       return x + y;
   }
}

Da der Taschenrechner eine Zahl speichern soll, können wir hier die Zahl x verwenden. Allerdings soll der Taschenrechner auch Kommazahlen verarbeiten, so dass int durch double ersetzt wird.

private double x;

Um die erste Zahl zu setzen, muss soll es eine Methode setzeZahl(double pZahl), welche die Zahl x durch den Wert des Parameters pZahl ersetzt:

public void setzeZahl(double pZahl){
    x = pZahl;
}

Das Addieren einer weiteren Zahl y zur Zahl x im speichern soll ebenfalls durch eine neuen Methode implementiert werden: addiere(double pZahl).

public void addiere(double y){
  x = x + y;
}

Eigentlich ist der Taschenrechner mit der Addition so fertig. Allerdings sieht man nichts. Damit man auch was sieht, wird noch eine Ausgabe in der Konsole ergänzt, welche immer nach der Rechnung das Ergebnis in die Konsole druckt. Dies geschieht mit dem Befehl System.out.println(...).

public void addiere(double y){
  x = x + y;
  System.out.println(x);
}

Insgesamt:

/**
* Ein einfacher Taschenrechner
*
* @author Tim Schellartz
* @version 10.11.2020
*/
public class Taschenrechner
{
   // Zahl im Speicher
   private double x;

   /**
    * Constructor for objects of class Taschenrechner
    */
   public Taschenrechner()
   {
       x = 0;
   }

   /**
    * Setzt die Zahl im Speicher auf den Wert des Parameters pZahl
    */
   public void setZahl(double pZahl){
       x = pZahl;
   }

   /**
    * Addiert zur Zahl im Speicher den Wert des Parameters y
    * Zudem wird das Ergebnis in der Konsole ausgegeben.
    */
   public void addiere(double y){
       x = x + y;
       System.out.println(x);
   }
}

Zum Abschluss soll der Taschenrechner getestet werden. Dazu wird durch Rechtsklick auf die Klasse Taschenrechner ein neues Objekt dieser Klasse angelegt. Im folgenden Dialog kann ein beliebiger Name für das Objekt verwendet werden.

Anschließend befindet sich ein Taschenrechner-Objekt im Bereich für Objekte. Per Rechtsklick auf das Objekt (rotes Rechteck) und anschließendem Klick auf inspect kann das Objektdiagramm aufgerufen werden. Hier werden alle Attribute und deren Werte aufgelistet. In diesem Beispiel also das Attribut x mit Wert 0.0.

Vielleicht ist es dir schon aufgefallen: Hier findest du auch die eben selbst geschriebenen Methoden. Durch einen Klick auf diese werden diese ausgeführt. Falls es Parameter gibt, wie in diesem Fall, hast du hier die Möglichkeit diese mit Werten zu belegen.

/**
 * Ein einfacher Taschenrechner
 *
 * @author Tim Schellartz
 * @version 10.11.2020
 */
public class Taschenrechner
{
    // Zahl im Speicher
    private double x;

    /**
     * Constructor for objects of class Taschenrechner
     */
    public Taschenrechner()
    {
        x = 0;
    }

    /**
     * Setzt die Zahl im Speicher auf den Wert des Parameters pZahl
     */
    public void setZahl(double pZahl){
        x = pZahl;
    }

    /**
     * Addiert zur Zahl im Speicher den Wert des Parameters y
     * Zudem wird das Ergebnis in der Konsole ausgegeben.
     */
    public void addiere(double y){
        x = x + y;
        System.out.println(x);
    }

    /**
     * Subtrahiert zur Zahl im Speicher den Wert des Parameters y
     * Zudem wird das Ergebnis in der Konsole ausgegeben.
     */
    public void subtrahiere(double y){
        x = x - y;
        System.out.println(x);
    }

    /**
     * Multipliziert zur Zahl im Speicher den Wert des Parameters y
     * Zudem wird das Ergebnis in der Konsole ausgegeben.
     */
    public void multipliziere(double y){
        x = x * y;
        System.out.println(x);
    }
    /**
     * Dividiert die Zahl im Speicher durch den Wert des Parameters y
     * Zudem wird das Ergebnis in der Konsole ausgegeben.
     */
    public void dividiere(double y){
        x = x / y;
        System.out.println(x);
    }
}

/**
* Berechnet x hoch n
* Zudem wird das Ergebnis in der Konsole ausgegeben.
*/
public void hoch(int n){
    double potenz = 1;
    for(int i=0;i < n;i++){
        potenz = potenz*x;
    }
    x=potenz;
    System.out.println(x);
}

/**
  * Berechnet näherungsweise die Wurzel von x.
  * Zudem wird das Ergebnis in der Konsole ausgegeben.
  */
public void wurzel(){
    double wurzel = 1;
    if(x > 0){ 
        for(int i=0;i < 10;i++){
            wurzel = (wurzel+x/wurzel)/2.0;
        }
    }
    x=wurzel;
    System.out.println(x);
}

/**
  * Berechnet die Wurzel von x mit dem Heron Verfahren und einem Genauigkeitswert von 0,001.
  * Zudem wird das Ergebnis in der Konsole ausgegeben.
  */
public void wurzel2(){
    double wurzel = 1.0;
    double old = -1.0;
    if(x>0){
        while(Math.abs(wurzel-old)>0.001){
            old = wurzel;
            wurzel = (wurzel+x/wurzel)/2.0;
        }
    }
    x=wurzel;
    System.out.println(x);
}
      

Funktionen mit Rückgabe (return)

Häufig sollen Funktionen in Java nicht nur etwas machen, sondern einen Wert zurückliefern. Ein einfaches Beispiel ist die Funktion max(int a, int b), welche das Maximum der Zahlen a und b zurückliefert.

  public int max(int a, int b){
    if(a>b){
      return a;
    }
    return b;
  }

Das diese Funktion einen Wert, genauer eine ganze Zahl zurückliefert, wird schon in der Methodendeklaration

public int max(int a, int b)

deutlich. Funktionen mit Rückgabetyp in der Methodendeklaration müssen einen Wert zurückgegeben, also immer return ...; enthalten. Ein praktischer Tipp: Die Zeile mit return ...; beendet die Methode, daher kann das Beispiel ohne else implementiert werden.

/**
* Berechnet die fakultät von n
*/
public int fakultaet(int n){
  int erg = 1;
  for(int i=2;i<=n;i++){
      erg *= i;
  }
  return erg;
}

/**
* Berechnet die Summe der Zahlen von 1 bis n
*/
public int sum(int n){
  int erg = 0;
  for(int i=1;i<=n;i++){
      erg += i;
  }
  return erg;
}

Pseudocode größter gemeinsamer Teiler
ggt(a,b):
  wenn a = 0 dann
    Ergebnis = b
  sonst
    solange b ungleich 0
      wenn a > b dann
        ersetze a durch a-b
      sonst
        ersetze b durch b-a
      ende wenn
    ende solange
    Ergebnis = a
  ende sonst

/**
* Berechnet den größten gemeinsamen Teiler von a und b
*/
public int ggt(int a, int b){
    if(a==0){
        return b;
    }else{
        while(b!=0){
            if(a>b){
                a = a-b;
            }else{
                b = b-a;
            }
        }
        return a;
    }
}

Eingaben einlesen mit der Scanner-Klasse

Scanner Klasse

Das dein toller Taschenrechner nur über die BlueJ-Oberfläche bedient werden kann hat zwei Nachteile: Zum einen hat nicht jeder potenzielle Benutzer BlueJ installiert und zum anderen ist Bedingung per Maus umständlich. Abhilfe schafft das Einlesen von Befehlen und Werten über die Konsole.

import java.util.Scanner;
/**
  * Eine einfache Klasse mit Scanner
  */
public class EineKlasse{
  Scanner sc = new Scanner(System.in);

  /**
   * Liest den Namen einer Person ein und begrüßt diese
   */
  public void eineMethode(){
    String name = sc.nextLine();
    System.out.println("Hallo " + name);
  }
}

import java.util.Scanner;
/**
  * Write a description of class Main here.
  *
  * @author Tim Schellartz
  * @version 18.11.2020
  */
public class Main
{
    Taschenrechner tr;
    Scanner sc;
    
    public Main(){
        tr = new Taschenrechner();
        sc = new Scanner(System.in);
    }
    
    public void starteRechner(){
        String eingabe = "";
        while(!eingabe.equalsIgnoreCase("ende")){
            eingabe = sc.nextLine();
            String operator = eingabe.substring(0, 1);
            double zahl = Double.parseDouble(eingabe.substring(1));
            
            if(operator.equals("+")){
                tr.addiere(zahl);
            }else if(operator.equals("-")){
                tr.subtrahiere(zahl);
            }else if(operator.equals("*")){
                tr.multipliziere(zahl);
            }else if(operator.equals("/")){
                tr.dividiere(zahl);
            }else {
                System.out.println("Operator nicht enthalten. Verwenden Sie:");
                System.out.println("+,-,*,/");
                System.out.println("Beispiel für 'Addiere 565': +565");
            }
        }
    }
}

Exkurs: Gefährliche Fehler

Meist sind Softwarefehler vor allem ärgerlich. Manchmal können die Folgen von fehlerhafter Programmierung allerdings sehr teuer oder sogar tödlich sein. Die Webseite listet einige Beispiele auf. Auch das folgende Video zeigt ein teures Beispiel.