Assoziationen

Am Ende des Kapitels solltest du

• die Begriffe Assoziation und Multiplizität kennen,
• die Funktion einer Referenzvariable nachvollziehen können,
• mit dem Datentyp Arraylist und den Methoden dieser Klasse umgehen können,
• Klassenvariablen und Klassenmethoden kennen und anwenden können.

Eine wichtige Eigenschaft objektorientierter Systeme ist der Austausch von Botschaften zwischen Objekten. Dazu muss ein Objekt andere Objekte "kennen" und kann Botschaften weitergeben. Diese Verbindung nennt sich Assoziation. Bei Assoziationen ist zu unterscheiden, ob nur eine Seite die andere kennt oder ob eine Navigation in beiden Richtungen möglich ist:

• Eine unidirektionale Beziehung geht nur in eine Richtung.
• Eine bidirektionale Beziehung geht in beide Richtungen.

Daneben ist bei Beziehungen die Multiplizität zu beachten. Sie sagt aus, mit wie vielen Objekten eine Seite eine Beziehung haben kann. Übliche Beziehungen sind 1:1 und 1:n. Wir beschränken uns hier auf unidirektionale Beziehungen.

Implementierung einer unidirektionalen 1:1-Beziehung

Bei bekannten Computerspielen kann ein Spieler seine Fahrkünste auf einem Formel 1-Kurs testen oder als Pilot einen Flughafen anfliegen. Dabei muss jeweils ein Spieler mit einem Kurs/Flughafen assoziiert werden. Damit ein Spieler sich auf einem Kurs befinden kann, lässt sich in Spieler eine Referenzvariable vom Typ Kurs anlegen. In Java sähe das in etwa so aus:

public class Spieler {
 
    public Kurs k;
 
}
 
 
public class Kurs {
 
 
}

Während des Spiels müssen dann natürlich noch entsprechende Referenzen gesetzt werden:

public class Spiel {
 
 
Spieler uschi = new Spieler();
Kurs   hockenheim  = new Kurs();
uschi.k   = hockenheim;  
 
}

Aufgabe 1

Erstelle eine Klasse Punkt, die die Attribute x und y und entsprechende Getter- und Setter-Methoden hat, und eine Klasse Kreis mit den Attributen radius und Mittelpunkt. Die Klasse Kreis soll zwei Methoden zum Verändern des Mittelpunktes und zum Verändern des Radius erhalten.

Lösungsvorschlag anzeigen

Lösungsvorschlag verstecken

public class Punkt{
//Attribute
private int x;
private int y;
 
//Konstruktor
public Punkt(int x, int y){
this.x=x;
this.y=y;
}
 
//Getter- und Setter-Methoden
public int getX(){
return x;
}
 
public int getY(){
return y;
}
 
public void setX(int newX){
x=newX;
}
 
public void setY(int newY){
y=newY;
}
}
 
 
 
public class Kreis{
//Attribute
private int radius;
private Punkt center;
 
//Konstruktor
public Kreis(int radius, int x, int y){
this.radius = radius;
center = new Punkt(x,y);
}
 
public void verschieben(int newX, int newY){
center.setX(newX);
center.setY(newY);
}
 
//Alternative Umsetzung der Methode verschieben()
public void verschiebenAlt(int newX, int newY){
center = new Punkt(newX, newY);
}
 
public void radiusVeraendern(int radNew){
radius=radNew;
}
}

Aufgabe 2

Für die Verwaltung einer Spedition werden zwei Klassen angelegt: Eine Klasse LKW, in dessen Konstruktor Marke, Tankinhalt und Verbrauch (in l pro 100 km) initialisiert werden. Die Klasse bekommt Getter-Methoden für Tankinhalt und Verbrauch und eine Setter-Methode für den Tankinhalt. Die Klasse Fahrer initialisiert im Konstruktor Name, Vorname und LKW und die Fahrtstrecke wird auf 0 gesetzt. Weiterhin bekommt die Klasse eine Methode fahren(int strecke), die die gefahrene Strecke speichert und den Tankinhalt aktualisiert. Eine weitere Methode benzinstand() gibt den aktuellen Tankinhalt zurück.

