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.
Hi...ich versuch grad ne Queue zu programmieren, und will nun beim adden von elementen vorher überprüfen, dass auch nur elemente dazugefügt werden können, die vom gleichen Typ sind wie die, die schon drin sind.
Folgender Code wirft mir nun aber schon beim ersten element dass ich überhaupt einfügen will ne Exception:
Java:
import java.util.*;
/**
* Write a description of class Queue here.
*
* @author (your name)
* @version (a version number or a date)
*/
public class Queue {
//private static final int MAXSIZE = 3;
private Object[] elements;
private int maxSize;
private int leseIndex;
private int schreibIndex;
Queue(int maxAnzahlEintraege){
maxSize = maxAnzahlEintraege+1;
elements = new Object[maxSize];
leseIndex = schreibIndex = 0;
}
public boolean leer() {
// Die Queue ist leer, wenn Lese- und Schreibindex auf dieselbe Position zeigen.
return schreibIndex==leseIndex;
}
public boolean voll() {
// Die Queue ist voll, wenn nach einer Schreiboperation der Schreibindex auf dieselbe Position
// wie der Leseindex verweisen würde.
return (schreibIndex+1)%maxSize==leseIndex;
}
public boolean add(Object o) throws Exception { // Hinzufügen eines neuen Eintrags an das Queue-Ende
// ::::::::::::: folgende zwei zeilen machen die Probleme::::::::::::::::::::::::
if (!(o instanceof Comparable))
throw new Exception(o.toString() + " ist nicht vom gleichen Typ");
if (voll())
return false;
elements[schreibIndex] = o;
schreibIndex = (schreibIndex+1)%maxSize;
System.out.println(toString());
return true;
}
public Object remove() { // Entfernen der Eintrags von der Queue-Spitze
if (leer())
return null;
Object erg = elements[leseIndex];
leseIndex = (leseIndex+1)%maxSize;
System.out.println(toString());
return erg;
}
public String toString() { // Hilfsmethode zur Ausgabe des Queueinhalts
String erg = "Queue: ";
int i = leseIndex;
while(i!=schreibIndex) {
erg += "-> [" + elements[i] + "] ";
i = (i+1)%maxSize;
}
return erg;
}
}
Exception siehe ::::::: Markierung
Aber eigentlich müsste das doch so stimmen? Hab diesen part bei ner linkedList schonma genau so verwendet...
Btw mit z.b. Strings scheints zu gehn; Ich benutze aber als Elemente eine Klasse Auftrag...Einfach nur ne Klasse mit Attributen Auftragsnummer und Auftragsersteller, nix grossartiges.
..Naja, jedenfalls, wer kann mir sagen was ich falsch mach? Danke ^^
Sorry ich hab echt schon oft probleme mit diesem Comparable Kram, das will ich irgendwie nich so recht verstehn...
Wenn ich das implementiere, meint er aber "class Auftrag is not abstract and does not override compareTo....." blabla
Aber ich brauch ja gar keine neue compareTo methode, ich will ja nix größenmässig vergleichen...will ja nur wissen obs vom selben Typ is.
Was soll von wessen Typ sein? Wenn du die Methode compareTo nicht brauchst warum kontrollierst du dann ob das Object eine Implementation von Comparable ist?
aeh .. ich les da zwischen den zeilen grad was ganz komisches ^^
"du willst nur wissen ob sie vom selben typ sind" .. aeh ich übersetz das mal als "you want to know if some elements are comparable to each other" !?!? das wäre ja ne Hintergrundinformation die man erstma rausbekommen muss ^^ .. das würde bedeuten du willst wissen ob 2 versch. Elemente miteinander vergleichbar sind, das ist alles andere als der Sinn hinterm Comparable-Interface
aeh .. ich les da zwischen den zeilen grad was ganz komisches ^^
"du willst nur wissen ob sie vom selben typ sind" .. aeh ich übersetz das mal als "you want to know if some elements are comparable to each other" !?!? das wäre ja ne Hintergrundinformation die man erstma rausbekommen muss ^^ .. das würde bedeuten du willst wissen ob 2 versch. Elemente miteinander vergleichbar sind, das ist alles andere als der Sinn hinterm Comparable-Interface
...will nun beim adden von elementen vorher überprüfen, dass auch nur elemente dazugefügt werden können, die vom gleichen Typ sind wie die, die schon drin sind.
Ich dachte das wäre dann klar? Jedenfalls is das genau so gemeint wie du gesagt hast ^^
Ich will in der GANZEN Queue nur Objekte EINES typs haben; und damit wollte ich das überprüfen...
Mir is aber grad noch ne Idee gekommen: Kann ich vllt einfach so schreiben:
Java:
if (!(o instanceof ( **datentyp von elements[leseIndex]** )))
Das müsste (nach Abfrage auf nullpointerException) doch eigentlich auch gehn...Nur weiss ich nich genau wie man den datentyp ermittelt; getInstance() scheint falsch zu sein ^^'
o.getClass() == elemXY.getClass() .. notfalls ein toString.equals(elemXY.getClass().toString) .. oder sowas .. aber sieht mir alles mehr nach Hack aus als alles andere .. willst deine Queue nich gleich auf Generics umbaun
if (leseIndex != 0)
if (!(o.getClass() == elements[leseIndex].getClass() ))
throw new Exception(o.toString() + " ist nicht vom gleichen Typ");
Generics benutz ich nich, weil ich grad ma angefangen hab zu studiern und wir das noch nicht gemacht haben. Alles was ich über Generics zu glauben wisse is, dasses was mit spitzen Klammern < > zu tun hat ^____^ Ansonsten kein Plan, und die Profs setzen, wenn ich mich recht erinner, voraus, dass es auch so lösbar is (ohne Generics).
edit: zu wissen glaube
so sollte es heissen xD sorry
mach mal ein leseIndex-1 in die Klammer .. wenn leseIndex != 0 ist, zB 1 heisst das du hast 1 element gespeichert. Wenn du nun das nächste einfügst, dann versuchst du element[1] abzugreifen, was nich existent sein sollte .. zumindest wenn du den leseIndex beim adden veränderst .. vielleicht solltest besser den schreibIndex-1 verwenden ^^ .. wobei letzteres wieder hierbei querschlägt: schreibIndex = (schreibIndex+1)%maxSize;
Ich bekomm keine Exception und garnichts, aber ich kann ohne Probleme Auftrags-Objete adden und dann noch nen String oder so...Und eben das sollte ja eigentlich nich gehn ^^'
ach das kann aber nich zufällig daran liegn (die Wissenden frag) das er da Object als Parameter hat .. und irgendwie ja alles von Object erbt?! Daher getClass auch das Gleiche liefert?
vllt. weil leseIndex fast immer 0 ist da du es nur in der Methode remove veränderst?
ach das kann aber nich zufällig daran liegn (die Wissenden frag) das er da Object als Parameter hat .. und irgendwie ja alles von Object erbt?! Daher getClass auch das Gleiche liefert?
Nein, wenn man die "Membermethoden" eines Objectes benutzt wird immer der Methodenbody der höchsten Klasse in der Klassenhierarchie genommen, egal von welchen Typ die Referenz ist.
Bei statischen Methoden würde der Methodenbody der Klasse benutzt werden, von dessen Typ die Referenz ist, aber darum gehts hier ja nicht
Übrigens sind diese ganzen Gedankengänge bei "getClass()" eh sinnlos, da getClass() final ist und deswegen überhaupt nicht überschrieben werden kann. Es wird irgendwie intern immer die tatsächliche Class des Objectes zurückgegeben.
Naja...aber wie kann ich das dann anders machen? Ich hab echt keine Ahnung wie ne Lösung sein könnte...
Wie gesagt was ich will is: Beim adden von elementen vorher überprüfen, dass auch nur elemente dazugefügt werden können, die vom gleichen Typ sind wie die, die schon drin sind.
Und von Generics hab ich wie gesagt leider kein plan...und vorher gings auch einfach mit (o instanceof Comparable), bei nem ähnlichen Projekt, nur mit Stack / LinkedList.
public class Queue<T> {
//private static final int MAXSIZE = 3;
private final T[] elements;
private int leseIndex = 0;
private int schreibIndex = 0;
Queue(Class<T> clazz, int maxAnzahlEintraege) {
elements = (T[]) Array.newInstance(clazz, maxAnzahlEintraege + 1);
}
private int maxSize() {
return elements.length;
}
public boolean leer() {
// Die Queue ist leer, wenn Lese- und Schreibindex auf dieselbe Position zeigen.
return schreibIndex == leseIndex;
}
public boolean voll() {
// Die Queue ist voll, wenn nach einer Schreiboperation der Schreibindex auf dieselbe Position
// wie der Leseindex verweisen würde.
return (schreibIndex + 1) % maxSize() == leseIndex;
}
public boolean add(T t) throws Exception { // Hinzufügen eines neuen Eintrags an das Queue-Ende
if (voll()) {
return false;
}
elements[schreibIndex] = t;
schreibIndex = (schreibIndex + 1) % maxSize();
System.out.println(toString());
return true;
}
public T remove() { // Entfernen der Eintrags von der Queue-Spitze
if (leer()) {
return null;
}
T erg = elements[leseIndex];
leseIndex = (leseIndex + 1) % maxSize();
System.out.println(toString());
return erg;
}
public String toString() { // Hilfsmethode zur Ausgabe des Queueinhalts
String erg = "Queue: ";
int i = leseIndex;
while (i != schreibIndex) {
erg += "-> [" + elements[i] + "] ";
i = (i + 1) % maxSize();
}
return erg;
}
}
Ich hab nur deinen Code umgeschrieben, keine Ahnung, ob es so funktioniert...
^^" Hab zum theme Generics meinem Prof nochma ne email geschrieben, es hiess die solln wir definitiv noch nich verwenden, weil wirs halt noch nich besprochen haben, und das Problem anders lösen...Wie ich befürchtet hatte : /
Muss also ne Lösung geben ausser Generics...
Und wie gesagt, ich versteh vorallem net, warums bei den zwei Projekten vorher mit instanceof comparable ging...Und hier nich
Hmm, tatsache Dieses verdammte equals...Das is immer so ne Sache wenn ma net dran denkt.
Außerdem dachte ich das ginge nich, weil elements[0] immer ma wieder 0 wird, aber da hab ich ja wohl falsch gelegen ^^ Scheint prima zu klappen.
