Warum kommt immer die 0 als Ergebnis? Was habe ich falsch gemacht?

babuschka

Top Contributor
Hallo COmmunity,
ich habe 3 verschiedene Methoden, die verschiedene Aufgaben haben. Jetzt nun meine Frage bei allen kommt das Ergebnis 0 raus, obwohl ich die Zahlen umändere etc. an was kann das liegen?


Java:
package test;

public class Punkt{
    private int x; //Variable x vom Typ int ist nur innerhalb der eigenen Klasse sichtbar da private
    private int y; //Variable y vom Typ int ist nur innerhalb der eigenen Klasse sichtbar da private
    private String bezeichnung;  //Variable bezeichnung vom typ String wird erzeugt
    private static int anzahl; //Variable anzahlObjekte vom Typ int wird erzeugt
    
    
    //leere Konstruktor ohne Parameter
    public Punkt() { 
        anzahl = anzahl + 1; //anzahl wird immer um 1 erhöht, wenn ein OBjekt von diesem Konstrukor erzeugt wird!
    }


    //Konstruktor mit x, y und String b als Paramter
    public Punkt(int x, int y, String b) {
        this.x = x; //x wird dem x zugewiesen
        this.y = y; //y wird dem y zugewiesen
        this.bezeichnung = b; //b wird dem bezeichnung zugewiesen
    }
    
    
    public void berechneAbstand(Punkt p) {
        if(0 <= x && x <= 100 && 0 <= y && y <= 100) { //Wenn x=0 und x<=100 und y=0 und <=100, dann führe untere Bedinung aus!
            double ddx = p.x - this.x;
            double ddy = p.y - this.y;
            System.out.println(Math.sqrt(ddx * ddx + ddy * ddy));
        } else {
            System.out.println("Nur Zahlen zwischen 0 und 100 eingeben!"); //Falls x oder y größer als 100 dann wird diese Zeile ausgegeben!
        }
    }


    //Berechnung des Richtungwinkels zweier Punkte in Altgrad
    public void richt(Punkt p) { 
        if(0 <= x && x <= 100 && 0 <= y && y <= 100) { // Wenn x=0 und x<=100 und y=0 und y<=100 dann führe untere If Anweisung aus!
            double dt = 0;
            double ddx = p.x - this.x;
            double ddy = p.y - this.y;

            if (ddy != 0) { // If Anweisung wenn ddy ungleich 0 dann wird die untere Bedinung ausgeführt
                dt = Math.atan(ddx / ddy);
                // dy ungleich 0, Berechnung Richtungswinkel t
                if (ddy < 0) { // Wenn ddy kleiner als 0 dann untere Bedinung ausführen
                    dt = dt + Math.PI; // +Pi wenn Ay entgegengesetzt
                }
            } else { // Wenn ddy nicht kleiner als 0 dann wird untere if anweisung ausgeführt
                if (ddx != 0) { //Wenn ddx ungleich 0 dann führe untere Bedinung aus
                    if (ddx > 0) {
                        dt = 1.0 / 2 * Math.PI;
                    } else {
                        dt = 3.0 / 2 * Math.PI;
                    }
                } else {
                    System.out.println("Falsche Eingabe ddx darf nicht 0 sein!"); // wenn ddy == 0 dann wird Falsche Eingabe ausgegeben!
                }
            }
            dt = dt * 180 / Math.PI;
            System.out.println(dt); //Ergebnis dt wird ausgegeben!
        }
    }

    
    //Berechnung der Dreiecksfläche
    public void dreiecksflaeche(Punkt p1, Punkt p2) {

        if(0 <= x && x <= 100 && 0 <= y && y <= 100) { //Wenn x=0 oder x<=100 und y=0 und y<=100, dann führe untere Bedinung aus!
            double a = Math.sqrt(Math.pow((p1.x - this.x), 2) + Math.pow((p1.y - this.y), 2));
            double b = Math.sqrt(Math.pow((p2.x - p1.x), 2) + Math.pow((p2.y - p1.y), 2));
            double c = Math.sqrt(Math.pow((p2.x - this.x), 2) + Math.pow((p2.y - this.y), 2));

            double summe = (a + b + c) / 2; //Summe wird berechnet
            double ergebnis = Math.sqrt(summe * (summe - a) * (summe - b) * (summe - c)); //Endgültige Ergebnis wird berechnet!
            System.out.println(ergebnis); //Ergebnis wird ausgegeben!
        } else {
            System.out.println("Nur Zahlen zwischen 0-100 eingeben!"); //Wenn die If-Anweisung nicht erfüllt wird, wird die Zeile ausgegeben!
        }
    }
}


Java:
package test;

public class Testklasse {
    
    public static void main(String[] args) {
        Punkt p1 = new Punkt(2, 3, "A");
        Punkt p2 = new Punkt(4, 5, "B");
        
        p1.berechneAbstand(p2);
        p1.dreiecksflaeche(p1, p2);
        p2.richt(p2);
    }
}
 

Ziegenpeter

Aktives Mitglied
Also ist im Grunde ganz einfach. Deine Berechnungen sehen korrekt aus, du rufst es nur mit Werten auf, die natürlich 0 ergeben.

1. berechneAbstand: Funktioniert bei mir ohne Probleme. kommt 2.8284271247461903 sollte stimmen

2. dreiecksFläche: Kommt natürlich 0 raus, da zwei Punkte deines Dreiecks die gleichen sind. Daher hast du nur eine Gerade, die den Flächeninhalt 0 hat. Also auch korrekt.

3. richt: Auch korrekt, da du
Java:
p2.richt(p2)
aufrufst und der Winkel natürlich 0 ist, da die Punkte die gleichen sind.

Fazit: Erstelle richtige Tests, denn die Berechnungen sehen korrekt aus.
 

