Verebung und Methoden

[kwurzel]

Guten Abend! Ich muss für eine Hausaufgabe ein Programm schreiben, das (ua.) verschiedene geometrische Objekte erstellt und für diese Volumen und Transportkosten berechnet. Dafür gibt es recht strenge Regeln, unter anderem mit Interfaces etc.

Ich habe testhalber eine Kugel erstellen wollen, hier erstmal der Quellcode:

public abstract class Gegenstand {
	public double volumen;
	public int kosten;
	
	public Gegenstand () {
		
	}
	
	public abstract void volumenBerechnen();
	public void kostenBerechnen() {
		// TODO - muesste allgemein hier definiert werden
	}
}

public class Kugel extends Gegenstand {
	double radius;
	double volumen;
	int kosten;
	
	public Kugel (double r) {
		radius = r;
		this.volumenBerechnen();
		this.kostenBerechnen(); // TODO - muesste allgemein in der abstr. Klasse
								// Gegenstand definiert werden
	}
	
	public void volumenBerechnen() {
		this.volumen = 4./3. * Math.PI * (Math.pow(radius, 3));
	}
	
	// Muss nach Gegenstand.java verschoben werden (s.o.)
	public void kostenBerechnen() {
		this.kosten = (int) (this.volumen) * 3;
	}
}

public class TeleportationsTest {
	public static void main(String[] args) {
		Kugel Kugel1 = new Kugel (17);
		
		System.out.println(Kugel1.volumen);
		System.out.println(Kugel1.kosten);
	}
}

Die Berechnung des Volumens ist für unterschiedliche Objekte (Kugel, Quader, Zylinder etc.) verschieden, weshalb ich sie in den jeweiligen Klassen definieren möchte. Wie schon an den Kommentaren zu erkennen ist möchte ich die Berechnung der Kosten gerne einmal in der Gegenstandsklasse definieren, da sie für alle Objekte gleich ist (Volumen mal 3).

Obiger Quelltext funktioniert, allerdings bekomme ich die kostenBerechnen() nicht in die Klasse Gegenstand. Was muss ich tun, damit ich diese nur einmal definieren muss?

 

[hdi]

Das ist schon richtig so in der Klasse Gegenstand, du kannst durchaus machen:

public abstract class Gegenstand {
   private double volumen;
   private int kosten;
   
   public Gegenstand () {
      
   }
   
   public abstract void volumenBerechnen();
   public void kostenBerechnen() {
      this.kosten = (int) (this.volumen) * 3; 
   }
}

aber dann darfst du diese Methode halt nicht in den Unterklassen überschreiben, was du getan hast.
Nimm einfach die Methode kostenBerechnen() aus der Klasse Kugel raus.

Ausserdem überschreibst du auch die Attribute volumen und Kosten. Auch diese müssen aus den
Unterklassen raus! Sonst speicherst du da irgendwas ab, und die abstrakte KostenBerechnen() Methode
bezieht sich auf ihre eignen, die beide den Wert 0 haben.

PS: Du solltest die Variablen private deklarieren, und dir getter und setter dafür schreiben. Klassen-Attribute
public zu machen ist kein guter Stil, das bringt Sicherheitslücken. (Für dich jetz egal, aber generell)

 

[kwurzel]

Vielen Dank, so klappt es tatsächlich. Hatte es schon in der Oberklasse versucht, aber die erneute Deklaration der Variablen hatte ich nicht bedacht. So sieht es jetzt also aus:

public abstract class Gegenstand {
	private double volumen;
	private int kosten;

	/* Constructor */
	public Gegenstand () {
		
	}


	/* Methoden */
	public abstract void volumenBerechnen();
	public void kostenBerechnen() {
	      this.kosten = (int) (this.volumen) * 3; 
	}

	/* Getters und Setters */
	public void setVolumen(double volumen) {
		this.volumen = volumen;
	}

	public void setKosten(int kosten) {
		this.kosten = kosten;
	}
	
	public double getVolumen() {
		return volumen;
	}

	public int getKosten() {
		return kosten;
	}
}

public class Kugel extends Gegenstand {
	double radius;
	
	public Kugel (double r) {
		radius = r;
		this.volumenBerechnen();
		this.kostenBerechnen();
	}
	
	public void volumenBerechnen() {
		[b]this.volumen = 4./3. * Math.PI * (Math.pow(radius, 3));[/b]
	}
}

public class TeleportationsTest {
	public static void main(String[] args) {
		Kugel Kugel1 = new Kugel (17);
		
		System.out.println(Kugel1.getVolumen());
		System.out.println(Kugel1.getKosten());
	}
}

Was jetzt noch einen Fehler ausgibt, ist die fette Zeile: The field Gegenstand.volumen is not visible. Hier muss ich wahrscheinlich den Setter einsetzen, aber wie mache ich das?

