Programmazione/Progetti/Architettura3D/Stesura IV

Da WikiDsy.
  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];
      }
  }