Produktgruppe - methodenfehler

[Spin]

Hey Leute mag mir mal schnell einer auf die Sprünge helfen. Danke

public class Produktgruppe {

    /*Variablen*/
    Produkt produkt;
    private String name;
    private ArrayList<Produktgruppe> pg;



    public Produktgruppe(String p_name) {
        this.name = p_name;

    }

    /**
     *
     * @param p_Produkt -Produktobjekt
     * @param zeiger - Variable die auf die entsprechende Gruppe verweist.
     */
    public void hinzu(Produkt p_Produkt,int zeiger ){

        if(zeiger != 0 && p_Produkt != null){
            if(zeiger == 1){

                new ArrayList<Produktgruppe>();
                pg.add(this);
            }
    }
    }

    /* Ausgabe der Produktgruppen*/
    public void ausgabe(){

        for(Produktgruppe p: pg){
            System.out.println(p);
        }
    }

Er sagt mir null .

Bestimmt weil meine Liste nicht gefüllt wird.
Aber ich kann p_Produkt nicht meiner Liste übergeben.
Was mache ich falsch?

  public void hinzu(Produkt p_Produkt,int zeiger ){

        if(zeiger != 0 && p_Produkt != null){
            if(zeiger == 1){

                new ArrayList<Produktgruppe>();
                pg.add(p_Produkt);
            }
    }
    }

so geht es nicht :/

Für jede Produktgruppe brauche ich eine neue liste

 public void hinzu(Produkt p_Produkt,int zeiger ){

        if(zeiger != 0 && p_Produkt != null){
            if(zeiger == 1){

                new ArrayList<Produktgruppe>();
                pg.add(p_Produkt);
            }
            if(zeiger == 2){

                new ArrayList<Produktgruppe>();
                pg.add(p_Produkt);
            }
    }
    }

so wollte ich es eigentlich machen . denn .

Mag mir einer meinen fehler sagen?

 

[ARadauer]

new ArrayList<Produktgruppe>(); willst du das der variable pg zuweisen?

so vielleicht?

pg = new ArrayList<Produktgruppe>();

 

[mvitz]

Da ein Produkt keine Produktgruppe ist, kannst du das Produkt nicht zur Liste hinzufügen.

Du möchtest vermutlich so etwas machen.

...
List<List<Produkt>> produktGruppen;
...
public ProduktGruppe() {
  produktGruppen = new ArrayList<List<Produkt>>();
}

public void hinzu(Produkt produkt, int gruppe) {
  List<Produkt> produktGruppe = produktGruppen.get(gruppe);
  if (produktGruppe == null) {
    produktGruppe = new ArrayList<Produkt>();
    produktGruppen.add(gruppe, produktGruppe);
  }
  produktGruppe.add(produkt);
}
...

 

[Spin]

Ist das richtig so?

/**
     *
     * @param produkt - Produkt Object
     * @param gruppe - Index der Gruppe
     */
    public void hinzu(Produkt produkt, int gruppe) {
         /* Instanziieren einer neuen Gruppe (Liste) mit ProduktObjekten
            und holen von Index*/
         /* Returns the element at the specified position in this list.*/
          List<Produkt> produktGruppe = produktGruppen.get(gruppe);
          if (produktGruppe == null) {
            /*Der produktGruppe wird eine Liste von ProduktObjekten hinzugefügt*/
            produktGruppe = new ArrayList<Produkt>();
            /* Die Gruppe(Liste) der ProduktObjekte einer neuen Liste hinzufügen und setzen an der Stelle von Index*/
            produktGruppen.add(gruppe, produktGruppe);
          }
          /* Wenn es die Gruppe schon gibt , nur noch Produkt der Gruppe hinzufügen*/
          produktGruppe.add(produkt);
}