Hinweise: Zuerst ein LKW-Objekt erzeugen und dieses beim Konstruktor des Fahrers durch einen Mausklick als Parameterwert übernehmen. Der Benzinverbrauch auf einer bestimmten Strecke errechnet sich aus (Strecke*Verbrauch in l) / 100.

Lösungsvorschlag anzeigen

Lösungsvorschlag verstecken

public class LKW{
 
private String marke;
private double tankinhalt;
private double verbrauch;
 
public LKW (String marke, double tankinhalt, double verbrauch){
this.marke = marke;
this.tankinhalt = tankinhalt;
this.verbrauch = verbrauch;
}
 
public double getTankinhalt(){
    return tankinhalt;
}
 
public double getVerbrauch(){
    return verbrauch;
}
 
public void setTankinhalt(double benzinverbraucht){
    tankinhalt=tankinhalt - benzinverbraucht;
}
}
 
 
 
public class Fahrer{
 
private String name;
private String vorname;
private LKW meinBrummi;
private int fahrtstrecke;
 
public Fahrer (String name, String vorname, LKW meinBrummi){
this.name=name;
this.vorname=vorname;
this.meinBrummi=meinBrummi;
 
fahrtstrecke=0;
}
 
public void fahren (int strecke){
fahrtstrecke=fahrtstrecke+strecke;
meinBrummi.setTankinhalt((fahrtstrecke*meinBrummi.getVerbrauch())/100);
}
 
public void benzinanzeige(){
System.out.println("Es sind noch "+meinBrummi.getTankinhalt()+" Liter Benzin im Tank.");
}
}

Implementierung einer unidirektionalen 1:n-Beziehung

Immer dann, wenn ein Objekt auf mehrere andere Objekte verweisen muss, reicht eine einfache Referenzvariable vom Typ der anderen Seite nicht mehr aus. Dann werden Datenstrukturen benötigt, die mehrere Referenzen aufnehmen können. In Computerspielen kann ein Spieler häufig Gegenstände, Waffen etc. sammeln. Um dies in der Programmierung umzusetzen, muss man auf der 1-Seite eine Datenstruktur verwenden, die eine Anzahl anderer Objekte aufnimmt. Handelt es sich um eine feste Anzahl von Gegenständen, ist als Datenstruktur das bereits bekannte Array gut geeignet. Bei Spielen, in denen sich die Anzahl der Gegenstände dynamisch ändert, ist ein Array wenig elegant, da die manuelle Vergrößerung oder Verkleinerung des Arrays aufwendig ist. Hier kann man beispielsweise die Klasse ArrayList aus dem Package java.util.ArrayList zum Einsatz bringen.

Exkurs:Die Klasse ArrayList

Die Klasse ArrayList dient zum Speichern von Objekten. Die ArrayList, hat gegenüber dem Array den Vorteil, dass sie jederzeit vergrößert oder verkleinert werden kann. Darüber hinaus benötigt die ArrayList als normales Java-Objekt keine besondere Array-Syntax. Allerding kann die ArrayList nur Elemente vom Typ Object speichern, d.h. es ist (zumindest ohne weitere Vorarbeit) ungeeignet um Zahlen abzuspeichern. Für die Zwecke der objektorientierten Programmierung ist sie allerdings ein sehr geeignetes Werkzeug und bietet einige sehr hilfreiche Methoden (siehe Dokumentation). Die wichtigsten sind hier in einem Anwendungsbeispiel demonstriert:

import java.util.ArrayList;
 
public class ArrayListBeispiel {
 
