java.awt.Shape - zmiana położenia

Drawable.java:
    public interface Drawable2D extends Shape {
        public void draw(Graphics2D g2);
    }
    
MojKsztalt.java:
    public class MojKsztalt implements Drawable2D {
        // nadpisanie metod z interfejsu Shape, konstruktor
        public void draw(Graphics2D g2) {
            // wywołanie funkcji rysujących
        }
    }


konstruktor JPanelu:
    List<Shape> elementy = new ArrayList<Shape>();
    elementy.add(new Rectangle(..));
    elementy.add(new MojKsztalt(..));

rysowanie:
    paintComponent() {
        for (Shape s : elementy) {
            if (s instanceof Drawable) {
                ((Drawable)s).draw(g2);
            }
            else {
                g2.draw(s);
            }            
        }
    }

 
public class Draw2DObjects extends JFrame {
  Shape shapes[] = new Shape[5];
  public static void main(String args[]) {
    Draw2DObjects app = new Draw2DObjects();
  }

  public Draw2DObjects() {
    add("Center", new MyCanvas());
    shapes[0] = new Line2D.Double(0.0, 0.0, 100.0, 100.0);
    shapes[1] = new Rectangle2D.Double(10.0, 100.0, 200.0, 200.0);
    shapes[2] = new Ellipse2D.Double(20.0, 200.0, 100.0, 100.0);
    GeneralPath path = new GeneralPath(new Line2D.Double(300.0, 100.0, 400.0, 150.0));
    path.append(new Line2D.Double(25.0, 175.0, 300.0, 100.0), true);
    shapes[3] = path;
    shapes[4] = new RoundRectangle2D.Double(350.0, 250, 200.0, 100.0, 50.0, 25.0);
    setSize(400, 400);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setVisible(true);
  }

  class MyCanvas extends Canvas {
    public void paint(Graphics graphics) {
      Graphics2D g = (Graphics2D) graphics;
      for (int i = 0; i < shapes.length; ++i) {
        if (shapes[i] != null)
          g.draw(shapes[i]);
      }
    }
  }
}

import java.awt.geom.AffineTransform;
import java.awt.geom.PathIterator;

public class QuadratPathIterator implements PathIterator {
	
	private double x, y, size;
	private AffineTransform affine;
	private int index = 0;

	public QuadratPathIterator(AffineTransform affine, double x, double y, double size) {
		this.affine = affine;
		this.x = x;
		this,y = y;
		this.size = size;
	}

	@Override
	public int getWindingRule() {
		return PathIterator.WIND_NON_ZERO;
	}

	@Override
	public boolean isDone() {
                return index > 5;
        }

	@Override
	public void next() {
                this.index++;
        }

	@Override
        public int currentSegment(float[] coords) {
		if(index == 5) {
			return PathIterator.SEG_CLOSE;
		coords[0] = (float) this.x;
		coords[1] = (float) this.y;
		if(index == 1 || index == 2) {
			coords[0] += (float) size;
		} else if(index == 2 || index == 3) {
			coords[1] += (float) size;
		}
		if(affine != null) {
			affine.transform(coords, 0, coords, 0, 1);
		}
		return (index == 0 ? PathIterator.SEG_MOVETO : PathIterator.SEG_LINETO);
	}

	@Override
        public int currentSegment(double[] coords) {
		if(index == 5) {
			return PathIterator.SEG_CLOSE;
		coords[0] = this.x;
		coords[1] = this.y;
		if(index == 1 || index == 2) {
			coords[0] += size;
		} else if(index == 2 || index == 3) {
			coords[1] += size;
		}
		if(affine != null) {
			affine.transform(coords, 0, coords, 0, 1);
		}
		return (index == 0 ? PathIterator.SEG_MOVETO : PathIterator.SEG_LINETO);
	}

	public double getX() {
		return this.x;
	}

	public double getY() {
		return this.y;
	}

	public double getSize() {
		return this.size;
	}

	// można dodać settery, ale ja nie polecam :)
}

import java.awt.Shape;
import java.awt.geom.FlatteningPathIterator;
import java.awt.geom.Rectangle2D;

public class Quadrat2D implements Shape {

	private double x, y, size;

	public Quadrat(double x, double y, double size) {
		this.x = x;
		this.y = y;
		this.size = size;
	}

	@Override
    	public boolean contains(double x, double y) {
        	throw new UnsupportedOperationException("Nie chce mi się myśleć nad tą metodą. Napiszcie ją sobie sami :)");
    	}

    	@Override
    	public boolean contains(Point2D p) {
        	return contains(p.getX(), p.getY());
    	}

    	@Override
    	public boolean contains(Rectangle2D r) {
        	return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight());
    	}

    	@Override
    	public boolean contains(double x, double y, double w, double h) {
        	throw new UnsupportedOperationException("Nie chce mi się myśleć nad tą metodą. Napiszcie ją sobie sami :)");
    	}

    	@Override
    	public boolean intersects(double x, double y, double w, double h) {
        	throw new UnsupportedOperationException("Nie chce mi się myśleć nad tą metodą. Napiszcie ją sobie sami :)");
    	}

    	@Override
    	public boolean intersects(Rectangle2D r) {
        	return this.intersects(r.getX(), r.getY(), r.getWidth(), r.getHeight());
    	}

    	@Override
    	public Rectangle getBounds() {
        	return this.getBounds2D().getBounds();
    	}

    	@Override
    	public Rectangle2D getBounds2D() {
        	return new Rectangle2D.Double(this.x, this.y, this.size, this.size);
    	}

    	@Override
    	public PathIterator getPathIterator(AffineTransform at) {
        	return new QuadratPathIterator(at, this.x, this.y, this.size);
    	}

	@Override
	public PathIterator getPathIterator(final AffineTransform at, double flatness) {
		return new FlatteningPathIterator(getPathIterator(at), flatness);
	}
}