Klassen Probleme mit den grundlegenen Konzepten der Objektorientierten Programmierung

DerBobby

Mitglied
Hi.

Wir haben in der Uni jetzt mit den grundlegenen Konzepten der Objektorientierten Programmierung begonnen und eine entsprechende Aufgabe dafür gekriegt:

czck8itv.jpg
8dujcriw.jpg

So, der Anfang ist recht klar und einfach. Allerdings weiß ich nicht genau, was ab "Überlagerung von Methoden der Klasse Object" genau gemacht werden soll. Behandelt wurde das in der Vorlesung ebenfalls nicht.

Mein Programmcode sieht bisher so aus:

Java:
public class Punkt {

// Attribute

    private double x;
    private double y;
    private double a;
    private double b;
    private final double eps = 0.0000001;

// Konstruktur

    public Punkt(double x, double y) {

        this.x = x;
        this.y = y;
    }
    
// get-/set-Methoden

    public double getX() {

        return this.x;
    }

    public double getY() {

        return this.y;
    }

    public void setX(double x) {
 
        this.x = x;
    }

    public void setY(double y) {

        this.y = y;
    }

// Überlagerung von Methoden der Klasse Object

    public boolean equals(Object x) {

        if (this.x - y < eps) 
            return x.equals(y);
        else
            return false;
    }

    public String toString() {

        return "Die Koordinaten des aktuellen Objekts liegen bei" + "(" + this.x + "," + this.y + ")";
    } 

    public double abstand() {

        double abstand = Math.sqrt(Math.pow((this.x - 0.0), 2.0) + Math.pow((this.y - 0.0), 2.0));
        return abstand;
    } 
    
    public double abstand(Punkt p) {
 
        double abstandp = Math.sqrt(Math.pow((this.x - this.a), 2.0) + Math.pow((this.y - 0.0), this.b));
        return abstandp;
    }
}

Inwiefern ich das mit dem zweiten Teil der Aufgabe verbinden soll, versteh ich auch nicht wirklich. Ich hoffe ihr könnt mir ein paar Anregungen geben.
 
Zuletzt bearbeitet von einem Moderator:
B

Beni

Gast
Die Klasse "Punkt" erbt von "Object", und in "Object" sind bereits die Methoden "equals" und "toString" implementiert. Wenn du nun in "Punkt" neue "equals" und "toString" Methoden schreibst, überschreibst (überlagern... was für ein hässliches Wort) du die Methoden von Object.

Was du nicht am zweiten Teil der Aufgabe verstehst, verstehe ich nicht. Den vorgegebenen Code kopieren, und alles was fehlt ergänzen...
 

DerBobby

Mitglied
Die Klasse "Punkt" erbt von "Object", und in "Object" sind bereits die Methoden "equals" und "toString" implementiert. Wenn du nun in "Punkt" neue "equals" und "toString" Methoden schreibst, überschreibst (überlagern... was für ein hässliches Wort) du die Methoden von Object.

Was du nicht am zweiten Teil der Aufgabe verstehst, verstehe ich nicht. Den vorgegebenen Code kopieren, und alles was fehlt ergänzen...

Ok, danke für die schnelle Hilfe.

Hmm, habe mich wohl falsch ausgedrückt. Ich versteh schon was ich machen soll, nur weiß ich nicht genau wie es umgesetzt werden soll.
 
N

nillehammer

Gast
"Überlagern" von Methoden gibt es nicht. Es gibt "Überladen (engl overload)". Das heißt mehrere Methoden gleichen Namens aber mit unterschiedlichen Parametern. Deine Methode abstand() ist z.B. überladen. Und es gibt "Überschreiben (schlecht übersetzt, im Englischen spricht man von override). Das heißt, eine Methode einer Superklasse in der Subklasse neu definieren. Das ist das, was Du z.B. mit equals(), hashCode() und toString() machst.