Marco13

Top Contributor
Ein Dreieck, bei dem zwei Punkte gleich sind, hat eine Fläche von 0. Und die Richtung von einem Punkt zu sich selbst ist auch 0.
Code:
public class PunktTestklasse {

    public static void main(String[] args) {
        Punkt p1 = new Punkt(2, 3, "A");
        Punkt p2 = new Punkt(4, 5, "B");
        Punkt p3 = new Punkt(5, 6, "C");

        p1.berechneAbstand(p2);
        p3.dreiecksflaeche(p1, p2);
        p2.richt(p1);
    }
}
 

babuschka

Top Contributor
Also ich habe meien Fehler erkannt und verbessert, die Methoden funktionieren endlich! Aber wie kann ich jetzt sagen, dass die Zahlen zufällig genommen werden und dass man die nicht angeben muss? Wo kann ich die einbauen? Bitte um Antwort vielen Dank!

Java:
package studienarbeit; //Paketname

public class Punkt { //Klassenname

    private int x; //Variable x vom Typ int ist nur innerhalb der eigenen Klasse sichtbar da private
    private int y; //Variable y vom Typ int ist nur innerhalb der eigenen Klasse sichtbar da private
    private String bezeichnung;  //Variable bezeichnung vom typ String wird erzeugt
    private static int anzahl; //Variable anzahlObjekte vom Typ int wird erzeugt und ist statisch


    //Konstruktor mit x, y und String b als Paramter
    public Punkt(int x, int y, String b) {
        if (0 <= x && x <= 100 && 0 <= y && y <= 100) { //Wenn x=0, x<=100 und y=0, y<=100 dann wird die untere Bedinung ausgeführt!
            this.x = x; //x wird dem x zugewiesen
            this.y = y; //y wird dem y zugewiesen
            this.bezeichnung = b; //b wird dem bezeichnung zugewiesen
        } else { //Oder
            throw new IllegalArgumentException("X und Y müssen zwischen 0 und 100 sein"); //Exception wurde eingebaut, damit bei nichterfüllung der Anweisung eine Fehlermeldung auftretet!
        }
    }

    //Parameterloser Konstruktor
    public Punkt() {
        anzahl = anzahl + 1; //anzahl wird immer um 1 erhöht, wenn ein OBjekt von diesem Konstrukor erzeugt wird!
    }


    //Methode toString mit den Rückgabewert vom String
    @Override //Methode toString wird überschrieben!
    public String toString() {
        return "Punkt x=" + this.x + ", Punkt y=" + this.y + ", Bezeichnung= " + this.bezeichnung; //mit return werden die Eigenschaften zurückgegeben!
    }


    //Methode berechneAbstand mit p vom Typ Punkt als Parameter
    public void berechneAbstand(Punkt p) {
        if (0 <= x && x <= 100 && 0 <= y && y <= 100) { //Wenn x=0, x<=100 und y=0, y<=100, dann führe untere Bedinung aus!
            double ddx = p.x - this.x;
            double ddy = p.y - this.y;
            System.out.println(Math.sqrt(ddx * ddx + ddy * ddy)); //Ausgabe end-Ergebnis
        } else { //Oder
            System.out.println("Nur Zahlen zwischen 0 und 100 eingeben!"); //Falls x oder y größer als 100 dann wird diese Zeile ausgegeben!
        }
    }
    

    //Berechnung des Richtungwinkels zweier Punkte in Altgrad
    public void richt(Punkt p) { //Keine Rückgabewert, enthält eine Variable p vom Typ Punkt
        if(0 <= x && x <= 100 && 0 <= y && y <= 100) { // Wenn x=0 und x<=100 und y=0 und y<=100 dann führe untere If Anweisung aus!
            double dt = 0; //Variable dt vom Typ double wird erzeugt und wird mit 0 zugewiesen!
            double ddx = p.x - this.x; //Variable ddx vom Typ double wird erzeugt und dies enthält dann das Ergebnis von p.x - this.x
            double ddy = p.y - this.y; //Variable ddy vom Typ double wird erzeugt und dies enthält dann das Ergebnis von p.y - this.y

            if (ddy != 0) { // If Anweisung wenn ddy ungleich 0 dann wird die untere Bedinung ausgeführt
                dt = Math.atan(ddx / ddy);
                
                if (ddy < 0) { // Wenn ddy kleiner als 0 dann untere Bedinung ausführen
                    dt = dt + Math.PI; // +Pi wenn Ay entgegengesetzt
                }
            } else { // Wenn ddy nicht kleiner als 0 dann wird untere if anweisung ausgeführt
                if (ddx != 0) { //Wenn ddx ungleich 0 dann führe untere Bedinung aus
                    if (ddx > 0) {
                        dt = 1.0 / 2 * Math.PI;
                    } else { //Oder
                        dt = 3.0 / 2 * Math.PI;
                    }
                } else { //oder
                    System.out.println("Falsche Eingabe ddx darf nicht 0 sein!"); // wenn ddy == 0 dann wird Falsche Eingabe ausgegeben!
                }
            }
            dt = dt * 180 / Math.PI;
            System.out.println(dt); //Ergebnis dt wird ausgegeben!
        }
    }

    
    //Berechnung der Dreiecksfläche
    public void dreiecksflaeche(Punkt p1, Punkt p2) { //enthält zwei Variablen p1 und p2 vom Typ Punkt, etnhält kein Rückgabwert 

        if(0 <= x && x <= 100 && 0 <= y && y <= 100) { //Wenn x=0 oder x<=100 und y=0 und y<=100, dann führe untere Bedinung aus!
            double a = Math.sqrt(Math.pow((p1.x - this.x), 2) + Math.pow((p1.y - this.y), 2));
            double b = Math.sqrt(Math.pow((p2.x - p1.x), 2) + Math.pow((p2.y - p1.y), 2));
            double c = Math.sqrt(Math.pow((p2.x - this.x), 2) + Math.pow((p2.y - this.y), 2));
            double summe = (a + b + c) / 2; //Summe wird berechnet
            double ergebnis = Math.sqrt(summe * (summe - a) * (summe - b) * (summe - c)); //Endgültige Ergebnis wird berechnet!
            System.out.println(ergebnis); //Ergebnis wird ausgegeben!
        } else { //Oder
            System.out.println("Nur Zahlen zwischen 0-100 eingeben!"); //Wenn die If-Anweisung nicht erfüllt wird, wird die Zeile ausgegeben!
        }
    }


