# Programmierung eines 3-dimensionalen dreiecks



## paco89 (15. Nov 2011)

hi,

habe folgende aufgabe:

Schreiben Sie eine Klasse Dreieck mit sechs Attributen x1, y1, x2, y2, x3 und y3 vom Typ double. Ein Objekt vom Typ Dreieck soll ein Dreieck im zweidimensionalen Raum mit Eckpunkten (x1; y1); (x2; y2) und (x3; y3) repräsentieren. Für die gesamte Aufgabe gilt, dass kein Fall betrachtet werden muss, bei denen die drei Eckpunkte kein echtes Dreieck bilden, weil sie auf einer Geraden liegen.

a) Erweitern Sie die Klasse Dreieck um eine Methode flaeche ohne Argumente, welche den Flächeninhalt
des Dreiecks als double Wert zurück liefert. Der Flächeninhalt A eines beliebigen Dreiecks mit gegebenen
Koordinaten (x1; y1); (x2; y2) und (x3; y3) der Eckpunkte errechnet sich gemäÿ der folgenden Trapezformel : |(1/2) x1*(y2-y3)+x2*(y3-y1)+x3*(y1-y2))|

b)
Erweitern Sie die Klasse Dreieck um die argumentlosen Methoden minimalX, minimalY, maximalX und
maximalY. Diese Methoden sollen jeweils die minimale (maximale) X- bzw. Y-Koordinate als double Wert
zurück liefern, die zum Dreieck gehört. Weiterhin soll die Klasse um eine Methode verschiebe erweitert
werden, welche zwei double Werte als Argumente erhält und das Dreieck um die übergebenen Koordinaten
verschiebt. Da diese Methode nur das Objekt manipuliert und keinen Wert zurück liefert, hat sie den Rückgabetyp void.


so ich habe dazu folgenden code geschrieben:


```
public class Dreieck{
           
        double x1;
        double x2;
        double y1;
        double y2; 
        double x3;
        double y3;


        double flaeche()
        
        {
            return Math.abs ((1/2)*(x1*(y2-y3) + x2*(y3-y1) + x_3*(y1-y2)))
        }
        
        /* die folgenden Methoden sollen jeweils die minimale bwz. (maximale)
         * X-bzw.Y-Koordinate als double-Wert zurückliefern  
         */
        
        double minimalX()
        {
           Math.max(x1,x2,x3); 
        }
        
        double minimalY()
        {
           Math.min(y,1y2,y3);
        }
        
        double maximalX()
        {
           Math.min(x1,x2,x3);
        }
        
        double maximalY()
        {
           Math.max(y1,y2,y3);
        }
        
        // Methode, die die Koordinaten verschieben soll
        
        void verschiebe(double x, double y)
        {
            x1 = x1 + x;
            x2 = x2 + x;
            x3 = x3 + x;
            y1 = y1 + y;
            y2 = y2 + y;
            y3 = y3 + y;
        }
```



ist der code bishierhin okay? die letzte methode "verschiebe" scheint mir nicht richtig zu sein. da bin ich nämlich stehen geblieben. hatte keine ansätze mehr wie ich weitermachen sollte.


----------



## xehpuk (15. Nov 2011)

Hey,

wieso testest du den Code nicht mal selbst?

Im momentanen Zustand ist er nicht mal kompilierbar.

Zeile 15: x_3 gibts nicht. Außerdem fehlt ein Semikolon.
Zeilen 24, 29, 34, 39: Die Methoden nehmen nur zwei Parameter, siehe [japi]Math[/japi]. Außerdem fehlt [c]return[/c].

Ansonsten: Bei 
	
	
	
	





```
flaeche()
```
 wird immer 0 rauskommen, weil 
	
	
	
	





```
1 / 2 == 0
```
. Bei 
	
	
	
	





```
minimalX()
```
 und 
	
	
	
	





```
maximalX()
```
 hast du wohl auch etwas vertauscht.


```
verschiebe()
```
 sieht in Ordnung aus. Mit dem "+="-Operator wäre es noch ein wenig schöner, also 
	
	
	
	





```
x1 += x;
```
 etc.

Übrigens gibts keine dreidimensionalen Dreiecke. Davon ist in der Aufgabenstellung aber auch nicht die Rede.


----------



## paco89 (15. Nov 2011)