Die Variablen a und b in Punkt sind überflüssig. Objekorientierte Programmierung bietet den Vorteil, dass man Sachverhalte aus der realen Welt mehr oder weniger eins zu eins in Klassen mit geeigneten Attributen abbilden kann. In der realen Welt hat ein Punkt eine x- und eine y-Koordinate, mehr nicht. Streiche a und b ersatzlos.

equals(): Ermittelt, ob das übergebene Object gleich this ist. Dazu musst Du natürlich auch irgend eine Eigenschaft des übergebenen Objekts zum Vergleich heranziehen. Das machst Du in Deinem Code effektiv nicht (x.equals führt nicht dazu): Eine equals-Methode könnte so aussehen:
Java:
// Du weißt noch nicht, was Object in Wirklichkeit ist
// nenne den Parameter also besser obj. x ist besonders
// unglücklich, weil ein Attribut von Punkt so heißt
public final boolean equals(final Object obj) {

  // Abkürzung, wenn identisch automatisch gleich
  if(this == obj) {
    return true;
  }
  // Wenn obj null oder kein Punkt, ist Vergleich nicht möglich
  // gleich false returnen
  if(obj == null || obj.getClass() != this.getClass()) {
   return false;
  }

  // An dieser Stelle wissen wir jetzt, dass obj nicht null
  // UND ein Punkt ist. Wir können gefahrlos casten, um
  // dann die Attribute zu vergleichen.
  final Punkt that = (Punkt) obj;

  // Ich mache hier "nur" den Attributvergleich. Ändere den
  // Teil, sodass die Differenz berücksichtigt wird
  return (this.x == that.x) && (this.y == that.y);
}

hashCode() sollte überschrieben werden, sodass alle Instanzen, bei denen equals true liefert, denselben hashCode zurückgeben (MUSS) und Instanzen, bei denen equals false liefert verschiedene hashCodes zurückgeben (SOLLTE, muss aber nicht).

abstand(Punkt p): Du musst sicher die Koordinaten des anderen Punktes heranziehen. Das machst Du in Deinem Code garnicht. Irgendwo muss in der Methode bspw. sowas vorkommen:
Java:
this.x - p.x
Die Methode abstand() soll den Abstand des Punktes zum Ursprung ermitteln. Der Ursprung hat die Koordinaten 0,0. Mache Dir eine Konstante für diesen Punkt und rufe mit dieser als Parameter einfach die Methode abstand(Punkt p) auf. So ersparst Du Dir doppelten Code.
 
Zuletzt bearbeitet von einem Moderator:

DerBobby

Mitglied
Danke erstmal. Werden mich jetzt nochmal ransetzen und versuchen weiterzukommen.

Wie ich sehe, hat jemand anderes zur genau der gleichen Frage einen Thread erstellt. ^^


EDIT:

Eine Frage noch. Was genau bewirkt dieses "getclass()"? Die Beschreibung in der API versteh ich nicht ganz. ^^


EDIT2:

So sieht jetzt mein Programmcode aus:

Java:
import java.lang.Math;

public class Punkt {

// Attribute

    private double x;
    private double y;
    private final double eps = 0.0000001;

// Konstruktur

    public Punkt(double x, double y) {

        this.x = x;
        this.y = y;
    }
    
// get-/set-Methoden

    public double getX() {

        return this.x;
    }

    public double getY() {

        return this.y;
    }

    public void setX(double x) {
 
        this.x = x;
    }

    public void setY(double y) {

        this.y = y;
    }

// Überlagerung von Methoden der Klasse Object

    public boolean equals(Object x) {

        if(x == this) { 
            return true;
        }

        if(x == null || x.getClass() != getClass()) { 
            return false;
        }
        
        final Punkt a = (Punkt) x;

        if((this.x - a.x) < eps && (this.y - a.y) < eps) {
            return (this.x == a.x) && (this.y == a.y);
        }
        return false;      
    }

    public Object clone() {

        return new Punkt(x, y);
    }

    public String toString() {

        return "Die Koordinaten des aktuellen Objekts liegen bei" + "(" + this.x + "," + this.y + ")";
    } 

