Salve a tutti, premetto che sono alle prime armi con la OOP.... Mi è stato assegnato l'esercizio qui sotto, l'ho svolto in gran parte, (non sono sicuro della totale essattezza), comunque sia mi sono bloccato nella creazione della classe "ScaffaleDiPoligoni", sopprattuttto nei metodi "sistemaPoligono" dove all'interno dell'if, nn so come verificare che il poligono "form" appartenga alla classe Triangle,Circle o Rettangle e come verificare succesivamente verificare quale lato sia il piu piccolo, cosi poi da sommarlo alla variabile shelf.

Potete darmi qualche dritta???
Inoltre, il codice è scritto con chiarezza e indentato corretamente??
L'uso dei commenti è buono?

P.S: Se vedete errori di ragionamento, ecc nel codice vi chiederei cortesemente di farmelo notare

Grazie mille fin da ora

codice:
 /*
Realizza la classe Punto con tutti i metodi che ritieni opportuni più il metodo (statico) creaCasuale()
che crea un punto casuale e lo restituisce. Successivamente crea la superclasse astratta Poligono che ha i
metodi getPerimetro () e getArea(). Da questa classe derivano le classi Cerchio, Rettangolo e Triangolo.
Per ciascuna di queste classi, dopo avere realizzato i metodi che ritieni opportuni, realizza un metodo statico
creaCasuale() che crea un oggetto con valori a caso e lo restituisce.
Realizza infine la classe ScaffaleDiPoligoni che è una collezione di (massimo) dieci poligoni sistemati in modo da
occupare meno spazio possibile (i triangoli e i rettangoli sono poggiati sul lato più corto, le circonferenze
occupano lo spazio del loro diametro: si trascuri l'eventuale contatto tra i poligoni al di sopra della retta presa in
considerazione).
I metodi di questa classe sono: getPorzioneOccupata(), getTotPoligoni(), getPoligono(i), sistemaPoligono(p),
toString(). Il primo metodo restituisce la misura dello scaffale occupata. Il metodo getTotPoligoni() restituisce
un intero tra 0 e 10 che rappresenta la quantità di poligoni già sistemati sullo scaffale. Il metodo getPoligono(i)
restituisce un puntatore al poligono inserito in posizione i-esima. Il metodo sistemaPoligono(p) posiziona nel modo più
opportuno il poligono sullo scaffale. Il metodo toString() presenta un elenco dei poligono inseriti sullo scaffale; di
ciascun poligono si presenterà il tipo (Triangolo, Rettangolo, Cerchio), le sue caratteristiche
(i vertici o il centro con il raggio) ed infine l'ingombro.
Realizza infine una classe Test che sistema su uno scaffale un numero di poligoni a caso tra 5 e 10.
I poligoni saranno scelti a caso tra quelli disponibili.
I punti e l'eventuale misura del raggio saranno anch'essi casuali.
 */

class Point {
    private int x;
    private int y;
    private static int x1;
    private static int y1;
    static int nPoint;


    //Costruttore

    public Point() {
        nPoint++;
    }

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
        nPoint++;
    }

    //Getter e Setter di x,y e x1,y1

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public static int getX1() {
        return x1;
    }

    public static int getY1() {
        return y1;
    }

    //Metodo creazione punto casuale

    public static String creaCasuale() {
        //N casuale da 0.0 a 20
        x1 = (int) (20 * Math.random());
        y1 = (int) (20 * Math.random());
        return getX1() + " " + getY1();
    }
}

abstract class Poligono {

    //Metodi astratti

    public abstract double getPerimetro();
    public abstract double getArea();
   // public abstract String getPoligono();
}

class Rettangle extends Poligono{
    private double AB, BC, CD, DA;
    private static double Ab,Bc;
    private static String rettangle;

    //Costruttori

    public Rettangle (double AB, double BC){
        this.AB = AB;
        this.BC = BC;
    }

    public Rettangle(Point A, Point B, Point C, Point D){

        //Formula distanza tra due punti

        AB = Math.sqrt(Math.pow((B.getX()-A.getX()),2)+Math.pow((B.getY()-A.getY()),2));
        BC = Math.sqrt(Math.pow((C.getX()-B.getX()),2)+Math.pow((C.getY()-B.getY()),2));
        CD = Math.sqrt(Math.pow((D.getX()-C.getX()),2)+Math.pow((D.getY()-C.getY()),2));
        DA = Math.sqrt(Math.pow((A.getX()-D.getX()),2)+Math.pow((A.getY()-D.getY()),2));
    }

    public double getAB() {
        return AB;
    }

    public double getBC() {
        return BC;
    }

    public double getCD() {
        return CD;
    }

