Yoruno il 09:15, 3 feb 2006

2006-02-03T09:15:59Z

Nuova pagina

import java.lang.Math;
import prog.utili.Sequenza;

class Architettura3D {

private Sequenza figure;

/**Crea un nuovo oggetto di Architetture3D.*/
public Architettura3D() {
figure = new Sequenza();
}

/**Inserisce un oggetto di tipo Figura3D in un insieme*/
public void addFigura3D(Figura3D figura) {
figure.add(figura);
}

//**Restituisce un array contenente tutte le figure 3D inserite nell'oggetto che esegue il metodo*/
public Figura3D[] getFigure3D() {
Figura3D[] arrayFigure = new Figura3D[figure.size()];
Object[] arrayObject = figure.toArray();
for (int i = 0; i <= figure.size()-1; i++) {
arrayFigure[i] = (Figura3D)(arrayObject[i]);
}
return arrayFigure;
}

/**Restituisce il volume totale del tipo di figure specificate dall'argomento tipoFigura tra tutte quelle inserite fino al momento dell'invocazione del metodo.
*Stringhe valide per tale argomento sono le seguenti:
*SC (oggetti di tipo Sfera e Cilindro)
*PC (oggetti di tipo Parallelepipedo e Cubo)
*TC (oggetti di tipo Cono e TroncoDiCono)
*TUTTE (tutti gli oggetti)*/
public double getVolume(String tipoFigura) throws TipoNonPrevistoException {
double volumeTotale = 0;
Figura3D[] arrayFigure = new Figura3D[figure.size()];
arrayFigure = this.getFigure3D();
if (tipoFigura.equals("SC"))
for (int i = 0; i <= (arrayFigure.length)-1; i++) {
if (arrayFigure[i] instanceof Cilindro)
volumeTotale+=arrayFigure[i].getVolume();
}
else if (tipoFigura.equals("PC"))
for (int i = 0; i <= (arrayFigure.length)-1; i++) {
if (arrayFigure[i] instanceof Parallelepipedo)
volumeTotale+=arrayFigure[i].getVolume();
}
else if (tipoFigura.equals("TC"))
for (int i = 0; i <= (arrayFigure.length)-1; i++) {
if (arrayFigure[i] instanceof TroncoDiCono)
volumeTotale+=arrayFigure[i].getVolume();
}
else if (tipoFigura.equals("TUTTE"))
for (int i = 0; i <= (arrayFigure.length)-1; i++)
volumeTotale+=arrayFigure[i].getVolume();
else throw new TipoNonPrevistoException("Il tipo "+tipoFigura+" non è previsto");
return volumeTotale;
}

/**Restituisce la superficie totale del tipo di figure specificate dall'argomento tipoFigura tra tutte quelle inserite fino al momento dell'invocazione del metodo.
*Stringhe valide per tale argomento sono le seguenti:
*SC (oggetti di tipo Sfera e Cilindro)
*PC (oggetti di tipo Parallelepipedo e Cubo)
*TC (oggetti di tipo Cono e TroncoDiCono)
*TUTTE (tutti gli oggetti)*/
public double getSuperficie(String tipoFigura) throws TipoNonPrevistoException {
double superficieTotale = 0;
Figura3D[] arrayFigure = new Figura3D[figure.size()];
arrayFigure = this.getFigure3D();
if (tipoFigura.equals("SC"))
for (int i = 0; i <= arrayFigure.length-1; i++) {
if (arrayFigure[i] instanceof Cilindro)
superficieTotale+=arrayFigure[i].getSuperficie();
}
else if (tipoFigura.equals("PC"))
for (int i = 0; i <= arrayFigure.length-1; i++) {
if (arrayFigure[i] instanceof Parallelepipedo)
superficieTotale+=arrayFigure[i].getSuperficie();
}
else if (tipoFigura.equals("TC"))
for (int i = 0; i <= arrayFigure.length-1; i++) {
if (arrayFigure[i] instanceof TroncoDiCono)
superficieTotale+=arrayFigure[i].getSuperficie();
}
else if (tipoFigura.equals("TUTTE"))
for (int i = 0; i <= arrayFigure.length-1; i++)
superficieTotale+=arrayFigure[i].getSuperficie();
else
throw new TipoNonPrevistoException("Il tipo "+tipoFigura+" non è previsto");
return superficieTotale;
}

/**Restituisce il valore medio calcolato su tutti i volumi delle figure inserite.*/
public double getVolumeMedio() {
double volumeMedio = 0;
try {
volumeMedio = this.getVolume("TUTTE")/this.getFigure3D().length;
} catch (TipoNonPrevistoException e) {
System.out.println(e.toString());
}
return volumeMedio;
}

/**Restituisce il valore medio calcolato su tutte le superfici delle figure inserite*/
public double getSuperficieMedia() {
double superficieMedia = 0;
try {
superficieMedia = this.getSuperficie("TUTTE")/this.getFigure3D().length;
} catch (TipoNonPrevistoException e) {
System.out.println(e.toString());
}
return superficieMedia;
}

/**Effettua la ricerca della figura specificata dall'argomento tra tutte quelle inserite nell'oggetto che esegue il metodo.
*Restituisce il riferimento alla prima occorrenza della figura nel caso in cui venga trovata, null altrimenti.*/
public Figura3D trova(Figura3D fig) {
return (Figura3D)(figure.find((Object)fig));
}
}

