Yoruno il 09:13, 3 feb 2006

2006-02-03T09:13:55Z

Nuova pagina

import prog.io.*;
import java.lang.Math;
import java.util.List;
import java.util.LinkedList;
import java.util.Set;
import java.util.HashSet;
import java.util.Iterator;

class Figura3DException extends RuntimeException {
public Figura3DException(String message) {"
super(message);"
}"
}

/**
Questa classe e' stata creata per poter derivare piu' facilmente le sottoclassi"
relative alle varie figure senza apportare modifiche ai metodi fissati di Figura3D."
*/
abstract class Figura3DAutomatica extends Figura3D {
protected double[] prms;"

/**"
Crea una nuova Figura3DAutomatica contenente un numero specificato di parametri."
@param numprms il numero dei parametri della figura"
*/"
public Figura3DAutomatica(int numprms) {"
prms=new double[numprms];"
}"

/**"
Controlla che il parametro fornito sia valido; se non lo e', solleva un'eccezione."
@param parametro il parametro da controllare"
@return il parametro stesso"
*/"
protected double check(double parameter) {"
if(parameter<=0) throw new Figura3DException(this.getClass().getName()+"": Parametro errato!"");"
return parameter;"
}"

/**"
Imposta i parametri relativi ad una figura, effettuando i test di correttezza."
@param param l'array di double contenente i parametri"
*/"
public void setParametri(double[] param) {"
if(param.length==prms.length) {"
for(int i=0; i<param.length; i++) {"
check(param[i]);"
}"
} else throw new Figura3DException(this.getClass().getName()+"": Numero di parametri errato!"");"
prms=(double[])param.clone();"
}"

/**"
Restituisce un'array contenente i parametri della figura."
@return i parametri della figura sotto forma di array di double"
*/"
public double[] getParametri() {"
return (double[])prms.clone();"
}"

/**"
Restituisce una rappresentazione testuale della figura, nel formato:"
NomeFigura: parametro0 = n0, parametro1 = n1, ... parametrom = nm"
@return una rappresentazione testuale della figura"
*/"
public String toString() {"
String stringRepresentation=""Figura3DAutomatica:"";"
for(int i=0; i<prms.length; i++) {"
stringRepresentation+="" parametro""+i+"" = ""+prms[i];"
}"
return stringRepresentation;"
}"

/*
Questo metodo e' stato abbandonato a favore di quello che segue poiche'"
forniva a volte risultati errati, e non avevo voglia di trovare il motivo."

public boolean equals(Object shape) {"
if(!(shape instanceof Figura3DAutomatica)) return false; else {"
double[] shapePrms=((Figura3D)shape).getParametri();"
if(shapePrms.length!=prms.length) return false; else {"
for(int i=0; i<prms.length; i++) {"
if(shapePrms[i]!=prms[i]) return false;"
}"
return true;"
}"
}"
}"
*/

/**"
Confronta la figura con un'altra figura per congruenza."
@param shape la figura da confrontare"
@return true se le due figure sono congruenti, altrimenti false"
*/"
public boolean equals(Object shape) {"
if(!(shape instanceof Figura3DAutomatica)) return false; else {"
if(shape.toString().equals(this.toString())) return true;"
else return false;"
}"
}"
}

class Sfera extends Figura3DAutomatica {
protected final short R=0;"

public Sfera(double r) {"
super(1);"
prms[R]=check(r);"
}"

public double getVolume() {"
return (4.0/3.0)*Math.PI*Math.pow(prms[R], 3);"
}"

public double getSuperficie() {"
return 4.0*Math.PI*Math.pow(prms[R], 2);"
}"

public String toString() {"
return ""Sfera: raggio = ""+prms[R];"
}"
}

class Parallelepipedo extends Figura3DAutomatica {
protected final short A=0;"
protected final short B=1;"
protected final short H=2;"

public Parallelepipedo(double a, double b, double h) {"
super(3);"
prms[A]=check(a);"
prms[B]=check(b);"
prms[H]=check(h);"
}"

public double getVolume() {"
return prms[A]*prms[B]*prms[H];"
}"

public double getSuperficie() {"
return 2*(prms[H]*(prms[A]+prms[B])+prms[A]*prms[B]);"
}"

public String toString() {"
return ""Parallelepipedo: latoA = ""+prms[A]+"", latoB = ""+prms[B]+"", altezza = ""+prms[H];"
}"
}

