Rechnen mit zwei Klassen

[district]

Hallo zusammen.

Grüble schon seit längerem an diesem Problem...

Ich habe zwei Klassen, Saison und Produkte. Nun möchte ich in Saison den Gewinn aller Produkte berechnen.
Ich hab dies schon mit einer While Schleife probiert, jedoch ohne Erfolg.

Ebenfalls hab ich eine Arraylist mit Datenfeld textilstueck welches die Objekte von Produkt verwaltet.

Mit folgendem Code berechne ich den Gewinn eines Produktes (Verkaufspreis - Einkaufspreis * Anzahl Produkte auf Lager):

public class Produkt
{
    /**
     * Datenfelder der Klasse Produkt
     */
    private double ep;
    private double vp;
    private double gewinn;
    private double gewinntotal;
    private int menge;


    /**
     * Berechnen den Gewinn pro Produkt.
     */
    public void winProductCalc()
    {
        double neuergewinn = vp - ep;
        gewinn = neuergewinn;
    }
    
     /**
     * Berechne den totalen Gewinn eines Produktetypes,
     * anhand der Anzahl Exemplare auf Lager.
     */
    public void winProductTotCalc()
    {
        gewinntotal = gewinn * menge;
    }

Wie könnte ich nun in der Klasse Saison eine Methode schreiben mit void dass sie mir von allen Produkt-Objekten den Subtotalen Gewinn errechnet?


Habs mal so probiert:

    private Produkt saisongt;


     /**
     * Rechnet den saisonalen Gewinn aus, 
     * auf Grund aller Objekte.
     */
    
    public void saisongtCalc()
    {
        while(saisongt < 10000.0 )
        {
            saisongt += saisongt.gtwinProductTotCalc();
        }
    }

 

[Guest]

wenn ich dich jetzt richtig verstanden habe soll in saison der gewinn aller produkte berechnet werden.

damit saison aus den produkten den gesamtgewinn berechnen kann muss saison die produkte kennen.

dann iterierst du einmal über die produkte drüber und frags jedes produkt nach seinem gewinn.

was macht deine methode gtwinProductTotCalc()? hat die einen rückgabewert?

stell doch mal den ganzen code der klassen saison und produkt hier rein ;-)

 

[diggaa1984]

du brauchst nur zu wissen welche produkte alle in einer saison verkauft wurden oder was auch immer ... und die liste kannst dazu nutzen alle produktgewinne zu ermitteln .. optimierenderweise, kannst auch 2d-array nehmen und pro produkt speichern wieviel in der saison verkauft wurden (damit brauchst nicht die Methode winProductTotCalc .. welche ja saisonunabhängig agiert wies scheint) .. mit dem array sparst ein ganz paar aufrufe, wenn die einzelne produkte öfter verkauft wurden.

wenn in einer saison produkt x verkauft wird, dann eben zu der liste der aktuellen saison nen neuen verweis machen, oder nen vorhandenen eintrag um 1 erhöhen, je nachdem welche variante du nimmst.

meinst in etwa sowas?

 

[district]

oke werd ich machen.. beim kapitel interieren hab ich in meinem bluej buch auch schon gestöbert.. hmm

import java.util.ArrayList;

public class Produkt
{
    /**
     * Datenfelder der Klasse Produkt
     */
    private String artname;
    private String groesse;
    private String farbe;
    private String sex;
    private double ep;
    private double vp;
    private double gewinn;
    private double gewinntotal;
    private int menge;

    /**
     * Konstruktor für Objekte der Klasse Produkt
     */
    public Produkt(String artname, String groesse, String farbe, String sex, double ep, double vp, int menge)
    {
        this.artname = artname;
        this.groesse = groesse;
        this.farbe = farbe;
        this.sex = sex;
        this.ep = ep;
        this.vp = vp;
        this.menge = menge;
    }

    /**
     * Setze Anzahl vorhandene Produkte.
     */
    public void setAnzProdukte(int menge)
    {
        if (menge > 0)
        {
            this.menge = menge;
        }
        else
        {
            System.out.println("Die Artikelmenge muss hoeher als 0 sein.");
        }
    }
    
    
     /**
     * Gebe Anzahl vorhandene Produkte zurück.
     */
    public int getAnzProdukte()
    {
        return menge;
    }
    