class Figura3DException extends RuntimeException {

public Figura3DException() {
}

public Figura3DException(String s) {
super(s);
}

}

class TipoNonPrevistoException extends Exception {

public TipoNonPrevistoException() {
}

public TipoNonPrevistoException(String s) {
super(s);
}
}

class Parallelepipedo extends Figura3D {

private double[] par = new double[3];

/**Crea una figura 3d del tipo Parallelepipedo.
* @throws Figura3DException quando il valore di almeno uno dei parametri non è valido.*/
public Parallelepipedo(double latoA, double latoB, double altezza) throws Figura3DException {
if (latoA <= 0 || latoB <= 0 || altezza <= 0)
throw new Figura3DException(this.getClass().getName()+": Parametri Errati");
else {
par[0] = latoA;
par[1] = latoB;
par[2] = altezza;
}
}

/**Restituisce i parametri dimensionali che definicono la figura 3D.
* @param param un array contenente i valori dei nuovi parametri.*/
public double[] getParametri() {
return par;
}

/**Restituisce la superficie della figura 3D.*/
public double getSuperficie() {
return 2*(par[2]*(par[0]+par[1])+par[0]*par[1]);
}

/**Restituisce il volume della figura 3D.*/
public double getVolume() {
return par[0]*par[1]*par[2];
}

/**Modifica i parametri dimensionali che definicono la figura 3D.
* @param param un array contenente i valori dei nuovi parametri.
* @throws Figura3DException quando il valore di almeno uno dei parametri non è valido.*/
public void setParametri(double[] param) throws Figura3DException {
if (param.length == 3 && param[0] > 0 && param[1] > 0 & param[2] > 0) {
par[0] = param[0];
par[1] = param[1];
par[2] = param[2];
}
else
throw new Figura3DException(this.getClass().getName()+": Parametri Errati");
}

/**Stampa una stringa contenente i parametri che definiscono la figura 3D.*/
public String toString() {
return "Parallelepipedo: latoA = "+par[0]+", latoB = "+par[1]+", altezza = "+par[2];
}

/**Confronta due parallelepipedi.*/
public boolean equals(Parallelepipedo parall) {
return parall.getParametri() == this.getParametri();
}

/**Confronta un oggetto con un Parallelepipedo.*/
public boolean equals(Object obj) {
if(obj instanceof Parallelepipedo) {
Parallelepipedo parall = (Parallelepipedo)obj;
return this.equals(parall);
} else {
return false;
}
}
}

class Cubo extends Parallelepipedo {

/**Crea una figura 3d del tipo Cubo.*/
public Cubo(double l) {
super(l, l, l);
}

/**Stampa una stringa contenente i parametri che definiscono la figura 3D.*/
public String toString() {
double[] param = super.getParametri();
return "Cubo: lato = "+param[0];
}
}

