# For-Schleife in OOP, Methode



## MaxXxOfficial (17. Dez 2020)

Hallo,

ich muss bis morgen folgende Methode programmieren:

Die Klasse enthält die Methode *einzelnAuffuellen()*. Dabei wird der Bestand solange um den Wert 10 erhöht, bis das Lager voll ist. Es wird gezählt, wie oft die Schleife durchlaufen wird. Dieser Wert wird von der Methode zurückgegeben.

Dabei haben wir Variablen: Bestand und Kapazitaet (double)

Ich weiß, dass eine for-Schleife angebracht wäre, komme aber leider nicht wirklich weiter. Habt ihr eine Idee?
Grüße


----------



## mihe7 (17. Dez 2020)

Verstehe ich nicht: wieso sollte in einer Methode, die *einzeln*Auffuellen heißt, eine for-Schleife dafür sorgen, dass das Lager zig-mal gefüllt wird, bis es voll ist?


----------



## Blender3D (17. Dez 2020)

mihe7 hat gesagt.:


> Verstehe ich nicht: wieso sollte in einer Methode, die *einzeln*Auffuellen heißt


Wahrscheinlich meint der Aufgabensteller damit, dass die Bestandsvariable nicht sofort auf den Maximalwert gesetzt wird. Sondern über die Schleife sukzessiv  um 1 erhöht wird bis der Zustand ist voll erreicht ist.

```
pulbic boolean isDepotFull(){
    return inventoryCount == inventoryMaximum;
}
```
Dient wohl eher didaktischen Zwecken


----------



## temi (17. Dez 2020)

MaxXxOfficial hat gesagt.:


> Ich weiß, dass eine for-Schleife angebracht wäre, komme aber leider nicht wirklich weiter. Habt


Eher eine while Schleife.

Wie sieht denn dein aktueller Code aus?


----------



## MaxXxOfficial (17. Dez 2020)

temi hat gesagt.:


> Eher eine while Schleife.
> 
> Wie sieht denn dein aktueller Code aus?




```
class Silo {
     //Instanzvariablen
  private int silonummer;
  private double kapazitaet;
  private double bestand;
 
  //Konstruktoren
 
  Silo () {
    }
 
  Silo (int pSilonummer, double pKapazitaet) {
    silonummer = pSilonummer;
    kapazitaet = pKapazitaet;
    }
 
  Silo (int pSilonummer, double pKapazitaet, double pBestand) {
    silonummer = pSilonummer;
    kapazitaet = pKapazitaet;
    bestand = pBestand;
    }
 
  //set methoden
 
  public void setSilonummer ( int pSilonummer) {
    silonummer = pSilonummer;
    }
 
  public void setKapazitaet (double pKapazitaet) {
    kapazitaet = pKapazitaet;
    }
 
  public void setBestand (double pBestand) {
    bestand = pBestand;
    }
 
  //Get Methoden
 
  public int getSilonummer () {
    return silonummer; }
 
  public double getKapazitaet () {
    return kapazitaet; }
 
  public double getBestand () {
    return bestand; }
 
  //Methoden
 
  public void ausgeben () {
    System.out.println ( "Die Silonummer ist: " + getSilonummer());
    System.out.println ( "Die Kapazitaet ist: " + getKapazitaet());
    System.out.println ( "Der Bestand ist: " + getBestand());
    }
 
  public void einlagern (double pMenge) {
    if (pMenge < getKapazitaet() - getBestand()) {
      System.out.println ("Der alte Bestand betraegt: " + getBestand ());
      setBestand ( getBestand() + pMenge) ;
      System.out.println ("Der neue Bestand betraegt: " + getBestand ());
      }
       else {
      System.out.println ("Die eingegebene Menge ist hoeher als die Kapazitaet des Silos!");
       }
     }
 
  public void auslagern (double pMenge) {
    if (pMenge > getBestand () ) {
      System.out.println("Die auszulagernde Menge ist groesser als der Bestand!"); }
    else {
      setBestand ( getBestand () - pMenge );
      System.out.println ("Das Auslagern war erfolgreich. Der neue Bestand betraegt :" + getBestand ());
      }
    }
 
  public void trocknenEinfach () {
    setBestand ( getBestand () * 0.8 ) ;
    }
 
  public void trocknenEingabe (double pProzent) {
    pProzent = (100 - pProzent) / 100 ;
    setBestand (getBestand () * pProzent);
    }
 
  public boolean pruefenEinlagern (double pMenge) {
    if ((getKapazitaet () - getBestand ()) < pMenge) {
      return false;
      }
    else {
      return true;
       }
        }
 
  public boolean pruefenEntnehmen (double pMenge) {
    if (getBestand () > pMenge) {
      return false;
      }
    else {
      return true;
      }
          }
 
  public void entnehmen (double pMenge) {
    if (pruefenEntnehmen (pMenge)  ) {
      setBestand ( getBestand () - pMenge);
    }
    else {
      System.out.println("Nicht moeglich!");
      }
    }
 
  public void umlagern (Silo pSilo, double pMenge) {
    if (pruefenEntnehmen(pMenge) && pSilo.pruefenEinlagern(pMenge) ) {
      setBestand ( getBestand () - pMenge );
      pSilo.setBestand ( getBestand () + pMenge);
      System.out.println(" Das Umlagern war erfolgreich!");
      }
    else {
      System.out.println ("Das Umlagern ist nicht moeglich!");
      }
    }
 

   }
```


----------



## MaxXxOfficial (17. Dez 2020)

MaxXxOfficial hat gesagt.:


> ```
> class Silo {
> //Instanzvariablen
> private int silonummer;
> ...


Und meine Idee war folgende:



```
public int einzelnAuffuellen() {
   for (int i=1; getBestand() = getKapazitaet (); i++) {
     setBestand (getBestand() + 10 );
     }
   return i;
   }
```

aber ich weiß ja auch dass das so nicht geht :/


----------



## temi (17. Dez 2020)

Man vergleicht mit == und nicht mit = (das ist eine Zuweisung).

Und du solltest berücksichtigen, dass die Schleife ausgeführt wird *solange *die Bedingung erfüllt ist.


----------



## mihe7 (17. Dez 2020)

Für das Einlagern und das Prüfen einer Einlagerung hast Du doch schon Methoden: 

Die gewünschte Menge sei 10. So lange Einlagern der gewünschten Menge möglich, lagere die gewünschte Menge ein. Das lässt sich 1:1 in Java übersetzen:


```
final double menge = 10.0;
while (pruefeEinlagern(menge)) {
    einlagern(menge);
}
```


----------

