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
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.
*/
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
codice:
/*
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
codice:
/*
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
codice:
/*
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
codice:
/*
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
codice:
/*
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.
- In che altro modo lo posso fare??
- 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?
Rispondi quotando
Originariamente inviata da megaorso
