An example of a pattern for constructing immutable objects using a fluent builder implemented as an inner class.

Point.java

package innerclassbuilderexample;

/*
 * An example of a pattern for constructing immutable
 * objects using a fluent builder implemented as an
 * inner class.
 *
 * Some boiler plate code can be saved if one is willing to give up
 * fluency in the Builder's interface.
 */
public class Point {
    private int x;
    private int y;

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    public static Builder builder() {
        return new Point().new Builder();
    }

    /** Zero arg constructor is deliberately not public */
    Point() {
    }

    public class Builder {

        public Point build() {
            return Point.this;
        }

        public Builder setX(int x) {
            Point.this.x = x;
            return this;
        }

        public Builder setY(int y) {
            Point.this.y = y;
            return this;
        }

        /** Zero arg constructor is deliberately not public */
        Builder() {
        }
    }

    /*
     * A demonstration of usage.
     *
     * The constructed object (Point) is immutable (read-only).  The
     * builder that must be used to construct the Point is
     * write-only. This forces a clear separation of object
     * construction (writing) from object use (reading).
     */
    public static void main(String[] args) {
        Point.Builder b = Point.builder();
        b.setX(1).setY(2);
        Point p = b.build();
        System.err.println(p.getX() + p.getY());
    }
}