Announcement

Collapse
No announcement yet.

Java Anfänger - Aufgabe - Hilfestellungen und Tips erwünscht

Collapse
This topic is closed.
X
X
  • Filter
  • Time
  • Show
Clear All
new posts

  • Java Anfänger - Aufgabe - Hilfestellungen und Tips erwünscht

    Hallo liebe Community,

    ich hoffe ich poste mein Anliegen in der richtigen Kategorie bin etwas skeptisch deswegen gewesen, vorallem weil die beiträge hier "veraltet" scheinen.
    Ich versuche dennoch mein Glück, ich bin neu in der Welt von Java und schreibe gerade mein 2tes übungsprogramm, wobei ich aber einige probleme habe und so gut wie gar nicht zurecht komme.

    Problem Nr1: Klasse Polygon - berechneSeitenlaenge
    Code:
       public double[] berechneSeitenlaengen(){
         double[] result = new double[eckpunkte.length]; 
           int i;
         for (i from 0 to result.lenght) {
         double deltax = eckpunkte[(i + 1) % eckpunkte.lenght].x - eckpunkte[i].x;
         double deltay = eckpunkte[(i + 1) % eckpunkte.lenght].y - eckpunkte[i].y;
         result[i] = Math.sqrt(deltax * deltax + deltay *deltay);
       }
         return result;
       }
    .lenght wird bei mir rot unterstrichen und ich finde nicht so wirklich den fehler

    Problem Nr2: Klasse Punkte - abstand
    Code:
    public double abstand(Punkt B) {
            return 0;
        }
    brauch ich die methode um die seitenlänge zu berechnen bzw umgekehrt für die Umfangsberechnung? Wäre über hilfestellungen und tips sehr dankbar, auf Wunsch kann ich auch teilweise die ganzen Codes der jeweiligen Klassen posten, sind aber 2 von 5 Klassen,..

    Danke schonmal im vorraus für eure Hilfe

  • #2
    zu1)
    Liegt daran, dass man .length so schreibt
    Sollte dir die Codevervollständigung sagen..

    zu2)
    Ist wohl eher eine mathematische Frage.
    http://de.wikipedia.org/wiki/Polygon
    Dort steht die Formel

    EDIT
    Hoffe du benutzt eine IDE wie Eclipse oder Netbeans
    Zuletzt editiert von Christian Marquardt; 26.05.2015, 16:42.
    Christian

    Comment


    • #3
      Originally posted by Christian Marquardt View Post
      zu1)
      Liegt daran, dass man .length so schreibt
      Sollte dir die Codevervollständig sagen..

      zu2)
      Ist wohl eher eine mathematische Frage.
      http://de.wikipedia.org/wiki/Polygon
      Dort steht die Formel

      EDIT
      Hoffe du benutzt eine IDE wie Eclipse oder Netbeans
      Danke dir ja so kleinigkeiten -.-
      Ja benutze netbeans, aber die codevervollständigung sagt mir gar nichts,..

      Comment


      • #4
        Ja benutze netbeans, aber die codevervollständigung sagt mir gar nichts,..
        Wenn du nach einer Klasse einen Punkt setzt, sollte die angezeigt werden

        p.jpg
        Christian

        Comment


        • #5
          Originally posted by Christian Marquardt View Post
          Wenn du nach einer Klasse einen Punkt setzt, sollte die angezeigt werden

          [ATTACH=CONFIG]2274[/ATTACH]
          Gerade geprüft, klappt doch, nie darauf geachtet. Dürfte ich dich bitten dir meine zwei klassen anzuschauen:
          Klasse Punkt
          Code:
          public class Punkt {
              
             private final static int maxpos = 1023;
             private int xpos;
             private int ypos;
              double x,y;
          
             public Punkt(int xpos, int ypos) {
               this.xpos = xpos;
               this.ypos = ypos;
               
              if(xpos<0) {
              this.xpos = 0;
            } else if(xpos>maxpos) {
              this.xpos=maxpos;
            } else {
              this.xpos=xpos;
            }
             if(ypos<0) {
              this.ypos = 0;
            } else if(xpos>maxpos) {
              this.ypos=maxpos;
            } else {
              this.ypos=ypos;
            }
             }
          
             public Punkt() {
               this.xpos = 511;
               this.ypos = 511;
                }
          
             public int getXpos() {
               return this.xpos;
             }
          
             public void setXYpos(int xpos, int ypos) {
               this.xpos = xpos;
               this.ypos = ypos;
             }
          
             public int getYpos() {
               return this.ypos;
             }
          
             public Punkt verschiebeUm(int deltax, int deltay) {
               return new Punkt(xpos + deltax, ypos + deltay);
             }
          
             public Punkt verschiebeUm(Punkt deltaxy) {
               return new Punkt(xpos + deltaxy.xpos, ypos + deltaxy.ypos);
             }
          
             public String toString() {
               return "(" + xpos + "," + ypos + ")";
             }
           
             public double abstand(Punkt B) {
                  return 0;
              }
             
          }
          Klasse Polygon
          Code:
          import java.util.Arrays;
          
          public class Polygon {
             private String bezeichnung;
             private Punkt[] eckpunkte;
             
             
          
             public Polygon() {
               eckpunkte = new Punkt[0];
               this.bezeichnung = "Testpoly ";
             }
           
             public Polygon(Punkt[] eckpunkte, String bezeichnung) {
               this.eckpunkte = eckpunkte;
               this.bezeichnung = bezeichnung;
             }
          
             public Polygon(Punkt[] eckpunkte) {
               this.eckpunkte = eckpunkte;
               this.bezeichnung = "";
             }
           
             public Punkt[] getEckpunkte() {
               return eckpunkte;
             }
           
             public int getAnzahlEcken() {
               return eckpunkte.length;
             }
           
             public void setEckpunkte(Punkt[] eckpunkte) {
               this.eckpunkte = eckpunkte;
             }
           
             public double[] berechneSeitenlaengen(){
               double[] result = new double[eckpunkte.length]; 
               for (int i = 0; i < result.length; i++) {
               double deltax = eckpunkte[(i + 1) % eckpunkte.length].x - eckpunkte[i].x;
               double deltay = eckpunkte[(i + 1) % eckpunkte.length].y - eckpunkte[i].y;
               result[i] = Math.sqrt(deltax * deltax + deltay *deltay);
             }
               return result;
             }
           
             public double berechneUmfang() {
              double umfang = 0;
              for (int i=0; i<eckpunkte.length-1; i++)
              {
              umfang += eckpunkte[i].abstand(eckpunkte[i+1]);
              }
              return umfang;
          }
           
             @Override
             public String toString() {
                 return bezeichnung + 
                         "mit N= " + getAnzahlEcken() + 
                         ", U= " + berechneUmfang() +
                         " und den Koordinaten P=" +Arrays.toString(eckpunkte);
             }
          }
          Mir wurde gesagt das meine berechneUmfang methode falsch sei, wüsste aber nicht woran das liegen sollte, du vielleicht?

          Comment


          • #6
            Weiß ich nicht. Meine Schulzeit und die Polygone sind 40 Jahre her.

            Du musst doch wissen, ob da das richtige Ergebnis bei der Methode rauskommt, also ob

            return umfang

            den korrekten Wert zurückgibt
            Christian

            Comment


            • #7
              30 Sek. Suche:

              http://www.google.dk/url?sa=t&rct=j&...,d.bGg&cad=rja

              [highlight=java] public static void main( String[] args ) // hier startet das Programm
              {
              double umfang = 0.0 ; // 19.1
              double flaeche = 0.0 ; // 19.2
              int ecke ;
              double[] X = { 0, 3, 0 } ;
              double[] Y = { 0, 0, 4 } ;

              for ( ecke=1 ; ecke < X.length ; ecke++ )
              {
              umfang += abstand( X[ecke-1], Y[ecke-1], X[ecke], Y[ecke] ) ; // 19.1
              flaeche += areal( X[ecke-1], Y[ecke-1], X[ecke], Y[ecke] ) ; // 19.2
              }
              umfang += abstand( X[0], Y[0], X[X.length-1], Y[X.length-1] ) ; // 19.1
              flaeche += areal( X[0], Y[0], X[X.length-1], Y[X.length-1] ) ; // 19.2
              System.out.println( "Der Umfang ist " + umfang ) ;
              System.out.println( "Die Fläche ist " + flaeche ) ;
              }


              [/highlight]
              Christian

              Comment


              • #8
                Ja die Word datei hab ich auch gefunden und gelesen, mein Problem in der Methode ist, das mir die letzte strecke vom letzten Punkt zum Anfangspunkt fehlt. Ich wüsste nicht wie ich diese mit einbeziehen kann,..

                Comment


                • #9
                  So wie im Code den Christian zeigt auch. Nach der Schleife über alle Punkte nochmal den Abstang zwischen letztem und ersten Punkt hinzuaddieren mit der selben Methode die du auch in der Schleife verwendest.

                  Comment


                  • #10
                    Originally posted by Ralf Jansen View Post
                    So wie im Code den Christian zeigt auch. Nach der Schleife über alle Punkte nochmal den Abstang zwischen letztem und ersten Punkt hinzuaddieren mit der selben Methode die du auch in der Schleife verwendest.
                    verstehe nicht so genau wie ich das machen soll, ich muss auch ehrlich sagen, nach dem ich nun den ganzen vormittag/mittag dran saß denke ich würde vielleicht eine pause gut tun, hätte nur gern den punkt vorher abgeschlossen gehabt,..

                    Comment


                    • #11
                      Die Schleife

                      [highlight=java]

                      for ( ecke=1 ; ecke < X.length ; ecke++ )
                      {
                      umfang += abstand( X[ecke-1], Y[ecke-1], X[ecke], Y[ecke] ) ; // 19.1
                      flaeche += areal( X[ecke-1], Y[ecke-1], X[ecke], Y[ecke] ) ; // 19.2
                      }

                      [/highlight]
                      und nocheinmal

                      [highlight=java]
                      umfang += abstand( X[0], Y[0], X[X.length-1], Y[X.length-1] ) ;

                      [/highlight]
                      Christian

                      Comment


                      • #12
                        http://www.java-forum.org/allgemeine...-polygone.html

                        geschlossen
                        Christian

                        Comment

                        Working...
                        X