Vererbung

[Mariexshhx]

Hey, ich möchte in meiner Klasse diese Typen Unterscheidung loswerden. Ich habe schon einzelne Klassen für die einzelnen Typen erstellt und diese dann von Unit erben lassen. Ich weiß nur nicht wie ich mit den Methoden isLivingPlant(), isLivingBug() umgehen soll, damit ich hier meine Typen Unterscheidung nicht mehr brauche kann mir jemand helfen ? Die Methode act () habe ich für die einzelnenTypen von Unit überschrieben ...

 

[httpdigest]

Deine gepostete erste Lösung mit nur einer Unit-Klasse macht schon Sinn.
Warum möchtest du hier Polymorphie einführen, wenn dann letztlich doch wieder der Aufrufer/Client wissen muss, um welche Art von Einheit es geht?
Vererbung ist nicht immer sinnvoll!
Insbesondere nicht, wenn man Flexibilität durch (Laufzeit-)Konfiguration oder Scripting haben möchte. Klassenhierarchien und ihre Ausprägungen sind ja fix.
Aber isLivingPlant() und isLivingBug() etc könnten dann eben in den konkreten Unterklassen einfach nur noch false/true zurückliefern.

 

[Mariexshhx]

Deine gepostete erste Lösung mit nur einer Unit-Klasse macht schon Sinn.
Warum möchtest du hier Polymorphie einführen, wenn dann letztlich doch wieder der Aufrufer/Client wissen muss, um welche Art von Einheit es geht?
Vererbung ist nicht immer sinnvoll!
Insbesondere nicht, wenn man Flexibilität durch (Laufzeit-)Konfiguration oder Scripting haben möchte. Klassenhierarchien und ihre Ausprägungen sind ja fix.
Aber isLivingPlant() und isLivingBug() etc könnten dann eben in den konkreten Unterklassen einfach nur noch false/true zurückliefern.

das war die Aufgabenstellung, dass man diese Typ Unterscheidung in Unit loswerden soll
Und Vererbung wollte ich Einführen damit ich weitere Arten wie z.B die Krähe einfacher hinzufügen kann

 

[Robert Zenz]

Naja, von der Aufgabenstellung mal abgesehen (sowas solltest du immer gleich dazu schreiben, moeglichst so genau wie moeglich), wuerde ich eher die Unterscheidung in den Enum UnitType ziehen. Also jeder UnitType weisz selbst ob dieser eine Pflanze ist oder nicht. Das verschiebt die Logik aber natuerlich nur.

Was in dem Fall eventuell Sinn machen koennte ist ein Entity Component System. Also eine Unit hat Kompoenten welche wiederum das Verhalten bestimmen. Das sieht dann in etwa so aus:

public class Unit {
    public <COMPONENT_TYPE> COMPONENT_TYPE getComponent(Class<COMPONENT_TYPE> componentClass);
}

public class PlantProcessor implements Processor {
    public void process(Unit unit) {
        Plant plant = unit.getComponent(Plant.class);
      
        if (plant != null) {
            // Do something here with the plant.
        }
    }
}

// In der Logik:

List<Processor> processors = Arrays.asList(new PlantProcessor(), new BlubProcessor(), new BlaProcessor());

for (Processor processor : processors) {
    processor.process(unit);
}

Also die Logik was eine Einheit tut verschiebt sich dann von der Unit in den entsprechenden Processor.

 

[Mariexshhx]

Naja, von der Aufgabenstellung mal abgesehen (sowas solltest du immer gleich dazu schreiben, moeglichst so genau wie moeglich), wuerde ich eher die Unterscheidung in den Enum UnitType ziehen. Also jeder UnitType weisz selbst ob dieser eine Pflanze ist oder nicht. Das verschiebt die Logik aber natuerlich nur.

Was in dem Fall eventuell Sinn machen koennte ist ein Entity Component System. Also eine Unit hat Kompoenten welche wiederum das Verhalten bestimmen. Das sieht dann in etwa so aus:

public class Unit {
    public <COMPONENT_TYPE> COMPONENT_TYPE getComponent(Class<COMPONENT_TYPE> componentClass);
}

public class PlantProcessor implements Processor {
    public void process(Unit unit) {
        Plant plant = unit.getComponent(Plant.class);
     
        if (plant != null) {
            // Do something here with the plant.
        }
    }
}

// In der Logik:

List<Processor> processors = Arrays.asList(new PlantProcessor(), new BlubProcessor(), new BlaProcessor());

for (Processor processor : processors) {
    processor.process(unit);
}

Also die Logik was eine Einheit tut verschiebt sich dann von der Unit in den entsprechenden Processor.

ah okay vielen dank ! Wenn ich jetzt aber den enum typen loswerden will. Kann man ja in der Methode act in der Klasse Unit die Implementerierung "weglassen". Ich kann daraus aber ja keine abstrakte Methode machen, weil die Klasse ja nicht abstrakt sein kann, weil die Methoden zum bewegen der Spielfiguren ja gleich sind für alle unterschiedenlichen Typen von Spielfiguren. Erst hatte ich überlegt aus Unit ein Interface zu machen, macht aber ja aufgrund dessen keinen Sinn oder ? Aber was mache ich dann mit der Methode act, die dann keine Implementierung hat?

 

[Mariexshhx]

Deine gepostete erste Lösung mit nur einer Unit-Klasse macht schon Sinn.
Warum möchtest du hier Polymorphie einführen, wenn dann letztlich doch wieder der Aufrufer/Client wissen muss, um welche Art von Einheit es geht?
Vererbung ist nicht immer sinnvoll!
Insbesondere nicht, wenn man Flexibilität durch (Laufzeit-)Konfiguration oder Scripting haben möchte. Klassenhierarchien und ihre Ausprägungen sind ja fix.
Aber isLivingPlant() und isLivingBug() etc könnten dann eben in den konkreten Unterklassen einfach nur noch false/true zurückliefern.

muss ich nicht aber trotzdem immer eine Überprüfung für die Hitpoints mit implemetieren ?

 

[Mariexshhx]

Deine gepostete erste Lösung mit nur einer Unit-Klasse macht schon Sinn.
Warum möchtest du hier Polymorphie einführen, wenn dann letztlich doch wieder der Aufrufer/Client wissen muss, um welche Art von Einheit es geht?
Vererbung ist nicht immer sinnvoll!
Insbesondere nicht, wenn man Flexibilität durch (Laufzeit-)Konfiguration oder Scripting haben möchte. Klassenhierarchien und ihre Ausprägungen sind ja fix.
Aber isLivingPlant() und isLivingBug() etc könnten dann eben in den konkreten Unterklassen einfach nur noch false/true zurückliefern.

@Override
public boolean isLivingPlant() {
if(hitpoints>0){
return true;
}
else{
return false;
}