ja, ne ich weiß dass der code nicht perfekt ist. ich wollte nur´n feedback haben um zu wissen, wie der code bislang aufgebaut ist, damit ich ungefähr weiß, dass ich auf dem richtigen weg bin. 

ja, mit dem dreidimensionalen habe ich mich wohl nicht so gemeint. ich meinte einfach ein dreieck mit 3 punkten 



trotzdem danke...ich werde mal weiterhin daran herumbasteln und irgendwann schon auf die lösung kommen...(hoffe ich)


----------



## Landei (16. Nov 2011)

Also ich zähle auch nur zwei Dimensionen...


----------



## paco89 (16. Nov 2011)

xehpuk hat gesagt.:


> Hey,
> 
> 
> Ansonsten: Bei
> ...



wieso? wie kann ich das ändern?

das mit dem 1/2 habe ich nicht verstanden. deswegen habe ich das mal weiterhin so gelassen. ich habe meinen Code ein wenig erweitert + Korrekturen vorgenommen:


```
public class Dreieck{
           
        double x1;
        double x2;
        double y1;
        double y2; 
        double x3;
        double y3;


        double flaeche()
        
        {
            return Math.abs ((1/2)*(x1*(y2-y3) + x2*(y3-y1) + x3*(y1-y2)));
        }
        
        /* die folgenden Methoden sollen jeweils die minimale bwz. (maximale)
         * X-bzw.Y-Koordinate als double-Wert zurückliefern  
         */
        
        double minimalX()
        {
           return Math.max((x1),(x2,x3)); 
        }
        
        double minimalY()
        {
           return Math.min((y1),(y2,y3));
        }
        
        double maximalX()
        {
           return Math.min((x1),(x2,x3));
        }
        
        double maximalY()
        {
           return Math.max((y1),(y2,y3));
        }
        
        
        
        
        // Methode "verschiebe" soll die Koordinaten verschieben
        
        void verschiebe(double x, double y)
        {
            x1 += x;
            x2 += x;
            x3 += x;
            y1 += y;
            y2 += y;
            y3 += y;
          
        }
        
       
       
        /* Methode inDreieck mit 2 Argumenten vom Typ double
        * soll true zurückliefern, falls die beiden Argumente
        * ein Punkt innerhalb des Dreiecks repräsentieren
        * wenn nicht dann false
        */
        boolean inDreieck(double x, double y)
        {
        
        if ()
        
        }
        
        
        public static void main (String [] args){
        
        //Erzeugung des Objekts, also des Dreiecks, mit dem new-Operator
        
        Dreieck d = new Dreieck();                                  
         
        System.out.println("Bitte geben Sie die x1-Koordinate ein: ");
        d.x1 = Double.parseDouble(System.console().readLine());
        System.out.println("Bitte geben Sie die y1-Koordinate ein: ");
        d.y1 = Double.parseDouble(System.console().readLine());
        System.out.println("Bitte geben Sie die x2-Koordinate ein: ");
        d.x2 = Double.parseDouble(System.console().readLine());
        System.out.println("Bitte geben Sie die y2-Koordinate ein: ");
        d.y2 = Double.parseDouble(System.console().readLine());
        System.out.println("Bitte geben Sie die x3-Koordinate ein: ");
        d.x3 = Double.parseDouble(System.console().readLine());
        System.out.println("Bitte geben Sie die y3-Koordinate ein: ");
        d.y3 = Double.parseDouble(System.console().readLine());
        }
```


----------



## Landei (17. Nov 2011)

Ganzzahlen werden in Java auch ganzzahlig dividiert, der Divisionsrest fällt unter den Tisch (kann aber mit [c]%[/c] aufgesammelt werden): 1/2 = 0, 5/4 = 1. Für Realzahlen hat man die normale Division ohne Rest: 1.0/2.0 = 0.5, 5.0/4.0 = 1.25. Der Trick ist, dass wenigstens einer der beiden Operanden eine Realzahl sein muss. Ganzzahlen kann man z.B. casten ([c](double) i;[/c]) oder mit 1.0 multiplizieren.


----------



## Andi_CH (17. Nov 2011)

```
double minimalX() {
    return Math.max((x1),(x2,x3)); 
}
```

Hm, bist du da sicher? Einfach so ein Hinweis - es gibt noch mehr von der Sorte ...


So nebenbei - woher hast du die Formel für die Fläche?


----------