    /**
     * Aktuallisiere ein Produkt.
     */
    public void setProduktAktuell(String artname, String groesse, String farbe, String sex, double ep, double vp, int mengeAendern)
    {
        //Ersetzt den Artikelnname
        this.artname = artname;
        //Ersetzt die Groesse
        this.groesse = groesse;
        //Ersetzt die Farbe
        this.farbe = farbe;
        //Ersetzt das Geschlecht
        this.sex = sex;
        //Menge erhoehen oder herunterseten um Anzahl Produkte.
        menge += mengeAendern;
        //Einkauspreis ersetzen, wenn tiefer als VP und groesser als 0
        if (ep < vp && ep > 0)
        {
            this.ep = ep;
        }
        else
        {
            System.out.println("Der Einkaufspreis muss groesser als 0 und tiefer als der Verkaufspreis sein.");
        }
        //Einkauspreis ersetzen, wenn hoeher als EP und groesser als 0
        if (vp > ep && vp > 0)
        {
            this.vp = vp;
        }
        else
        {
            System.out.println("Der Verkaufspreis muss groesser als 0 und hoher als der Einkaufspreis sein.");
        }
    }
    
    /**
     * Berechnen den Gewinn pro Produkt,
     * und gebe ihn auf der Konsole au.
     */
    public void winProductCalc()
    {
        double neuergewinn = vp - ep;
        gewinn = neuergewinn;
        System.out.println("Gewinn des Produktes: " + gewinn);
    }
    
     

    
    /**
     * Berechne den totalen Gewinn eines Produktetypes,
     * anhand der Anzahl Exemplare auf Lager.
     * Und gebe ihn auf der Konsole aus.
     */
    public void winProductTotCalc()
    {
        gewinntotal = gewinn * menge;
        System.out.println("Gewinn der vorhandenen Produkte " + gewinntotal);
    }
    
  
    /**
     * Produkt ausgeben.
     */
    public void ausgeben()
    {
        System.out.println("*****************************************************");
        System.out.println("Produktname: " + artname);
        System.out.println("Groesse: " + groesse);
        System.out.println("Farbe: " + farbe);
        System.out.println("Geschlecht: " + sex);
        System.out.println("Vorhandende Artikel; " + menge);
        System.out.println("Einkaufspreis: " + ep + " CHF.");
        System.out.println("Verkaufspreis: " + vp +" CHF.");
        //Die folgenden zwei Ausdrücke wurden bewusst nicht mit gewinn,gewinntotal implementiert.
        System.out.println("Gewinn des Produktes: " + (vp - ep) +" CHF.");
        System.out.println("Gewinn der vorhandenen Produkte: " + ((vp - ep) * menge) +" CHF.");
        System.out.println("*****************************************************");
    }
    
    
}

import java.util.ArrayList;


public class Saison
{   
    //Datenfeld um die Kollektion nach Saisons zu gliedern.
    private ArrayList<Produkt> textilstueck;
    //Saisongewinn Total.
    private Produkt saisongt;

    /**
     * Konstruktor für Objekte der Klasse Produktekatalog
     */
    public Saison()
    {
        // Erzeuge neue Arraylist für Produkt.
        textilstueck = new ArrayList<Produkt>();
        // Speicher der Totalgewinn einer Saison.

    }
    
    /**
     * Anzahl Jahr der herausgebrachten Kollektionen
     */
    public int retourAnzTextilstuecke()
    {
        return textilstueck.size();
    }
    
    
    /**
     * Textilstueck hinzufuegen
     */
    public void hinzufuegenTextilstueck(Produkt newTextil)
    {
        textilstueck.add(newTextil);
    }
    
    /**
     * Textilstueck aus Liste entfernen
     */
    public void entferneTextilstueck(int index)
    {
        textilstueck.remove(index);
    }

    /**
     * Suche ein Textilstueck heraus
     */
    public int sucheTextilstueck(Produkt index)
    {
        return textilstueck.indexOf(index);
    }
    
    /**
     * Gibt alle Produkte einer Saison, 
     * auf der Konsole aus.
     */
    
    public void ausgebenProdukteSaison()
    {
        int index = 0;
        while(index < textilstueck.size())
        {
            System.out.println(textilstueck.get(index));
            index++;
        }
    }

    
     /**
     * Rechnet den saisonalen Gewinn aus, 
     * auf Grund aller Objekte.
     */
    
    public void saisongtCalc()
    {
       while(saisongt < 10000.0 )
        {
          aisongt += saisongt.gtwinProductTotCalc();
        }
    }



    
}

 

[district]

wenn ich dich jetzt richtig verstanden habe soll in saison der gewinn aller produkte berechnet werden.

damit saison aus den produkten den gesamtgewinn berechnen kann muss saison die produkte kennen.

dann iterierst du einmal über die produkte drüber und frags jedes produkt nach seinem gewinn.

was macht deine methode gtwinProductTotCalc()? hat die einen rückgabewert?

stell doch mal den ganzen code der klassen saison und produkt hier rein ;-)

gtwinProductTotCalc() berechnet den Subtotalengewinn der eines Produktes im Lager möglich ist.
Also Verkaufspreis minus Einkaufspreis mal Anzahl Produkte im Lager.

Ist eigentlich eine Produkteverwaltung welche schlussendlich vier Klasse mit Produktekatalog nach Jahr, Saison und Produkt gliedert.