class Cubo extends Parallelepipedo {
protected final short SIDE=0;"

public Cubo(double side) {"
super(side, side, side);"
}"

public void setParametri(double[] prms) {"
double[] prmsSuper={prms[SIDE], prms[SIDE], prms[SIDE]};"
super.setParametri(prmsSuper);"
}"

public double[] getParametri() {"
double[] prms={super.prms[super.H]};"
return prms;"
}"

public String toString() {"
// Stampo 'raggio' perche' cosi' e' nei risultati di esempio"
return ""Cubo: raggio = ""+prms[SIDE];"
}"
}

class TroncoDiCono extends Figura3DAutomatica {
protected final short R1=0;"
protected final short R2=1;"
protected final short H=2;"

public TroncoDiCono(double r1, double r2, double h) {"
super(3);"
prms[R1]=check(r1);"
prms[R2]=check(r2);"
prms[H]=check(h);"
}"

/**"
Crea un tronco di cono col raggio minore nullo, ad uso esclusivo"
delle sottoclassi."
@param r1 il raggio maggiore"
@param h l'altezza"
*/"
protected TroncoDiCono(double r1, double h) {"
super(3);"
prms[R1]=check(r1);"
prms[R2]=0;"
prms[H]=check(h);"
}"

public double getVolume() {"
return (Math.PI/3.0)*(prms[R1]*prms[R2]+Math.pow(prms[R1], 2)+Math.pow(prms[R2], 2))*prms[H];"
}"

public double getSuperficie() {"
return Math.PI*(prms[R1]+prms[R2])*Math.sqrt(Math.pow(prms[R1]-prms[R2], 2)+Math.pow(prms[H], 2));"
}"

public String toString() {"
return ""Tronco di cono: raggio grande = ""+prms[R1]+"", raggio piccolo = ""+prms[R2]+"", altezza = ""+prms[H];"
}"
}

class Cilindro extends TroncoDiCono {
protected final short R=0;"
protected final short H=1;"

public Cilindro(double r, double h) {"
super(r, r, h);"
}"

public void setParametri(double[] prms) {"
double[] prmsSuper={prms[R], prms[R], prms[H]};"
super.setParametri(prmsSuper);"
}"

public double[] getParametri() {"
double[] prmsSub={prms[super.R1], prms[super.H]};"
return prmsSub;"
}"

public String toString() {"
return ""Cilindro: raggio = ""+prms[super.R1]+"", altezza = ""+prms[super.H];"
}"
}

class Cono extends TroncoDiCono {
protected final short R=0;"
protected final short H=1;"

public Cono(double r, double h) {"
super(r, h);"
}"

public void setParametri(double[] prms) {"
// TroncoDiCono non accetta, da specifiche, 0 come raggio minore"
double[] prmsSuper={prms[R], 1, prms[H]};"
super.setParametri(prmsSuper);"
super.prms[super.R2]=0;"
}"

public double[] getParametri() {"
double[] prmsSub={prms[super.R1], prms[super.H]};"
return prmsSub;"
}"

public String toString() {"
return ""Cono: raggio = ""+prms[super.R1]+"", altezza = ""+prms[super.H];"
}"
}

class TipoNonPrevistoException extends Exception {
public TipoNonPrevistoException(String msg) {"
super(msg);"
}"
}

