4.2 Gegenstände, Rucksäcke und Helden

Zielsetzung

Auf dieser Seite lernen Sie, wie man in Java mit Objekt-Arrays arbeitet. Dabei begleiten Sie eine Spielfigur auf ihrem Abenteuer und entwickeln eigene Klassen für Gegenstände, ein Inventar und schließlich sogar für einen Helden. Schritt für Schritt erweitern Sie das System und vertiefen dabei wichtige Konzepte der objektorientierten Programmierung – ganz praktisch und anschaulich.

Inhalt dieser Seite

Einleitung

Nachdem wir uns nun intensiv mit dem Aufbau von Java-Klassen, Instanzvariablen, Getter- und Setter-Methoden, Kontrollstrukturen wie if-else und switch-case sowie mit for- und while-Schleifen und ersten Arrays beschäftigt haben, möchten wir dieses Wissen in einem kleinen Projekt anwenden. Dazu dient ein einfaches Adventure-Spiel, das uns die Möglichkeit gibt, alle bisher behandelten Inhalte sinnvoll zu verknüpfen und zu vertiefen.

Solche projektorientierten Beispiele finden sich inzwischen auch in einigen Informatik-Schulbüchern – ob diese Idee durch meine Homepage angeregt wurde (die seit 1997 besteht) oder unabhängig entstanden ist, lässt sich natürlich schwer sagen. Wir beginnen nun jedenfalls mit der praktischen Umsetzung und folgen dabei einem Bottom-Up-Vorgehen: Zuerst entwerfen wir eine Klasse Gegenstand.

Im Mittelpunkt stehen dabei:

• Klassen und Instanzvariablen
• Getter- und Setter-Methoden
• Formatierte Ausgabe mit printf()

Ein Held mit einem Rucksack und Gegenständen
Autor: ChatGPT 4.0, 7/2025, Lizenz: Public domain

4.2.1 Die Klasse Gegenstand ^↑

Bei einem solchen Gegenstand kann es sich beispielsweise um ein Schwert, ein Beil oder eine andere Waffe handeln, oder um einen Helm, einen Brustpanzer, einen Heiltrank oder Ähnliches, wie es eben in Abenteuerspielen üblich ist.

Attribute

Wer sich etwas mit Adventure-Games wie Diablo oder Baldur's Gate auskennt, wird sofort sagen können, was die wichtigsten Attribute eines solchen Gegenstands sind. Als erstes fallen dazu die folgenden Eigenschaften ein:

• Name
• Typ
• Seltenheit
• Angriffswert
• Verteidigungswert
• Goldwert
• Gewicht
• Zustand

Diese Attribute müssen jetzt mithilfe von Instanzvariablen implementiert werden. Für den Anfang beschränken wir uns aber auf vier Attribute, nämlich Angriffswert, Verteidigungswert, Goldwert und Zustand. Der erste Entwurf der Klasse Gegenstand würde dann so aussehen:

public class Gegenstand
{
    private String name;
    private int angriffswert, verteidigungswert, goldwert, zustand;
    
    public Gegenstand(String n, int a, int v, int g)
    {
       name              = n;
       angriffswert      = a;
       verteidigungswert = v;
       goldwert          = g;
       zustand           = 100; // Prozent
    }
    
   public void anzeigen()
   {
       System.out.printf("%-20s %s%n", "Bezeichnung:", name);
       System.out.printf("%-20s %5d%n", "Angriffswert:", angriffswert);
       System.out.printf("%-20s %5d%n", "Verteidigungswert:", verteidigungswert);
       System.out.printf("%-20s %5d%n", "Goldwert:", goldwert);
       System.out.printf("%-20s %5d%%%n", "Zustand:", zustand);
   }
}

Zum printf()-Befehl

In der anzeigen()-Methode wird übrigens reichlich Gebrauch printf(), der formatierten Ausgabe, gemacht. Die Strings werden mit genau 20 Stellen Breite angezeigt (%-20s). Der Strich vor der 20 führt dazu, dass die Ausgabe linksbündig erfolgt, ohne den Strich hätten wir eine rechtsbündige Ausgabe.

Dann folgt der Platzhalter für die auszugebende Variable.

• %s ist der Platzhalter für einen String ohne Angabe der Stellen
• %5e steht für eine int-Zahl mit Platz für 5 Stellen
• %n steht für einen Zeilenumbruch
• %% steht für das Prozentzeichen

public class TesteGegenstand // Für BlueJ
{
    Gegenstand g0, g1, g2;

    public TesteGegenstand()
    {
        g0 = new Gegenstand("Hammer",20,3,567);
        g1 = new Gegenstand("Helm",0,13,230);
        g2 = new Gegenstand("Stiefel",4,10,177);    
        
        g0.anzeigen();
        System.out.println( );
        g1.anzeigen();
        System.out.println( );
        g2.anzeigen();
        System.out.println( );
    }
}

