Eine Methode kann nicht von Klassen innerhalb eines Hashsets aufgerufen werden

Question

Ich versuche zu tun, ist die Auswirkungen der Auswirkungen in der Gefahrenklasse zusammenzufassen

Zum Beispiel wird es eine Liste von Insassen durchlaufen, eine Gefahr finden und die Auswirkungen davon erhalten. Setzen Sie dann die Gesamtwirkung aller Gefahren zusammen und geben Sie diesen Wert an mich zurück.

Unten habe ich das Höhlenklasse, Gefahrenklasse und Abstrakte Insassenklasse.

Wenn Sie der Höhle eine Gefahr hinzufügen, wird sie im Hashset ein Insassen. Beim Versuch, die Energieniveaus mit der Getimpact () -Methode zu erhalten, kann die Methode nicht wie in Gefahr und nicht in Bewohner zugegriffen werden.

Ich habe zwei weitere Klassen, die auch den Insassen erstrecken. Spieler und Artikel.

Ich kann keinen Weg finden, um die Gefahr als Gefahrenklasse bei der Hinzufügen zum Hashset zu halten, damit die Methode für Getimpact () verwendet werden kann.

Dies muss auch für den anderen Klassenspieler und den Artikel eingereicht werden, wenn sie zum Hashset hinzugefügt werden.

---

public class Cave {

HashSet<Occupant> occupants;
private double impact;

/**
 * Creat a new Cave instance with no occupants.
 */
public Cave() 
{
    occupants = new HashSet<Occupant>();
}

/**
 * Adds an occupant to a Cave if the occupant is not already there and
 * if cave currently has fewer than the maximum number of occupants.
 * @param occupant, the occupant to add
 * @return  true if successfully added
*/
public boolean addOccupant(Occupant occupant) {
    boolean validNewOccupant = occupant != null;
    boolean enoughRoom = occupants.size() < MAX_OCCUPANTS;
    if (validNewOccupant && enoughRoom) {
        validNewOccupant = occupants.add(occupant);
    }

    return validNewOccupant && enoughRoom;
}

/**
 * Gets the sum of the impact from all hazards in the cave
 * @returns hazardEnergyImpact
 */
public double getHazardEnergyImpacts(){
    double energyImpact = 0.0;
    for( Occupant occupant : occupants ){
        if(occupant.toString() == "!"){
            energyImpact += occupant.getImpact();
        }
    }
    return energyImpact;
}
}

---

public abstract class Occupant {

private Address address;
private String name;

/**
 * Construct an occupant for a known address & name.
 * @ param row, row of address  
 * @ param column, row of address.
 * @ param name, occupant's name
 */
public Occupant(Address address, String name) {
    this.address = address;
    this.name = name;
}

@Override
public String toString(){
    return "";
}
}

---

public class Hazard extends Occupant  {

private String longDescription;
private double impact;

/**
 * Construct a hazard with know attributes
 * @param row
 * @param column
 * @param name
 * @param longDescription
 * @param impact
 */
public Hazard(Address address, String name, String longDescription, double impact) {
    super(address, name);
    this.longDescription = longDescription;
    this.impact = impact;
}

@Override
public String toString(){
    return "!";
}

/**
 * gets impact amount
 * @returns impact
 */
public double getImpact(){
    return this.impact;
}
}

Answer 1

Beim Iterieren über Ihre occupants Sie können überprüfen, ob jedes Element a ist Hazard Like SO:

for(Occupant occupant : occupants){
    if(occupant instanceof Hazard){
        Hazard hazard = (Hazard) occupant; // now it's safe to cast
        double impact = hazard.getImpact();
        // do what you want with impact
    }
}

Answer 2

Eine andere Möglichkeit besteht darin, das hinzuzufügen getImpact() Methode zum Insassen, z. B., z. B.

public double getImpact() {
    return 0.0;
}

wohingegen Hazard's @Override Implementierung von getImpact() würde einfach seine zurückgeben impact Instanzvariable, wie Sie es bereits eingerichtet haben. Dann ist Ihre Schleife vereinfacht zu:

public double getHazardEnergyImpacts() {
    double energyImpact = 0.0;
    for( Occupant occupant : occupants ) {
        energyImpact += occupant.getImpact();
    }
    return energyImpact;
}

Wenn Sie später eine angemessene Schnittstellenabstraktion extrahieren müssen, ist dies gut, die moderne Ides so einfach machen.

Answer 3

Jeremy hat mich dazu geschlagen.

Instanz ist jedoch nicht immer die beste Lösung. In diesem Fall ist es jedoch eine Lösung.

Ich würde tatsächlich empfehlen, hier Schnittstellen für das Verhalten zu verwenden, anstatt eine abstrakte Klasse zu verwenden. Wenn Sie jedoch eine abstrakte Klasse verwenden müssen, besteht eine effizientere Möglichkeit darin, einfach abstrakte Methoden zu erstellen, die Sie in Ihren untergeordneten Klassen verwenden möchten. Sie müssten sie alle in jedem Kind außer Kraft setzen, aber Sie müssen sie in jedem Fall nicht umsetzen.

Answer 4

Ich würde das verwenden Besuchermuster hier.

public interface Occupant {
  void interact(Player p);
}

public class Player {
  public void handleInteraction(Hazard hazard) {
    // add code here
  }
  public void handleInteraction(Person person) {
    // add code here
  }
}

public class Hazard implements Occupant {
  public void interact(Player p) {
    p.handleInteraction(this);
  }

  public double getImpact(){
    return this.impact;
  }
}