double[x] , double[y] zu Point[] points kopieren?

S

student1

Mitglied
Hallo,
hoffe einer kann mir bei meinem Problem weiterhelfen.

Ich hab zwei Arrays vom Typ double[]x,double[]y erzeugt, die Punkte beinhalten.

Java: 
public double x[];
public double y[];

Die möchte ich nun in das Objekt Point[] points kopieren.
Java: 
public static Point[] points;

Ich habe das versucht:
Java: 
Polygon coord = new Polygon(x,y);
for (int i = 0; i < sides; i++) {
		
	points[i].x = coord.x[i];
        points[i].y = coord.y[i];
}

Ich kriege immer diese Fehlermeldung: "java.lang.NullPointerException"


Wie mache ich das richtig??


mfg
 
Nach Datum sortieren Nach Zustimmungen sortieren
Ok. Ich hab es initialisiert..
aber wie krieg da jetzt die x[] und y[] werte rein?

sodass ich für points.x alle meine x-koordinaten habe und für points.y alle y-koordinaten?
Sorry steh gerade aufm Schlauch..sitze schon zulange davor..
 
Zustimmen 0
Java: 
Polygon coord = new Polygon(x,y);
		Point[] myarray = new Point[2];
		for (int i = 0; i < sides; i++) {

			x[i] = cx + Math.cos(i * theta) * radius.x;
			y[i] = cy + Math.sin(i * theta) * radius.y;

			double xn = x[i];
			double yn = y[i];
			
			
			myarray = new Point[]{new Point(xn,yn)};
		;
			
		}
		
		System.out.println(myarray[0].x+ " " + x[0]);
 
Zuletzt bearbeitet:
Zustimmen 0
@student1: Das ist eine seltsame Lösung...

Java: 
int[] x = new int[10];
int[] y = new int[10];
Point[] points = new Point[10];

for (int i = 0; i < points.length; i++) {
   points[i] = new Point(x[i], y[i]);
}
 
Zuletzt bearbeitet:
Zustimmen 0
ja..schaut ein bisschen komisch aus 😀

hab aber trotzdem ein Problem mit den Punkten.

Java: 
..........
Point[] points = new Point[n];
		for (int i = 0; i < sides; i++) {

			x[i] = cx + Math.cos(i * theta) * 1;
			y[i] = cy + Math.sin(i * theta) * 1;

			points[i] = new Point(x[i], y[i]);

			this.points = points;
                    System.out.println(points[i].x);
		}

 System.out.println(points[0].x);
}


Bei meiner ersten Ausgabe -->
1.0
-0.4999999999999998
-0.5000000000000004

Kriege ich die Punkte, die ich brauche,also in der Schleife gibt er mit das richtige raus.

Bei meiner zweiten Ausgabe-->
-0.5000000000000004

das kriege ich für points[0].x,points[1].x,points[2].x

immer das gleiche??
warum nicht.. 
points[0].x --> 1.0
points[1].x---> -0.4999999999999998
points[2].x --> -0.5000000000000004

Hier mein kompletter Quellcode, für diese Klasse...
Für diese Aufgabe habe ich noch die Klasse Point, Angle und App, die main() beinhaltet.

Java: 
public class Polygon {

	private Point[] points;
	public int sides;
	private double theta, radius, cx, cy;
	private double x[];
	private double y[];

	public Polygon(Point[] points) {
		this.points = points;

	}// end polygon points

	// Punkte rotieren
	public Polygon rotate(Angle phi) {

		for (int i = 0; i < this.points.length; i++) {
			this.points[i].rotate(phi);

		}

		return new Polygon(new Point[] { new Point(points[0].x, points[0].y) });
	}

	// Punkte verschieben
	public Polygon translate(Point point) {

		for (int i = 0; i < this.points.length; i++) {
			points[i].shift(Point.x, Point.y);

		}

		return new Polygon(new Point[] { new Point(points[0].x, points[0].y) });
	}