   public ArrayListBeispiel() {
 
        //anlegen einer ArrayListe mit Objekten vom Typ String
        ArrayList<String> liste = new ArrayList<String>();
 
        //fuellen der Liste mit Daten
        liste.add("Keule");
        liste.add("Morgenstern");
        liste.add("Wattebausch");
        liste.add("Schleuder");
        liste.add("Armbrust");
 
        //Ausgeben der Liste
        System.out.println("Alle meine Waffen:");
        System.out.println(liste); 
        System.out.println(); 
 
        //Mit dem Wattebausch kann man keinen schrecken!
        liste.remove("Wattebausch");
 
        // nochmal ausgeben
        System.out.println("Liste nach Entfernen des Wattebauschs");
        System.out.println(liste);
        System.out.println();
 
 
        // Testen ob der Wattebausch noch enthalten ist:
        if (liste.contains ("Wattebausch")){
            System.out.println("Der Wattebausch ist noch drin.");
        }else{
            System.out.println("Der Wattebausch ist draußen.");
        }
 
        // Testen ob Morgenstern enthalten:
        if (liste.contains ("Morgenstern")){
            System.out.println("Der Morgenstern ist noch drin.");
        }else{
            System.out.println("Der Morgenstern ist draußen.");
        }
 
 
        // Das erste Element der Liste abfragen
        System.out.println();
        System.out.print("Das erste Element der Liste:  ");
        System.out.println(liste.get(0));
 
        // Die Größe der ArrayList abfragen
        System.out.println(); 
        System.out.print("Laenge der ArrayList:  ");
        System.out.println(liste.size());
        System.out.println();
 
        //Auflisten aller Elemente über erweiterte Schleife
         for (String s : liste) {         //gelesen: für alle s vom Typ String in der ArrayList liste
             System.out.println(s);
        }
 
    }
}

Ausgabe:

Alle meine Waffen:
[Keule, Morgenstern, Wattebausch, Schleuder, Armbrust]
 
Liste nach Entfernen des Wattebauschs
[Keule, Morgenstern, Schleuder, Armbrust]
 
Der Wattebausch ist draußen.
Der Morgenstern ist noch drin.
 
Das erste Element der Liste:  Keule
 
Laenge der ArrayList:  4
 
Keule
Morgenstern
Schleuder
Armbrust

Aufgabe 1

Das bereits bekannte Bank soll nun erweitert werden. Zuerst erhält die Klasse Konto noch zwei Methoden einzahlen() und auszahlen(), mit denen ein bestimmter Betrag ein- bzw. ausgezahlt werden kann. Dann erstellen wir eine Klasse Bank, die eine ArrayList vom Typ Konto enthält. Dazu noch eine Methode zum Hinzufügen von Konten, eine Methode zur Ausgabe sämtlicher Kunden mit den aktuellen Kontoständen und einer Methode, mit der ein Betrag von einem Konto auf ein anderes überwiesen werden kann.

Um die Funktionalität zu überprüfen, erstellt man in BlueJ zuerst einmal drei Konto-Objekte und anschließend ein Bank-Objekt. Ruft man im Bank-Objekt die Methode hinzufuegen(Konto k) auf, dann kann man durch Klicken auf ein Konto-Objekt dieses in die ArrayList übernehmen. Auf diese Weise kann man auch bei der Methode ueberweisen(Konto a, Konto b, int betrag) die Parameterwerte für die Konten übergeben. Anschließend kann man verschiedene Kontobewegungen simulieren und entweder über den Menüeintrag Inspect bei den Konto-Objekten oder über den Aufruf der Daten mit der Ausgabemethode überprüfen.

Lösungsvorschlag anzeigen

Lösungsvorschlag verstecken

public class Konto{
//Attribute
private String name;
private String vorname;
private String kontonr;
private int kontostand;
 
//Konstruktor
public Konto(String kontonr, String name, String vorname){
this.kontonr=kontonr;
this.name=name;
this.vorname=vorname;
 
kontostand=0;
}
 
//Methoden
public String getName(){
return name;
}
 
public String getVorname(){
return vorname;
}
 
public String getKontonr(){
return kontonr;
}
 
public int getKontostand(){
return kontostand;
}
 
public void setKontostand(int neuerKontostand){
kontostand=neuerKontostand;
}
 
public void einzahlen(int betrag){
kontostand=kontostand + betrag;
}
 
public void auszahlen(int betrag){
kontostand=kontostand - betrag;
}
}
 
 
 
import java.util.ArrayList;
 
public class Bank
{
 
private ArrayList<Konto> konten = new ArrayList<Konto>();
 
 
public void hinzufuegen(Konto k){
konten.add(k);
}
 
public void listeAusgeben(){
for(Konto i: konten){
System.out.println(i.getKontonr()+"   "+i.getName()+"   "+i.getVorname()+"   "+i.getKontostand());}
}
 
public void ueberweisen(Konto A, Konto B, int betrag){
A.setKontostand(A.getKontostand()+betrag);
B.setKontostand(B.getKontostand()-betrag);
}
 
}

Aufgabe 2

