Java Arraylist mit Objekten eigener Klasse befüllen?
Hi, also ich habe hier ein paar Probleme bei dieser Aufgabe :
Attribute sind :
private String description;
private int priority;
Für mich stellt sich jetzt erstmal hier die Frage ob ich das Befüllen mit einer Schleife machen soll. Ich verstehe noch nicht ganz wie ich dann die Attribute festlege:
so würde ja ein Objekt der Klasse Task aussehen:
Task a = new Task("Testaufgabe 1", 4);
wenn ich dann nun random Prioritäten zuweisen möchte und ich es nicht in einer Schlafe mache, müsste ich ja jedesmal mit math.random einen wert zuweisen .Wäre eine Option mit Schleife so:
ArrayList<Task> mylist = new ArrayList<Task>();
for(int i = 1; i <= 10; ++i){
Task a = new Task("Testaufgabe " + (char) i, (int) Math.random() * 9 + 1);
mylist.add(a);
}
Zu den Ausnahmen hab ich jetzt die seter so:
public void setPriority(int priority) throws IllegalArgumentException, PriorityFormatExpeption{
this.priority = priority;
if(!checkPriority(priority)){
throw new IllegalArgumentException("Priorität darf nur zwischen 1 - 5 liegen!");
}
}
public void setDescription(String description) throws IllegalArgumentException, DescriptionFormatExpetion{
this.description = description;
if(!checkDescription(description)){
throw new IllegalArgumentException("String darf nicht leer sein!");
}
}
hier die Fehler der for
2 Antworten
Könnte man so machen.
Allerdings fehlen hier (zur Beurteilung) die Definitionen der Hilfsmethoden "check..." und natürlich die Definition der Klasse "Task".
Ruft der Konstruktor von new Task(String, int) die Setter auf?
Funktioniert der Cast in
(int) Math.random() * 9 + 1
so, wie beabsichtigt? Nach https://www.programmierenlernenhq.de/java-grundlagen-rangfolge-der-java-operatoren/ hat der Cast-Operator dieselbe Priorität wie andere unäre Operatoren auch, insbesondere also höhere Priorität als Multiplikation und Addition.
Gewöhn dir bitte an, ERST die Checks durchzuführen und DANACH ggf. die Setzungen vorzunehmen - sonst passiert es zu leicht, dass eine Ausnahme abgefangen wird und danach versehentlich mit ungültigen Werten weitergearbeitet wird.
Wenn ich Fehlermeldungen wie
Unknown class: 'i'
sehe, obwohl es lediglich eine Variable namens "i" gibt, starte ich für gewöhnlich meine Entwicklungsumgebung neu - üblicherweise hat sich bei so was der Compiler so gründlich verschluckt, dass ein vernünftiges Weiterarbeiten nicht mehr möglich ist. Aber um das wirklich beurteilen zu können, müsste ich den kompletten Quelltext aller beteiligten Elemente sehen.
(Übrigens steht in der Aufgabe, dass die Priorität zwischen 1 und 10 einschließlich liegen soll, in der Fehlermeldung steht "1 - 5".)
Sieht brauchbar aus, ja.
Auch wenn man evtl. lieber java.util.Random verwenden möchte.
EDIT:
Bei "setPriority" solltest du die Priorität nur setzen, wenn diese valide ist, selbiges gilt für "setDescription".
Zudem sollte die Fehlermeldung hier nicht so konkret sein, denn den Check abstrahierst du ja, da könnte ja auch etwas anderes falsch sein, als das, was in der Fehlermeldung steht.
Random n = new Random();
gehört nach außerhalb der Schleife - wenn man bei jedem Durchlauf eine neue Instanz erzeugt, verliert man alle Vorteile, die die Klasse Random bietet. Abgesehen von den Performanz-Einbußen durch Erzeugen und Vernichten von Objekten (das spielt bei Aufgaben zum Lernen keine Rolle, kann einem aber später bei größeren Projekten ganz schön in den Allerwertesten beißen).
Ja, das ist der Fehler. Der Code müsste innerhalb einer Methode stehen.
Die Fehlermeldungen gebündelt in der Main-Methode zu behandeln macht nur Sinn, wenn dir egal ist, wo die Meldungen auftraten und soetwas. Aber kann man schon machen, ja.
Aber meine seter sollten ja außer : IllegalArgumentException
nichts werfen, oder? Also so:
public void setPriority(int priority) throws IllegalArgumentException{
this.priority = priority;
if(!checkPriority(priority)){
throw new IllegalArgumentException("Fehler bei Priorität");
}
beachte jetzt mal nicht die Fehlermeldung , wird überarbeitet noch ;)
Wie genau mach ich jetzt in der Main die Überprüfung, bzw an welcher Stelle mit welchen Ausnahmen? Hier mal eine Idee:
public class Teilaufgabe {
public static void main(String[] args) {
ArrayList<Task> mylist = new ArrayList<Task>();
for(int i = 1; i <= 10; ++i){
Random n = new Random();
try{
Task a = new Task("Testaufgabe " + (char) i, n.nextInt(10) + 1);
mylist.add(a);
}catch(ArrayIndexOutOfBoundsException e) {
throw new IllegalArgumentException("Falsches Format!");
}
}
}
}
Du ersetzt halt "ArrayIndexOutOfBoundsException" im catch durch "IllegalArgumentException" oder etwas in der Art (Superclass oder mehrere Exceptions oder mehrere cacth-Klauses). Je nachdem, was du halt machen möchtest.
Und dann halt "e.printStacktrace()" oder etwas in der Art.
Schau in die Doku und spiel ein Bisschen damit herum. Dabei lernst du am meisten.
Ok, gut. Danke. ich hatte es mir so überlegt, dass ich die Ausnahmen an die Main weiterreiche damit ich dort dann gebündelt die Fehler überprüfen kann. Ok, dass mit der Fehlermeldung muss ich noch ändern. Mir wird im Code jetzt gerade angezeigt :
bei der for schleife bekomm ich irgendwie Fehler :
habs oben angehangen