	// Eckpunkte generieren
	public Polygon(int n) {

		Point args = new Point(n);

		sides = n; // n-ecken
		x = new double[sides];
		y = new double[sides];
		theta = 2.0 * Math.PI / sides;
		cx = 0; // Mittelpunkt
		cy = 0;

		Point[] points = new Point[n];
		for (int i = 0; i < sides; i++) {

			x[i] = cx + Math.cos(i * theta) * 1;
			y[i] = cy + Math.sin(i * theta) * 1;

			points[i] = new Point(x[i], y[i]);

			this.points = points;

		}

	}// end polygon n

	public void draw() {

	}

}// end Isogon
 
Zustimmen 0
Hat keiner eine Idee, warum meine Punkte in Point[], alle mit dem gleichen Punkt besetzt sind,
sodass ich für points[0].x ,points[1].x,points[2].x......... immer den gleichen Wert hab und nicht die gewünschten x-Koordinaten, die ich ja in x[0], x[1],... ja habe??

Java: 
import gdp.stdlib.*;

public class Polygon {

	private Point[] points;
	public int sides;
	private double theta, radius, cx, cy;
	private double x[];
	private double y[];

	public Polygon(Point[] points) {

		this.points = points;

	}// end polygon points

	// Punkte rotieren
	public Polygon rotate(Angle phi) {

		for (int i = 0; i < this.points.length; i++) {
			points[i].rotate(phi);

		}
		System.out.println(points[0].x + " " + points[1].x + " " + points[2].x);
		return new Polygon(points);
	}

	// Punkte verschieben
	public Polygon translate(Point point) {

		for (int i = 0; i < this.points.length; i++) {
			this.points[i].shift(Point.x, Point.y);

		}
		System.out.println(points[0].x + " " + points[1].x + " " + points[2].x);
		return new Polygon(points);
	}

	// Eckpunkte generieren
	public Polygon(int n) {
		Point args = new Point(n);
		sides = n; // n-ecken
		this.x = new double[sides];
		this.y = new double[sides];
		theta = 2.0 * Math.PI / sides;
		cx = 0; // Mittelpunkt
		cy = 0;

		Point[] points = new Point[n];
		for (int i = 0; i < sides; i++) {

			x[i] = cx + Math.cos(i * theta) * 1;
			y[i] = cy + Math.sin(i * theta) * 1;

			points[i] = new Point(x[i], y[i]);

			this.points = points;
			System.out.println(points[0].x + " " + points[1].x + " " + points[2].x);
		}
		System.out.println(points[0].x + " " + points[1].x + " " + points[2].x);
	}// end polygon n

	public void draw() {

		System.out.println(points[0].x + " " + points[1].x + " " + points[2].x);
		
		/*
		double[] x1 = new double[points.length];
		double[] y1 = new double[points.length];
		
		for(int i=0;i<points.length;i++){
			x1[0] = points[0].x;
			x1[1] = points[1].x;
			x1[2] = points[2].x;
			
			y1[i] = Point.y;
			System.out.println(x1[i]);
		}
		
		 */
		

	}

}// end Isogon
 
Zustimmen 0
Ich habe es gerade bei mir mal ausgeführt und bekomme drei verschiedene Punkte ausgegeben.

Was mir aber auffällt:
- Du erzeugst im Konstruktor eine lokale Variable "points". Entferne die und arbeite besser direkt auf dem privaten Point-Array. Es müllt den Code nur unnötig zu.

- die Variable Point args wird nie benutzt

- Warum erzeugst du die x- und y-Arrays? Du arbeitest nie mit ihnen, sondern speicherst die Werte direkt in einer Point-Instanz. Auch das würde ich vereinfachen und mit lokalen Variablen arbeiten, die ins Array geschrieben werden.
(Außerdem kostet dich die Erzeugung eines Arrays mehr Speicher als ein Integer, aber das ist wahrscheinlich Korinthenkackerei....)

- Außerdem würde ich Zeile 59 und 61 entfernen und stattdessen die draw()-Methode aufrufen. Man versucht, Redundanz und Dopplungen zu vermeiden, um eventuelle Änderungen nur an einer Stelle vornehmen zu müssen.
 