        /* Ausgabe der Produktgruppen*/
         public void ausgabe(){

        for(List<Produkt> p: produktGruppen){
            System.out.println(p);
        }
    }

Er haut mir nen fehler , wenn ich die Methode fülle.:

System.out.println("Erstellen einer Produktgruppe: ");
        ProduktGruppe pg_gruppe = new ProduktGruppe("Milchprodukte");
        pg_gruppe.hinzu(milch,1);
        pg_gruppe.ausgabe();

Fehler:

Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 1, Size: 0
        at java.util.ArrayList.RangeCheck(ArrayList.java:547)
        at java.util.ArrayList.get(ArrayList.java:322)
        at kuehlschranksystem.core.ProduktGruppe.hinzu(ProduktGruppe.java:34)
        at kuehlschranksystem.core.Main.starten(Main.java:44)
        at kuehlschranksystem.core.Main.main(Main.java:55)
Java Result: 1

MH . Mein Array ist wohl zu klein.
mhh...

Aso schonmal danke für eure schnellen antworten.

 

[bygones]

du hast eine leere Liste und die faengt nun mal bei 0 an, wenn du 1 einfuegen willst kommt der fehler.

immer bei 0 anfangen zu zaehlen.

dennoch ist es gefaehrlich einen bestimmten Index mitzugeben, da du immer gefahr laeufst, dass dein Index groesser ist als der der liste...

ich seh nicht wirklich den nutzen dieses int "gruppe"... vll waere aber eine Map sinnvoller

 

[Spin]

Naja das ganze hat die Aufgabe , ein Produkt einer richtigen Produktgruppe zuzuweisen.

Ich muss ja das Produkt irgendetwas mitgeben , damit ich eine Zufüg-kriterium habe.

Was würdest du denn mitgeben , anstatt ein Integer.?

In einer Map<Scklüssel>
müsste ich doch auch was mitgeben.

Also irgendeinkriterium , damit mein Prog weiß, dass das Produkt auch bsp.: Milchprodukte zugehört.

Denn wenn ich nichts mitgebe, woher weiß mein Prog , dass "milch " auch ein Milchprodukt ist.


Hast du da nen kurzen quellcode für ne Map?


Danke

 

[ARadauer]

Ich fürchte sehr um die Note deiner Freundin....

warum gibbst du beim einfügen, in eine gewisse gruppe dann eine 1 mit?
du hast ja die Gruppe schon oder?

 

[ARadauer]

ahh jetzt verstehe ich... die Methode public void hinzu(Produkt produkt, int gruppe)
hat nichts in dem Objekt Produktgruppe zu suchen. Das gehört in das Objekt das die Prodduktgruppen verwalltet...

 

[Spin]

Naja bisher habe ich nur die Main methode und da wollte ich eigentlich eine Gruppe erstellen.

System.out.println("Erstellen einer Produktgruppe: ");
        ProduktGruppe pg_gruppe = new ProduktGruppe("Milchprodukte");
        pg_gruppe.hinzu(milch,1);
        pg_gruppe.ausgabe();

Hier habe ich eine Gruppe erstellt.
Und die Liste habe ich ja eh in der ProduktGruppe.
Warum gehört denn die Methode woanders hin?

Kann sich Produktgruppe nicht selbst verwalten?

Ich erstelle da eine Liste( Gruppe) und deklariere in derselben gruppe die funktion.
Die ruf ich in der main auf und fülle sie.

Durch die übergabe / mitgabe eines Integers kann ich verschiedene arry listen füllen.
Das heißt für jede Produktgruppe erstell ich eine neue Liste. Und wenn sie schon existiert dann halt der Produktgruppe hinzufügen.

habi hat mir nen guten quellcode gepostet . Der entspricht meinen Gedanken.

Doch nun schreibt bygones ne map wäre besser und du sagst die soll nicht in dasselbe objekt deklariert werden.

Bisher habe ich noch keine Lösung für meine Exception .

Klar ich hole von einem array einen wert . get(gruppe) obwohl der ja noch nicht gesetzt wurde.

 

[ARadauer]

Ich erstelle da eine Liste( Gruppe) und deklariere in derselben gruppe die funktion.

was?
Hat deine Gruppe eine Liste mit Gruppen?
Sorry ich kann mir das nicht ganz vorstellen. Poste nochmal bitte deinen ganzen Code


Nachtrag:
Sollen die Gruppen in der Gruppe, Untergruppen darstellen?
Denk objektorientiert... wenn du mehrere Schachteln in einer Schachteln hast, kann das schon sinn machen, aber ob du das wirklich willst bezweifle ich...

Ich denk du denkst zu kompliziert...

 

[Spin]

run:
Folgende Produkte existieren im System: 
1. Milch mit:         weiß        0.45        0.75        1        35993
2. Cola mit:         schwarz        1.0        1.5        1        35993

Diese Produkt wurden einer Liste hinzugefügt: 
Produktliste: 
Milch
Cola

Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 1, Size: 0
Folgende Produkte wurden über dem Scanner gezogen und sind aktuell im Kuehlschrank: 
Produkt: Milch        07.10.2009        07.10.2009
Erstellen einer Produktgruppe: 
        at java.util.ArrayList.RangeCheck(ArrayList.java:547)
        at java.util.ArrayList.get(ArrayList.java:322)
        at kuehlschranksystem.core.ProduktGruppe.hinzu(ProduktGruppe.java:35)
        at kuehlschranksystem.core.Main.starten(Main.java:54)
        at kuehlschranksystem.core.Main.main(Main.java:65)
Java Result: 1

import java.util.*;
public class ProduktGruppe {