    // Ausgabe der anzahl Instanzen
    public static int getAnzahl() { //Methode ohne Parameter, enthält aber int als Rückgabewert
        return anzahl; //Variable anzahl wird zurückgelifert
    }


    //boolscher Vergleich auf identische Koordinaten
    public boolean vergleich1(Punkt p) { //enthält eine Variable p vom Typ Punkt und hat die Rückgabewert double
        boolean result = true; //Variable result vom Typ boolean wird erzeugt, true wird dem result zugewiesen

        if ((this.x != p.x) || (this.y != p.y)) { //Wenn this.x ungleich p.x oder this.y ungleich p.y dann führe untere Bedinung aus!
            result = false; //result wird als false zurückgelifert!
        }
        return result; //Es muss ein booleanwert ausgegeben werden in diesem Fall ist es die result es wird zurückgelifert, also wird true zurückgeliefert!
    }


    //boolescher Prüfung der Wertgleichheit zweier Instanzen in allen Attributen
    boolean vergleich2(Punkt p) { //enthält Variable p vom Typ Punkt und hat die Rückgabewert boolean
        boolean result = true; //Variable vergleich vom Typ boolean wird erzeugt

        if ((this.x != p.x) || (this.y != p.y) || (this.bezeichnung.equals(p.bezeichnung))) { //Alle Attributen 2er Objekte werden verglichen
            result = false; //result wird als false zurückgeliefert!
        }
        return result; // result wird zurückgelifert, also true in diesem Fall!
    }


    //Verschiebung eines Punktes
    public void move(int dx, int dy) {//Ohne Rückgabewert, enthält die zwei Variablen dx und dy vom Typ int
        if(0 <= x && x <= 100 && 0 <= y && y <= 100) { //wenn x=0, x<=100 und y=0, y<=100 dann wird die untere Bedinung ausgeführt!
        System.out.println(this.x = this.x + dx); //x wird um dx verschoben!
        System.out.println(this.y = this.y + dy); //y wird um dy verschoben!
        }else{ //Oder
            System.out.println("Nur Zahlen zwischen 0 und 100 eingeben!"); //Wird ausgegeben, wenn x oder y oder beides die obere If-Anweisung nicht erfüllen!
        }
    }
}


Java:
package studienarbeit; //Paketname

public class Testklasse { //Klassenname
    public static void main(String[] args) { //Main Methode

        //Es werden hier 3 Objekte vom Typ Punkt erzeugt mit Instanzvariable p1, p2 und p3
        Punkt p1=new Punkt(2,3,"A"); //x=2, y=3 und b="A"
        Punkt p2=new Punkt(2,5,"B"); //x=2, y=3 und b ="B"
        Punkt p3=new Punkt(4,6,"C"); //x=4, y=6 und b ="C"

        //Es werden hier 2 Objekte der parameterlosen Konstruktor erzeugt, damit sich der Anzahl s.u. erhöht!
        Punkt p4=new Punkt();
        Punkt p5=new Punkt();

        
        //Eigenschaften ausgeben mit toString Methode!
        System.out.println("Eigenschaften: ");
        System.out.println(p1.toString()); //Hier wird die Methode toString mit der Referenzvariable p1 aufgerufen und die Eigenschaften werden ausgegeben!

        
        //Methode berechneAbstand wird aufgerufen!
        System.out.println("Abstand: ");
        p1.berechneAbstand(p2); //Hier wird die Methode berechneAbstand mit der Referenzvariable p1 aufgerufen und p2 wird als Parameter eingesetzt!

        //Methode richt wird aufgerufen!
        System.out.println("Richtungswinkel: ");
        p2.richt(p1); //Hier wird die Methode richt mit der Referenzvariable p2 aufgerufen und das Ergebnis wird angezeigt!

        //Methode dreiecksflaeche wird aufgerufen!
        System.out.println("Dreiecksfläche: ");
        p1.dreiecksflaeche(p2, p3); //Hier wird die Methode dreiecksflaeche mit der Referenzvariable p1 aufgerufen, p2 und p3 werden als Parameter eingesetzt!
        
        //Vergleich Methoden werden aufgerufen!
        System.out.println("Vergleichungen: ");
        System.out.println(p1.vergleich1(p2)); //p1 wird mit p2 verglichen!
        System.out.println(p1.vergleich2(p2)); //p1 wird mit p2 verglichen!


        //GetAnzahl wird aufgerufen!
        System.out.println("Anzahl der Objekte: ");
        System.out.println(p1.getAnzahl()); //Hier wird die Methode getAnzahl mit der Referenzvariable p1 aufgerufen!

        
        //Methode move wird aufgerufen!
        System.out.println("Verschiebung: ");
        p1.move(5, 1); //Hier wird die Methode move aufgerufen, x=5 und y=1 werden als Parameter eingesetzt!
    }
}
 

Ziegenpeter

Aktives Mitglied
Ich würde das in den Paramterlosen Konstruktor packen. Wenn benötigt musst du vielleicht dem Konstruktor noch einen Parameter String geben, da du die Namen vielleicht noch brauchst. (Kannst du aber auch zufällig erstellen)

