Programmazione/Progetti/Architettura3D/Stesura IV
Versione del 3 feb 2006 alle 09:17 di Yoruno (discussione | contributi)
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]; } }