Brauche Denkanstoß

[rumpi]

Hallo,

ich möchte gern das Volumen und die Oberfläche von Körpern (Quader, Kugel, Zylinder) berechnen und diese dann vergleichen. Das soll folgende Form haben:



Ich weiß gar nicht, wo ich anfangen soll! Ich bin erstmal hier:

abstract class Körper implements Comparable {
	
	public abstract double volumen();
	public abstract double oberflaeche();
	public int compareTo(Object object){
		
	}
	public static void sort(Körper[] k){
		
	}
	public static void main (String[] args){
		Körper[] k = new Körper[6];
		k[0] = new Quader(3.0, 2.0, 1.0);		
	}
}

class Quader extends Körper{
	public Quader (){
		
	}
	public double volumen(){
		
	}
	public double oberflaeche(){
		
	}
	
		
}
class Zylinder extends Körper{
	
}
class Kugel extends Körper{
	
}

Könnt ihr mir nen Hinweis geben?

Gruß,
Rumpi

 

[ARadauer]

wo ist konkret das Problem? Quader, Zylender und Kugel müssen die volumen und oberflache methode implementieren. Schreib mal diese Methoden.

 

[rumpi]

class Quader extends Körper{
   public Quader (){
      
   }
   public double volumen(){
      
   }
   public double oberflaeche(){
      
   }      
}

Ich weiß allerdings nicht wo ich die einzelnen Werte hernehmen soll, die dann das Volumen bilden.

 

[SlaterB]

tja, dann musst du wohl alle nötigen Attribute
wie Länge, Breite, Höhe, Durchmesser, Krümmungsradius, plancksche Wirkungskonstante und wer weiß noch alles dazumodellieren und im Konstruktor setzen

> new Quader(3.0, 2.0, 1.0);

da kommen dann die Werte her

 

[ARadauer]

"Die Klassen sollen entsprechende Konstrukturen enthalten"

so zb

class Quader extends Körper{ 
         int laenge;
         int breite;
         int hoehe;
         public Quader (int laenge, int breite, int hoehe){
            this.laenge = laenge;
            this.breite = breite;
            this.hoehe = hoehe;
            
         } 
         public double volumen(){ 
            return laenge*breite*hoehe;
         } 
         public double oberflaeche(){ 
           .. usw... 
         }      
      }

 

[rumpi]

class Quader extends Körper{
	double laenge, breite, hoehe;
	public Quader(double laenge, double breite, double hoehe){
		this.laenge=laenge;
		this.breite=breite;
		this.hoehe=hoehe;
	}
	public double volumen(){
		return laenge*breite*hoehe;
	}
	public double oberflaeche(){
		return 2*(breite*laenge+breite*hoehe+hoehe*laenge);		
	}
}
class Zylinder extends Körper{
	double radius, hoehe;
	public Zylinder(double radius, double hoehe){
		this.radius=radius;
		this.hoehe=hoehe;
	}
	public double volumen(){
		return Math.PI*radius*radius*hoehe;
	}
	public double oberflaeche(){
		return 2*Math.PI*radius*(radius+hoehe);
	}
	
}
class Kugel extends Körper{
	double radius;
	public Kugel(double radius){
		this.radius=radius;
	}
	public double volumen(){
		return Math.PI*radius*radius*radius*(4/3);
	}
	public double oberflaeche(){
		return 4*Math.PI*radius*radius;		
	}
	
}

Jetzt noch ne andere Frage. Warum sollen denn in

public static void sort(Object[] k)

die Parameter sortiert werden?

 

[SlaterB]

gute Frage, was sollen wir jetzt raten?

dem/r Aufgabensteller/in ist keine interessantere Aufgabe eingefallen?

 

[rumpi]

Hihi. Das das nicht lebensnotwendig war, ist mir klar.
Hätte besser gefragt "wie" ich das machen kann.
Geht es um die Parameter, die bei der Objecterzeugung mitgegeben werden? z.b. hier:
k[0] = new Quader(3.0, 2.0, 1.0);

 

[ARadauer]

du könntest jetzt nach volumen oder oberfläche sortieren...
da du schon Comparable implementierst musst du nur noch entscheiden, was größer oder kleiner ist...

[qoute]
int compareTo(T o)Compares this object with the specified object for order. Returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object.
[/quote]

zb so

public int compareTo(Körper o){ 
            if(volumen()>o.volumen())
                  return 1;
            if(volumen()<o.volumen())
               return -1;
            return 0;
            
         }

da musst du aber dann implements Comparable<Körper> implementieren, was eh besser ist ;-)

Wenn du das machst kannst du so zb sortieren..

         public static void sort(Körper[] k){ 
            Arrays.sort(k);
         }

 

[SlaterB]

> Geht es um die Parameter, die bei der Objecterzeugung mitgegeben werden? z.b. hier:
> k[0] = new Quader(3.0, 2.0, 1.0);