statt
Java:
int x = random.nextInt(10); // Wert 0...9
...
schreibst du dann
Java:
this.x = random.nextInt(10); // Wert 0...9
...
 

babuschka

Top Contributor
Ich würde das in den Paramterlosen Konstruktor packen. Wenn benötigt musst du vielleicht dem Konstruktor noch einen Parameter String geben, da du die Namen vielleicht noch brauchst. (Kannst du aber auch zufällig erstellen)

statt
Java:
int x = random.nextInt(10); // Wert 0...9
...
schreibst du dann
Java:
this.x = random.nextInt(10); // Wert 0...9
...

also so dann?

Java:
public Punkt(int x, int y, String b) {
        if (0 <= x && x <= 100 && 0 <= y && y <= 100) {
            Random random = new Random();
            this.x = random.nextInt(100); //x wird dem x zugewiesen
            this.y = random.nextInt(100); //y wird dem y zugewiesen
            this.bezeichnung = b; //b wird dem bezeichnung zugewiesen
        } else {
            throw new IllegalArgumentException("X und Y müssen zwischen 0 und 100 sein");
        }
    }


Muss ich dann tortzdem innerhalb der Parameter zahlen einsetzen? Die werden ja garnicht benötigt? Da die Zahlen zufällig genommen werden?


Java:
package test;

public class Testklasse {

    public static void main(String[] args) {
        Punkt p1 = new Punkt(3,3,"A");
        Punkt p2=new Punkt (4,5,"B");
        Punkt p3=new Punkt(5,7,"C");

        System.out.println("Abstand");
        p1.berechneAbstand(p2);

        System.out.println("Dreiecksfläche");
        p1.dreiecksflaeche(p2,p3);

        System.out.println("Richt");
        p2.richt(p1);
    }
}
 
Zuletzt bearbeitet von einem Moderator:

Marco13

Top Contributor
So ganz verstehe ich die Frage nicht. Ob so ein "Random" wirklich in einen Parameterlosen Konstruktor sollte... weiß ich nicht. (Den würde ich eher für einen Punkt (0,0) reservierten wollen ;) )


Man könnte in der Testklasse z.B. eine eigene Methode machen, wie
Java:
class Testklasse
{
    private Random random = new Random();

    public static void main(String args[])
    {
        Punkt p1 = createRandomPoint(10,10,"A");
        Punkt p2 = createRandomPoint(10,10,"B");
        ...
    }
    private static Punkt createRandomPoint(int xRange, int yRange, String name)
    {
        int x = random.nextInt(xRange);
        int y = random.nextInt(yRange);
        return new Punkt(x,y,name);
    }
 

babuschka

Top Contributor
So ganz verstehe ich die Frage nicht. Ob so ein "Random" wirklich in einen Parameterlosen Konstruktor sollte... weiß ich nicht. (Den würde ich eher für einen Punkt (0,0) reservierten wollen ;) )


Man könnte in der Testklasse z.B. eine eigene Methode machen, wie
Java:
class Testklasse
{
    private Random random = new Random();

    public static void main(String args[])
    {
        Punkt p1 = createRandomPoint(10,10,"A");
        Punkt p2 = createRandomPoint(10,10,"B");
        ...
    }
    private static Punkt createRandomPoint(int xRange, int yRange, String name)
    {
        int x = random.nextInt(xRange);
        int y = random.nextInt(yRange);
        return new Punkt(x,y,name);
    }

also es muss eine leere konstruktor und konstruktor mit parameter vorhanden sein! denn in einer methode wird auch z.b. nach anzahl der parameterlosen konstruktor objekte gefragt. Der Porf hat auch noch geschrieben, dass es Zufallswerte enthalten soll (ich glaube er meint damit x und y)also random. Aber weis nicht was für einen sinn das ganze hat!
 

babuschka

Top Contributor
Also so funktioniert es mit den Zufallszahlen! Aber was ich nicht verstehe ist die Parameter bei der Objekterzeugung innerhalb der Testklasse. Da werden ja die werte für x und y angegeben die aber nicht berücksichtigt werden. Ist das so richtig oder ist das doppelt gemoppelt?

Java:
package test;

public class Testklasse {

    public static void main(String[] args) {
        Punkt p1 = new Punkt(3,3,"A");
        Punkt p2=new Punkt (4,5,"B");
        Punkt p3=new Punkt(5,7,"C");

        System.out.println("Abstand");
        p1.berechneAbstand(p2);

        System.out.println("Dreiecksfläche");
        p1.dreiecksflaeche(p2,p3);

        System.out.println("Richt");
        p2.richt(p1);
    }
}


Java:
package test;

import java.util.Random;

public class Punkt {

    private int x; //Variable x vom Typ int ist nur innerhalb der eigenen Klasse sichtbar da private
    private int y; //Variable y vom Typ int ist nur innerhalb der eigenen Klasse sichtbar da private
    private String bezeichnung;  //Variable bezeichnung vom typ String wird erzeugt
    private static int anzahl; //Variable anzahlObjekte vom Typ int wird erzeugt


    //Konstruktor mit x, y und String b als Paramter
    public Punkt(int x, int y, String b) {
        if (0 <= x && x <= 100 && 0 <= y && y <= 100) {
            Random random = new Random();
            this.x = random.nextInt(100); //x wird dem x zugewiesen
            this.y = random.nextInt(100); //y wird dem y zugewiesen
            this.bezeichnung = b; //b wird dem bezeichnung zugewiesen
        } else {
            throw new IllegalArgumentException("X und Y müssen zwischen 0 und 100 sein");
        }
    }

    //leere Konstruktor ohne Parameter
    public Punkt() {
        anzahl = anzahl + 1; //anzahl wird immer um 1 erhöht, wenn ein OBjekt von diesem Konstrukor erzeugt wird!
    }