Zuletzt bearbeitet:
Zustimmen 0
Erstmal Danke für die Tipps.
Ich sollte wohl noch ergänzend meine andere Klassen zeigen, die zu diesem Programm gehören.

Da wäre die erste Klasse, mein "Main" Klasse. Hier darf ich nichts verändern.. mein Programm muss mit diesen Angaben funktionieren:

Java: 
import gdp.stdlib.StdDraw;

public class App {

	public static void main(String[] args) {
		if (args.length == 0) System.exit(-1);
		int n = Integer.parseInt(args[0]); 

		double myscale = 5.0; 

		
		Angle delta = new Angle(360. / n);
	
		
		Angle phi   = new Angle(0.0);

		Point pos = new Point(3., 0); 
		
		
		StdDraw.setXscale(-myscale, myscale);
		StdDraw.setYscale(-myscale, myscale);

		
	
		for (int i = 3; i < 3+n; i++) {

			
			
			new Polygon(i).rotate(phi).translate(pos.rotate(phi)).draw();
			
			phi = Angle.add(delta);
			
		}
		
		

		
	
		StdDraw.show();
	}

	
}

Dazu muss ich drei weitere Klassen benutzen.
Einmal die,die ich hier schon gepostet hab... Polygon

und dann noch die hier:

Java: 
import gdp.stdlib.StdDraw;



public class Point  {

	public static double x;
	public static double y;
	public static int args;
	
	public Point(double x, double y){
		this.x = x;
		this.y = y;
	
	}//end Point
		
	public Point(int k){
		this.args = k;
	}
	
	public Point rotate (Angle phi){
		double xOld = Point.x;
		double yOld = Point.y;
		Point.x = xOld * Math.cos(Math.toRadians(phi.angle)) - yOld * Math.sin(Math.toRadians(phi.angle));
		Point.y = xOld * Math.sin(Math.toRadians(phi.angle)) + yOld * Math.cos(Math.toRadians(phi.angle));	
		
		return new Point(Point.x,Point.y);
	}//end rotate
	

	public Point shift (double dx, double dy) {
		Point.x = Point.x + dx;
		Point.y = Point.y + dy;	
		
		return new Point(Point.x,Point.y);
	}//end shift
	
}//end class Point

Java: 
[code=Java]
public class Angle {

	public static double angle;

	Angle(double angle) {
		Angle.angle = Math.toRadians(angle);
	}

	public static Angle add(Angle angle) {

		Angle.angle = Math.toRadians(Angle.angle + (360 / Point.args));
		return angle;
	}

}





Also es muss new Polygon(i).rotate(phi).translate(pos.rotate(phi)).draw(); ausgeführt werden und für die Methode draw()
brauch ich zwei double[] damit ich meine Polygone zeichnen kann, mit dem Befehl StdDraw.polygon(double[]x,double[]y)
 
Zuletzt bearbeitet:
Zustimmen 0
Mich deucht ein static Fehler in der Point-Klasse:

Analogie:

Java: 
public class Test {
  public static void main(String... args) {
    StaticFail[] fail = new StaticFail[10];
    for (int i = 0; i < fail.length; i++) {
      fail[i] = new StaticFail(i);
    }
    for (int i = 0; i < fail.length; i++) {
      System.out.println(fail[i].x);
    }
  }
  
  static class StaticFail {
    public static int x;
    
    public StaticFail(int x) {
      this.x = x;
    }
  }
}
 
Zustimmen 0

Aktuelle Jobs

Neue Themen

Ähnliche Themen

ArrayList<Point> in eine neue ArrayList<Point> kopieren
Antworten: 8
String zu Double parsen (multiple points)
Antworten: 2
Collections kopieren (ArrayList<Point>)
Antworten: 3
AspectJ - Join Points und Pointcuts. Unterschied?
Antworten: 2
Array mit Points initialisieren
Antworten: 6

Zurück
Oben