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.
public void getGegenstand(int weight, int benefit)
{
}
und möchte nun Objekte erstellen, die ein Gewicht und einen Benefit haben. Wie kann ich das realisieren? Das ganze dreht sich um das KnapSack-Problem, dh die Objekte müssen dann untereinander verglichen werden und nach Gewicht und/oder Benefit sortiert werden können.
Diese Frage läßt so ziemlich jede nötige Expertise, die es für das Knapsack-Problem braucht, vermissen (nicht bös' gemeint). Die Grundlagen solltest du dir schon aneignen...
Eine mögliche Implementierung:
Code:
public class Gegenstand implements Comparable {
public static Gegenstand getGegenstand(int weight, int benefit) {
return new Gegenstand(weight, benefit);
}
private int weight;
private int benefit;
private Gegenstand(int weight, int benefit) {
this.weight = weight;
this.benefit = benefit;
}
public int getWeight() {
return weight;
}
public int getBenefit() {
return benefit;
}
public int compareTo(Gegenstand another) {
// Knapsack-Vergleich
}
}
Das sieht mir nach Rekursion aus. Woher kommt aber der Aufruf "new Gegenstand(weight, benefit)"? Welche Werte werden übergeben?
mit der compareTo-Methode hab ich auch meine Probleme. Klar ist, dass ein Objekt der gleichen Klasse mit dem Objekt Gegenstand verglichen werden sollen. Doch wie ist das zu realisieren? Ich nehme an, dass dies mit der rekursiven Methode zusammenhängt, die ich ja noch nicht ganz verstanden habe.
Nebenfrage: wieso deklarierst du den Konstruktur als private?
Da ist nichts rekursiv. Die von dir angesprochene Methode ist eine sogenannte Factory - das, was du in deinem Eingangspost haben wolltest. Die Methode heißt getGegenstand(), bekommt die Parameter weight und benefit und liefert ein Objekt der Klasse Gegenstand zurück. Dafür ruft sie den Konstruktor Gegenstand(int,ínt) auf, welcher, wie du richtig erkannt hast, private deklariert ist. Er ist private, um neue Objekte nur über die Factory erzeugen zu können (welche in diesem Beispiel eigentlich wenig Sinn macht - ich habe mich hier an deinem Ursprungspost orientiert). Wäre er public, so könnte man neue Gegenstände sowohl über die Factory als auch über einen einfachen Konstruktoraufruf erzeugen.
Die compare-Methode vergleicht zwei Gegenstände miteinander und liefert -1, wenn Gegenstand a kleiner als Gegenstand b, 0, wenn sie gleich groß und 1, wenn Gegenstand a größer Gegenstand b. Siehe dazu auch die Javadoc vom Interface Comparable.
Eine Beispielimplementierung von compareTo (die nicht das Knapsack-Problem löst, sondern nur nach dem Gewicht sortiert!):
Code:
public int compareTo(Gegenstand b) {
return getWeight().compareTo(b.getWeight());
}
Hier hole ich mir das Gewicht des Gegenstands a und vergleiche es mit dem Gewicht von Gegenstand b. Weil ich faul bin, benutze ich dafür die compareTo-Methode der Klasse Integer, denn die implementiert die Spezifikation schon korrekt und befreit mich somit von etwas Schreibarbeit. Besser verständlich ist wahrscheinlich das hier:
Code:
public int compareTo(Gegenstand b) {
if(getWeight() < b.getWeight()) { // eigenes Gewicht kleiner als das von b
return -1;
}
if(getWeight() > b.getWeight()) { // eigenes Gewicht größer als das von b
return 1;
}
return 0; // Wenn er bis hierher kommt, muß das Gewicht gleich sein.
}
Nochmals: Lies dir die Grundlagen an! "Java ist auch eine Insel" (www.galileocomputing.de/openbook/javainsel6/) ist zum Beispiel empfehlenswert. Oder auch das Java-Buch (www.javabuch.de). Konstruktoraufrufe, statische Methode, Rückgabewerte und Parameter müssen vom Hirn ins Rückenmark übergehen. Da solltest du beim Programmieren nicht mehr drüber nachdenken müssen...
public int compareTo(Gegenstand b) {
if(getWeight() < b.getWeight()) { // eigenes Gewicht kleiner als das von b
return -1;
}
if(getWeight() > b.getWeight()) { // eigenes Gewicht größer als das von b
return 1;
}
return 0; // Wenn er bis hierher kommt, muß das Gewicht gleich sein.
}
Ich sehe trotzdem nicht, wo da das Problem sein sollte. Alle drei Zahlen sind schließlich im Wertebereich von int. Oder hast du jetzt Angst wegen der Grenzen des Wertebereichs (betragsmäßig größte negative Zahl)?
Okay, dann darf ich also noch hinzufügen, dass diese Methode kein richtiges Ergebnis liefern kann, wenn ein Overflow für vorzeichenbehaftete Zahlen auftritt. Da man in Java kein V-Flag zur Kontrolle hat, ist diese Methode nur dann auf jeden Fall sinnvoll einzusetzen, wenn beide Zahlen vorzeichenlos (nur positiv) sind. Zufrieden? :roll:
So, und jetzt will ich von dir wissen, welcher praktische Gegenstand eine negative Masse hat. :lol:
Eclipse beschwert sich, dass meine Klasse nicht alle nötigen Methoden des Interfaces implementiert.
Code:
public int compareTo(Gegenstand g) {
// Knapsack-Vergleich
if(getWeight() < g.getWeight()) { // eigenes Gewicht kleiner als das von b
return -1;
}
if(getWeight() > g.getWeight()) { // eigenes Gewicht größer als das von b
return 1;
}
return 0; // Wenn er bis hierher kommt, muß das Gewicht gleich sein.
}
gefordert wird eine Methode wie:
Code:
public int compareTo(Object g) {}
"Gegenstand" ist doch ein Objekt!? Wo liegt das Problem?
Vielen Dank und lasst euch bei eurer Diskussion nicht stören...
public int compareTo(Gegenstand g) {
// Knapsack-Vergleich
if (g insanceof Gegenstand) {
Gegenstand gegenstand = (Gegenstand) g;
if(getWeight() < gegenstand.getWeight()) { // eigenes Gewicht kleiner als das von b
return -1;
}
if(getWeight() > gegenstand.getWeight()) { // eigenes Gewicht größer als das von b
return 1;
}
}
return 0; // Wenn er bis hierher kommt, muß das Gewicht gleich sein.
}