    public void berechneAbstand(Punkt p) {
        if (0 <= x && x <= 100 && 0 <= y && y <= 100) { //Wenn x=0 und x<=100 und y=0 und <=100, dann führe untere Bedinung aus!
            double ddx = p.x - this.x;
            double ddy = p.y - this.y;
            System.out.println(Math.sqrt(ddx * ddx + ddy * ddy));
        } else {
            System.out.println("Nur Zahlen zwischen 0 und 100 eingeben!"); //Falls x oder y größer als 100 dann wird diese Zeile ausgegeben!
        }
    }


    //Berechnung des Richtungwinkels zweier Punkte in Altgrad
    public void richt(Punkt p) {
        if (0 <= x && x <= 100 && 0 <= y && y <= 100) { // Wenn x=0 und x<=100 und y=0 und y<=100 dann führe untere If Anweisung aus!
            double dt = 0;
            double ddx = p.x - this.x;
            double ddy = p.y - this.y;

            if (ddy != 0) { // If Anweisung wenn ddy ungleich 0 dann wird die untere Bedinung ausgeführt
                dt = Math.atan(ddx / ddy);
                // dy ungleich 0, Berechnung Richtungswinkel t
                if (ddy < 0) { // Wenn ddy kleiner als 0 dann untere Bedinung ausführen
                    dt = dt + Math.PI; // +Pi wenn Ay entgegengesetzt
                }
            } else { // Wenn ddy nicht kleiner als 0 dann wird untere if anweisung ausgeführt
                if (ddx != 0) { //Wenn ddx ungleich 0 dann führe untere Bedinung aus
                    if (ddx > 0) {
                        dt = 1.0 / 2 * Math.PI;
                    } else {
                        dt = 3.0 / 2 * Math.PI;
                    }
                } else {
                    System.out.println("Falsche Eingabe ddx darf nicht 0 sein!"); // wenn ddy == 0 dann wird Falsche Eingabe ausgegeben!
                }
            }
            dt = dt * 180 / Math.PI;
            System.out.println(dt); //Ergebnis dt wird ausgegeben!
        }
    }


    //Berechnung der Dreiecksfläche
    public void dreiecksflaeche(Punkt p1, Punkt p2) {

        if (0 <= x && x <= 100 && 0 <= y && y <= 100) { //Wenn x=0 oder x<=100 und y=0 und y<=100, dann führe untere Bedinung aus!
            double a = Math.sqrt(Math.pow((p1.x - this.x), 2) + Math.pow((p1.y - this.y), 2));
            double b = Math.sqrt(Math.pow((p2.x - p1.x), 2) + Math.pow((p2.y - p1.y), 2));
            double c = Math.sqrt(Math.pow((p2.x - this.x), 2) + Math.pow((p2.y - this.y), 2));

            double summe = (a + b + c) / 2; //Summe wird berechnet
            double ergebnis = Math.sqrt(summe * (summe - a) * (summe - b) * (summe - c)); //Endgültige Ergebnis wird berechnet!
            System.out.println(ergebnis); //Ergebnis wird ausgegeben!
        } else {
            System.out.println("Nur Zahlen zwischen 0-100 eingeben!"); //Wenn die If-Anweisung nicht erfüllt wird, wird die Zeile ausgegeben!
        }
    }
}
 

Marco13

Top Contributor
Das war wohl ein mißverständnis. Die Klasse "Punkt" sollte nach wie vor diesen Konstruktor haben:
Java:
    //Konstruktor mit x, y und String b als Paramter
    public Punkt(int x, int y, String b) {
        if (0 <= x && x <= 100 && 0 <= y && y <= 100) { //Wenn x=0, x<=100 und y=0, y<=100 dann wird die untere Bedinung ausgeführt!
            this.x = x; //x wird dem x zugewiesen
            this.y = y; //y wird dem y zugewiesen
            this.bezeichnung = b; //b wird dem bezeichnung zugewiesen
        } else { //Oder
            throw new IllegalArgumentException("X und Y müssen zwischen 0 und 100 sein"); //Exception wurde eingebaut, damit bei nichterfüllung der Anweisung eine Fehlermeldung auftretet!
        }
    }

Aber zusätzlich noch so einen wie
Java:
    //Konstruktor mit String b als Paramter, wählt zufällige Koordinaten
    public Punkt(String b) {
        Random random = new Random();
        this.x = random.nextInt(100); //x wird dem x zugewiesen
        this.y = random.nextInt(100); //y wird dem y zugewiesen
        this.bezeichnung = b; //b wird dem bezeichnung zugewiesen
    }

Dann kann man in der main zufällige Punkte erstellen mit
Code:
Punkt p0 = new Punkt("A"); // Bekommt zufällige Position
Punkt p1 = new Punkt("B"); // Bekommt zufällige Position

Ob das so sinnvoll ist, oder man nicht lieber eine Hilfsmethode zum Erstellen zufälliger Punkte verwenden sollte, könnte man sich überlegen, aber ist vielleicht hier nicht so wichtig....
 

babuschka

Top Contributor
Also da ich nur 2 Konstruktoren haben darf, habe ich es su umgestellt geht ja auch oder? Methoden funktionieren einwandfrei!

Java:
package test;

import java.util.Random;

public class Punkt {

    private int x; //Variable x vom Typ int ist nur innerhalb der eigenen Klasse sichtbar da private
    private int y; //Variable y vom Typ int ist nur innerhalb der eigenen Klasse sichtbar da private
    private String bezeichnung;  //Variable bezeichnung vom typ String wird erzeugt
    private static int anzahl; //Variable anzahlObjekte vom Typ int wird erzeugt