    public double getDA() {
        return DA;
    }

    public static double getAb() {
        return Ab;
    }

    public static double getBc() {
        return Bc;
    }
    //Metodi Perimetro e Area non Static

    @Override
    public double getPerimetro() {
        return (AB + BC) * 2;
    }

    @Override
    public double getArea() {
        return AB * BC;
    }

    //Metodi Static

    public static String creaCasuale() {
        //Creo i lati del Rettangolo

        Ab = (int)(20 * Math.random()) + 1;
        Bc = (int)(20 * Math.random()) + 1;

        //Per maggiore compresione utilizzo una variabile Stringa

        rettangle = ("AB=CD=" + Ab + " BC=DA=" + Bc);
        return rettangle;
    }

    public static double getPerimeter(){
        return (Ab + Bc) * 2;
    }

    public static double getAreA(){
        return Ab * Bc;
    }
}

class Triangle extends Poligono{
    private double AB, BC, CA;
    private static double Ab, Bc, Ca;
    private static String triangle;

    //Costruttore
    public Triangle(double AB, double BC, double CA) {
        this.AB = AB;
        this.BC = BC;
        this.CA = CA;
    }

    public Triangle(Point A, Point B, Point C){

        //Formula distanza tra due punti

        AB = (int)Math.sqrt(Math.pow((B.getX()-A.getX()),2)+Math.pow((B.getY()-A.getY()),2));
        BC = (int)Math.sqrt(Math.pow((C.getX()-B.getX()),2)+Math.pow((C.getY()-B.getY()),2));
        CA = (int)Math.sqrt(Math.pow((A.getX()-C.getX()),2)+Math.pow((A.getY()-C.getY()),2));
    }

    //Metodi getter

    public double getAB() {
        return AB;
    }

    public double getBC() {
        return BC;
    }

    public double getCA() {
        return CA;
    }

    public static double getAb() {
        return Ab;
    }

    public static double getBc() {
        return Bc;
    }

    public static double getCa() {
        return Ca;
    }

    //Metodi Perimetro e Area non Static

    @Override
    public double getPerimetro() {
        return AB +BC +CA;
    }

    @Override
    public double getArea() {
        double halfPerimeter = (AB +BC +CA)/2;
        return Math.sqrt( halfPerimeter * (halfPerimeter - AB) * (halfPerimeter - BC) * (halfPerimeter -CA));
    }

    //Metodi Static

    public static String creaCasuale() {
        //Creo i lati del Triangolo

        Ab = (int)(20 * Math.random()) + 1;
        Bc = (int)(20 * Math.random()) + 1;
        Ca = (int)(20 * Math.random()) + 1;

        //Per maggiore compresione utilizzo una variabile Stringa

        triangle = "AB= " + Ab + " BC= " + Bc + " CA= " + Ca;
        return triangle;
    }

    public static double getPerimeter(){
        return Ab + Bc + Ca;
    }

    public static double getAreA(){
        double halfPerimeter = (Ab +Bc +Ca)/2;
        return Math.sqrt( halfPerimeter * (halfPerimeter - Ab) * (halfPerimeter - Bc) * (halfPerimeter -Ca));
    }
}

class Circle extends Poligono{
    private double radius;
    private static final double piGreco = 3.14159;
    private static double radiuss;

    //Costruttori

    public Circle(double radius) {
        this.radius = radius;
    }

    //Metodi getter

    public double getRadius() {
        return radius;
    }

    public static double getRadiuss() {
        return radiuss;
    }

    //Metodo Area e Perimetro non Statici

    @Override
    public double getPerimetro() {
        return 2 * radius * piGreco;
    }

    @Override
    public double getArea() {
        return Math.pow(radius,2.0) * piGreco;
    }

    //Metodi Statici

    public static String creaCasuale() {
        //Creo il ragiio

        radiuss = (int)(20 * Math.random()) + 1;

        return "r = " + radiuss;
    }

    public static double getPerimeter(){
        return 2 * radiuss * piGreco;
    }

    public static double getAreA(){
        return Math.pow(radiuss,2.0) * piGreco;
    }
}

class ScaffaleDiPoligoni {
    private double shelf;
    private Poligono [] vetPoligoni = new Poligono [10];
    private int cnt = 0;

    //Costruttore
    public ScaffaleDiPoligoni(){}

    //Metodi

    public void sistemaPoligono(Poligono form){

        if(cnt < 10){
            vetPoligoni[cnt] = form;
            cnt++;
        }else {
            System.out.println("Raggiunto limite massimo di Poligoni sullo scaffale")}
    }

    public int getTotPoligoni() {
        return cnt;
    }

    public int getPorzioneOccupata(){

    }
}