Ausgangspunkt sei die ebenfalls bekannte Klasse Schueler. Erstelle eine Klasse Schule, die eine ArrayList zum Abspeichern der Schüler enthält. Darüberhinaus enthält die Klasse eine Methode schuelerHinzufuegen(), mit der neue Schüler mit ihren Daten in die ArrayList eingefügt werden können, eine Methode schuelerzahlAusgeben(), die die Anzahl der Schüler in der Liste ausgibt und eine Methode aktuelleListe(), die die in der ArrayList enthaltenen Schueler mit ihren Daten ausgibt.

Lösungsvorschlag anzeigen

Lösungsvorschlag verstecken

public class Schueler
{
//Attribute
private String name;
private String vorname;
private String klasse;
 
 
 
//Konstruktor
public Schueler(String name, String vorname, String klasse){
this.name=name;
this.vorname=vorname;
this.klasse=klasse;
}   
 
public String getName(){
return name;
}
 
public String getVorname(){
return vorname;
}
 
public String getKlasse(){
return klasse;
}
 
 
}
 
 
import java.util.ArrayList;
 
public class Schule{
 
private ArrayList<Schueler> liste = new ArrayList<Schueler>();
 
public void schuelerHinzufuegen(String name, String vorname, String klasse){
Schueler s = new Schueler(name, vorname, klasse);
liste.add(s);
}
 
public void schuelerzahlAusgeben(){
System.out.println("Schülerzahl: "+liste.size();
}
 
public void aktuelleListe(){
for(Schueler i:liste){
System.out.println(i.getName()+" "+i.getVorname()+", "+i.getKlasse());
}
 
}
}

Aufgabe 3

Der Handyverkäufer Checker D. baut für sein Geschäft eine Kundendatei auf. In einer Klasse Kunde können Kundenobjekte mit den Attributen Name, Vorname, Wohnort und Anzahl (der Handys) erzeugt werden. Es sind für die Attribute nur die entsprechenden Getter-Methoden zu erstellen. Eine weitere Klasse Kundenverwaltung enthält eine ArrayList zur Verwaltung der Kunden. Daneben enthält die Klasse mehrere Methoden. Mit der Methode kundeHinzufuegen() können neue Kunden in die ArrayList eingefügt werden (Es darf angenommen werden, dass die Kundenobjekte bereits erzeugt wurden.). Eine Methode kundenliste() gibt sämtliche Kundendaten in einer Liste aus. Mit wohnortSuche kann nach Eingabe eines Ortes ermittelt werden, wieviele Kunden aus dem entsprechenden Wohnort stammen (Hinweis: Hier ist ein Stringvergleich notwendig). Die Methode gesamtzahl() schließlich stellt fest, wieviele Kundenhandys das Geschäft insgesamt betreut.

Lösungsvorschlag anzeigen

Lösungsvorschlag verstecken

public class Kunde {
 
//Attribute
private String name;
private String vorname;
private String wohnort;
private int anzahl;
 
public Kunde(String name, String vorname, String wohnort, int anzahl){
this.name = name;
this.vorname = vorname;
this.wohnort = wohnort;
this.anzahl = anzahl;
}
 
public String getName(){
return name;}
 
public String getVorname(){
return vorname;}
 
public String getWohnort(){
return wohnort;}
 
public int getAnzahl(){
return anzahl;}
}
 
 
 
import java.util.ArrayList;
 
public class Kundenverwaltung(){
 
private ArrayList <Kunde> kunden = new ArrayList<Kunde>();
 
public void kundeHinzufuegen (Kunde k){
kunden.add(k);
}
 
public void kundenliste(){
for(Kunde i : kunden){
System.out.println(i.getName()+"  "+i.getVorname()+"  "+i.getWohnort()+"  "+i.getAnzahl());}
}
 
public void wohnortSuche(String w){
int anzahl = 0;
for(Kunde i : kunden){
if((i.getWohnort()).equals(w)){anzahl++;}
}
System.out.println("Es kommen "+anzahl+" Kunden aus "+w.);
}
 
public void gesamtzahl(){
int sum = 0;
for(Kunde i : kunden){
sum=sum+i.getAnzahl();
}
System.out.println("Der Betrieb betreut "+sum+" Geräte.");
}
}

Wenn wir nun von einem Spiel ausgehen, in dem ein Spieler Waffen sammeln kann, könnte die Umsetzung mit Hilfe einer ArrayList folgendermaßen aussehen:

public class Weapon
{
  public String bezeichnung;
 