in der Aufgabe ist ein Beispiel-Arrray gegeben, welches du sortieren sollst

 

[rumpi]

Was genau sagt denn dieser Parameter <Körper> in dem Fall? Es funktioniert zwar, aber ich verstehe nicht warum...

 

[rumpi]

Ich soll also die k[0], k[1] usw sortieren? Nach dem Volumen also?

 

[SlaterB]

> Was genau sagt denn dieser Parameter <Körper> in dem Fall?

welcher Parameter <Körper>?

in
> public static void sort(Körper[] k){
ist Körper[] k ein Körper-Array, nicht mehr und nicht weniger

> Ich soll also die k[0], k[1] usw sortieren? Nach dem Volumen also?

ein Array kann man nur ganz oder gar nicht sortieren, nicht jeden Wert einzeln,
nach Volumen, ja (edit: scheint nicht vorgegeben, dann kannst du es dir aussuchen)

 

[rumpi]

Ich verstehs immer noch nicht :cry:
Wie kann man so dumm sein^^
k[0], ... ,k[4], k[5] das sind doch alles Objecte. Und die stehen in dem Array k? Ist das so richtig?

Edit: Also an Stelle k[0] des Arrays steht ein Quader mit den Parametern (3.0,2.0,1.0). Steh dort das Volumen und die Oberfläche?

 

[SlaterB]

ein Quader-Objekt kannst du per volumen() nach seinem Volumen fragen, ja

 

[rumpi]

Ich müsste also mit sowas wie nem Sortierverfahren (bubblesort z.b.) ran?

boolean  sorted;
		do  {
			sorted  =  true;
			for  (int  i = 0;  i  <  k.length  -  1;  ++i)  {
				if  (k[i].compareTo(k[i  +  1])  >  0)  {
					Comparable<Körper>  tmp  =  k[i];
				k[i]  =  k[i  +  1];
				k[i  +  1]  =  (Körper)tmp;
				sorted  =  false;
				}
			}
		}  while  (!sorted);

 

[SlaterB]

oder siehe letztes Posting von ARadauer, Arrays.sort(k)

 

[rumpi]

Das nimmt dann Quicksort, was nicht so schnell wie mein Bubblesort ist
Aber ich muss noch mal fragen. Wo nach wird denn nun sortiert?
Oder anders gefragt, was steht jetzt explizit in k[0] drin?

 

[SlaterB]

du kennst doch dein Körper-Interface und damit alle Methoden, die zur Verfügung stehen,
siehe immer noch letztes Posting von ARadauer

 

[rumpi]

Steht dann dort Volumen und Oberfläche drin?

 

[SlaterB]

wo?

ein Quader-Objekt kannst du per volumen() nach seinem Volumen fragen, ja

 

[rumpi]

Also wenn ich jetzt richtig verstanden habe, steht in k[0] nach wie vor 3.0,2.0,1.0 drin.
Und erst wenn ich k[0].volumen(); aufrufe, wird das Volumen berechnet!?

 

[SlaterB]

ja

 

[rumpi]

public static void sort(Körper[] k){
		
		Arrays.sort(k);
		/*boolean  sorted;
		do  {
			sorted  =  true;
			for  (int  i = 0;  i  <  k.length  -  1;  ++i)  {
				if  (k[i].compareTo(k[i  +  1])  >  0)  {
					Comparable<Körper>  tmp  =  k[i];
				k[i]  =  k[i  +  1];
				k[i  +  1]  =  (Körper)tmp;
				sorted = false;
				}
			}
		}  while  (!sorted);*/
	}
	public static void main (String[] args){
		Körper[] k = new Körper[6];
		k[0] = new Quader(3.0, 2.0, 1.0);
		k[1] = new Quader(1.0,2.0,2.0);
		k[2] = new Zylinder(3.0,2.0);
		k[3] = new Zylinder(2.0,3.0);
		k[4] = new Kugel(2.0);
		k[5] = new Kugel(4.0);
		System.out.println(k[5].volumen());
	}

Wenn ich Arrays.sort(k) mache, kriege ich keine Ausgabe, aber auch keine Fehlermeldung.
Wenn ich den Bubblesort nehme (den ich temp mal auskommentiert habe), kriege ich die korrekte Berechnung. Woran liegt das?

 

[SlaterB]

deine main() enthält keinen sort-Aufruf und was für eine Ausgabe meinst du?
> System.out.println(k[5].volumen());
wird doch wohl immer etwas ausgeben

----

bei mir wird bei beiden Varianten alles vorher und nachher sauber ausgegeben und gleich sortiert, ich empfehle

	public static void main(String[] args) {
		Körper[] k = new Körper[6];
		k[0] = new Quader(3.0, 2.0, 1.0);
		k[1] = new Quader(1.0, 2.0, 2.0);
		k[2] = new Zylinder(3.0, 2.0);
		k[3] = new Zylinder(2.0, 3.0);
		k[4] = new Kugel(2.0);
		k[5] = new Kugel(4.0);
		for (int i = 0; i < k.length; i++) {
			System.out.println(k[i].volumen() + " - " + k[i].getClass());
		}
		sort(k);
		System.out.println();
		for (int i = 0; i < k.length; i++) {
			System.out.println(k[i].volumen() + " - " + k[i].getClass());
		}
	}

 

[rumpi]

Also bei mir kommt immer noch keine Ausgabe, aber auch keine Fehlermeldung. Sieht jemand, was ich falsch mache?

package test;

import java.util.Arrays;


abstract class Körper implements Comparable<Körper> {
	
	public abstract double volumen();
	public abstract double oberflaeche();
	public int compareTo(Körper object){
		if(volumen()>object.volumen())
			return 1;
		if(volumen()<object.volumen())
			return -1;
		return 0;
	}
	public static void sort(Körper[] k){
		
		Arrays.sort(k);
	}
	public static void main (String[] args){
		Körper[] k = new Körper[6];
		k[0] = new Quader(3.0, 2.0, 1.0);
		k[1] = new Quader(1.0,2.0,2.0);
		k[2] = new Zylinder(3.0,2.0);
		k[3] = new Zylinder(2.0,3.0);
		k[4] = new Kugel(2.0);
		k[5] = new Kugel(4.0);
		for (int i = 0; i < k.length; i++) {
	         System.out.println(k[i].volumen() + " - " + k[i].getClass());
	      }
	      sort(k);
	      System.out.println();
	      for (int i = 0; i < k.length; i++) {
	         System.out.println(k[i].volumen() + " - " + k[i].getClass());
	      } 
	}
}

class Quader extends Körper{
	double laenge, breite, hoehe;
	public Quader(double laenge, double breite, double hoehe){
		this.laenge = laenge;
		this.breite = breite;
		this.hoehe = hoehe;
		if (laenge < 0 | hoehe < 0 | breite < 0)
			System.out.print("Es wurde ein negativer Wert eingegeben. Programm wird beendet!");
			System.exit(1);
	}
	public double volumen(){
		return laenge*breite*hoehe;
	}
	public double oberflaeche(){
		return 2*(breite*laenge+breite*hoehe+hoehe*laenge);		
	}
}
class Zylinder extends Körper{
	double radius, hoehe;
	public Zylinder(double radius, double hoehe){
		this.radius = radius;
		this.hoehe = hoehe;
		if (hoehe < 0 | radius < 0)
			if (radius < 0 | hoehe < 0)
				System.out.print("Es wurde ein negativer Wert eingegeben. Programm wird beendet!");
				System.exit(1);
	}
	public double volumen(){
		return Math.PI*radius*radius*hoehe;
	}
	public double oberflaeche(){
		return 2*Math.PI*radius*(radius+hoehe);
	}
	
}
class Kugel extends Körper{
	double radius;
	public Kugel(double radius){
		this.radius = radius;
		if(radius<0)
			System.out.print("Es wurde ein negativer Wert eingegeben. Programm wird beendet!");
		System.exit(1);
	}
	public double volumen(){
		return Math.PI*radius*radius*radius*4/3;
	}
	public double oberflaeche(){
		return 4*Math.PI*radius*radius;		
	}
	
}

 

[SlaterB]

wenn ein Programm nichts ausgibt,
dann testet man
System.out.println("Hello World");
und schreibt keine 90 Zeilen seltsamen Code,

entweder die eine Zeile funktioniert oder nicht, wie siehts aus?

 

[rumpi]

So, das kommt davon, wenn man keine Ahnung hat und trotzdem Ecplipse nutzt...
Habs auf der Konsole ausgeführt und da geht es. Eclipse hat mich vor dem Ausführen gefragt, welche class, oder so ähnlich und ich hab ** (Vorauswahl) drin gelassen und hab einfach OK geklickt... Anscheind war das falsch.

Edit: Allerdings kommt auch auf der Konsole bei deiner For Schleife keine Ausgabe.

Edit2: Hier mal ein Screenshot:

 

[SlaterB]

in deinem Code ist keine for-Schleife,

wenn das Hallo geht, kannst du aber gerne folgendes testen

for (int i = 0; i < 3; i++) {
System.out.println("i: "+i);
}

+ später
System.out.println("gleich kommt k: "+k.length);
for (int i = 0; i < k.length; i++) {
System.out.println(k.volumen() + " - " + k.getClass());
}

 

[rumpi]

Geht nix.
wenn ich

      k[0] = new Quader(3.0, 2.0, 1.0);
      k[1] = new Quader(1.0,2.0,2.0);
      k[2] = new Zylinder(3.0,2.0);
      k[3] = new Zylinder(2.0,3.0);
      k[4] = new Kugel(2.0);
      k[5] = new Kugel(4.0);

lösche, geht die Ausgabe wieder.

 

[kashmir]

Hast du das Problem nun lösen können?

 

[rumpi]

Ne :/