     //Konstruktor mit String b als Paramter, wählt zufällige Koordinaten
    public Punkt(String b) {
        if (0 <= x && x <= 100 && 0 <= y && y <= 100) {
            Random random = new Random(); //Objekt vom Typ Random wird erzeugt um davon die Methoden nützen zu können!
            this.x = random.nextInt(100); //x wird dem random.nextInt(100) zugewiesen,es darf eine Zahl zwischen 0-100 erhalten!
            this.y = random.nextInt(100); //y wird dem random.nextInt(100) zugewiesen,es darf eine Zahl zwischen 0-100 erhalten!
            this.bezeichnung = b; //b wird dem bezeichnung zugewiesen
        } else { //Oder
            throw new IllegalArgumentException("X und Y müssen zwischen 0 und 100 sein"); //Exception wurde eingebaut, damit bei nichterfüllung der Anweisung eine Fehlermeldung auftretet!
        }
    }
    //leere Konstruktor ohne Parameter
    public Punkt() {
        anzahl = anzahl + 1; //anzahl wird immer um 1 erhöht, wenn ein OBjekt von diesem Konstrukor erzeugt wird!
    }

    public void berechneAbstand(Punkt p) {
        if (0 <= x && x <= 100 && 0 <= y && y <= 100) { //Wenn x=0 und x<=100 und y=0 und <=100, dann führe untere Bedinung aus!
            double ddx = p.x - this.x;
            double ddy = p.y - this.y;
            System.out.println(Math.sqrt(ddx * ddx + ddy * ddy));
        } else {
            System.out.println("Nur Zahlen zwischen 0 und 100 eingeben!"); //Falls x oder y größer als 100 dann wird diese Zeile ausgegeben!
        }
    }


    //Berechnung des Richtungwinkels zweier Punkte in Altgrad
    public void richt(Punkt p) {
        if (0 <= x && x <= 100 && 0 <= y && y <= 100) { // Wenn x=0 und x<=100 und y=0 und y<=100 dann führe untere If Anweisung aus!
            double dt = 0;
            double ddx = p.x - this.x;
            double ddy = p.y - this.y;

            if (ddy != 0) { // If Anweisung wenn ddy ungleich 0 dann wird die untere Bedinung ausgeführt
                dt = Math.atan(ddx / ddy);
                // dy ungleich 0, Berechnung Richtungswinkel t
                if (ddy < 0) { // Wenn ddy kleiner als 0 dann untere Bedinung ausführen
                    dt = dt + Math.PI; // +Pi wenn Ay entgegengesetzt
                }
            } else { // Wenn ddy nicht kleiner als 0 dann wird untere if anweisung ausgeführt
                if (ddx != 0) { //Wenn ddx ungleich 0 dann führe untere Bedinung aus
                    if (ddx > 0) {
                        dt = 1.0 / 2 * Math.PI;
                    } else {
                        dt = 3.0 / 2 * Math.PI;
                    }
                } else {
                    System.out.println("Falsche Eingabe ddx darf nicht 0 sein!"); // wenn ddy == 0 dann wird Falsche Eingabe ausgegeben!
                }
            }
            dt = dt * 180 / Math.PI;
            System.out.println(dt); //Ergebnis dt wird ausgegeben!
        }
    }


    //Berechnung der Dreiecksfläche
    public void dreiecksflaeche(Punkt p1, Punkt p2) {

        if (0 <= x && x <= 100 && 0 <= y && y <= 100) { //Wenn x=0 oder x<=100 und y=0 und y<=100, dann führe untere Bedinung aus!
            double a = Math.sqrt(Math.pow((p1.x - this.x), 2) + Math.pow((p1.y - this.y), 2));
            double b = Math.sqrt(Math.pow((p2.x - p1.x), 2) + Math.pow((p2.y - p1.y), 2));
            double c = Math.sqrt(Math.pow((p2.x - this.x), 2) + Math.pow((p2.y - this.y), 2));

            double summe = (a + b + c) / 2; //Summe wird berechnet
            double ergebnis = Math.sqrt(summe * (summe - a) * (summe - b) * (summe - c)); //Endgültige Ergebnis wird berechnet!
            System.out.println(ergebnis); //Ergebnis wird ausgegeben!
        } else {
            System.out.println("Nur Zahlen zwischen 0-100 eingeben!"); //Wenn die If-Anweisung nicht erfüllt wird, wird die Zeile ausgegeben!
        }
    }
}


Java:
package test;

public class Testklasse {

    public static void main(String[] args) {

        Punkt p1 = new Punkt("A");
        Punkt p2 = new Punkt("B"); // Bekommt zufällige Position
        Punkt p3 = new Punkt("C"); // Bekommt zufällige Position

        System.out.println("Abstand");
        p1.berechneAbstand(p2);

        System.out.println("Dreiecksfläche");
        p1.dreiecksflaeche(p2,p3);

        System.out.println("Richt");
        p2.richt(p1);
    }
}
 
Zuletzt bearbeitet von einem Moderator:

Ziegenpeter

Aktives Mitglied
So kannst du das im Konstruktor nicht machen. Da x und y nicht initailisiert sind dürfte es schon beim Vergleich in der if-Anweisung knallen. Außerdem möchtest du die 100 einschließlich, musst also random 101 übergeben, da die Zahl die obere Grenze ist und ausgeschlossen wird.

Insgesamt also:
Java:
public Punkt(String b) {
     Random random = new Random(); //Objekt vom Typ Random wird erzeugt um davon die Methoden nützen zu können!
     this.x = random.nextInt(101); //x wird dem random.nextInt(100) zugewiesen,es darf eine Zahl zwischen 0-100 erhalten!
     this.y = random.nextInt(101); //y wird dem random.nextInt(100) zugewiesen,es darf eine Zahl zwischen 0-100 erhalten!
            this.bezeichnung = b; //b wird dem bezeichnung zugewiesen
}
 
Zuletzt bearbeitet:

Marco13

Top Contributor
Das stimmt natürlich :)