  public Weapon( String bezeichnung )
  {
    this.bezeichnung = bezeichnung;
  }
}

Die Klasse Spieler erhält nun ein Attribut weapons von Typ ArrayList:

private ArrayList<Weapon> weapons = new ArrayList<Weapon>();

Damit sieht die Klasse wie folgt aus:

public class Spieler
{
  private ArrayList<Weapon> weapons = new ArrayList<Weapon>();
 
  public void addWeapon( Weapon w )
  {
    weapons.add(w);
  }
 
  public void listWeapons()
  {
    for(int i=0;i<weapons.size();i++){
      System.out.println( weapons.get(i).bezeichnung );}
  }
}

Zuletzt führen wir Spieler und Waffen in der Klasse Spiel zusammen:

public class Spiel{
 
public Spiel(){
 
Spieler uschi = new Spieler();
 
uschi.addWeapon( new Weapon( "Keule" ) );
uschi.addWeapon( new Weapon( "Morgenstern" ) );
uschi.listWeapons();                      // Ausgabe: Keule   Morgenstern
 
}
}

Klassenvariablen und Klassenmethoden

Bis jetzt kennen wir bei Variablen zwei Typen: Lokale Variablen, wie wir sie beispielsweise in Schleifen als Zählvariablen verwenden, und Instanzvariablen. Innerhalb der Klasse Kreis, die sozusagen den Datentyp Kreis definiert, haben wir beispielsweise Radius, Fuellfarbe oder Linienstärke als Instanzvariablen. Jede Variable wird für sich separat für eine Instanz (also ein aus der Klasse erzeugtes Objekt) angelegt, d.h. jede Instanz hat eine eigene Kopie der Variablen. Die Methoden beziehen sich auf die jeweils angelegte Instanz.

Damit alle Objekte einer Klasse eine bestimmte Variable gemeinsam verwenden können, gibt es die sog. Klassenvariablen. Analog dazu benutzt man Klassenmethoden für Operationen, die sich nicht auf ein bestimmtes Objekt, sondern auf die Klasse an sich beziehen. Variablen und Methoden werden mit dem Schlüsselwort static an die jeweilige Klasse gebunden. Der Zugriff auf statische Variablen erfolgt über Klassenname.Variablenname, der Zugriff auf statische Methoden über Klassenname.Methodennname

Folgendes Beispiel soll das Konzept verdeutlichen:

In einer Klasse Testobjekt wird eine statische Variable zaehler angelegt, in der die Anzahl der erzeugten Instanzen der Klasse abgespeichert wird. Über eine statische Getter-Methode kann der aktuelle Wert des Zählers abgefragt werden. In einer zweiten Klasse ZaehlerTest werden drei Instanzen der Klasse Testobjekt erzeugt und als Kontrolle ihre jeweilige Rangzahl ausgegeben. Am Ende wird über die Methode getZaehler() die Anzahl der erzeugten Instanzen abgefragt.

public class Testobjekt {
 
// Klassenvariable
    static int zaehler = 0;
 
// Instanzvariable
    int nummer;
 
    // Konstruktor 
    public Testobjekt() {
        zaehler= zaehler+1;
        nummer = zaehler;
    }
 
