Zylinder/Eigenschaften (auf Größe) vergleichen

[davio]

Hey Programmierer

Erstmal zu mir:

Ich habe vor kurzem das Studium der Wirtschaftsinformatik aufgenommen. Bei uns wird selbstverständlich auch programmiert, nämlich mit Java. Ich bin blutiger Anfänger, habe vor dem Studium noch nie eine Zeile programmiert, und muss mich deshalb ziemlich durchbeißen. Aber das tue ich gerne, denn mir macht es Spaß.

Zu meinem Problem:

Ich hänge nun seit einigen Stunden an einer Aufgabe fest, und weiß nicht mehr weiter. Ich sehe keinen weiteren Lösungsansatz, weil ich geistig einfach noch nicht soweit bin, um die Zusammenhänge zu erkennen. Deshalb brauche ich von euch Hilfe. Entweder Konkrete oder einen Lösungsansatz!

Teil 1 der Aufgabe besteht darin, eine Klasse Zylinder zu erzeugen. Dem Konstruktor sollen die Werte Radius (r) und Höhe (h) übergeben werden welche dann im Attribut int gespeichert werden. Außerdem sollen die Methoden getHoehe, getRadius, setHoehe, setRadius bereitgestellt werden um die Werte r und h auszulesen oder zu verändern.

Teil 2 der Aufgabe besteht darin, die Klasse um getGrundfläche, getVolumen und getOberfläche erweitert werden in mm² und mm³

Ich denke diesen Teil habe ich bis jetzt geschafft und mein bisheriges Programm sieht so aus:

package Zylinder;

public class Zylinder {

	//Attribute

	private int radius, hoehe;
	
	
	// Konstruktor

	  Zylinder (int r,int h){
		r = radius; h = hoehe;}
	 
	  //Methoden

	 public int getRadius ()
	 {return  radius;}
	 
	 public int getHoehe ()
	 {return hoehe;}
	 
	 public void setRadius (int r)
	 {radius = r;}
	 
	 public void setHoehe (int h)
	 {hoehe = h ;}
	 
	//Berechnungen zum Zylinder
	 
	//Grundfläche

	 public double getGrundfläche (double grundfläche)
	{grundfläche = 							//2*Radius*Pi
		radius * radius * 3.14159;
	return grundfläche;
	}

	
	 //Oberfläche

	public double getOberfläche (double oberfläche)
	{oberfläche =					       //Oberfläche = Umfang * Höhe + 2 * Grundfläche
		
		2 * 3.14159 * radius  			        //Umfang
		* hoehe                           	                //*Höhe
		+  2 * radius * radius * 3.14159; 	        //+ 2* Grundfläche
	
	return oberfläche;
	}
	
	//Volumen

	public double getVolumen (double volumen)
	{volumen = 						//Grundfläche * Höhe
		
		radius * radius * 3.14159 			//Grundfläche
		* hoehe;					        //Höhe
	
	return volumen;}

}

Teil 3 der Aufgabe ( und hier komme ich nicht weiter), besteht darin, dass behauptet wird, dass ein Zylinder in einen anderen Zylinder passt, sofern Radius und Höhe des zweiten Zylinders jeweils "echt kleiner" sind als die Werte des ersten Zylinders. Ich soll eine boolean "echtKleiner(Zylinder zwei)"-Funktion schreiben die überprüft, ob der übergebene Zylinder in den Zylinder der aufrufenden Instanz passt oder nicht.

Das Fettgeschrieben macht mir Probleme, weil ich nicht weiß, was das bedeuten soll. Was eine boolean Funktion ist, weiß ich aber.