Insbesondere ist die if-Anweisung so gesehen bei ALLEN Methoden überflüssig, weil schon im Konstruktor sichergestellt ist, dass die Zahlen im gültigen Bereich sind.... entweder durch die Abfrage dort, oder dadurch, dass man die Zahlen selbst per Random passend wählt.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
P Wie kann ich meine Keylistener Klasse unterscheiden lassen, von welcher "Quelle" der Input kommt? Java Basics - Anfänger-Themen 2
T Text einlesen code was kommt dahin? Java Basics - Anfänger-Themen 1
R Anfänger: Ausgabe kommt minus raus? Java Basics - Anfänger-Themen 6
P Probleme mit JUnit-Tests, es kommt was anderes raus als bei manuellen Tests Java Basics - Anfänger-Themen 5
S Wohin kommt das „abstract“? Vor oder nach „public“/ „private“ /... Java Basics - Anfänger-Themen 3
E Was kommt in ein Objekt und was in die Main Methode? Java Basics - Anfänger-Themen 8
G Woher kommt diese Eigenschaft Java Basics - Anfänger-Themen 5
D Woher kommt die 48?! Wie setz ich den Anfangswert auf 0??? Java Basics - Anfänger-Themen 8
I Schleife fragt Wert ab bis 0 kommt (mit IO.java klasse) Java Basics - Anfänger-Themen 16
L Input/Output Wieso kommt diese Ausgabe? Java Basics - Anfänger-Themen 12
V Operatoren Warum kommt bei double bei den Nachkommastellen irgendwann eine 2?! (1.20000000000002) Java Basics - Anfänger-Themen 5
V Operatoren Warum kommt nicht das gewünschte Ergebnis dieser Operation? Java Basics - Anfänger-Themen 3
J Ein Objekt zurückgeben, was kommt dabei raus ? Java Basics - Anfänger-Themen 4
S button kommt durch bild Java Basics - Anfänger-Themen 13
T Datum wird auf der Konsole richtig ausgegeben, aber im Textarea kommt ERROR Java Basics - Anfänger-Themen 8
Tacofan Hangman - ist der Buchstabe vorhanden wenn ja wo kommt er vor Java Basics - Anfänger-Themen 6
G Vertsändnisfrage zu Code - Wie kommt diese Ausgabe zustande? Java Basics - Anfänger-Themen 2
J BlueJ - kompilieren - und wie weit kommt man mit BlueJ? Java Basics - Anfänger-Themen 4
IngoF Welches Event kommt wann? Java Basics - Anfänger-Themen 8
S Kommt es zu Seiteneffekten wenn man waehrend den laufenden JUnit Tests den Code aendert? Java Basics - Anfänger-Themen 2
K Methoden ResultSet als Methodenübergabewert kommt leer an Java Basics - Anfänger-Themen 0
C For-Schleife wie kommt man auf die Lösung? Java Basics - Anfänger-Themen 2
M Erste Schritte Wie kommt man auf diese Ausgabe? Java Basics - Anfänger-Themen 3
K String kommt schon in Vector vor? Java Basics - Anfänger-Themen 36
A Input/Output Wo kommt das Newline her? Java Basics - Anfänger-Themen 7
A Wie kommt diese NullPointerException zustande? Java Basics - Anfänger-Themen 13
R Input/Output ImageIO kommt mit pic_url nicht klar Java Basics - Anfänger-Themen 10
J Woher kommt das Objekt "Math" bei Math.random(); ? Java Basics - Anfänger-Themen 3
D Was kommt raus, wenn NaN mit einer Zahl verglichen wird? Java Basics - Anfänger-Themen 5
K Arraylisten auslesen, kommt nur Quatsch raus Java Basics - Anfänger-Themen 15
X JTable in JPanel in JTabbedPane mouseevent von jtable kommt nicht durch Java Basics - Anfänger-Themen 3
S Beim kompilieren kommt Ant Build.Was ist das? Java Basics - Anfänger-Themen 8
T TCP, Empfang nur wenn wirklich etwas kommt Java Basics - Anfänger-Themen 6
R Zeit kommt mir zu lange vor... Java Basics - Anfänger-Themen 7
A ArrayIndexOutOfBoundsException - woher kommt er?! Java Basics - Anfänger-Themen 4
eXistenZ Java-Boon kommt nicht zurrecht mit der Umsetzung einer Aufgabe... Java Basics - Anfänger-Themen 7
J Woher kommt diese NullPointerException? Java Basics - Anfänger-Themen 6
I Warum kommt der Fehler? Minesweeper programmieren Java Basics - Anfänger-Themen 7
M Woher kommt der Funktionsaufruf? Java Basics - Anfänger-Themen 2
K Wieso kommt ne NullPointerException Java Basics - Anfänger-Themen 3
A nach if abfrage kommt fehler Java Basics - Anfänger-Themen 8
G JFileChooser kommt doppelt Java Basics - Anfänger-Themen 3
P Wieso kommt die Fehlermeldung ".class expected"? Java Basics - Anfänger-Themen 2
P Textdateischreiben, etwas fehlt noch bzw. 1 error kommt Java Basics - Anfänger-Themen 4
J Hilfe Java Hausaufgabe kommt nicht weiter Java Basics - Anfänger-Themen 5
H Server Client, es kommt nichts an. Java Basics - Anfänger-Themen 5
B Char kommt 2 mal im Wort vor (indexOf) Java Basics - Anfänger-Themen 5
B Woher kommt der Name Java? Java Basics - Anfänger-Themen 4
L Compilieren funktioniert, aber beim öffnen kommt nichts Java Basics - Anfänger-Themen 7
G Stringsuche: Wie häufig kommt String1 in Strin2 vor? Java Basics - Anfänger-Themen 7
U Wie oft kommt WertX int[] vor? Java Basics - Anfänger-Themen 2
frau-u StackOverflow - woher kommt es? Java Basics - Anfänger-Themen 7
G Java-1.5-Installation: warum kommt keine javac.exe mit? Java Basics - Anfänger-Themen 7
S die java machine läuft viel zuuuu langsam, woher kommt das?? Java Basics - Anfänger-Themen 3
krgewb Immer dieselbe Zufallszahl Java Basics - Anfänger-Themen 4
R Umgebungsvariable java -cp gibt immer Java-Hilfe... Java Basics - Anfänger-Themen 3
F Warum muss ich ein SSL cert immer manuell hinzufügen? Java Basics - Anfänger-Themen 46
M Queue-Datenstruktur: nach dem Elementen entfernen, das Ergebnis ist immer noch nicht optimal. Java Basics - Anfänger-Themen 3
K Warum werden immer noch doppelte Zahlen ausgegeben ? Java Basics - Anfänger-Themen 13
J Componente immer in Front halten, wie? Java Basics - Anfänger-Themen 5
berserkerdq2 Brauche ich while != -1, wenn ich immer einen BufferedReader verwende? Java Basics - Anfänger-Themen 8
berserkerdq2 Habe ein Spiel entwickelt, dass immer in der 4 Runde einen cast-Fehler erhält Java Basics - Anfänger-Themen 3
berserkerdq2 Spiel hängt sich immer in der 4 Runde auf, obwohl ich jede Runde das gleiche mache Java Basics - Anfänger-Themen 1
berserkerdq2 An selbst ersteller txt Datei immer Text dranhängen, ohne den vorherign Text zu löschen Java Basics - Anfänger-Themen 8
K In andere Zahlensysteme umwandeln, wann klappt immer der Trick mit log? Java Basics - Anfänger-Themen 6
F Wieso wird immer die falsche Mausposition angegeben? Java Basics - Anfänger-Themen 1
D Codeblöcke, die immer wieder im Programmverlauf benötigt werden Java Basics - Anfänger-Themen 5
chocobear26 Interface JOptionPane - Dialog_Fenster zeigt immer vorherige Eingabe an. Java Basics - Anfänger-Themen 4
C Objekt1.equals(Objekt2) = immer false. Wieso? Java Basics - Anfänger-Themen 22
I Array übernimmt immer den letzten Input. Java Basics - Anfänger-Themen 14
tom.j85 Doppelte Foreach Schleife: Am Ende wird immer das Gleiche Objekt eingefügt Java Basics - Anfänger-Themen 4
M Untersuchen ob ein Graph nach entfernen einer Kante immer noch zusammenhängend ist Java Basics - Anfänger-Themen 70
J Zweck von Interfaces immer noch nicht klar Java Basics - Anfänger-Themen 3
M Array immer wieder um ein Element erweitern Java Basics - Anfänger-Themen 6
CptK Methoden Event bei gedrückter Maustaste immer wieder ausführen Java Basics - Anfänger-Themen 1
CptK Klassen Event bei gedrückter Maus immer wieder mit Pause ausführen Java Basics - Anfänger-Themen 2
IMain23 2d Array variabler Spaltenwert, Spaltenwert immer um eins erhöhen Java Basics - Anfänger-Themen 3
M JTextField blitzt immer wieder nur auf Java Basics - Anfänger-Themen 12
N Arbeitsspeicher nach kompilieren immer voller Java Basics - Anfänger-Themen 6
S Immer das selbe mit den Schleifen Java Basics - Anfänger-Themen 24
H OOP eine Zahl immer weiter durch 2 teilen Java Basics - Anfänger-Themen 15
B Operatoren Java berechnet immer 0? Java Basics - Anfänger-Themen 3
J Timer bauen, Main Methode immer wieder neu starten Java Basics - Anfänger-Themen 13
N Funktion funktioniert nicht immer Java Basics - Anfänger-Themen 6
I Methoden Schleife immer wieder durchlaufen lassen Java Basics - Anfänger-Themen 15
3 JFrame immer im Hintergrund Java Basics - Anfänger-Themen 1
F Immer wieder gleiche Zufallszahl? Java Basics - Anfänger-Themen 4
J Operatoren Random wird nur einmal erstellt und dann immer verwendet Java Basics - Anfänger-Themen 2
S Repaint() in der Schleife funktioniert nicht immer Java Basics - Anfänger-Themen 5
S Variable in JTextField soll immer um 5 zunehmen Java Basics - Anfänger-Themen 8
schoenosrockos JButton füllt immer das ganze frame Java Basics - Anfänger-Themen 1
N JList + DefaultListModel + JScrollPane --> ensureIndexIsVisible funktioniert nicht immer Java Basics - Anfänger-Themen 1
N Immer Aktiv sein. Java Basics - Anfänger-Themen 8
D Array wird immer mir 100 für jeden Wert initialisiert? Java Basics - Anfänger-Themen 2
J Ergebnis immer 0 Java Basics - Anfänger-Themen 8
S If-Anweisunng ist IMMER true Java Basics - Anfänger-Themen 2
F Inhalt einer Variable auswerten, die sich immer wieder ändert Java Basics - Anfänger-Themen 1
S UserPref und Java Application klappt immer nicht. Java Basics - Anfänger-Themen 2
Ponychan95 Erste Schritte Switch fällt immer bis zum default durch Java Basics - Anfänger-Themen 4
F String immer weiter nach Bedarf vergrößern Java Basics - Anfänger-Themen 3

Ähnliche Java Themen

Neue Themen


Oben