Danke nochmals.

 

[diggaa1984]

so is ja schonma ne gute grundlage

private ArrayList<Produkt> textilstueck;

ist eine art katalog wies scheint.

was noch fehlt ist ne art bestellliste, in der alle Produkte und eventuell gleich mit anzahl pro produkt auftauchen, und damit kannst dann simpel den gesamtgewinn der saison errechnen.

ODER gehst du davon aus, das ALLE Produkte auf Lager, welche auch in "textilstueck" enthalten sind verkauft werden? Dann brauchst keine Bestellliste, sondern musst nur die ArrayList da oben abklappern und dir pro Produkt den Lagerinhalt holen, bzw dann gleich den totalgewinn aus der Produktklasse

darfst dich entscheiden

 

[district]

Ahm... dann nehm ich die zweite Variante :-D

Wenn ich nun bei jedem objekt der arraylist den totalgewinn abholen will, muss ich dies mit einem iterator lösen?
For each und while gehn da nicht, stimmt das?

Versuche das nun mit einem Interator zu lösen.. leider bekomm ich eine Fehlermeldung... operator + cannot be applied to Produkt, Produkt

Hab dies eingesetzt:

    public void saisongGewinnCalc()
    {
        Iterator<Produkt> it = textilstueck.iterator();
        while(it.hasNext())
        {
            saisongt +=  it.next();
        }
    }

Hier die ganze Klasse Produkte:

import java.util.ArrayList;
import java.util.Iterator;


public class Saison
{   
    //Datenfeld um die Kollektion nach Saisons zu gliedern.
    private ArrayList<Produkt> textilstueck;
    //Saisongewinn Total.
    private Produkt saisongt;

    /**
     * Konstruktor für Objekte der Klasse Produktekatalog
     */
    public Saison()
    {
        // Erzeuge neue Arraylist für Produkt.
        textilstueck = new ArrayList<Produkt>();
        // Speicher der Totalgewinn einer Saison.

    }
    
    /**
     * Anzahl Jahr der herausgebrachten Kollektionen
     */
    public int retourAnzTextilstuecke()
    {
        return textilstueck.size();
    }
    
    
    /**
     * Textilstueck hinzufuegen
     */
    public void hinzufuegenTextilstueck(Produkt newTextil)
    {
        textilstueck.add(newTextil);
    }
    
    /**
     * Textilstueck aus Liste entfernen
     */
    public void entferneTextilstueck(int index)
    {
        textilstueck.remove(index);
    }

    /**
     * Suche ein Textilstueck heraus
     */
    public int sucheTextilstueck(Produkt index)
    {
        return textilstueck.indexOf(index);
    }
    
    /**
     * Gibt alle Produkte einer Saison, 
     * auf der Konsole aus.
     */
    
    public void ausgebenProdukteSaison()
    {
        int index = 0;
        while(index < textilstueck.size())
        {
            System.out.println(textilstueck.get(index));
            index++;
        }
    }

    
     /**
     * Rechnet den saisonalen Gewinn aus, 
     * auf Grund aller Objekte.
     */
    
    
    public void saisongGewinnCalc()
    {
        Iterator<Produkt> it = textilstueck.iterator();
        while(it.hasNext())
        {
            saisongt +=  it.next();
        }
    }

    
}

 

[Guest]

du iterierst über eine liste von objekten.

hinter it.next verbirgt sich ein produkt-objekt, das kannst du nicht aufaddieren.

du willst da bestimmt den umsatz haben, dann musst du it.next nach dem umsatz fragen.

 

[district]

hmm... ich berechne in Produkt mit einer Methode den total möglichen Gewinn mittels Verkaufspreis minus Einkaufspreis mal Anzahl vorhandener Produkte. Nun möchte ich in Saison den Gewinn aller Objekte zusammen rechnen...

Aber ich find da keinen grünen Zweig .. wahrscheinlich ist der Fehler minimm. :roll:

Wie kann ich denn mit next klar machen, dass jedes objekt zur totalsumme bzw. umsatz (datenfeld: summegt) dazu addiert wird?

 

[diggaa1984]

also wenn deine arraylist einen katalog für die saison darstellt (keine produkte doppelt eingetragen) dann ist es ein leichtes.

einfach per iterator über die liste rennen und dann immer

saisongt +=  it.next().winProductTotCalc();

mit it.next() hast an der Stelle quasi nen finger auf nem Produkt-Objekt, und kannst dann per .-Operator einfach eine Methode der Produktklasse aufrufen

 

[district]

oke super .. jetzt hab ichs kapiert ;-)

jedoch wirft er mir immer noch diese Meldung an den Kopf:

Operator + cannot be applied to Produkt, void

public void saisongGewinnCalc()
{
Iterator<Produkt> it = textilstueck.iterator();
while(it.hasNext())
{
saisongt += it.next().winProductTotCalc();
System.out.println("Der Gewinn dieser Saison beträg: " + saisongt + (" CHF"));
}
}