    /*Variablen*/
    Produkt produkt;
    private String name;
    List<List<Produkt>> produktGruppen;





    public ProduktGruppe(String p_name) {
        this.name = p_name;
        produktGruppen = new ArrayList<List<Produkt>>();

   }

    /**
     *
     * @param produkt - Produkt Object
     * @param gruppe - Index der Gruppe
     */
  public void hinzu(Produkt produkt, int gruppe) {
         /* Instanziieren einer neuen Gruppe (Liste) mit ProduktObjekten
            und holen von Index*/
         /* Returns the element at the specified position in this list.*/
          List<Produkt> produktGruppe = produktGruppen.get(gruppe);
          if (produktGruppe == null) {
            /*Der produktGruppe wird eine Liste von ProduktObjekten hinzugefügt*/
            produktGruppe = new ArrayList<Produkt>();
            /* Die Gruppe(Liste) der ProduktObjekte einer neuen Liste hinzufügen und setzen an der Stelle von Index*/
            produktGruppen.add(gruppe, produktGruppe);
          }
          /* Wenn es die Gruppe schon gibt , nur noch Produkt der Gruppe hinzufügen*/
          produktGruppe.add(produkt);
}

        /* Ausgabe der Produktgruppen*/
         public void ausgabe(){

        for(List<Produkt> p: produktGruppen){
            System.out.println(p);
        }

    }

    /*Kapselung get und set*/
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Das sind Listen in Listen . Problemstellung oben, danke ARadauer.

 

[ARadauer]

ja find ich aber nicht so schön... warum hält die Gruppe eine Liste der Gruppen.

die int gruppe die du bei hinzu übergibst. woher kommt das? woher weißt du die position der gruppe in die der artikel hinein gehört? Das kanns du so nicht machen... mach dir eine map, da kannst du objekte über einen key heraushohlen...

Das gruppen dings is ja nix neues... hab da schon mal was in ein forum geschrieben....
sie dir das mal an...

public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		GruppenVerwalter verwalter = new GruppenVerwalter();
		verwalter.addProdukt(new Produkt("A1", "Gruppe A"));
		verwalter.addProdukt(new Produkt("A2", "Gruppe A"));
		verwalter.addProdukt(new Produkt("B1", "Gruppe B"));
		verwalter.addProdukt(new Produkt("B2", "Gruppe B"));
		verwalter.addProdukt(new Produkt("B3", "Gruppe B"));
		verwalter.addProdukt(new Produkt("C1", "Gruppe C"));
		
		System.out.println(verwalter);
		

	}

}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;


public class GruppenVerwalter {
	
	HashMap<String, Gruppe> gruppen = new HashMap<String, Gruppe>();
	
	public void addProdukt(Produkt produkt){
		Gruppe gruppe = gruppen.get(produkt.getGruppenName());
		if(gruppe==null){
			gruppe = new Gruppe(produkt.getGruppenName());
			gruppen.put(gruppe.getName(), gruppe);
		}
		gruppe.addProdukt(produkt);
			
	}
	
	public ArrayList<Gruppe> getGruppen(){
		//..
		return null;
	}
	
	public ArrayList<Produkt> getProdukteForGruppe(String gruppe){
		//..
		return null;
	}
	
	public String toString(){
		StringBuffer buf = new StringBuffer();
		
		Set<String> keys =  gruppen.keySet();
		buf.append("Wir haben "+keys.size()+" Gruppen\n");
		for(String key: keys){
			buf.append(gruppen.get(key));
		}
		return buf.toString();
	}

}
import java.util.ArrayList;


public class Gruppe {
	
	private String name;
	private ArrayList<Produkt> produkte = new ArrayList<Produkt>();
	
	
	public Gruppe(String name) {
		super();
		this.name = name;
	}

	public void addProdukt(Produkt p){
		produkte.add(p);
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public ArrayList<Produkt> getProdukte() {
		return produkte;
	}

	public void setProdukte(ArrayList<Produkt> produkte) {
		this.produkte = produkte;
	}
	
	
	public String toString(){
		StringBuffer buf = new StringBuffer();
		buf.append("Gruppe: "+getName()+" "+produkte.size()+" Produkte\n");
		for(Produkt p: produkte)
			buf.append("\t"+p).append("\n");
		return buf.toString();
	}
	

}

public class Produkt {
	