    public double abstand() {

        double abstand = Math.sqrt(Math.pow((this.x - 0.0), 2.0) + Math.pow((this.y - 0.0), 2.0));
        return abstand;
    } 
    
    public double abstand(Punkt p) {
       
        double abstandp = Math.sqrt(Math.pow((this.x - p.x), 2.0) + Math.pow((this.y - 0.0), - p.y));
        return abstandp;
    }
}

Die letzten beiden Punkte habe ich erstmal so belassen.
 
Zuletzt bearbeitet:

Amstaff51

Mitglied
Und wie bekommt man das mit dem Schnittpunkt hin? Habe bisher folgenden Ansatz:

Java:
public class Gerade {
        private Punkt p;
        private Punkt q;
        private double m;
        private double b;
        
        public Gerade(Punkt p, Punkt q) {
        	if( p.getX() == q.getX() ){
                System exit(0);
        	}
        }
        public String toString() {
            m = ((p.getY() - q.getY()) / (p.getX() - q.getX()));
            b = p.getY() - m * getX();
            return "y = " + m + "x +" + b;
        }
        public Punkt schnittPunkt(Gerade g) {

Jetzt müsste man beide Geraden gleichsetzen und x ausrechnen und dann wieder einsetzen um y rauszubekommen. Wie stell ich das am besten an?
 
P

pappawinni

Gast
Also ich würd Steigung und Achsenabschnitt nicht als Instanzvariable sehen.
Die Gerade ist durch die zwei Punkte vollständig beschrieben.Wenn du die in einer Methode brauchst, dann kannst du sie dort temporär berechnen.
Dann wirst du zur Berechnung eines Abstandes irgendwie auf die Punkte deiner Geraden zugreifen müssen, da die private sind, bräuchte es dafür wohl ne Methode.
[EDIT]Die Darstellung von Geraden in der Form y=mx+b eignet sich im Grunde hier nicht besonders gut. Aber so soll es halt mal sein. Du willst offensichtlich keine vertikale Gerade (z.B. der Form z.B. x=4) zulassen. Das würd ich mir nochmal überlegen, denn du schränkst damit ja die Funktionalität ein. Ok, die Aufgabenstellung will das so.[/EDIT]
 
Zuletzt bearbeitet von einem Moderator:

bwbg

Mitglied
m, b sollten keine Felder sein, sondern lokale Objekte der Methode toString.

[STRIKE]Was passiert beim Aufruf von toString, wenn die Gerade senkrecht auf der X-Achse steht[/STRIKE]?

Edit: Ich sehe gerade, das wird sehr hässlich im Konstruktor ausgeschlossen.

Ansonsten, Differenz der beiden Punkte (=Vektor) beider Geraden vergleichen. Es gibt ja nur drei mögliche Ergebnisse: Geraden schneiden sich (Winkel beider Ergebnisvektoren unterscheiden sich), Geraden verlaufen parallel oder Geraden liegen genau übereinander.

Grüße ... bwbg
 
Zuletzt bearbeitet:
P

pappawinni

Gast
Denn Schnittpunkt könnte man evtl. so berechnen ( mal nicht in Java).
Wenn ich mich nicht irre:
Geraden G1 und G2 seien durch Punkte wie folgt definiert

G1: P1(x1,y1) und P3(x3,y3)
G2: P2(x2,y2) und P4(x4,y4)

dann wäre:

dx1 = x1-x3
dy1 = y1-y3

dx2 = x2-x4
dy2 = y2-y4

wenn (dy2*dx1-dx2*dy1)<>0
dann:

f = ((x2-x1)*dy1-(y2-y1)*dx1)/(dy2*dx1-dx2*dy1)

und Schnittpunkt PS(xs,ys)
xs = x2+f*dx2
ys = y2+f*dy2

sonst nix mit schneiden.
 
Zuletzt bearbeitet von einem Moderator:

DerBobby

Mitglied
Habe mir mittlerweile mal die Klasse Test erstellt, um an die Klasse Gerade Werte übergeben zu können. Allerdings bekomme ich beim ausrechnen der der Werte für die Gleichung y=mx+n für m und n immer NaN angezeigt. Hier der Programmcode:

Test:

Java:
public class Test {

    public static void main(String[] args) {

        Punkt p = new Punkt(6.0, 8.0);
        Punkt q = new Punkt(2.0, 2.0);
        Gerade a = new Gerade(p, q);
        a.toString();
        System.out.println(a.toString());
    }
}

Gerade:

Java:
public class Gerade {

    double x, y;
    private Punkt p;
    private Punkt q;

    public Gerade(Punkt p, Punkt q) {

         this.p = new Punkt(x, y);
         this.q = new Punkt(x, y);

    }

    public String toString() {

        double m = (p.getY() - q.getY()) / (p.getX() - q.getX());
        double n = p.getY() - m * p.getX();
        return "y = " + m + " * x + " + n;
    } 
}

Weiß nicht so recht, wo jetzt der Fehler liegt. ^^
 
P

pappawinni

Gast
Also ich würd ja dir, Amstaff, mal empfehlen dir ne Klasse mit ner main-Methode zu erzeugen, mit der du dein Zeug testest.
Mit einer IDE scheinst du dich auch noch nicht angefreundet zu haben.
Java:
class Gerade {
    private Punkt p;
    private Punkt q;
    
    public Gerade(Punkt p, Punkt q) {
    	this.p = p;
    	this.q = q;
        if( p.getX() == q.getX() ){
            System.exit(0);
        }
    }
    public String toString() {
        double m = ((p.getY() - q.getY()) / (p.getX() - q.getX()));
        double b = p.getY() - m * p.getX();
        return "y = " + m + " * x + (" + b+")";
    }
    
    public Punkt getPunkt1() {
		return p;
	}
	public Punkt getPunkt2() {
		return q;
	}
	public Punkt schnittPunkt(Gerade g) {
		double x1 = g.getPunkt1().getX();
		double y1 = g.getPunkt1().getY();
        double dx1 = x1-g.getPunkt2().getX();
        double dy1 = y1-g.getPunkt2().getY();
		double x2 = p.getX();
		double y2 = p.getY();
        double dx2 = x2-q.getX();
        double dy2 = y2-q.getY();
        double div = (dy2*dx1-dx2*dy1);
        if (div != 0){
        	double f =  ((x2-x1)*dy1-(y2-y1)*dx1)/div;
        	return new Punkt(x2+f*dx2,y2+f*dy2);
        }
		return null;
    }
}
 
Zuletzt bearbeitet von einem Moderator:

DerBobby

Mitglied
Kann ich wie folgt Werte an "public Punkt schnittPunkt(Gerade g) {" übergeben:

Java:
public class Test {

    public static void main(String[] args) {

        Punkt p = new Punkt(-1.0, 10.2);
        Punkt q = new Punkt(4.0, 0.2);
        Gerade a = new Gerade(p, q);
        a.toString();
        System.out.println(a.toString());

        Punkt g1 = new Punkt(1.0, 1.4);
        Punkt g2 = new Punkt(3.0, 3.8);
        Gerade g = new Gerade(g1, g2);
        g.schnittPunkt(g);
        System.out.println(g.schnittPunkt(g));
    }
}

?

Wenn ja, wie komme ich dann an sie ran? :D
 
M

Marcinek

Gast
Hallo,

du musst das konzentrierter machen.

Du berechnest einen Schnittpunkt zwischen g und g.

---

Deine Methode hat die folgende Deklaration:

Code:
    public Punkt schnittPunkt(Gerade g) {

Du kammst dann innerhalb det Methode über g auf die übergebene Gerade zugreifen.
 

DerBobby

Mitglied
Hallo,

du musst das konzentrierter machen.

Du berechnest einen Schnittpunkt zwischen g und g.

---

Deine Methode hat die folgende Deklaration:

Code:
    public Punkt schnittPunkt(Gerade g) {

Du kammst dann innerhalb det Methode über g auf die übergebene Gerade zugreifen.

Ah, ok.

Aber wie genau kann ich dann auf die die andere Gerade wieder zugreifen?
 

DerBobby

Mitglied
In der anderen gerade befindes du dich.

Also mit this.

Ok, dann müsste ich ja so:

Java:
    public Punkt schnittPunkt(Gerade g) {

        double xSchnittPunkt = this.p.getX();
        double ySchnittPunkt = this.p.getY();
        Punkt schnittPunkt = new Punkt(xSchnittPunkt, ySchnittPunkt);
        return schnittPunkt;

    }

Auf die Werte der anderen Gerade zugreifen können, oder?

Die Rechnung für den Schnittpunkt habe ich mal eben weggelassen.
 
M

Marcinek

Gast
Dann zeig mal den Code.

Und ich gehe davon aus, dass du das hier
Code:
 g.schnittPunkt(g);
bereits korrgiert hast.
 

DerBobby

Mitglied
Dann zeig mal den Code.

Hier:

Test:

Java:
public class Test {

    public static void main(String[] args) {

        Punkt p = new Punkt(-1.0, 10.2);
        Punkt q = new Punkt(4.0, 0.2);
        Gerade h = new Gerade(p, q);
        h.toString();
        System.out.println(h.toString());

        Punkt g1 = new Punkt(1.0, 1.4);
        Punkt g2 = new Punkt(3.0, 3.8);
        Gerade g = new Gerade(g1, g2);
        System.out.println(g.schnittPunkt(g));
    }
}

Gerade:

Java:
public class Gerade {

    double x, y;
    private Punkt p;
    private Punkt q;

    public Gerade(Punkt p, Punkt q) {

        this.p = p;
        this.q = q;
        if(p.getX() == q.getX()) { // Wenn die x-Werte beider Punkte gleich ist (senkrecht) wird abgebrochen
            System.exit(0);    
        }
    }

    public String toString() {

        double m = (p.getY() - q.getY()) / (p.getX() - q.getX());
        double n = p.getY() - m * p.getX();
        return "y = " + m + " * x + " + n;

    }

    public Punkt schnittPunkt(Gerade g) {

        double xSchnittPunkt = this.p.getX();
        double ySchnittPunkt = this.p.getY();
        Punkt schnittPunkt1 = new Punkt(xSchnittPunkt, ySchnittPunkt);
        return schnittPunkt1;

    }
}
 
P

pappawinni

Gast
Für den Schnittpunkt musst du natürlich ne Berechnung durchführen.
Hatte ich doch schon gepostet.


Java:
public class PunktTest {

    Punkt p1 = new Punkt();
    Punkt p3 = new Punkt(1,0.5);
    Punkt p2 = new Punkt(1,0);
    Punkt p4 = new Punkt(9,10);
    Gerade g1 = new Gerade(p1,p3);
    Gerade g2 = new Gerade(p2,p4);
    System.out.println("G2 : "+g1);
    System.out.println("G2 : "+g2);
    Punkt ps= g1.schnittPunkt(g2);   
    System.out.println("Schnittpunkt PS"+ps);    
    
	}

}

class Punkt {
   private static final double EPS = 0.0000001;
   private double x;
   private double y;

   // Kontruktor für Punkt am Koordinatenursprung (0,0).
   public Punkt() {
       this.x = 0;
       this.y = 0;
   }

   // Konstruktor mit gegebenen Koordinaten.
   public Punkt(final double x, final double y) {
       this.x = x;
       this.y = y;
   }
   
   // Copy-Konstruktor
   public Punkt(Punkt p)
   {
       this.x = p.getX();
       this.y = p.getY();
   }

   // Liefert die horizontale Koordinate dieses Punktes.
   public double getX() {
       return x;
   }

   // Liefert die vertikale Koordinate dieses Punktes.
   public double getY() {
       return y;
   }

   // Setzt die horizontale Koordinate dieses Punktes.
   public void setX(double x) { 
	   this.x = x; 
   }
   
   // Setzt die vertikale Koordinate dieses Punktes.
   public void setY(double y) { 
	   this.y = y; 
   }

   private boolean isEqual(double a, double b)
   {    
       return Math.abs(a-b)<EPS;
   }

   public boolean equals(Punkt p)
   {   
		  return isEqual(x, p.getX()) && isEqual(y, p.getY());
   }

   @Override
   public boolean equals(Object x)
   {   
	   if(x instanceof Punkt){
		  return equals((Punkt) x);
	   }
       return false;
   }
   
   @Override
   public Object clone() { 
	   return new Punkt(x,y); 
   }
   
   // euklidischer Abstand von (0,0)
   public double abstand() { 
	   return Math.sqrt(x*x+y*y);
   }

   // euklidischer Abstand von einem zweiten Punkt
   public double abstand(Punkt p) {
	   double dx = x - p.getX();
	   double dy = y - p.getY();
	   return Math.sqrt(dx*dx+dy*dy);	   
   }

   @Override
   public String toString()
   {
       return ("("+x+","+y+")");
   }

}

class Gerade {
    private Punkt p;
    private Punkt q;
    
    public Gerade(Punkt p, Punkt q) {
    	this.p = p;
    	this.q = q;
        if( p.getX() == q.getX() ){
            System.exit(0);
        }
    }
    public String toString() {
        double m = ((p.getY() - q.getY()) / (p.getX() - q.getX()));
        double b = p.getY() - m * p.getX();
        return "y = " + m + " * x + (" + b+")";
    }
    
    public Punkt getPunkt1() {
		return p;
	}
	public Punkt getPunkt2() {
		return q;
	}
	public Punkt schnittPunkt(Gerade g) {
		double x1 = g.getPunkt1().getX();
		double y1 = g.getPunkt1().getY();
        double dx1 = x1-g.getPunkt2().getX();
        double dy1 = y1-g.getPunkt2().getY();
		double x2 = p.getX();
		double y2 = p.getY();
        double dx2 = x2-q.getX();
        double dy2 = y2-q.getY();
        double div = (dy2*dx1-dx2*dy1);
        if (div != 0){
        	double f =  ((x2-x1)*dy1-(y2-y1)*dx1)/div;
        	return new Punkt(x2+f*dx2,y2+f*dy2);
        }
		return null;
    }
}
 
P

pappawinni

Gast
Wobei vermutlich angedacht war, dass mit der Geradenform y = m*x + b gearbeitet wird.
Also:

y = dy1/dx1 * x + b1, bzw. y = m1 * x + b1
y = dy2/dx2 * x + b2, bzw. y = m2 * x + b2

Gleichsetzung und Auflösung nach x liefert

xs = (b2 - b1)/(dy1/dx1 - dy2/dx2), bzw. xs = (b2 - b1)/(m1 - m2)
ys = dy2/dx2 * xs + b2, bzw. ys = m2 * xs + b2

Während ich von der Punkt-Richtungsform ausgegangen bin.
Gerade g1: (x,y) = (dx1,dy1) * k + (x1,y1)
Gerade g2: (x,y) = (dx2,dy2) * f + (x2,y2)

was sich letztlich auch ausdrücken lässt durch die Gleichungen
x = dx1 * k + x1
y = dy1 * k + y1
x = dx2 * f + x2
y = dy2 * f + y2
usw...wie bereits gezeigt.

Womit sich halt auch für vertikale Geraden Schnittpunkte errechnen lassen.
 
Zuletzt bearbeitet von einem Moderator:

DerBobby

Mitglied
Für den Schnittpunkt musst du natürlich ne Berechnung durchführen.
Hatte ich doch schon gepostet.


Java:
public class PunktTest {

    Punkt p1 = new Punkt();
    Punkt p3 = new Punkt(1,0.5);
    Punkt p2 = new Punkt(1,0);
    Punkt p4 = new Punkt(9,10);
    Gerade g1 = new Gerade(p1,p3);
    Gerade g2 = new Gerade(p2,p4);
    System.out.println("G2 : "+g1);
    System.out.println("G2 : "+g2);
    Punkt ps= g1.schnittPunkt(g2);   
    System.out.println("Schnittpunkt PS"+ps);    
    
	}

}

class Punkt {
   private static final double EPS = 0.0000001;
   private double x;
   private double y;

   // Kontruktor für Punkt am Koordinatenursprung (0,0).
   public Punkt() {
       this.x = 0;
       this.y = 0;
   }

   // Konstruktor mit gegebenen Koordinaten.
   public Punkt(final double x, final double y) {
       this.x = x;
       this.y = y;
   }
   
   // Copy-Konstruktor
   public Punkt(Punkt p)
   {
       this.x = p.getX();
       this.y = p.getY();
   }

   // Liefert die horizontale Koordinate dieses Punktes.
   public double getX() {
       return x;
   }

   // Liefert die vertikale Koordinate dieses Punktes.
   public double getY() {
       return y;
   }

   // Setzt die horizontale Koordinate dieses Punktes.
   public void setX(double x) { 
	   this.x = x; 
   }
   
   // Setzt die vertikale Koordinate dieses Punktes.
   public void setY(double y) { 
	   this.y = y; 
   }

   private boolean isEqual(double a, double b)
   {    
       return Math.abs(a-b)<EPS;
   }

   public boolean equals(Punkt p)
   {   
		  return isEqual(x, p.getX()) && isEqual(y, p.getY());
   }

   @Override
   public boolean equals(Object x)
   {   
	   if(x instanceof Punkt){
		  return equals((Punkt) x);
	   }
       return false;
   }
   
   @Override
   public Object clone() { 
	   return new Punkt(x,y); 
   }
   
   // euklidischer Abstand von (0,0)
   public double abstand() { 
	   return Math.sqrt(x*x+y*y);
   }

   // euklidischer Abstand von einem zweiten Punkt
   public double abstand(Punkt p) {
	   double dx = x - p.getX();
	   double dy = y - p.getY();
	   return Math.sqrt(dx*dx+dy*dy);	   
   }

   @Override
   public String toString()
   {
       return ("("+x+","+y+")");
   }

}

class Gerade {
    private Punkt p;
    private Punkt q;
    
    public Gerade(Punkt p, Punkt q) {
    	this.p = p;
    	this.q = q;
        if( p.getX() == q.getX() ){
            System.exit(0);
        }
    }
    public String toString() {
        double m = ((p.getY() - q.getY()) / (p.getX() - q.getX()));
        double b = p.getY() - m * p.getX();
        return "y = " + m + " * x + (" + b+")";
    }
    
    public Punkt getPunkt1() {
		return p;
	}
	public Punkt getPunkt2() {
		return q;
	}
	public Punkt schnittPunkt(Gerade g) {
		double x1 = g.getPunkt1().getX();
		double y1 = g.getPunkt1().getY();
        double dx1 = x1-g.getPunkt2().getX();
        double dy1 = y1-g.getPunkt2().getY();
		double x2 = p.getX();
		double y2 = p.getY();
        double dx2 = x2-q.getX();
        double dy2 = y2-q.getY();
        double div = (dy2*dx1-dx2*dy1);
        if (div != 0){
        	double f =  ((x2-x1)*dy1-(y2-y1)*dx1)/div;
        	return new Punkt(x2+f*dx2,y2+f*dy2);
        }
		return null;
    }
}

Das ist mir klar. Ich wollte nur erstmal die richtigen Werte abgerufen bekommen. ;)
 
M

Marcinek

Gast
Normalerweise ist es unüblich ganze Beiträge zu zitieren. Vor allem dann nicht wenn der Beitrag auf den man sich bezieht direkt drüber steht.
 

Neue Themen


Oben