Und noch was kleines am Rande: Was bringt ein leerer Konstruktor?

 

[hdi]

Du hast so eben am eigenen Leibe erfahren, warum man Variablen private macht: Du hast wie du siehst nicht
so einfach Schreibzugriff drauf, und wenn du jetz ein böser Hacker wärst, hättest du ein Problem

Wenn du nun Werte auslesen und ändern willst, brauchst du Setter & Getter, was du ja auch schon richtig
implementiert hast.

Was du wohl nicht weisst: als private deklarierte Metohden/Variablen sind auch in Unterklassen nicht sichtbar!
D.h. du musst auch in der Kugel-Klasse mit den Gettern und Settern der abstrakten Oberklasse arbeiten:

super.setVolumen( 4./3. * Math.PI * (Math.pow(radius, 3)));

Das "super" ist nicht zwingend nötig, das soll nur verdeutlichen, dass du hier eben ne Methode der Oberklasse
aufrufst. Das könntest du also auch bei kostenBerechnen() so machen.

PS: ein leerer Konstruktor macht nichts ausser ein Objekt von der Klasse zu erstellen und alle Attribute
auf ihre Initialwerten setzen (bei double und int ist das immer 0).

Diesen Konstruktor gibt es aber standardmässig schon, man nennt ihn "Default Constructor", und er ist auch da
ohne dass du ihn hinschreiben musst. Du kannst den Code also löschen vom abstrakten Konstruktor, du hast quasi
den Default-Konstruktor überschrieben mit einem neuen Konstruktor, der aber genau das gleiche macht. Einfach unnötig also

 

[kwurzel]

Vielen Dank, das hat mich ein schöne Stück weiter gebracht, nämlich bis zum nächsten Problem. Ich habe nun einen Vektor mit einigen Gegenständen gefüllt und soll nun die Gegenstände nach ihrem Volumen sortieren. Dazu soll ich die Klassen-Methode Collections.sort() einsetzen, was ich folgendermaßen versucht habe:

public class TeleportationsTest {
	public static void main(String[] args) {
	Vector<Gegenstand> v = new Vector<Gegenstand>();
	v.addElement(new Kugel (17));
	v.addElement(new Kugel (1));
	...
}

package teleport;

import java.util.Collections;

public abstract class Gegenstand implements Comparable<Gegenstand> {
	private double volumen;
	private int kosten;

	/* Constructor ist nicht notwendig, da Default Constructor ausreicht  */

	
	/* Methoden */
	public abstract void volumenBerechnen();
	public void kostenBerechnen() {
	      this.kosten = (int) (this.volumen) * 3; 
	}

	public int compareTo(Gegenstand o) {
	        Gegenstand e = o;
	        
	        Double vo = this.getVolumen();
	        Double ve = e.getVolumen();
	        
	        int result = vo.compareTo(ve);
			if (result < 0) {
				return -1;
			} else if (result == 0) {
				return 0;
			} else {
		        return 1;
		    }
	}

	public Gegenstand sort() {
		Gegenstand sorted = (Gegenstand) this.clone();
		Collections.sort(sorted);
		return sorted;
	}
	
    /* Getters und Setters */
...
}

Aber eigentlich verstehe ich die Funktion dieser Methode aber nicht. Eclipse zeigt mir bei Collections.sort(sorted); den Fehler "The method sort(List<T>) in the type Collections is not applicable for the arguments (Gegenstand)" an.

Was bedeutet das und wie kann ich den sortierten Vektor ausgeben lassen? Den originalen gebe ich so aus:

for (int i = 0; i < v.size(); i++) {
	System.out.println((i + 1) + ". Gegenstand: " + "Volumen: "
			+ v.elementAt(i).getVolumen() + " cm³,\tKosten: "
			+ v.elementAt(i).getKosten() + " Dublonen");
}

Vielen Dank für deine Hilfe!

 

[Schandro]

Collections.sort(sorted);

du willst einen Gegenstand sortieren?

 

[kwurzel]

Ähm nein, ich wollte einen Vektor mit vielen Gegenständen sortieren.
Ich bin nach der Anleitung auf http://davidwinter.me.uk/articles/2005/12/08/sorting-a-vector-using-collections-sort/ vorgegangen und habe das Beispiel so übernommen.

 

[Schandro]

Ich bin nach der Anleitung auf http://davidwinter.me.uk/articles/2005/12/08/sorting-a-vector-using-collections-sort/ vorgegangen und habe das Beispiel so übernommen.

Nein hast du nicht. Die sort-Methode steht nämlich in einer neuen Klasse ProductList, die von Vector erbt und deswegen sortiert werden kann.

 

[kwurzel]

Okay, das klingt logisch.

Edit: Denkfehler im ursprünglichen Post, muss erstmal noch drüber nachdenken.