Heisst das, dass die Methode "winProductTotCalc "nicht void haben darf?

 

[district]

oke super .. jetzt hab ichs kapiert ;-)

jedoch wirft er mir immer noch diese Meldung an den Kopf:

Operator + cannot be applied to Produkt, void

    public void saisongGewinnCalc()
    {
        Iterator<Produkt> it = textilstueck.iterator();
        while(it.hasNext())
        {
            saisongt +=  it.next().winProductTotCalc();
            System.out.println("Der Gewinn dieser Saison beträg: " + saisongt + (" CHF"));
        }
    }

Heisst das, dass die Methode "winProductTotCalc "nicht void haben darf?

 

[diggaa1984]

tatsache habsch nich richtig hingeschaut, und bin intuitiv vom falschen ausgegangen :d

public class Produkt 
{ 
    /** 
     * Datenfelder der Klasse Produkt 
     */ 
    private double ep; 
    private double vp; 
    private double gewinn; 
    private double gewinntotal; 
    private int menge; 


    /** 
     * Berechnen den Gewinn pro Produkt. 
     */ 
    public void winProductCalc() 
    { 
        double neuergewinn = vp - ep; 
        gewinn = neuergewinn; 
    } 
    
     /** 
     * Berechne den totalen Gewinn eines Produktetypes, 
     * anhand der Anzahl Exemplare auf Lager. 
     */ 
    public void winProductTotCalc() 
    { 
        gewinntotal = gewinn * menge; 
    }

du schreibst den gesamtgewinn ja in eine Variable. Diese kannst aber nicht direkt abfragen, also hast du nun 2 Möglichkeiten. Entweder du gibst den errechneten Gewinn als Rückgabewert zurück (double statt void) oder, du erstellst eine Methode (public double getGewinnTotal()) .. welche dann eben die Variable zurückgibt.

und die Ausgabe würde ich hinter die while-schleife setzen, da sonst nach jedem Produkt der bisherige Saisongewinn ausgegeben wird.

 

[district]

Hab nun die Methode in Produkt in double geändert...kompliert auch.

    public double winProductTotCalc()
    {
        gewinntotal = gewinn * menge;
        return gewinntotal;
    }

jedoch gibt es mir immer noch einen Fehler aus.. ich steig da wohl nicht ganz.

     /**
     * Rechnet den saisonalen Gewinn aus, 
     * auf Grund aller Objekte.
     */
    
    
    public void saisongGewinnCalc()
    {
        Iterator<Produkt> it = textilstueck.iterator();
        while(it.hasNext())
        {
            saisongt +=  it.next().winProductTotCalc() &&System.out.println("Der Gewinn dieser Saison beträg: " + saisongt + (" CHF"));
        }
    }

Fehler:
Operator + cannnot be applied to Produkt, double

 

[district]

oder war das Ganze so gemeint:

    public void winProductTotCalc()
    {
        gewinntotal = gewinn * menge;
    }

    public double getGewinnTotal()
    {
        return gewinntotal;
    }

In Saison schreib ich dann:

    public void saisongGewinnCalc()
    {
        Iterator<Produkt> it = textilstueck.iterator();
        while(it.hasNext())
        {
            saisongt +=  it.next().gewinntotal(); 
        }
    }

 

[diggaa1984]

nu seh ich das erst, gehen beide Varianten, sofern du saisongt nicht Produkt, sondern double machst, weil du speicherst ja schliessliche nen Finanzwert darin

 

[district]

Sags mal so: FREUDE HERRSCHT :-D hihi danke dir nochmals

 

[district]

noch ne ganz kurze Frage.. wie implementiere ich nun dass mir erst am schluss den subtotalen Gewinn ausgeben wird:

    public void saisongGewinnCalc()
    {
        Iterator<Produkt> it = textilstueck.iterator();
        while(it.hasNext())
        {
            saisongt +=  it.next().winProductTotCalc(); 
            System.out.println("Die Kollektion dieser Saison ergab einen Gewinn von " + saisongt + " CHF.");
        }
    }

Jetz wir jedes mal nacht dem Abruf eine Zeile ausgeben.. hier bei zwei Produkten:
Die Kollektion dieser Saison ergab einen Gewinn von 0.0 CHF.
Die Kollektion dieser Saison ergab einen Gewinn von 500.0 CHF.


Kann das Ganze ja auch einfach mit einer return-Methode lösen, aber System.out.println ist schon edler.

 

[diggaa1984]

na einfach den System-Befehl hinter die while-schleife setzen :roll: oder sollt ich sagen drunter :?:

 

[district]

oh ich hirsch... 12h arbeiten und java lerne kommt nicht gut :-D... schönen abend .. danke nochmals