Thread: Create a polygone

2.7 is a double. 2.7f is a float. (float)2.7 is also a float.

No. Your points ArrayList only accepts Doubles. A Point is not a Double, it contains Doubles (or doubles). Trying to add a Point to an ArrayList of Doubles won't work. Perhaps you want an ArrayList of Points instead?

Because that's what's returned by Point.toString(), which is probably just using Object's toString().

What did you expect to print out? Java doesn't automatically know how to format a String version of an Object. For example, what do you think should happen if you did something like this:

JFrame frame = new JFrame();
System.out.println("Frame: " + frame);

If you want something else to print out, you'll have to get at that information yourself.

The API is your friend.

Java Platform SE 6 (that's a link, click it)

Originally Posted by r0x

// Custom toString() Method.
	public String toString() {
		return "X=" + x + " " + "Y=" + y;
	}

ok, so I need to write my own version of toString method ? so that after in Main it could be overriden.

I suppose that's one way to do it. Or you could just use the getter functions in Point to print the values out yourself.

For example, say I have a Rectangle r, and I want to print its width. I would just do this:

System.out.println("Width: " + r.getWidth());

Originally Posted by r0x

so the idea is that when I use System.out.println() this method needs toString to print the stuff ?

Sort of. If you don't use a getter or some other function (like in my example), then println() is going to look at the toString() method to figure out what it should print.

Originally Posted by r0x

and by default println takes Object's toString, am I right ?

Not necessarily. For example, many Objects (take Integer for example) override toString to provide a more meaningful String representation. If toString is not overridden by any of the parent classes, then the toString() inherited from Object is used.

Check out the API to see which classes override toString().

[edit] oops, didn't read to the end

No, you can't do something like that. You could base type Point and Line and have ArrayList contain that base type.

// I didn't define the classes, but you obviously would need to
public class Geometry
{}
 
public class Point extends Geometry
{}
 
public class Line extends Geometry
{}

Then something like this would work:

ArrayList<Geometry> geometries = new ArrayList<Geometry>();
geometries.add(new Line(/*with the correct constructor params*/));
geometries.add(new Point(/*with the correct constructor params*/));

Additionally, all objects are base-typed as Object, so in theory you could create an ArrayList of Objects and it can hold anything, however this practice is generally frowned upon.

And to reiterate what helloworld922 said, you could also do something like this:

ArrayList<Number> numbers = new ArrayList<Number>();
Integer i = new Integer(1);
Double d = new Double(3.14);
numbers.add(i);
numbers.add(d);

You can do this because both Integer and Double extend Number.

So since everything extends Object, you could have an ArrayList of Objects (or just don't user generics). But again, that's generally not the way to go.

Arrays in Java are always fixed size. You can create a new array to replace the old one, but you must fix the size of the array.

Actually that notation of [][2] isn't correct Java syntax. Instead, you must do one of the following:

Remove the 2 and let Java figure out the size the array must be.

float endpoints[][] = { {2.7, 5.4}, {1.1, 2.8}, {1.9, 1.3} }; // Java will create a 3*2 array of floats
float endpoints[][] = new float[][] { {2.7, 5.4}, {1.1, 2.8}, {1.9, 1.3} }; // this does the exact same thing

Declare the size of all the dimensions.

float endpoints[][] = new float[3][2]; // you can put values into endpoints either 1 by 1 or row by row

If you want an "infinite" number of rows, you can either create an array of very large size (generally not a good idea) or use ArrayLists (see: http://www.javaprogrammingforums.com...t-example.html). Note that ultimately you are going to be limited by the amount of memory your system has (more specifically the maximum JVM heap size).

With Java arrays there is no way to enforce that the columns must be width 2 (at least without a wrapper class), however if you're careful you can enforce this de-facto.