Java lernen mit BlueJ - Problem Objektinteraktion

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Java lernen mit BlueJ - Problem Objektinteraktion

    ich habe ein Problem zweier Klassen die miteinander interagieren sollten:

    hier die 1. Klasse, die so einwandfrei funktioniert:

    Quellcode

    1. public class Vater
    2. {
    3. // Vorname des Vaters
    4. private String name;
    5. // Familienname des Vaters
    6. private String vatersname;
    8. public Vater(String name, String vatersname)
    9. {
    10. this.name = name;
    11. this.vatersname = vatersname;
    12. }
    14. public String gibVatersName()
    15. {
    16. return vatersname;
    17. }
    19. public String gibName()
    20. {
    21. return name;
    22. }
    23. }
    26. bei der 2. Klasse habe ich ein Problem mit dem Konstruktor:
    28. public class Kind
    29. {
    30. // Vorname des Kindes
    31. private String name;
    32. // Name des Vaters vom Kind
    33. private Vater vater;
    34. // Alter des Kindes
    35. private int alt;
    37. public Kind(String name)
    38. {
    39. this.name = name;
    40. vater = new Vater(vatersname);
    41. }
    43. public void druckeVatersName()
    44. {
    45. String papa = vater.gibVatersName();
    46. System.out.println(papa);
    47. }
    49. public void setzeAlt(int alt)
    50. {
    51. this.alt = alt;
    52. }
    53. }
    Alles anzeigen


    ich bekomme die folgende Fehlermeldung: cannot find symbol - constructor Vater()

    ich wäre extrem froh wenn mir jemand helfen könnte!?

    Dankeschön!!

  • Hi,

    schau mal:
    In der Vaterklasse legst du den Konstruktor an und sagst "du bekommst genau zwei Parameter".
    In der Kindklasse machst du demnach zwei Fehler:
    • Du legst einen neuen Vater an und übergibst einen Wert (vatername) den es bis dahin garnicht gibt. Wo legst du denn den String "vatername" an? Du musst die aktualparameter (mit denen du den Konstruktor aufrust) nicht genauso benennen, wie die Formalparameter (welche im Konstruktorstehen).
    • Ein Wert ist zu wenig! Der Vater will doch vor und nachname!


    Nachtrag:
    Benutz bitte in Zukunft die Syntaxhighlight funktion des Forums indem du unten auf eines der Bildchen klickst. In deinem Fall einfach auf die Kaffetasse und zwischen den Tags den Code schreiben :)

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von F0kus ()

  • hi, besten dank für dein bemühen. leider arbeite ich noch nicht sehr lange mit jave und blueJ, deshalb verstehe ich nicht wirklich was du mit aktualparameter und formalparameter meinst. mein problem liegt offensichtlich im konstruktor der klasse kind oder? wie muss ich diesen umprogrammieren damit ich für das Kind den Nachnamen aus der Klasse Vater holen kann?

    Quellcode

    1. public Kind(String name)
    2. {
    3. this.name = name;
    4. vater = new Vater(vatersname);
    5. }



    zu deinem zweiten punkt, ich brauche ja nur den Nachnamen des Vaters, der für das Kind gleich bleibt. Oder wie hast du das gmeint?

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von nitr0it ()

  • Hi :)

    Joa ist ja kein Problem, machen wir es stück für stück.
    Also kurz zu der Frage bzgl. der Parameter.

    Nehmen wir mal den Konstruktor für das Kind aus deinem beispiel:

    Quellcode

    1. public Kind(String name)
    2. {
    3. ...
    4. }


    Hier ist der Formalparameter "name". Mehr weißt du ja an dieser stelle nicht. Du weißt nur das dort ein String erwartet wird der name heißt. Deshalb heißt es hier Formalparameter, da du keinerlei infos hast was da drin ist.

    Wenn du jetzt folgendes machst:

    Quellcode

    1. ...
    2. Kind fritz = new Kind("Fritz");
    3. ...


    Dann übergibst du einen Parameter mit einem konkreten Wert. Dieser wert ist aktual "Fritz". Daher die Bezeichnung Aktualparameter.
    Okay?

    So nun zum eigentlichen Problem:

    Derzeit machst du es so, dass du über das Kind den Vater anlegst und dem Vater versuchst dem selben Nachnamen zu geben wie dem Kind.
    Andersrum wäre irgendwie logischer, oder? Wer kommt denn zuerst? Papa oder Kind? ;)

    Ein Kind hat außerdem einen (biologischen) Vater, ein Vater hingegen kann mehrere Kinder haben. (Ginge bei dir über umwege auch aber egal...).
    Deswegen würde ich im Konstruktor vom Vater (oder wo du halt möchtest) das Kind anlegen:

    Quellcode

    1. public class Vater
    2. {
    3. // Vorname des Vaters
    4. private String name;
    5. // Familienname des Vaters
    6. private String vatersname;
    7. // Kind vom Vater
    8. private Kind fritz = null;
    10. public Vater(String name, String vatersname)
    11. {
    12. this.name = name;
    13. this.vatersname = vatersname;
    15. this.fritz = new Kind("Fritz",vatersname,12);
    16. }
    18. public String gibVatersName()
    19. {
    20. return vatersname;
    21. }
    23. public String gibName()
    24. {
    25. return name;
    26. }
    28. public Kind gibKind() {
    29. return fritz;
    30. }
    32. public void druckeFamilie() {
    33. System.out.println("Vater: \n
    34. \t Vorname: "+name+"\n
    35. \t Nachname: "+vatersname+ "\n
    36. Kind: \n
    37. \t Vorname: "+fritz.gibVorname()+"\n
    38. \t Nachname: "+fritz.gibNachname()+"\n
    39. \t Alter: "+fritz.gibAlter());
    40. }
    Alles anzeigen


    Kind würdest du dann einfach so abändern:

    Quellcode

    1. public class Kind
    2. {
    3. // Vorname des Kindes
    4. private String vorname;
    6. //Nachname des Kindes
    7. private String nachname;
    9. // Alter des Kindes
    10. private private int alt;
    12. public Kind(String vorname, String nachname, int alter)
    13. {
    14. this.vorname = vorname;
    15. this.nachname = nachname;
    16. this.alt = alter;
    17. }
    19. public String gibVorname() {
    20. return vorname;
    21. }
    23. public String gibNachname() {
    24. return nachname;
    25. }
    27. public Int gibAlter() {
    28. return alt;
    29. }
    30. }
    Alles anzeigen


    So, nun hat der Papa ein Kind. Wenn du dich jetzt fragst, was ist wenn er mehrere Kinder hat? Dann könntest du entweder mehrere anlegen (so wie ich oben Fritz angelegt habe) was aber zur folge haben würde dass die Ausgabe nicht mehr klappen würde (bzw. nur für fritz ;) ) also müsstest du diese auch anpassen... aber aber du wartest das Kapitel Arrays ab ;)

    Viel Erfolg weiterhin!

    PS: Ich habe deinen Code an ein-zwei stellen etwas geändert, wenn du davon was nicht verstehst frag einfach nach :)

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von F0kus ()

  • vielleicht muss ich dir zuerst di aufgabe erklären, die ich machen muss.

    uns wurden diese programmtexte gegeben:

    Quellcode

    1. public class Vater
    2. {
    3. private String name;
    5. public Vater(string vatername)
    6. {
    7. this.vatername=vatername;
    8. }
    10. public String gibVatersName()
    11. {
    12. return vatername;
    13. }
    15. public String gibVatersName()
    16. {
    17. return name;
    18. }
    19. }
    21. public class Kind
    22. {
    23. private String name;
    24. private String vater vater;
    25. private int alt;
    27. public Kind(String name, String vatersname)
    28. {
    29. this.name = Name;
    30. vater = new vater(vatersname);
    31. }
    33. public String druckeVatersName()
    34. {
    35. System.out.println(vaters.gibVatersName);
    36. }
    38. public void setzeAlt(String alt)
    39. {
    40. this.alt = alt;
    41. }
    42. }
    Alles anzeigen


    wir haben nun den auftrag synaktische fehler zu suchen und zu korrigieren.
    die meisten sind offentlichlich und diese habe ich auch ohne probleme gefunden.
    nur beim konstruktor der klasse kind bin ich auf probleme gestossen.

    ich denke das programm sollte so laufen, dass zuerst ein vater erstellt wird.
    danach sollen beliebig viele kinder erstellt werden können, die jeweils den
    nachnamen des vater übernehmen. dies muss meiner ansicht nach in
    der klasse kind geschehen. gibt es nicht eine möglichkeit den nachnamen
    des vaters aus der klasse vater zu holen ohne einen neuen vater anzulegen?