Programma OOP, consiglii/aiuto completamento

[megaorso]

Ricapitolando, ho corretto un po' di cose, ed ora la classe Triangolo, Cerchio, Punto, e Rettangolo dovrebbere essere giuste, ho aggiunto un nuovo metodo per trovare l'ingombro minimo per ogni classe (mi serivirà per la classe Scaffale di poligoni.

PUNTO

/*
Realizza la classe Punto con tutti i metodi che ritieni opportuni più il metodo (statico) creaCasuale()
che crea un punto casuale e lo restituisce.
 */

class Punto {
    private int x;
    private int y;


    //Costruttore

    public Punto() {
    }

    public Punto(int x, int y) {
        this.x = x;
        this.y = y;
    }

    //Getter e Setter di x,y

    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 int CalcDistanza(Punto A, Punto B){
        //Distanza tra 2 punti
        int AB = (int) Math.sqrt( Math.pow( (B.getX() - A.getX() ), 2 ) + Math.pow( (B.getY() - A.getY() ) , 2) );
        return AB;
    }

    //Metodo creazione punto casuale

    public static Punto creaCasuale() {

        //Crea Punto Casuale
        Punto staticPunto = new Punto( (int) (20 * Math.random()), (int) (20 * Math.random()));

        return staticPunto;
    }
}

POLIGONO

/*
Successivamente crea la superclasse astratta Poligono che ha i
metodi getPerimetro () e getArea(). Da questa classe derivano le classi Cerchio, Rettangolo e Triangolo.
 */
abstract class Poligono {

    //Metodi astratti

    public abstract double getPerimetro();
    public abstract double getArea();
    public abstract double ingombroMin();

}

RETTANGOLO

/*
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.
 */
class Rettangolo extends Poligono{
    private double AB, BC;

    //Costruttori

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

    public double getAB() {
        return AB;
    }

    public double getBC() {
        return BC;
    }

    //Metodi Perimetro e Area

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

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

    //Metodo Static creaCasuale

    public static Rettangolo creaCasuale() {
        //Creo Rettangolo casuale

        Rettangolo RetCasuale = new Rettangolo((20 * Math.random()) + 1, (20 * Math.random()) + 1);

        return RetCasuale;
    }

    //metodo per trovare il lato più corto

    public double ingombroMin(){
        double min = Math.min(getAB(),getBC());
        return min;
    }

    public String toString(){
        return "[Rettangolo " + "AB=" + AB + " BC=" + BC + " Perimetro=" + getPerimetro() + "cm " + "Area=" + getArea() + "cm^2]";
    }
}

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.
 */
class Triangolo extends Poligono {
    private double AB, BC, CA;

    //Costruttore

    public Triangolo(Punto A, Punto B, Punto C) {

        //Formula distanza tra due punti

        AB = A.CalcDistanza(A, B);
        BC = B.CalcDistanza(B, C);
        CA = C.CalcDistanza(C, A);
    }

    //Metodi getter

    public double getAB() {
        return AB;
    }

    public double getBC() {
        return BC;
    }

    public double getCA() {
        return CA;
    }

    //Metodi Perimetro e Area

    @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 creaCasuale

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

        Triangolo TriCasuale = new Triangolo(Punto.creaCasuale(), Punto.creaCasuale(), Punto.creaCasuale());

        return TriCasuale;
    }

    //metodo per trovare il lato più corto

    public double ingombroMin(){
        double min = Math.min(getAB(),getBC());
        min = Math.min(min, getCA());
        return min;
    }

    public String toString(){
        return "[Triangolo AB=" + AB + " BC=" + BC + "CA= " +CA+ " Perimetro=" + getPerimetro() + "cm " + "Area=" + getArea() + "cm^2]";
    }
}

CERCHIO

/*
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.
 */

class Cerchio extends Poligono{
    private double radius;
    private Punto vertice;

    //Costruttori

    public Cerchio(double radius, Punto vertice) {
        this.vertice = vertice;
        this.radius = radius;
    }

    //Metodi getter

    public double getRadius() {
        return radius;
    }

    public Punto getVertice() {
        return vertice;
    }

    //Metodo Area e Perimetro

    @Override
    public double getPerimetro() {
        return 2 * radius *  Math.PI;
    }

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

    //Metodi Statici

    public static Cerchio creaCasuale() {

        Cerchio CerCasuale = new Cerchio(((20 * Math.random()) + 1), Punto.creaCasuale());

        return CerCasuale;
    }

    //metodo per trovare il lato più corto

    public double ingombroMin(){
       return radius*2;
    }

    public String toString(){
        return "[Cerchio " + "V(" + vertice.getX()+","+ vertice.getY()+")" + " r=" + radius + " Perimetro=" + getPerimetro() + "cm " + "Area=" + getArea() + "cm^2]";
    }
}

a questo punto ho iniziato l'ultima classe ossia

/*
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.
*/
class ScaffaleDiPoligoni {
    private double shelf;
    private Poligono [] vetPoligoni = new Poligono [10];
    private int cnt = 0;

    //Costruttore
    public ScaffaleDiPoligoni(){}

    //Metodi

    public void sistemaPoligono(Poligono form){

            vetPoligoni[cnt] = form;
            cnt++;
            shelf += form.ingombroMin();

    }

    public int getTotPoligoni() {
        return cnt;
    }

    public int getPorzioneOccupata(){
        return (int) shelf;
    }

    public Poligono getPoligono(int i){
        return vetPoligoni[i];
    }


    public String toString(){
        for(int i=0; i <= cnt; i++) {
            return vetPoligoni[i].toString();
        }
    }
}

funziona tutto (non so se sia consettualmente corretto e chiaro), tranne il toString che deve restiture la lista dei poligoni inseriti, ho provato a farlo ma non funziona poichè restituisce un errore al return.

1. In che altro modo lo posso fare??
2. Dovrei teriocamente sulla classe, getPoligono, sistemaPoligono gestire delle eccezioni in caso l'array sia pieno oppure si richieda un elemento di indice i non presente?

[andbin]

    public String toString(){
        for(int i=0; i <= cnt; i++) {
            return vetPoligoni[i].toString();
        }
    }

E questo è sbagliato concettualmente, oltre al fatto che non compila proprio. Il compilatore non sa quale sarà il flusso di esecuzione del metodo toString a runtime. Sa però che il for ha una condizione che in teoria "potrebbe" essere subito false e quindi il corpo potrebbe non venire neanche eseguito. E il metodo resterebbe sguarnito di un return, che invece ci deve essere.

Il for ti serve ma per comporre una stringa, non per restituire subito una stringa!