	private String name;
	private String gruppenName;
	
	
	public Produkt(String name, String gruppenName) {
		super();
		this.name = name;
		this.gruppenName = gruppenName;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getGruppenName() {
		return gruppenName;
	}
	public void setGruppenName(String gruppenName) {
		this.gruppenName = gruppenName;
	}
	
	
	public String toString(){
		return "Produkt: "+getName();
	}
	

}

das ist jetzt natürlich auch nicht so sauber... da sich die Gruppen automatisch anhand von dem String im Produkt erstellt werden... aber soll ja nur mal das prinzip mit der Hasmap verdeutlichen....

 

[Spin]

Vielen Dank , das funktioniert natürlich alles . Aber ich habe noch ein paar Fragen. Wäre ja schade wenn der Thread nun ein Ende nimmt.

Könnte ihr noch das ganze Softwareprojekt besprechen :toll:

(Ich fang erst am nächster Woche mit meinem Informatik Studium an , solange darf ich doch noch Fragen haben )

Derzeit nur komplizierter Hobbyprogrammierer....ok genug von mir

public ArrayList<Produkt> getProdukteForGruppe(String gruppe){
        //..
        return null;
    }

Ähm mit der Funktion meinstest du doch bestimmt getProduktVonGruppe oder?
Weil das hinzufügen machen wir ja schon.

public Produkt(String p_name, String p_anmerkung, double p_minPreis,
			double p_maxPreis, int p_inhaltsmenge, int p_barcodenummer,
			String p_gruppenName) {
		super();
		this.name = p_name;
		this.anmerkung = p_anmerkung;
		this.minPreis = p_minPreis;
		this.maxPreis = p_maxPreis;
		this.inhaltsmenge = p_inhaltsmenge;
		this.barcodenummer = p_barcodenummer;
		this.gruppenName = p_gruppenName;

	}

Dann warum rufe ich super aus? Wenn ich doch garnicht ableite , also erbe.

super -> Superklasse . Denk ich immer. Also von was ruf ich hier auf? Den Standartkonstruktor der Superklasse. Aber wenn ich kein extends habe, wer ist denn hier meine Vaterklasse?

 public String toString(){
	        StringBuffer stringSpeicher = new StringBuffer(); // modifizierter String , der eine Sequenz von chars darstellt.
	        stringSpeicher.append("Gruppe: "+this.getName()+" "+this.produkte.size()+" Produkte\n"); // Name und größe zurückgeben
	        for(Produkt p: produkte)
	            stringSpeicher.append("\t"+p).append("\n"); // Ausgabe
	        return stringSpeicher.toString();
	    }

Ist es richtig , dass der Vorteil eines Stringbuffers, das speichern verschiedener Datentypen ist.?

Also dass heißt man kann dadurch alle Datentypen ausgeben lassen. Ob eigene oder die reservierten.

StringBuffer muss man aber später wieder in ein String konvertieren , damit mein System.out nicht in schwirigkeiten kommt. richtig?

public Produktgruppe(String p_name) {
		super();
		this.name=p_name;
		
	}

Hier auch , warum super?



Weiter:

Ok die Map sollte ich verstanden haben.

Noch ne frage:


Macht es Sinn manche Konstrukor als private zu deklarieren, um dann die Objekte nur innerhalb der eigenen Klasse instanziieren zu lassen.

Ich habe es gemacht und sachte mir aufgrund der Kapselung ist das noch sicherer.

private ImKuehlschrank(Produkt p_produkt, String p_einleseDatum,
			String p_ausleseDatum, String p_haltbarkeitsDatum, int p_anzahl) {
		this.produkt = p_produkt;
		this.ausleseDatum = p_einleseDatum;
		this.ausleseDatum = p_ausleseDatum;
		this.haltbarkeitsDatum=p_haltbarkeitsDatum;
		this.anzahl = p_anzahl;

	}
	public static ImKuehlschrank fuerProdukt(Produkt p_produkt, String s){
		 ImKuehlschrank a= new ImKuehlschrank(p_produkt,s,s,s,5);
		
		return a;
		
	}

Hier beispielsweise darf ich das Objekt nur innerhalb der eigenen Klasse instanziieren und mache funktionen static, auf die ich denn außerhalb zugreifen kann.

Ich wollte dazu auch noch mal ne fachmännische Meinung hören , danke .

Ist bischen viel , aber wenn der eine oder andere nicht zu alles antwortet auch nicht schlimm , danke