public class TesteGegenstand // Für IntelliJ
{
    Gegenstand g0, g1, g2;

    public TesteGegenstand()
    {
        g0 = new Gegenstand("Hammer",20,3,567);
        g1 = new Gegenstand("Helm",0,13,230);
        g2 = new Gegenstand("Stiefel",4,10,177);    
        
        g0.anzeigen();
        System.out.println( );
        g1.anzeigen();
        System.out.println( );
        g2.anzeigen();
        System.out.println( );
    }

    // ---------------------------
    // main-Methode für IntelliJ
    // ---------------------------
    public static void main(String[] args)
    {
        new TesteGegenstand();   // Konstruktor führt alle Tests aus
    }	 
}

Hinweis: Die Länge des Namens können Sie wie folgt auf 30 Zeichen begrenzen:

name = name.substring(0, 30);

Die Methode substring() der Klasse String besitzt zwei Parameter. Der erste Parameter gibt an, an welchem Index der Substring anfangen soll. Der zweite Parameter gibt die Länge des Substrings an.

Falls der Name keine fünf Zeichen lang ist, soll er standardmäßig auf "Nicht definiert" oder eine andere Fehlermeldung gesetzt werden.

public Gegenstand(String n, int a, int v, int g)
{
    setName(n);
    setAngriffswert(a);
    setVerteidigungswert(v);
    setGoldwert(g);
    zustand = 100; 
}

public class Gegenstand
{
    // --- Konstanten ---
    private static final int  MIN_NAME_LEN    =   5;
    private static final int  MAX_NAME_LEN    =  30;
    private static final int  MIN_ANGRIFF     =   0;
    private static final int  MAX_ANGRIFF     = 200;
    // und so weiter ...

    // --- Felder ---
    private String name;
    private int angriffswert, verteidigungswert, goldwert, zustand;
	 
    // --- Konstruktor ---
    

    public void setAngriffswert(int a)
    {
        if (a < MIN_ANGRIFF)
            angriffswert = MIN_ANGRIFF;
        else if (a > MAX_ANGRIFF)
            angriffswert = MAX_ANGRIFF;
        else
            angriffswert = a;
    }

Wir wollen jetzt jeden Gegenstand mit einem Typ versehen, wobei wir sechs Kategorien unterscheiden:

0. "Waffe"
1. "Schild"
2. "Rüstung"
3. "Trank"
4. "Werkzeug"
5. "Sonstiges"

Man könnte hier eine Enumerations einsetzen, aber das erscheint mir für das 1. Semester etwas zu kompliziert. Statt dessen machen wir das folgendermaßen:

Wir ergänzen die Instanzvariablen um einen String-Array

    // --- Gegenstands-Typen (Konstanten) ---
    private static final String[] TYP_STRING =
    {
        "Waffe", "Schild", "Ruestung", "Trank", "Werkzeug", "Sonstiges"
    };

verwalten den Typ des Gegenstandes aber als einfache int-Zahl zwischen 0 und 5. Typ 0 bedeutet dann "Waffe", Typ 1 "Schild" und so weiter.

Die Setter-Methode für die Instanzvariable typ sieht dann so aus:

    public void setTyp(int t)
    {
        if (t < 0)
            typ = 0;
        else if (t >= TYP_STRING.length)
            typ = TYP_STRING.length - 1;  // oder: typ = 0;
        else
            typ = t;
    }

Durch die Verwendung von typen.length können wir den Array typen problemlos um weitere Gegenstands-Typen erweitern. Für den Minimal-Wert von typ brauchen wir auch keine Konstante, denn typ ist nichts anderes als ein Array-Index, und dieser darf keinen Wert kleiner als 0 haben. Diesen Minimalwert werden wir also mit Sicherheit niemals ändern.

Die Methode zum Anzeigen der Gegenstände erweitern wir um einen weiteren printf()-Befehl:

System.out.printf("%-30s %s%n", "Typ:", TYP_STRING[typ]);

4.2.2 Die Klasse Inventar ^↑

An dieser Stelle wollen wir nun den Umgang mit Objekt-Arrays üben. Ein Objekt-Array enthält keine int- oder double-Zahlen oder andere primitive Datentypen, sondern Objekte einer Klasse. Alle Objekte des Arrays müssen aber der gleichen Klasse angehören.

Hier der  Quelltext der ersten Version einer solchen Inventar-Klasse:

public class Inventar
{
    private Gegenstand[] item;
    private int anzahl;
    
    public Inventar()
    {
        item = new Gegenstand[12];
        anzahl = 0;
        erstellen();
    }