    // Klassenmethode
    static int getZaehler() {
       return zaehler;
    }
}
 
 
public class Zaehlertest{
 
public void zaehlerTest(){
    System.out.println("Klassenvariable zaehler:"+ Testobjekt.getZaehler());
 
        Testobjekt obj_1 = new Testobjekt();
        Testobjekt obj_2 = new Testobjekt();
        Testobjekt obj_3 = new Testobjekt();
 
        System.out.println("Instanzvariable nummer im 1. Objekt: "+ obj_1.nummer);
        System.out.println("Instanzvariable nummer im 2. Objekt: "+ obj_2.nummer);
        System.out.println("Instanzvariable nummer im 3. Objekt: "+ obj_3.nummer);
        System.out.println("Klassenvariable zaehler: " + Testobjekt.getZaehler());
 
}
}

Aufgabe 1

Erstelle wiederum ausgehend von der bekannten Klasse Schueler eine Klasse Schueler, in der die Zahl der erzeugten Instanzen festgehalten und über eine Getter-Methode ausgelesen werden kann. Schreibe nun eine zweite Klasse Schule in deren Konstruktor vier Schueler-Objekte erzeugt werden und durch den Aufruf der Getter-Methode die Anzahl der erzeugten Instanzen der Klasse Schueler angezeigt wird.

Lösungsvorschlag anzeigen

Lösungsvorschlag verstecken

public class Schueler
{
//Attribute
private String name;
private String vorname;
private String klasse;
 
//Klassenvariable
static int schuelerzahl=0;
 
//Konstruktor
public Schueler(String name, String vorname, String klasse){
   this.name=name;
   this.vorname=vorname;
   this.klasse=klasse;
 
//Inkrementierung des Zählers
   schuelerzahl++;
 
   ausgeben(name,vorname,klasse);
}   
 
public void ausgeben(String name, String vorname, String klasse){
   System.out.println(name);
   System.out.println(vorname);
   System.out.println(klasse);
   System.out.println();
}
 
//Klassenmethode
static int getSchuelerzahl(){
   return schuelerzahl;
}
 
}
 
 
 
public class Schule
{
 
//Konstruktor
public Schule(){ 
   Schueler s1=new Schueler("Huber", "Hans", "5b");
   Schueler s2=new Schueler("Meier", "Marie", "5c");
   Schueler s3=new Schueler("Geier", "Gabi", "5d");
   Schueler s4=new Schueler("Mueller", "Martin", "5a");
   System.out.println();
 
   //Aufruf der Klassenmethode um den Wert der Klassenvariable abzufragen
   System.out.println("Die Schule hat "+Schueler.getSchuelerzahl()+" Schueler.");
}
 
}

Aufgabe 2

Löse das obige Problem mit Hilfe eines Arrays in der Klasse Schule. Entferne die Ausgabe-Methode aus der Klasse Schueler und verlege die Ausgabe in eine Methode schuelerAusgeben() in der Klasse Schule. Zusätzlich soll eine Methode klassenstaerke() erstellt werden, die nach Eingabe der gewünschten Klasse deren Stärke auf der Konsole ausgibt. Hinweis: Um einen Zugriff auf die Attribute der Schueler-Objekte zu erlauben, sind Getter-Methoden in der Klasse Schueler notwendig.

Lösungsvorschlag anzeigen

Lösungsvorschlag verstecken

public class Schueler
{
//Attribute
private String name;
private String vorname;
private String klasse;
 
//Klassenvariable
static int schuelerzahl=0;
 
public Schueler(String name, String vorname, String klasse){
this.name=name;
this.vorname=vorname;
this.klasse=klasse;
 
//Inkrementierung des Wertes der Klassenvariable
schuelerzahl++;
}  
 
public String getName(){
return name;
} 
 
public String getVorname(){
return vorname;
} 
 
public String getKlasse(){
return klasse;
} 
 
static int getSchuelerzahl(){
return schuelerzahl;
}
 
}
 
 
 
public class Schule
{
 
//Deklaration und Erzeugung des Arrays
Schueler[]s=new Schueler[4];
 
//Konstruktor
public Schule(){ 
//Initialisierung des Arrays
s[0]=new Schueler("Huber", "Hans", "5b");
s[1]=new Schueler("Meier", "Marie", "5c");
s[2]=new Schueler("Geier", "Gabi", "5d");
s[3]=new Schueler("Mueller", "Martin", "5b");
 
 
//Ausgabe des Wertes für die Anzahl der Schüler (Klassenvariable)
System.out.println("Die Schule hat "+Schueler.schuelerzahl+" Schueler.");
}
 
//Ausgabe-Methode
public void schuelerAusgeben(){
for(int i=0;i<s.length;i++){
System.out.println(s[i].getName()+", "+s[i].getVorname()+", "+s[i].getKlasse());}
}
 
//Methode zum Ermitteln der Klassenstärke
public void klassenstaerke(String klasse){
int zaehler=0;
for(int i=0;i<s.length;i++){
if((s[i].getKlasse()).equals(klasse)){zaehler++;};}
System.out.println("Die Klasse "+klasse+" hat "+zaehler+" Schueler.");
 
}
 
}

Aufgabe 3

Erstelle eine Klasse Kasse mit einem Konstruktor, der nur den Namen der Klasse und den Betrag für die Einnahmen enthält. Mit Hilfe einer Klassenvariable einnahmen sollen die Gesamteinnahmen der erzeugten Kassen-Objekte festgehalten werden. Eine entsprechende Getter-Methode erlaubt den Zugriff auf den Wert der Klassenvariable. Eine weitere Klasse Abrechnung enthält nur eine Methode gesamteinnahmen(), die unter Rückgriff auf die Klassenvariable von Kasse die Gesamteinnahmen der erzeugten Kassen-Objekte auf der Konsole ausgibt.

Lösungsvorschlag anzeigen

Lösungsvorschlag verstecken

public class Kasse {
 
private String nummer;
static int einnahmen = 0;
 
public Kasse(String nummer, int betrag){
this.nummer = nummer;
einnahmen = einnahmen + betrag;
}
 
static int getEinnahmen(){
return einnahmen;
}
}
 
 
 
public class Abrechnung {
 
public void gesamteinnahmen(){
System.out.println("Gesamteinnahmen: "+Kasse.getEinnahmen());}
 
}

Aufgabe 4

Für eine Firma soll ein Programm zur Abwicklung ihrer Aufträge erstellt werden. Die Grundlage ist folgendes Klassendiagramm:

Ziel ist die Ausgabe einer Bestellbestätigung folgender Art:

Sehr geehrter Herr Huber,
wir bestätigen ihre Bestellung von 5 St. Dachziegel
zum Stückpreis von 3,59 Euro.
Der für Sie zuständige Sachbearbeiter ist Heribert Freundlich.
Ihre Auftragsnummer: 1/2015.

Hinweis: Um eine Instanz der Klasse Auftrag zu erzeugen, müssen die zugehörigen Instanzen der Klassen Kunde, Ware und Mitarbeiter erzeugt werden.

Lösungsvorschlag anzeigen

Lösungsvorschlag verstecken

public class Kunde{
//Attribute
private String kndnr;
private String name;
private String vorname;
private String geschlecht;    //{m, w}
 
public Kunde(String kndnr, String name, String Vorname, String geschlecht){
this.kndnr=kndnr;
this.name=name;
this.vorname=vorname;
this.geschlecht=geschlecht;
}
 
 
//Getter-Methoden
public String getKndnr(){
return kndnr;
}
 
public String getName(){
return name;
}
 
public String getVorname(){
return vorname;
}
 
public String getAnrede(){
String g;
if(geschlecht.equals("m")){g="Sehr geehrter Herr "; return g;} 
else {g="Sehr geehrte Frau"; return g;}
}
 
 
}
 
 
 
public class Ware{
 
public String bezeichnung;
public double preis;
 
public Ware(String bezeichnung, double preis){
this.bezeichnung=bezeichnung;
this.preis=preis;}
 
public String getBezeichnung(){
return bezeichnung;
}
 
public double getPreis(){
return preis;
}
}
 
 
 
public class Mitarbeiter{
//Attribute
private String persnr;
private String name;
private String vorname;
 
public Mitarbeiter(String persnr, String name, String Vorname){
this.persnr=persnr;
this.name=name;
this.vorname=vorname;
}
 
 
//Getter-Methoden
public String getPersnr(){
return persnr;
}
 
public String getName(){
return name;
}
 
public String getVorname(){
return vorname;
}
 
 
}
 
 
 
public class Auftrag{
//Attribute
static int auftragsnr;
 
public Ware w;
public int anzahl;
public Kunde k;
public Mitarbeiter m;
 
public Auftrag(Kunde k, Mitarbeiter m, Ware w, int anzahl){
this.k=k;
this.anzahl=anzahl;
this.w=w;
this.m=m;
 
auftragsnr++;
}
 
public void auftragsbestaetigung(){
System.out.println(k.getAnrede()+k.getName());
System.out.println("Wir bestätigen die Bestellung von "+anzahl+" Stück "+w.getBezeichnung());
System.out.println("zum Peis von "+w.getPreis()+" pro Stück.");
System.out.println("Ihr zuständiger Kundenbetreuer: "+m.getVorname()+" "+m.getName());
System.out.println("Ihre Auftragsnummer: "+auftragsnr+"/2016.");
 
}
}