class TroncoDiCono extends Figura3D {

private double[] par = new double[3];

/**Crea una figura 3d del tipo Tronco di Cono.
* @throws Figura3DException quando il valore di almeno uno dei parametri non è valido.*/
public TroncoDiCono(double raggioMag, double raggioMin, double altezza) throws Figura3DException {
if (raggioMag <= 0 || raggioMin < 0 || altezza <= 0)
throw new Figura3DException(this.getClass().getName()+": Parametri Errati");
else {
par[0] = raggioMag;
par[1] = raggioMin;
par[2] = altezza;
}
}

/**Restituisce i parametri dimensionali che definicono la figura 3D.
* @param param un array contenente i valori dei nuovi parametri.*/
public double[] getParametri() {
return par;
}

/**Restituisce la superficie della figura 3D.*/
public double getSuperficie() {
return Math.PI*(par[0]+par[1])*Math.sqrt((par[0]-par[1])*(par[0]-par[1])+par[2]*par[2]);
}

/**Restituisce il volume della figura 3D.*/
public double getVolume() {
return Math.PI/3*(par[0]*par[1]+par[0]*par[0]+par[1]*par[1])*par[2];
}

/**Modifica i parametri dimensionali che definicono la figura 3D.
* @param param un array contenente i valori dei nuovi parametri.
* @throws Figura3DException quando il valore di almeno uno dei parametri non è valido.*/
public void setParametri(double[] param) throws Figura3DException {
if (param.length == 3 && param[0] > 0 && param[1] >= 0 & param[2] > 0) {
par[0] = param[0];
par[1] = param[1];
par[2] = param[2];
}
else
throw new Figura3DException(this.getClass().getName()+": Parametri Errati");
}

/**Stampa una stringa contenente i parametri che definiscono la figura 3D*/
public String toString() {
return "Tronco di cono: raggio grande = "+par[0]+", raggio piccolo = "+par[1]+", altezza = "+par[2];
}

/**Confronta due tronchi di cono.*/
public boolean equals(TroncoDiCono tronco) {
return tronco.toString().equals(this.toString());
}

/**Confronta un oggetto di Object con un Tronco di cono.*/
public boolean equals(Object obj) {
if(obj instanceof TroncoDiCono) {
TroncoDiCono tronco = (TroncoDiCono)obj;
return this.equals(tronco);
} else {
return false;
}
}
}

class Cono extends TroncoDiCono {

/**Crea una figura 3d del tipo Cono.*/
public Cono(double raggio, double altezza) {
super(raggio, 0, altezza);
}

/**Restituisce il volume della figura 3D.*/
public double getVolume() {
double[] param = super.getParametri();
return Math.PI/3*param[0]*param[0]*param[2];
}

/**Stampa una stringa contenente i parametri che definiscono la figura 3D, separati da uno spazio.*/
public String toString() {
double[] param = super.getParametri();
return "Cono: raggio = "+param[0]+", altezza = "+param[2];
}
}

class Cilindro extends Figura3D {

private double[] par = new double[2];

/**Crea una figura 3d del tipo Cilindro.
* @throws Figura3DException quando il valore di almeno uno dei parametri non è valido.*/
public Cilindro(double raggio, double altezza) throws Figura3DException {
if (raggio <= 0 || altezza <= 0)
throw new Figura3DException(this.getClass().getName()+": Parametri Errati");
else {
par[0] = raggio;
par[1] = altezza;
}
}

/**Restituisce i parametri dimensionali che definicono la figura 3D.
* @param param un array contenente i valori dei nuovi parametri.*/
public double[] getParametri() {
return par;
}

/**Restituisce la superficie della figura 3D.*/
public double getSuperficie() {
return 2*Math.PI*par[0]*par[1];
}

/**Restituisce il volume della figura 3D.*/
public double getVolume() {
return Math.PI*par[0]*par[0]*par[1];
}

/**Modifica i parametri dimensionali che definicono la figura 3D.
* @param param un array contenente i valori dei nuovi parametri.
* @throws Figura3DException quando il valore di almeno uno dei parametri non è valido.*/
public void setParametri(double[] param) throws Figura3DException {
if (param.length == 2 && param[0] > 0 && param[1] > 0) {
par[0] = param[0];
par[1] = param[1];
}
else
throw new Figura3DException(this.getClass().getName()+": Parametri Errati");
}

/**Stampa una stringa contenente i parametri che definiscono la figura 3D, separati da uno spazio.*/
public String toString() {
return "Cilindro: raggio = "+par[0]+", altezza = "+par[1];
}

/**Confronta due cilindri.*/
public boolean equals(Cilindro cil) {
return par[0] == cil.par[0] && par[1] == cil.par[1];
}

/**Confronta un oggetto di Object con un Cilindro.*/
public boolean equals(Object obj) {
if(obj instanceof Cilindro) {
Cilindro cil = (Cilindro)obj;
return equals(cil);
} else {
return false;
}
}
}

class Sfera extends Cilindro {

/**Crea una figura 3d del tipo Sfera.*/
public Sfera(double raggio) {
super(raggio, raggio);
}

/**Restituisce la superficie della figura 3D.*/
public double getSuperficie() {
double[] param = super.getParametri();
return 4*Math.PI*param[0]*param[0];
}

/**Restituisce il volume della figura 3D.*/
public double getVolume() {
double[] param = super.getParametri();
return 4*Math.PI/3*param[0]*param[0]*param[0];
}

/**Stampa una stringa contenente i parametri che definiscono la figura 3D.*/
public String toString() {
double[] param = super.getParametri();
return "Sfera: raggio = "+param[0];
}
}

[[Categoria:Progetti]]

Programmazione/Progetti/Architettura3D/Stesura IV - Cronologia

Yoruno il 09:15, 3 feb 2006