    public void erstellen()
    {
        hinzufuegen(new Gegenstand("Langschwert",      75,  0, 120, 0));
        hinzufuegen(new Gegenstand("Kurzbogen",        60,  0, 150, 0));
        hinzufuegen(new Gegenstand("Rundschild",        0, 45,  90, 1));
        hinzufuegen(new Gegenstand("kleiner Heiltrank", 0,  0,  35, 3));
        hinzufuegen(new Gegenstand("großer Heiltrank", 0,  0,  80, 3));
        hinzufuegen(new Gegenstand("Brustpanzer",       0, 70, 300, 2));
        hinzufuegen(new Gegenstand("Stiefel",           0, 15,  60, 2));
        hinzufuegen(new Gegenstand("Goldhelm",          0, 25, 110, 2));
        hinzufuegen(new Gegenstand("Dietrich",          0,  0,  25, 4));
        hinzufuegen(new Gegenstand("Seil (20 m)",       0,  0,  18, 4));
        hinzufuegen(new Gegenstand("Fackel",            0,  0,  10, 5));
        hinzufuegen(new Gegenstand("Karte der Gegend",  0,  0,  45, 5));
    }

    public void ausgeben()
    {
        for (int i = 0; i < 12; i++)
        {
            item[i].anzeigen();
            System.out.println();
        }
    }

    private void hinzufuegen(Gegenstand g)
    {
        if (anzahl >= 12) return;
        
        item[anzahl] = g;
        anzahl++;
    }
}

Hier sehen Sie die Klasse Inventar mit zwölf Gegenständen.

Um die Klasse für Erweiterungen flexibler zu halten, werden die Gegenstände hier über die Methode hinzufuegen() dem Inventar hinzugefügt. In diesem Quelltext ist die Anzahl der Gegenstände im Inventar auf 12 beschränkt. Dies kann man aber leicht ändern, indem man eine Konstante KAPAZITAET einführt, die bei der Initialisierung des Arrays und bei den for-Schleifen verwendet werden kann.

public class TesteInventar
{
    Inventar rucksack;

    public TesteInventar()
    {
        rucksack = new Inventar();
        rucksack.ausgeben();
    }

    public static void main(String[] args)
    {
        new TesteInventar();   
    }
}

4.2.3 Die Klasse Held ^↑

   public Held(String name, int angriff, int verteidigung)
    {
        Random rGenerator = new Random();
        
        this.name = name;
        setAngriffswert(angriff);
        setVerteidigungswert(verteidigung);
        leben = 80 + rGenerator.nextInt(20)+1;
    }

public class Teste
{
    Held otto;

    public Teste()
    {
        otto = new Held("Otto der Große",50,60);
        otto.anzeigen();
        
        otto.setAngriffswert(80);
        otto.setVerteidigungswert(210);
        otto.setLeben(150);
        
        otto.anzeigen();
    }

    public static void main(String[] args)
    {
        new Teste();   
    }
}

      waffe1 = null;
      waffe2 = null;
      schild = null;

Das war es erst mal mit dem kleinen Adventure-Game. In den folgenden Abschnitten dieses Kurses werde ich gelegentlich auf diese Thematik zurückkommen. Wenn Sie Lust haben oder Ihre Programmier-Fertigkeiten üben wollen, denken Sie sich noch ein paar weitere interessante Methoden für die Klasse Held aus.

Zur Klausur

Was ist von dem Ganzen für die Klausur wichtig?

Die Klausur besteht aus zwei Teilen. Im ersten Teil kommen ein paar kleinere Aufgaben zu Fallunterscheidungen, Schleifen und Arrays, wie Sie es bereits aus den vielen Übungsaufgaben kennen.

Im zweiten Teil kommt eine größere Aufgabe, bei der Sie eine ganze Klasse erstellen müssen. Die Methoden dieser Klasse können durchaus auf Methoden einer anderen Klasse zugreifen, so ähnlich, wie wir es hier mit der Klasse Inventar und der Klasse Gegenstand geübt haben. Eine so große Klasse wie Gegenstand oder Inventar wird in der Klausur natürlich nicht vorkommen. Dort haben Sie ja auch lange nicht so viel Zeit wie in den 180 minütigen Veranstaltungen.

Es kann auch gut sein, dass Sie in der Klausur ein Materialienblatt bekommen, auf dem Sie die Spezifikation von ein oder zwei Klassen finden. Was man unter einer Spezifikation versteht, finden Sie auf der Spezialseite "Spezifikation" auf dieser Homepage. Die Aufgabe könnte dann darin bestehen, eine neue Klasse zu schreiben, die auf die Methoden der vorgegebenen Klassen zugreift. Das würde dann so ähnlich sein wie im Informatik-Abitur NRW, allerdings nicht so umfangreich, da Sie weniger Zeit haben.

Zunächst aber wollen wir erst einmal verstehen, wie ein Objekt-Array überhaupt aufgebaut ist und funktioniert.