class Architettura3D {
private List shapes;"

boolean modified=false;"
Set cachedAccountables;"

private double volume;"
private double area;"
private double meanVolume;"
private double meanArea;"

/**"
Crea un nuovo insieme di Figura3D."
*/"
public Architettura3D() {"
shapes=new LinkedList();"
}"

/**"
Aggiunge una figura all'insieme."
@param figura la figura da aggiungere"
*/"
public void addFigura3D(Figura3D figura) {"
shapes.add(figura);"
modified=true;"
}"

/**"
Restituisce un'array contenente le figure appartenenti all'insieme."
@return le figure appartenenti all'insieme"
*/"
public Figura3D[] getFigure3D() {"
Object[] tempArray=shapes.toArray();"
Figura3D[] finalArray=new Figura3D[tempArray.length];"
for(int i=0; i<tempArray.length; i++) {"
finalArray[i]=(Figura3D)tempArray[i];"
}"
return finalArray;"
}"

/**"
Calcola volume totale, area totale, volume medio e area media di quelle figure"
il cui nome di classe e' contenuto nell'insieme accountables sotto forma di stringa,"
o di tutte le figure dell'architettura se accountables e' l'insieme vuoto."
@param accountables i nomi delle classi delle figure da considerare"
*/"
private void calculateOverviewData(Set accountables) {"
int count=0;"
if(modified || !accountables.equals(cachedAccountables)) {"
volume=area=0;"
Iterator i=shapes.iterator();"
while(i.hasNext()) {"
Figura3D shape=(Figura3D)i.next();"
if(accountables.isEmpty() || accountables.contains(shape.getClass().getName())) {"
volume+=shape.getVolume();"
area+=shape.getSuperficie();"
count++;"
}"
}"
// Anche se dovrebbe essere count!=0 sempre, controlliamo ugualmente"
if(count!=0) {"
meanVolume=volume/count;"
meanArea=area/count;"
} else meanVolume=meanArea=0;"
modified=false;"
cachedAccountables=accountables;"
}"
}"

/**"
Crea un insieme di nomi di classi di figure basandosi su una stringa che rappresenta"
un tipo di figure; tale stringa puo' essere: ""SC"", per Sfera e Cilindro; ""PC"", per"
Parallelepipedo e Cubo; ""TC"" per TroncoDiCono e Cono. La stringa ""TUTTE"" fa restituire"
l'insieme vuoto, mentre qualunque altra stringa solleva un'eccezione."
@param tipoFigura la stringa che rappresenta il tipo di figure"
@return l'insieme dei nomi delle classi delle figure rappresentate"
*/"
private Set resolveType(String tipoFigura) throws TipoNonPrevistoException {"
Set accountables=new HashSet();"
if(tipoFigura.equals(""SC"")) {"
accountables.add(""Sfera"");"
accountables.add(""Cilindro"");"
} else if(tipoFigura.equals(""PC"")) {"
accountables.add(""Parallelepipedo"");"
accountables.add(""Cubo"");"
} else if(tipoFigura.equals(""TC"")) {"
accountables.add(""TroncoDiCono"");"
accountables.add(""Cono"");"
} else if(!tipoFigura.equals(""TUTTE"")) {"
throw new TipoNonPrevistoException(""Il tipo ""+tipoFigura+"" non e' previsto!"");"
}"
return accountables;"
}"

/**"
Restituisce il volume totale che raggiungono le figure di tipo tipoFigura."
@param tipoFigura la stringa che rappresenta il tipo di figure"
@return il volume totale"
*/"
public double getVolume(String tipoFigura) throws TipoNonPrevistoException {"
Set accountables=resolveType(tipoFigura);"
calculateOverviewData(accountables);"
return volume;"
}"

/**"
Restituisce la superficie totale che raggiungono le figure di tipo tipoFigura."
@param tipoFigura la stringa che rappresenta il tipo di figure"
@return la superficie totale"
*/"
public double getSuperficie(String tipoFigura) throws TipoNonPrevistoException {"
Set accountables=resolveType(tipoFigura);"
calculateOverviewData(accountables);"
return area;"
}"

/**"
Restituisce il volume medio delle figure presenti nell'architettura."
@return il volume medio"
*/"
public double getVolumeMedio() throws TipoNonPrevistoException {"
Set accountables=resolveType(""TUTTE"");"
calculateOverviewData(accountables);"
return meanVolume;"
}"

/**"
Restituisce il volume medio delle figure presenti nell'architettura."
@return la superficie media"
*/"
public double getSuperficieMedia() throws TipoNonPrevistoException {"
Set accountables=resolveType(""TUTTE"");"
calculateOverviewData(accountables);"
return meanArea;"
}"

/**"
Restituisce un riferimento ad una figura dell'architettura congruente"
a fig, se esiste; altrimenti restituisce il riferimento nullo."
@param fig la figura da cercare nell'architettura"
@return una figura dell'architettura congruente a fig, o null"
*/"
public Figura3D trova(Figura3D fig) {"
int index=shapes.indexOf(fig);"
if(index==-1) return null; else {"
return (Figura3D)shapes.listIterator(index).next();"
}"
} "
}

[[Categoria:Progetti]]

Programmazione/Progetti/Architettura3D/Stesura II - Cronologia

Yoruno il 09:13, 3 feb 2006