huhu, ich bastel grad an einem progrämmchen, das geometrische dinge berechnen soll...mit nem quadrat klappt das schon ganz gut, nur beim Rechteck hab ich probleme.
bei einem quadrat reicht ja ein einzelner wert, doch bei nem rechteck und allen anderen geometrischen flächen oder formen brauch ich ja mindestens zwei werte.
wie muss ich da vorgehen??
ich poste hier mal meine quadratklasse und hoffe daß mir jemand tips geben kann, wie ich die rechteck-klasse schreiben muss/sollte.
hatte meine rechteck-klasse auch so aufgebaut, aber jenachdem wie ich diverse variablen in der main gefüllt habe, kamen unterschiedliche werte (unter anderem infinit) dabei raus!
hier mal mein bisheriger code fürs rechteck:
oder muss ich etwa die setter und getter-methoden so machen, daß wirklich nur der entsprechende wert gesetzt wird?
hab an andere weitere methoden gedacht, die dann die berechnungen durchführen, jedoch hab ich das problem, daß ich nicht weiß wie das dann nachher mit der wert-übergabe laufen soll(eben wegen der zwei variablen)...
bisher sieht das progrämmchen so aus: bitte klicken
bei einem quadrat reicht ja ein einzelner wert, doch bei nem rechteck und allen anderen geometrischen flächen oder formen brauch ich ja mindestens zwei werte.
wie muss ich da vorgehen??
ich poste hier mal meine quadratklasse und hoffe daß mir jemand tips geben kann, wie ich die rechteck-klasse schreiben muss/sollte.
Code:
package zweidimensional;
import java.math.*;
public class Quadrat {
private double seitenlaenge;
private double flaeche;
private double umfang;
private double diagonale;
public double getSeitenlaenge() {
return seitenlaenge;
}
public void setSeitenlaenge(double seitenlaenge) {
this.seitenlaenge = seitenlaenge;
this.flaeche = seitenlaenge*seitenlaenge;
this.umfang = seitenlaenge*4;
this.diagonale = seitenlaenge*Math.sqrt(2);
}
public double getFlaeche() {
return flaeche;
}
public void setFlaeche(double flaeche) {
this.flaeche = flaeche;
this.seitenlaenge = Math.sqrt(flaeche);
this.umfang = seitenlaenge*4;
this.diagonale = seitenlaenge*Math.sqrt(2);
}
public double getUmfang() {
return umfang;
}
public void setUmfang(double umfang) {
this.umfang = umfang;
this.seitenlaenge = umfang/4;
this.diagonale = seitenlaenge*Math.sqrt(2);
this.flaeche = seitenlaenge*seitenlaenge;
}
public double getDiagonale() {
return diagonale;
}
public void setDiagonale(double diagonale) {
this.diagonale = diagonale;
this.seitenlaenge = diagonale/Math.sqrt(2);
this.flaeche = seitenlaenge*seitenlaenge;
this.umfang = seitenlaenge*4;
}
/*
public static void main(String[] args) {
Quadrat quad = new Quadrat();
quad.setSeitenlaenge(6);
System.out.println(quad.getSeitenlaenge());
System.out.println(quad.getFlaeche());
System.out.println(quad.getUmfang());
System.out.println(quad.getDiagonale());
}
*/
}
hatte meine rechteck-klasse auch so aufgebaut, aber jenachdem wie ich diverse variablen in der main gefüllt habe, kamen unterschiedliche werte (unter anderem infinit) dabei raus!
hier mal mein bisheriger code fürs rechteck:
Code:
package zweidimensional;
import java.math.*;
public class Rechteck {
private double seitenlaenge_a = 0;
private double seitenlaenge_b = 0;
private double flaeche = 0;
private double umfang = 0;
private double diagonale = 0;
public double getSeitenlaenge_a() {
return seitenlaenge_a;
}
public void setSeitenlaenge_a(double seitenlaenge_a) {
this.seitenlaenge_a = seitenlaenge_a;
this.umfang = 2*(this.seitenlaenge_a+seitenlaenge_b);
this.flaeche = this.seitenlaenge_a*seitenlaenge_b;
this.diagonale = Math.sqrt((this.seitenlaenge_a*this.seitenlaenge_a)+(seitenlaenge_b*seitenlaenge_b));
}
public double getSeitenlaenge_b() {
return seitenlaenge_b;
}
public void setSeitenlaenge_b(double seitenlaenge_b) {
this.seitenlaenge_b = seitenlaenge_b;
this.umfang = 2*(seitenlaenge_a+seitenlaenge_b);
this.flaeche = seitenlaenge_a*seitenlaenge_b;
this.diagonale = Math.sqrt((seitenlaenge_a*seitenlaenge_a)+(seitenlaenge_b*seitenlaenge_b));
}
public double getFlaeche() {
return flaeche;
}
public void setFlaeche(double flaeche) {
this.flaeche = flaeche;
seitenlaenge_a = flaeche/seitenlaenge_b;
seitenlaenge_b = flaeche/seitenlaenge_a;
umfang = 2*(seitenlaenge_a+seitenlaenge_b);
diagonale = Math.sqrt((seitenlaenge_a*seitenlaenge_a)+(seitenlaenge_b*seitenlaenge_b));
}
public double getUmfang() {
return umfang;
}
public void setUmfang(double umfang) {
this.umfang = umfang;
this.seitenlaenge_a = (umfang/2) - seitenlaenge_b;
this.seitenlaenge_b = (umfang/2) - seitenlaenge_a;
}
public double getDiagonale() {
return diagonale;
}
public void setDiagonale(double diagonale) {
this.diagonale = diagonale;
}
public static void main(String[] args) {
Rechteck rect = new Rechteck();
rect.setSeitenlaenge_b(10);
rect.setSeitenlaenge_a(5);
rect.setFlaeche(25);
System.out.println("a= "+ rect.getSeitenlaenge_a());
System.out.println("b= "+ rect.getSeitenlaenge_b());
System.out.println("A= "+ rect.getFlaeche());
System.out.println("d= "+ rect.getDiagonale());
System.out.println("U= "+ rect.getUmfang());
}
}
oder muss ich etwa die setter und getter-methoden so machen, daß wirklich nur der entsprechende wert gesetzt wird?
hab an andere weitere methoden gedacht, die dann die berechnungen durchführen, jedoch hab ich das problem, daß ich nicht weiß wie das dann nachher mit der wert-übergabe laufen soll(eben wegen der zwei variablen)...
bisher sieht das progrämmchen so aus: bitte klicken