Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
ich schreibe gerade ein kleines Übungsprogramm (soll objektorientiert sein) und stehe vor einem kleinen Problem.
In einer Klasse "Interpreten" habe ich die Instanzvariablen "Name" und "Alter" sowie Getter und Setter notiert.
In einer weiteren Klasse "Songs" habe ich die Instanzvariablen "Titel" und "Erscheinungsjahr" sowie ebenfalls Getter und Setter notiert.
Jetzt möchte ich einem Interpreten z.b. 3 Songs zuordnen. Wie gehe ich da vor?
Ich verstehe den Interpreten als Klasse mit den Eigenschaften Alter und Name.
Und ich verstehe die Klasse Songs mit den Eigenschaften Titel und Erscheinungsjahr.
Aber die Verbindung dieser beiden Klassen bzw. der aus Ihnen entstehenden Objekte ist mir noch nicht ganz klar.
Du fügst dem Interpreten eine Eigenschaft "List<Songs> songs" hinzu.
Ich würde die Klassen ansonsten im Singular bennen. Interpreten michalJackson = new Interpreten() und Songs weWillRockYou = new Songs() ist sonst etwas irreführend. Ist ja jeweils nur ein Sänger und ein Lied, nicht mehrere.
Du fügst dem Interpreten eine Eigenschaft "List<Songs> songs" hinzu.
Ich würde die Klassen ansonsten im Singular bennen. Interpreten michalJackson = new Interpreten() und Songs weWillRockYou = new Songs() ist sonst etwas irreführend. Ist ja jeweils nur ein Sänger und ein Lied, nicht mehrere.
Danke, der Hinweis, den Singular zu benutzen, ist gut und auch schon umgesetzt.
Den Rest verstehe ich leider nicht ganz. Ich füge dem Interpreten eine Eigenschaft "???" hinzu? Ich verstehe schon den Ausdruck "List<Songs> songs" nicht. Was besagen die spitzen Klammern? Und, meinst Du mit Eigenschaft eine Instanzvariable?
UNd vielleicht ist hilfreich zu wissen, dass ich jedem Interpreten maximal 10 Songs zuweisen möchte?
public class Song{
private String name;
private int age;
private List<Song> songs;
}
Es ist eine ganz normale Eigenschaft (oder Instanzvariable, wenn dich das weniger verwirrt), genauso wie Alter oder Name.
List<> ist eine generische Klasse, d.h. du kannst genau festlegen, welche Typen von Daten in diese Liste dürfen.
Eine List<Song> darf nur Objekte vom Typ Song enthalten, List<String> nur Strings und so weiter.
Vorteil ist natürlich, dass bereits beim Hinzufügen eines neuen Elements eine Überprüfung erfolgt, ob das neue Element den richtigen Typ hat. In anderen Sprachen gibt es so etwas nicht, wodurch es passieren kann, dass ein Liste Objekte, Zahlen und Strings enthält und man z.B. sowas produzieren kann:
Code:
stuff = new array();
stuff[0] = "hallo";
stuff[1] = 25;
stuff[2] = new Object();
var sum = stuff[0] + stuff[1] + stuff[2];
sum = ???
Ok. Verstehe.
Bzw. verstehe noch nicht ganz, aber ich verstehe, dass ich so weit in Java noch nicht war. Ich werde mir die Generics anschauen.
Aber ich vermute trotzdem, dass eine Lösung etwas anders gehen sollte, denn in Deiner Lösung wird nichtr berücksichtigt, dass ich max. 10 Songs je Interpret eintragen will.
Könnte es sein, dass für mein Beispiel ein Array ein Rolle spielt?
Ich hatte mal so gedacht:
Code:
public class Interpret {
private String name;
private int alter;
Song songList[] = new Song[10];
public int songCounter = 0;
// Song dem Interpreten zuordnen:
public void ordneSongZu(Song song) {
this.songList[songCounter] = song;
songCounter++;
}
....
// Konstruktor, Getter, Setter usw.
}
Aber: Wie stelle ich die Beziehung zwischen Song bzw. mehreren Songs zu dem Interpreten her? Im Grunde fehlt mir die Beziehung bereits beim Counter, denn ich will ja den Counter bereits auf den Interpreten beziehen. Es geht mir auch mehr ium die Idee... der Code ist sicher noch ziemlicher Bullshit...
Du erstellst Objekte der Songs und übergibst sie über interpreter.setSong() oder du erlaubst im Konstruktor einen Parameter vom Typ Song.
Java:
public static void main(String[]args){
Song a = new Song();
Interpret interpret = new Interpret();
interpret.setSong(a);
}
class Interpret{
private Song[] songs = new Song[10];
public void setSongs(Song[]s){
this.songs = s;
}
}
Du kannst natürlich auch ein Array nehmen, wenn dir das lieber ist. Dann musst du aber beim Iterieren über das Array aufpassen:
Jeder Index, an dem sich kein Song-Objekt befindet, enthält "null". Willst du auf ein null zugreifen, wird eine Exception fliegen. Du musst also beim Iterieren prüfen, ob das Element, auf welches du Zugreifen möchtest, null ist oder nicht.
Muß nicht, wenn unnötig.
Dein obiger Code ist mir schon recht sympatisch. Was mich irritiert, ist die Main Funktion.
So weit war ich ja noch nicht.
Soll heißen, ich möchte erstmal nur die Klassen Interpret und Song auf mein Vorhaben vorbereiten.
Natürlich. Die main zeigt dir ja nur wie du das ganze dann erstellst. Ist aber grundsätzlich kein falscher Ansatz die Grundfunktionen bereits zu testen,
Prima.
Und wie lese ich die Songs dann wieder aus, wenn ich einen Interpreten übergebe?
Bitte nicht falsch verstehen, ich habe die Musterlösung für die Aufgabe hier... ich will aber nicht hienein gucken, sondern ich hierzu durcharbeiten, damit etwas mehr hiervon hängen bleibt.
Das ich mich ggf. etwas unbeholfen wirke, hängt damit zusammen, dass ich zum ersten mal 2 Objekte bzw. KJlassen miteinander interagieren lassen will.
Du könntest eine Methode schreiben welche den Titel als Übergabeparameter erhält und das Array oder die Liste danach durchsucht:
Java:
public Song getSongByTitel(String titel){
for(int i = 0; i<songList.size(); i++){
if(songList.get(i).titel.equals(titel)){
return songList.get(i);
}
}
return null;
}
public List<Song> getSongByPublishingYear(int year){
// to do....
}
Bei der Suche nach dem Erscheinungsjahr würde ich in der Suchmethode eine Liste anlegen und diese zurückgeben. In der Regel erscheint ja pro Jahr nicht nur ein Lied, sondern mehrere.
public class Interpret {
// Instanzvariablen:
private String name;
private String addresse;
private static Song songList[] = new Song[10];
private static int songListCounter = 0;
// Songs eintragen:
public void trageSongEin(Song song) {
songList[songListCounter] = song;
songListCounter++;
}
public Song[] getSongs() {
return songList;
}
...
Wenn ich mir nachher eine Liste der Interpreten samt eingetragener Songs ausgeben lasse, stelle ich aber fest, dass dem 2.Interpreten leider auch die Songs des ersten Interpreten zugeordnet wurden :bahnhof:
Deshalb gehe ich davon aus, daß nicht jeder Instanz der Klasse "Interpret" wirklich eine Liste mit je max. 10 Songinstanzen zugeordnet wird.
Kann man aus diesem Codeschnipsel erkennen, warum das so ist?
"static" bedeutet, dass alle Instanzen einer Klasse mit denselben Werten arbeiten. Das Song-Array gehört in dem Fall also nicht dem einzelnen Interpreten, sondern allen, die irgendwann irgendwo irgendwie mal von dir definiert werden.
"static" bedeutet, dass alle Instanzen einer Klasse mit denselben Werten arbeiten. Das Song-Array gehört in dem Fall also nicht dem einzelnen Interpreten, sondern allen, die irgendwann irgendwo irgendwie mal von dir definiert werden.
