// -*- java -*-

import java.util.ArrayList;

abstract class Point implements Cloneable {
    double x;

    Point(double xx) { x = xx; }
    
    Point translate(double x)
    {
	try {
	    Point p = (Point) clone();
	    p.x += x;
	    return p;
	} catch (java.lang.CloneNotSupportedException e) {
	    throw new RuntimeException("??");
	}
    }

    // for polymorphism, "add" must be described in class Point
    // but we can't restrict the parameter to be the same type as the derived class
    // => this must be runtime checked
    Point add(Point p) 
    {
	if (this.getClass() == p.getClass())
	    return wrapped_add(p);
	else
	    throw new RuntimeException("" + getClass().getName() + ".add only works with " + getClass().getName() + "'s");
    }
    abstract Point wrapped_add(Point p);
    abstract double length();
}

class Point2d extends Point {
    double y;

    Point2d(double xx, double yy) { super(xx); y = yy; }

    double length()
    {
	return Math.sqrt(x*x + y*y); 
    }

    Point2d add(Point2d p)
    {
	return new Point2d(x + p.x, y + p.y);
    }
    Point wrapped_add(Point p) 
    {
	// here, p *must* be a Point2d
	return add((Point2d) p); 
    }

    public String toString()
    {
	return "[" + x + ", " + y + "]";
    }
}

class Point3d extends Point {
    double y, z;

    Point3d(double xx, double yy, double zz) { super(xx); y = yy; z = zz; }

    double length()
    {
	return Math.sqrt(x*x + y*y + z*z); 
    }

    Point3d add(Point3d p)
    {
	return new Point3d(x + p.x, y + p.y, z + p.z);
    }
    Point wrapped_add(Point p) 
    {
	// here, p *must* be a Point3d
	return add((Point3d) p); 
    }

    public String toString()
    {
	return "[" + x + ", " + y + ", " + z + "]";
    }
}

public class java2 {

    public static void test(Point p) {
	System.out.print("" + p.length() + " " + p.translate(1) + " ");
    }

    public static Point twice(Point p) {
	return p.add(p);
    }

    public static void main(String[] args) {
	Point2d p2d = new Point2d(3, 4);
	Point3d p3d = new Point3d(1, 2, 2);

	Point[] l = { p2d, p3d };

	test(p2d); test(p3d);
	for (int i = 0; i < l.length; i++) System.out.print(" " + l[i].length());
	System.out.println("");

	// after translate, we have to down-cast back to Point3d
	System.out.println(((Point3d) p3d.translate(1)).z);

	System.out.print("" + twice(p2d) + " " + twice(p3d));
	for (int i = 0; i < l.length; i++) System.out.print(" " + twice(l[i]));
	System.out.println("");

	// p3d.add(p2d) and p2d.add(p3d) disallowed at runtime

	// after twice, we have to down-cast back to Point3d
	System.out.println("" + ((Point3d) twice(p3d)).z);

	// whereas after add, we still have a Point3d
	System.out.println("" + p3d.add(p3d).z);	
    }
}