Kann vielleicht jemand prüfen, ob in meiner bisherigen Arbeit Fehler sind? Und ich benötige dringend einen Denkanstoß für Teil 3 :-( Da ich leider absolut keine Ahnung habe, wie ich Anfangen soll.

Mein Noob-Ansatz: :lol:

Ich denke ich muss irgendwie einen neuen Konstruktor der Art "Zylinder zylinder2 = new Zylinder (Werte, Werte);" erschaffen und diesen mit dem ersten Zylinder vergleichen?! Ich weiß es aber auch nicht :-(

Teil 4 der Aufgabe ist es eine neue Klasse hinzuzufügen, die zwei unterschiedliche Instanzen der Klasse Zylinder anlegt und die von mir erstellten Methoden verwendet. Hier weiß ich nicht, wie man unterschiedliche Instanzen der Klasse Zylinder anlegt!

Danke für eure Hilfe

Viele Grüße
Davio

 

[eRaaaa]

Teil 1 der Aufgabe besteht darin, eine Klasse Zylinder zu erzeugen. Dem Konstruktor sollen die Werte Radius (r) und Höhe (h) übergeben werden welche dann im Attribut int gespeichert werden. Außerdem sollen die Methoden getHoehe, getRadius, setHoehe, setRadius bereitgestellt werden um die Werte r und h auszulesen oder zu verändern.

sieht soweit ganz okay aus, bis auf dein Konstruktor, da hast du r und radius und h und hoehe auf den Seiten vertauscht, schau dir nochmal an wie du das bei den settern gemacht hast.

Teil 2 der Aufgabe besteht darin, die Klasse um getGrundfläche, getVolumen und getOberfläche erweitert werden in mm² und mm³

Ich denke diesen Teil habe ich bis jetzt geschafft und mein bisheriges Programm sieht so aus:

Joah, ich würde anstelle dort Pi fest rein zuschreiben die Konstante aus Math benutzen: Math.PI und keine Umlaute verwenden!

Teil 3 [....]

Mein Noob-Ansatz: :lol:

Ich denke ich muss irgendwie einen neuen Konstruktor der Art "Zylinder zylinder2 = new Zylinder (Werte, Werte);" erschaffen und diesen mit dem ersten Zylinder vergleichen?! Ich weiß es aber auch nicht :-(

Nein, das Zylinder-Objekt wird ja nur der Methode übergeben. Was du machen musst ist einfach, dieses übergebene Zylinder-Objekt mit deinem zu vergleichen, dafür kannst du die Methoden getHoehe und Radius verwenden. Mit einer if-Abfrage dann kontrollieren ob die Werte kleiner sind. Das Schlüsselwort [c]this[/c] kann man hier auch mal in den Raum werfen!
Denkanstoss:
if(zwei.getRadius()<this.getRadius() && ...)

Teil 4 der Aufgabe ist es eine neue Klasse hinzuzufügen, die zwei unterschiedliche Instanzen der Klasse Zylinder anlegt und die von mir erstellten Methoden verwendet. Hier weiß ich nicht, wie man unterschiedliche Instanzen der Klasse Zylinder anlegt!

So wie du es eben in deinem "Noob-Ansatz" tun wolltest mit

new

 

[Marco13]

Und überleg' mal, ob es nicht Vorteile haben könnte, wenn in deinem Programm solche Zeilen wie
return getUmfang()*getHoehe()+2*getGrundfläche();
und
return getHoehe()*getGrundflaeche();
vorkommen würden...

(Preisfrage: Warum? )

 

[davio]

Also ich habe jetzt mal folgendes angehängt für Teil 3 (bzw. letzter Abschnitt mit der if-Anweisung)

package Zylinder;

public class Zylinder {
	//Attribute
	private int radius, hoehe;
	
	
	// Konstruktor
	  Zylinder (int r,int h){
		radius = r; hoehe = h;}
	 
	  //Methoden
	  
	 public int getRadius ()
	 {return  radius;}
	 
	 public int getHoehe ()
	 {return hoehe;}
	 
	 public void setRadius (int r)
	 {radius = r;}
	 
	 public void setHoehe (int h)
	 {hoehe = h ;}
	 
	//Berechnungen zum Zylinder
	 
	//Grundfläche
	 public double getGrundfläche (double grundfläche)
	{grundfläche = 							//2*Radius*Pi
		radius * radius * Math.PI;
	return grundfläche;
	}

	
	 //Oberfläche
	public double getOberfläche (double oberfläche)
	{oberfläche =							//Oberfläche = Umfang * Höhe + 2 * Grundfläche
		
		2 * Math.PI * radius  				//Umfang
		* hoehe                           	//*Höhe
		+  2 * radius * radius * Math.PI; 	//+ 2* Grundfläche
	
	return oberfläche;
	}
	
	//Volumen
	public double getVolumen (double volumen)
	{volumen = 								//Grundfläche * Höhe
		
		radius * radius * Math.PI			//Grundfläche
		* hoehe;							//Höhe
	
	return volumen;
	

	if (zylinderzwei.getRadius()<this.getRadius())
			if (zylinderzwei.getHoehe()<this.getHoehe())
					{System.out.println("Zylinder2 ist kleiner als Zylinder1");}
			else System.out.println("Zylinder2 ist größer als Zylinder1");
					
					

	}


}

Was muss ich jetzt bzw. vorher mit "zylinderzwei" machen, weil irgendwoher muss der ja Werte bekommen bzw. irgendwas muss in ihm drinstehen (Variabeln die auf Speicherplatz zugreifen), dass verglichen werden kann.

Wofür steht dieses this.getRadius? Das muss doch irgendwie die Werte des Ersten, vorherigen Zylinders aufrufen, oder?

Wo kann ich mich darüber schlau machen, wenn ich solche neue Begriffe wie "this." bei euch lese?


Es ist so hart, als Anfänger das alles zu verstehen! Aber mit viel fleiß schaffe ich das schon

 

[davio]

Und überleg' mal, ob es nicht Vorteile haben könnte, wenn in deinem Programm solche Zeilen wie
return getUmfang()*getHoehe()+2*getGrundfläche();
und
return getHoehe()*getGrundflaeche();
vorkommen würden...

(Preisfrage: Warum? )

Ohh, jetzt erst gelesen, mache ich mir mal direkt Gedanken drum!

 

[davio]

Und überleg' mal, ob es nicht Vorteile haben könnte, wenn in deinem Programm solche Zeilen wie
return getUmfang()*getHoehe()+2*getGrundfläche();
und
return getHoehe()*getGrundflaeche();
vorkommen würden...

(Preisfrage: Warum? )

Also ich stelle ja bei den Methoden getOberfläche und getVolumen berechnen an und
gebe die kompletten Rechnungschritte an. Dabei habe ich ja schon z.B. bei der Oberflächenberechnung
genau defininiert, wie die Grundfläche berechnet wird.

Es wäre als sinnvoll irgendwie diesen Rechnungsschritt mit getGrundfläche() in die Rechnung zu integrieren.
Aber ich weiß nicht wie ich es Syntaxmäßig schreiben soll - Eclipse zeigt mir immer Fehler an :-(

So hätte ich es versucht im Beispiel Volumen:

	//Volumen
	public double getVolumen (double volumen)
	{volumen = 								//Grundfläche * Höhe
                return getHoehe()*getGrundflaeche();

        return volumen;
	}

anstelle von

	//Volumen
	public double getVolumen (double volumen)
	{volumen = 								//Grundfläche * Höhe
	
		radius * radius * Math.PI			//Grundfläche
		* hoehe;							//Höhe
	
	return volumen;
	}

Als Fehler zeigt mir Eclipse aber dabei an, dass getGrundfläche für den Zylinder nicht definiert sei, und dass ich return entfernen soll! :-(

 

[SlaterB]

> volumen = return

gibts nicht

 

[XHelp]

Also

volumen = return ....

geht nicht. Mach mal return ohne Zuweisung. Desweiteren hast du keine

getGrundflaeche()

-Methode, sondern nur eine

getGrundflaeche(double)

. Wozu du da einen Parameter übergeben musst, ist mir allerdings nicht klar. Nur um eine Variable zum Arbeiten zu haben, brauchst du diese nicht per Parameter mitschleppen.

 

[davio]

Ok, ich weiß nicht mehr weiter. Meine Rübe qualmt mittlerweile und weiteres nachdenken macht keinen Sinn mehr :-(

Kann vielleicht jemand das Programm mal zuende schreiben, damit ich nen paar Denkanstöße und Kniffe daraus sehe? Ich weiß das soll hier ja eigentlich nicht gemacht werden laut Sticky, aber ich sitz nun Stunden daran und sehe einfach nicht die nächsten Schritte. Ich hab's wirklich versucht :-(

Viele Grüße und eine schöne Woche wünscht
Davio

 

[SlaterB]

statt
> volumen = return ..
schreibe
> volumen = ..

oder worum gehts aktuell?

aus
> public double getGrundfläche (double grundfläche)
muss als erster Schritt
> public double getGrundfläche ()
werden

welch einfache Schritte..

> public double getVolumen (double volumen)
genauso, get-Methoden haben generell keine Parameter, einfach zu merken

 

[xfeldt]

Hallo, ich werde vermutlich nächstes Semester Informatik als Nebenfach belegen und wollte mich schon einmal etwas vorbereiten. Die Übungszettel des letzten Jahres haben mich zu der gleichen Aufgabe geführt.
Der erste Teil scheint so OK zu sein, aber ab //-------------TestKlasse----------------- bekomme ich die Fehler nicht raus. Vielleicht kann mir jemand sagen was mein Fehler ist. Ich bin mir sicher ich habe irgend etwas in der Struktur nicht verstanden. Also wie sich public static void main(String[] args) auswirkt und wann ich wo neue Methoden beginne oder ob man die in einander schreiben darf etc.

Hier mein Code:

public class Zylinder 
{

			  
	
	private static int radius,hoehe,nummer;
	
	
	//Konstruktor
	
	public Zylinder (int n, int r, int h)
	{
		Zylinder.radius=r;
		Zylinder.hoehe=h;
		Zylinder.nummer=n;
	}
	
//	Methode zum nachträglichen ändern des Zylinderradius
	
	public void setRadius (int r)
	{
		radius=r;
	}
	
//	Methode zum nachträglichen ändern der Zylinderhöhe
	
	public void setHoehe (int h)
	{
		hoehe=h;
	}
	
//	Methoden zum auslesen Eigenschaften	
	
	public int getNummer()
	{
		return nummer;
	}
	
	public int getRadius()
	{
		return radius;
	}
	
	
	public int getHoehe()
	{
		return hoehe;
	}

	
	public double getGrundflaeche()
	{
		double grundflaeche;
		
		grundflaeche= 
				Math.PI  *radius * radius;
		
		return grundflaeche;
	}
	
	
	public double getOberflaeche()
	{
		double oberflaeche;
		
		oberflaeche= 
				2 * getGrundflaeche() 
				+ 2 * Math.PI * radius * hoehe;
		
		return oberflaeche;
	}
	
	
	public double getVolumen()
	{
		double volumen;
		
		volumen=
				getGrundflaeche()*hoehe;
		
		return volumen;
	}		
}

//-------------TestKlasse-----------------

class TestZylinder
{
	public static void main(String[] args)
	{
		Zylinder ersterZylinder = new Zylinder(1,5,10);
		{
			System.out.println("Zylinder"+ersterZylinder.getNummer());
			System.out.println("Radius: "+ersterZylinder.getRadius());
			System.out.println("Höhe: "+ersterZylinder.getHoehe());
			System.out.println("Grundfläche: "+ersterZylinder.getGrundflaeche());
			System.out.println("Oberfläche: "+ersterZylinder.getOberflaeche());
			System.out.println("Volumen: "+ersterZylinder.getVolumen());
		}	
		int nummer 				= ersterZylinder.getNummer();
		int radius 				= ersterZylinder.getRadius();
		int hoehe  				= ersterZylinder.getHoehe();
		double grundflaeche 	= ersterZylinder.getGrundflaeche();
		double oberflaeche 		= ersterZylinder.getOberflaeche();
		double volumen 			= ersterZylinder.getVolumen();
		
		Zylinder zweiterZylinder = new Zylinder(2,6,8);
		{
			System.out.println("Zylinder"+zweiterZylinder.getNummer());
			System.out.println("Radius: "+zweiterZylinder.getRadius());
			System.out.println("Höhe: "+zweiterZylinder.getHoehe());
			System.out.println("Grundfläche: "+zweiterZylinder.getGrundflaeche());
			System.out.println("Oberfläche: "+zweiterZylinder.getOberflaeche());
			System.out.println("Volumen: "+zweiterZylinder.getVolumen());
		}
		
	
		
	
	
		
	public boolean echtKleiner()
	{
			
		boolean x;
		
		
		
		if(zweiterZylinder.getRadius()<ersterZylinder.getRadius())
		{
			if(zweiterZylinder.getHoehe()<ersterZylinder.getHoehe())
				System.out.println("Zylinder2 passt vollständig in Zylinder1 hinein.");
			x=true;
		}
		else
		{
			System.out.println("Zylinder2 passt nicht in Zylinder1 hinein.");
			x=false;
		}
		
		System.out.println(x);
		return x;
		
	}
	}
}

vielen Dank schonmal!
LG Stefan

 

[xfeldt]

Wer die Aufgabe lesen will:
http://www.wi.uni-muenster.de/pi/lehre/ws1011/info1/uebungen/Blatt2.pdf

 

[jgh]

1. Die Methode

public boolean echtKleiner(Zylinder zwei)

gehört natürlich in die Klasse Zylinder und nicht in die "TestZylinder" Klasse!

2. in der ganzen Aufgabenstellung steht nichts von einem Konstruktor, der eine Nummer hat, geschweige denn, dass die int-Variablen static sein sollen!!

Und der Größenvergleich funktioniert so: Du hast einen Zylinder und dieser Zylinder bekommt in der Methode [c]echtKleiner(Zylinder zwei)[/c] einen anderen Zylinder übergeben und soll ihn auf "echtKleiner" überprüfen. In meinen Bsp frage ich die Höhe des übergebenen Zylinders ab und vergleiche ihn mit [c]this.getHoehe()[/c], also mit der aktuellen Instanz.
Sollte der übergebene Zylinder gleich, oder gar größer als die Instanz sein, return(ed) diese Instanz gleich false und springt somit aus der Methode. Sollte die Höhe echt kleiner sein, geht es zum nächsten Schritt.
Auch hier, wenn der Radius des übergebenen Zylinders größer oder gleich dem Radius der Instanz ist, wird ein [c]false[/c] return(ed) und er ist auch raus aus der Methode.

Nur wenn beide If-Abfragen unwahr sind, springt er in Zeile 64 und return(ed) true.

public class Zylinder {

	private int radius, hoehe;

	// Konstruktor

	public Zylinder(int r, int h) {
		radius = r;
		hoehe = h;
	}

	// Methode zum nachträglichen ändern des Zylinderradius

	public void setRadius(int r) {
		radius = r;
	}

	// Methode zum nachträglichen ändern der Zylinderhöhe

	public void setHoehe(int h) {
		hoehe = h;
	}

	// Methoden zum auslesen Eigenschaften

	public int getRadius() {
		return radius;
	}

	public int getHoehe() {
		return hoehe;
	}

	public double getGrundflaeche() {
		double grundflaeche;

		grundflaeche = Math.PI * radius * radius;

		return grundflaeche;
	}

	public double getOberflaeche() {
		double oberflaeche;

		oberflaeche = 2 * getGrundflaeche() + 2 * Math.PI * radius * hoehe;

		return oberflaeche;
	}

	public double getVolumen() {
		double volumen;

		volumen = getGrundflaeche() * hoehe;

		return volumen;
	}

	public boolean echtKleiner(Zylinder zwei) {
		if (zwei.getHoehe() >= this.getHoehe())
			return false;
		if (zwei.getRadius() >= this.getRadius())
			return false;

		return true;

	}
}

// -------------TestKlasse-----------------

class TestZylinder {
	public static void main(String[] args) {
		Zylinder ersterZylinder = new Zylinder(5, 10);
		System.out.println("Radius: " + ersterZylinder.getRadius());
		System.out.println("Höhe: " + ersterZylinder.getHoehe());
		System.out.println("Grundfläche: " + ersterZylinder.getGrundflaeche());
		System.out.println("Oberfläche: " + ersterZylinder.getOberflaeche());
		System.out.println("Volumen: " + ersterZylinder.getVolumen());

		Zylinder zweiterZylinder = new Zylinder(10, 20);
		System.out.println("Erster Zylinder ist kleiner als zweiter: "
				+ ersterZylinder.echtKleiner(zweiterZylinder));
		System.out.println("Zweiter Zylinder ist kleiner als erster: "
				+ zweiterZylinder.echtKleiner(ersterZylinder));

	}[
}

 

[xfeldt]

Vielen Dank,

So jetzt bin ich auch angemeldet, werde ja sicher noch öfter hier sein

Ja, macht Sinn den Größenvergleich nicht in der Testklasse zu haben.

2. in der ganzen Aufgabenstellung steht nichts von einem Konstruktor, der eine Nummer hat...

Ich hatte mich hinterher nicht mehr so genau an die Aufgabe gehalten, war ja nur für mich, allerdings hatte ich nicht verstanden wie das Argument in

echtKleiner(Zylinder zwei)

zu deuten ist.
Wenn ich also

...nder(Zylinder zwei)

im Argument habe sage ich, dass er eine Instanz von Zylinder mit dem Namen

zwei

erwarten soll? Ich hoffe ich habe die Begriffe so richtig. Mir fällt es noch sehr schwer den Aufbau/Semantik/Struktur von Java zu verstehen und somit wann man was machen kann und darf. Habe von 170 Seiten(von 1200 :-/ ) in meinem Javabuch durchgearbeitet, aber ich vermute sowas kommt nur durch Übung. Das viel mir in Fortran leichter^^.

LG Stefan

 

[jgh]

na ja, nicht 100%-ig
du erwartest nicht einen Zylinder der zwei heißen soll, sondern du bekommst einen Zylinder der unter den Namen zwei nur innerhalb dieser Methode gültig ist.

Wenn du dir die main-Methode anschaust, werden zwei verschiedene Zylinder initialisiert und auf diese Instanzen ruft man dann die ensprechenden Methoden auf....kommt alles noch, versuch erstmal ein wenig oo zu denken

 

[xfeldt]

Hab noch etwas an der Ausgabe geschraubt, ich weiß nicht ob man es so macht, aber es läuft

.
.
.
    public boolean echtKleiner(Zylinder zwei) {
        if (zwei.getHoehe() >= this.getHoehe())
            return false;
        if (zwei.getRadius() >= this.getRadius())
            return false;
 
        return true;
 
    }
    
   public String jaNein(boolean wahrheitwert){
	  String nein="nein";
      String ja="ja";
    	if(wahrheitwert)
    		return ja;
    	return nein;
    }

}
 
// -------------TestKlasse-----------------
 
class TestZylinder {
    public static void main(String[] args) {
        Zylinder ersterZylinder = new Zylinder(5, 10);
        System.out.println("Radius: " + ersterZylinder.getRadius());
        System.out.println("Höhe: " + ersterZylinder.getHoehe());
        System.out.println("Grundfläche: " + ersterZylinder.getGrundflaeche());
        System.out.println("Oberfläche: " + ersterZylinder.getOberflaeche());
        System.out.println("Volumen: " + ersterZylinder.getVolumen());
        
         
        Zylinder zweiterZylinder = new Zylinder(4,8);
        System.out.println("Erster Zylinder passt vollständig in den zweiten: "
                + ersterZylinder.jaNein(ersterZylinder.echtKleiner(zweiterZylinder)));   
              System.out.println("Zweiter Zylinder passt vollständig in den ersten: "
                + ersterZylinder.jaNein(zweiterZylinder.echtKleiner(ersterZylinder)));
 
    }
}

Bin für alle Korrekturen offen, ansonsten könnte meiner Meinung nach das Thema geschlossen werden.

 

[xfeldt]

na ja, nicht 100%-ig
du erwartest nicht einen Zylinder der zwei heißen soll, sondern du bekommst einen Zylinder der unter den Namen zwei nur innerhalb dieser Methode gültig ist.

Wenn du dir die main-Methode anschaust, werden zwei verschiedene Zylinder initialisiert und auf diese Instanzen ruft man dann die ensprechenden Methoden auf....kommt alles noch, versuch erstmal ein wenig oo zu denken

Ich glaub so in der Art meinte ich das. Das Argument ist

(Zylinder zwei)

also ich verstehe das so: nimm die (nur in dieser Methode vorhandene) Instanz von

Zylinder

mit Variable

zwei

der wir in unserem Fall mit Namen

zweiterZylinder

geben.
Ich wäre nicht auf die Idee gekommen

[B]Zylinder[/B] zwei

zu schreiben ich hätte nur

zwei

geschrieben, was vermutlich nicht geklappt hätte.