Methoden Zustand innerhalb einer Instanz ändern

[Kel]

Ich habe eine Aufgabe über Vererbung, bei der ich zum einen eine Superklasse 'Mario' definieren soll, von der dann 2 Subklassen erben (SuperMario, PinguinMario)
Teils unterschiedliche Funktionen bzw. Funktion für eine Subklasse nicht erlaubt - Methode überschreiben in der Subklasse hilft.
Das passt soweit auch.

Jetzt muss ich eine weitere Subklasse hinzufügen:

Sie wollen Ihr bestehendes Programm nun um FlugMario erweitern. Allerdings kann FlugMario nicht
– wie die bisherigen Formen – normal springen, sondern stattdessen eine kurze Zeit fliegen. Führen
Sie dazu eine abstrakte Klasse AbstrakterMario ein, von der alle drei konkreten Mario Klassen erben.
Überlegen Sie sich genau, welche Variablen und Methoden Sie in AbstrakterMario schreiben, und
welche Methoden davon abstrakt sein sollten.

Wie löse ich das am besten mit dem Konstruktor? Beim erzeugen einer FlugMario-Instanz muss ja die Flugzeit mitgegeben werden, ich dachte an einen extra Konstruktor in der Superklasse.

	public AbstrakterMario(boolean gross, int anzahlLeben) {
		this.gross = gross;
		this.anzahlLeben = anzahlLeben;
	}
	
	public AbstrakterMario(boolean gross, int anzahlLeben, int flugDauer) {
	this.gross = gross;
	this.anzahlLeben = anzahlLeben;
	this.flugDauer = flugDauer;
	}

Ist die Idee soweit gut, dass in der Superklasse zu machen, oder sollte ich das mit dem Konstruktor für FlugMario lieber in der Subklasse FlugMario machen?




Zweites Problem:

Zusätzlich soll Mario folgende Gegenstände einsammeln können. Fügen Sie den entsprechenden Code in die „Gegenstände sammeln“-Funktion Ihres Mario ein.
Als Parameter übergeben Sie einen AbstraktenGegenstand, die zu implementierenden Unterklassen sind die folgenden. Zusätzlich ändern Sie hier den Zustand innerhalb der jeweiligen Marioinstanz:
„roter Pilz“ : Der rote Pilz macht Mario groß.
„grüner Pilz“ : Mario bekommt ein Leben.
„Panzer“ : Mario kann bis zu 3 Panzer sammeln, die er schmeißen kann.

Hier bin ich mir unsicher, was genau gemeint ist und wie ich das lösen soll.

Eine neue Superklasse 'AbstrakterGegenstand' und 3 Subklassen (RoterPilz, GruenerPilz, Panzer) sind soweit klar. Die neue Superklasse kann ich ja auch 'abstrakt' machen, da es ja keinen Sinn macht, davon ein Objekt zu erzeugen.
Nur wie übergebe ich 'AbstrakterGegenstand' als Parameter? Dass wäre dann ja sowas wie

public void sammelGegenstand(AbstrakterGegenstand item) {

	}

Das sieht aber ehrlich gesagt nicht so wirklich sinnvoll oder logisch aus. Und wie änder ich den Zustand der Marioinstanzen, wenn z.B. SuperMario einen roten Pilz sammelt. Müsste ja eigentlich mit set-Methode machbar sein, aber wie greife ich auf die set-Methode der SuperMario-Instanz zu?
Und ist die Überlegung auch richtig oder hab ich da einen Denkfehler?

Und dann noch zu den Subklassen GruenerPilz, RoterPilz, Panzer - wie mach ich das? Mir fehlt da irgendwie der komplette Ansatz.
Überlegung meinerseits war, dass ich in bei der sammelGegenstand()-Methode ja ein Item übergeben muss, das Item hat ja dazu noch Auswirkungen auf meine Marioinstanz.
Zusätzlich verstehe ich die Aufgabenstellung so, dass ich die Änderung der Marioinstanz in der Subklasse der Items machen soll. Bloss wie?

Wäre nett wenn jemand Tipps für mich hat, Vererbung ist wohl doch nicht so leicht wie ich dachte :rtfm:.

 

[Crian]

Ich vermute, dass Mario dann eine Liste der eingesammelten Gegenstände braucht. Bei den Gegenständen kann nur die Information vermerkt werden, die diese Gegenstände betreffen. In einer anderen Klasse dürften sie nichts ändern.

Mario kann einfach abfragen, ob der Gegenstand in der Liste abstrakter Gegenstände ein roter Pilz ist, und wenn ja führt er die und die Auswirkungen durch.

Das ist nur etwas unglücklich, weil dann die Informationen über die Wirkungen der Gegenstände nicht in diesen Klassen stecken, sondern in Mario. Mmmh.


Edit: Alternativ kann Mario jeden Gegenstand nach allen Eigenschaften abfragen. Diese Abfragen können in der Abstrakten Klasse drinstehen und immer 0 zurückgeben, der einzelne Gegenstand überschreibt dann nur die ihn betreffende Methode (etwa erhoeheLeben()). So muss man dann auch, wenn weitere Eigenschaften dazu kommen, nur die Basisklasse ändern, und nicht alle Gegenstände.

Also etwa so, nur mal für zwei Pilze:

abstract class AbtrakterGegenstand {
    public int erhoeheLeben() {
        return 0;
    }

    public int erhoeheGroesse() {
        return 0;
    }
}

class RoterPilz extends AbtrakterGegenstand {
    public int erhoeheGroesse() {
        return 5;
    }
}

class GruenerPilz extends AbtrakterGegenstand {
    public int erhoeheLeben() {
        return 10;
    }
}

Vielleicht kann man das noch eleganter machen und die Werte in Variablen vorhalten. Aber so in der Art ginge das.

Und Mario ruft dann für jeden Gegenstand einfach alle Funktionen auf.

 

[Der Müde Joe]

vielleicht sowas:

public interface IMario {
   void collect(IItem gegenstand);
   void morph(IMorph morphStrategy);
}

interface IItem {
   void interact(IMario mario);
}

interface IMorph {
   boolean increase();
   boolean shot();
   boolean bulletproof();
}

class Mario implements IMario {

   @Override
   public void collect (IItem gegenstand) {
      gegenstand.interact (this);
   }

   @Override
   public void morph (IMorph morphStrategy)
   {
      if (morphStrategy.increase ()) {
         // lass mario wachsen
      }
      if (morphStrategy.bulletproof ()) {
         // lsd flacker modus
      }
      //..
   }
}

class SuperFlower implements IItem {

   private IMorph morphStrategy;
   
   @Override
   public void interact (IMario mario) {
      mario.morph (morphStrategy);
   }
   
class Star implements IItem {

   private IMorph morphStrategy;
   
   @Override
   public void interact (IMario mario) {
      mario.morph (morphStrategy);
   }
}
}

EDIT:
oder gleich direkt:

public interface IMario {
   void collect(IItem gegenstand);
}

interface IItem {
   void interact(IMario mario);
}

class Mario implements IMario {

   @Override
   public void collect (IItem gegenstand)
   {
      gegenstand.interact (this);
   }
}

class SuperFlower implements IItem {

   @Override
   public void interact (IMario mario) {
      // lass ihn schiessen
   }
   
class Star implements IItem {

   @Override
   public void interact (IMario mario) {
      // lass inh flackerrn
   }
}
}