Is this an immutable class?

No, it's not. You expose the Point[] and a caller could modify its contents. Also, your class is not final, so someone could subvert it by subclassing it.

No, it's definitely mutable.

Not only do you expose the actual Point[] array, you don't defensive-copy (Bloch 2nd ed., Item 39) the Point objects themselves when taking them in via the constructor.

1. The Point[] array could have items removed or added to it, so it's mutable.
2. You could pass in Points a, b, and c, then call setX() or setY() on them to change their data after construction.

Close. For one thing, an immutable class should make it's fields final, but that's not a requirement.

However, you are exposing an array through the getter, and that is not immutable. Make a defensive copy using Arrays.copyOf(array, length):

@Override public Point[] getPoints() { return Arrays.copyOf(this.points,this.points.length); } 

Here's what I'd do to make this class immutable, with the help of Guava. I see from the @Override in the code you posted that IShape seems to require a Point[] from the getPoints() method, but I'm ignoring that for the sake of example since the use of object arrays is a rather poor idea, especially if you want immutability (since they cannot be immutable and all).

public final class Triangle implements IShape, Serializable { private final ImmutableList<Point> points; public Triangle(Point a, Point b, Point c) { this.points = ImmutableList.of(a, b, c); } public ImmutableList<Point> getPoints() { return this.points; } // ... } 

Point should also be more like:

public final class Point implements Serializable { /* * Could use public final here really, but I prefer * consistent use of methods. */ private final int x; private final int y; private final int z; public Point(int x, int y, int z) { this.x = x; this.y = y; this.z = z; } // getters, etc. } 

In order to be an immutable class, it is not enough that your methods promise not to change the object. In addition to having all fields be private and the methods not allow changing, you must also guarantee that the subclasses have the same promise of immutability. This includes making the class itself final, and ensuring that no references to the fields are ever returned.

A short, but excellent treatment of this can be found in this article:

http://www.javaranch.com/journal/2003/04/immutable.htm

Not only do you need to provide an immutable copy of the internalised array, you also need to make sure that the Point object is immutable.

Consider the following use of the Point class in the standard Java API:

Point a = new Point(1,1); Point b = new Point(1,1); Point c = new Point(1,1); Triangle triangle = new Triangle(a, b, c); System.out.println(Arrays.toString(triangle.getPoints())); c.setLocation(99,99); System.out.println(Arrays.toString(triangle.getPoints())); 

It is not immutable because ...

Triangle t1 = new Triangle(new Point(0,0), new Point(0, 10), new Point(10, 10)); Triangle t2 = t1; System.out.println( t1.getPoints()[0] ); // -> 0 t2.getPoints()[0].x = 10; System.out.println( t1.getPoints()[0] ); // -> 10 

Thus the class is not immutable because you can change the state of an instance (internal Point[] exposed) and this also changes the state of a reference to the same instance.

To make it a true immutable class, you would need methods to separately get X and Y from each point, for example:

public int getPointX(int point) { return points[point].x; } public int getPointY(int point) { return points[point].y; } 

or

public Point getPoint(int point) { return new Point(points[point]); } 

or return a copy of the points like you suggested in your edit.

In addition to what others have already noted, you should:

• Make your Triangle class final to prevent the creation of mutable Triangles by subclasses.
• Declare all the fields final, to catch accidental modification of fields by the class itself.

In "Effective Java," Joshua Bloch provides a list of rules for immutable classes in general, in Item 15: Minimize Mutability.

1) Make members private and final - so

private Point[] points; //should be private final Point[] points; 

2) Make class final so it cannot be sub-classed

3) Exclusive access to mutable members (array) - meaning return copy of and not the reference to mutable members

For the best treatment of this subject refer to Joshua Bloch, Effective Java- item 15

This could be a better Point implementation. import java.io.Serializable;

public final class Point implements Serializable { private static final long serialVersionUID = 0x100; private final int x; private final int y; private final int z; public Point(int x, int y, int z) { this.x = x; this.y = y; this.z = z; } public Point(Point that) { this(that.x, that.y, that.z ); } public boolean equals(Object obj) { // assume this is a typical, safe .equals implementation // that compares the coordinates in this instance to the // other instance return true; } } 

Other than exposing the array (as getters are wont to do) and not being final, being serialisable is "problematic".

As a very nasty man, when deserialising, I can get another reference to the internal array. The obvious fix for this is:

private void readObject( ObjectInputStream in ) throws ClassNotFoundException, IOException { ObjectInputStream.GetField fields = in.readFields(); this.points = ((Point[])(fields.get("point", null)).clone(); } 

That still leaves the problem of points not being final and exposing the object without points initialised (or worse, but a bit thoeretical, partially initialised). What you really want is a "serial proxy", which you can find out about on the internets...

Note: If you implement equals you should also implement hashCode, probably toString and possible Comparable.

Point itself doesn't have to be immutable for Triangle to be immutable. You just have to do a lot of defensive copies so that nobody has a reference to the Point objects stored in the Triangle.

Also, shouldn't triangle a-b-c equal triange b-c-a (and 4 other permutations)

A immutable class example with mutable field:

public final class ImmutabilityTest { private final int i; private final C c1; ImmutabilityTest(int i, C c1){ this.i = i; this.c1 = c1; } public int getI() { return i; } public C getC1() { return (C)c1.clone();//If return c1 simply without calling clone then contract of immutable object will break down } @Override public String toString() { return "ImmutabilityTest [i=" + i + ", c1=" + c1 + "]"; } public static void main(String[] args) { ImmutabilityTest i1 = new ImmutabilityTest(10, new C(new D("before"))); System.out.println(i1); i1.getC1().getD1().name = "changed"; System.out.println(i1); } } class C implements Cloneable{ D d1; public C(D d1) { super(); this.d1 = d1; } public D getD1() { return d1; } public void setD1(D d1) { this.d1 = d1; } @Override public String toString() { return "C [d1=" + d1 + "]"; } public C clone(){ C c = null; try { c = (C) super.clone(); c.setD1(c.getD1().clone());// here deep cloning is handled if it is commented it will become shallow cloning } catch (CloneNotSupportedException e) { // TODO Auto-generated catch block e.printStackTrace(); } return c; } } class D implements Cloneable{ String name; public D(String name) { this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public String toString() { return "D [name=" + name + "]"; } public D clone(){ D d = null; try { d = (D) super.clone(); } catch (CloneNotSupportedException e) { // TODO Auto-generated catch block e.printStackTrace(); } return d; } }