Universidad Carlos III de Madrid

Solución

Las soluciones del ejercicio se pueden ver en los siguientes listados:

	      import java.io.*;


public class Fecha {

   /**
    * Meses del año, ordenados, para facilitar la conversión de formato cadena a número y viceversa
    *
    * El número de mes coincidirá con la posición de su nombre en el array más 1
    * (porque las posiciones del array se numeran a partir de 0 pero los meses a partir de 1)
    */
   private static final String[] meses = { "enero", "febrero", "marzo", "abril", "mayo", 
      "junio", "julio", "agosto", "septiembre", "octubre", "noviembre", "diciembre" };


   // ATRIBUTOS
   
   private int dia;
   private int mes;
   private int agno;



   // CONSTRUCTORES
   
   public Fecha(int dia, int mes, int agno) throws FechaException {
      
      comprobarFecha( dia, mes, agno );
   
      this.dia = dia;
      this.mes = mes;
      this.agno = agno;
      
   }

   public Fecha(String sDia, String sNombreMes, String sAgno) throws FechaException {
      
   	// Convertir las cadenas del dia y el año en numeros
      try {
         dia = Integer.parseInt(sDia);
         agno = Integer.parseInt(sAgno);
         
      } catch ( NumberFormatException nfe ) {
         // Error al convertir una cadena en numero
         throw new FechaException( "Fecha incorrecta" );
      }
   
      mes = getMes( sNombreMes );
         
      // Comprobar ademas que los valores tienen sentido
      comprobarFecha( dia, mes, agno );
   
   }


   // ACCESORES
   
   public int getDia() {
      return dia;
   }

   public int getMes() {
      return mes;
   }

   public int getAgno() {
      return agno;
   }

   public void setDia(int dia) throws FechaException {
       comprobarFecha(dia, this.mes, this.agno);
       this.dia = dia;
   }

   public void setMes(int mes) throws FechaException {
       comprobarFecha(this.dia, mes, this.agno);
       this.mes = mes;
   }

   public void setAgno(int agno) throws FechaException {
       comprobarFecha(dia, mes, agno);
       this.agno = agno;
   }



   // METODOS
   
   public String toString() {
      return ( dia + " de " + meses[mes-1] + " de " + agno );
   }

   public int compareTo( Fecha fecha ) {

       int resultado = 0;
   
      if ( agno < fecha.getAgno() ) {
         resultado = -1;
      } 
      else if ( agno > fecha.getAgno() ) {
         resultado = 1;
      } 
      else {		// los años son iguales => comparar los meses
      
         if ( mes < fecha.getMes() ) {
            resultado = -1;
         } 
         else if (mes > fecha.getMes()) {
            resultado = 1;
         } 
         else {		// los meses también son iguales => comparar los dias
         
            if (dia < fecha.getDia()) {
               resultado = -1;
            } 
            else if (dia > fecha.getDia()) {
               resultado = 1;
            } 
            else {		// los dias también son iguales => misma fecha
               resultado = 0;
            }
         }
      }	

      return resultado;
   }


   // METODOS AUXILIARES
   


   /**
    * Devuelve el numero de dias de un mes dado
    */
   private int getDiasMes( int mes ) throws FechaException {
      
      int diasMes = 0;
      
      switch( mes ) {
      
         case 1:
         case 3:
         case 5:
         case 7:
         case 8:
         case 10:
         case 12:		// meses de 31 dias
            diasMes = 31;
            break;
      
         case 4:
         case 6:
         case 9:
         case 11:		// meses de 30 dias
            diasMes = 30;
            break;
      
         case 2:		// febrero
            if (esBisiesto( agno ))
               diasMes = 29;
            else
               diasMes = 28;
            break;
      		
         default:			// mes incorrecto
            throw new FechaException( "Mes incorrecto" );
      }
      
      return diasMes;
   	
   }


   /**
    * Devuelve el número de días de un mes dado
    */
   private int getDiasMes( String mes ) throws FechaException {
      return getDiasMes( getMes(mes) );
   }



   /**
    * Método auxiliar para calcular el número de mes, dado su nombre.
    * Devuelve -1 si el texto introducido no se corresponde con un mes.
    */
   private static int getMes( String sNombreMes ) throws FechaException {

      // Hallar el numero de mes
      int mes = -1;
      for (int i=0; i<meses.length && mes==0; i++) {
         if ( meses[i].equalsIgnoreCase( sNombreMes ) ) {
            // El mes coincide con el elemento actual del array
            mes = i+1;  
         }
      }
      /*
      if (mes == 0) {
         // si el mes introducido no coincide con ninguno de los almacenados 
         // en el array es que hay un error
         throw new FechaException( "Mes incorrecto" );
      }
      */
      
      return mes;
      
   }
   

   /**
    * Método auxiliar para comprobar que una fecha es correcta
    */
   private void comprobarFecha( int dia, int mes, int agno ) throws FechaException {

      // Comprobar que el dia es correcto
      // (El método getDiasMes ya comprueba que el mes sea correcto)
      if ( (dia <= 0) || (dia > getDiasMes(mes)) ) {
         throw new FechaException( "Dia incorrecto" ); 
      }
   	
   }


	/**
	 * Comprueba si un año es bisiesto
	 * Son bisiestos los años múltiplos de 4 que no sean múltiplos de 100
	 * y los múltiplos de 400
	 */
   private boolean esBisiesto( int agno ) {
      return (( ((agno % 4) == 0) && ((agno % 100) != 0) ) 
             || ((agno % 400) == 0) );
   }

   public static Fecha leerFecha() {

       BufferedReader entrada = new BufferedReader( new InputStreamReader( System.in ) );
       Fecha fecha = null;
       String sDia, sMes, sAgno;	// Variables para almacenar la entrada del usuario
       int iMes;

       boolean correcto = false;

       do {

	   try {

	       System.out.print("Introduzca dia: ");
	       System.out.flush();
	       sDia = entrada.readLine();
	       System.out.print("Introduzca mes: ");
	       System.out.flush();
	       sMes = entrada.readLine();
	       System.out.print("Introduzca año: ");
	       System.out.flush();
	       sAgno = entrada.readLine();

	       // Probamos si el usuario ha introducido el nombre del mes
	       iMes = getMes(sMes);         

	       if (iMes == -1) {
		   // Probamos si el usuario ha introducido el número de mes
		   iMes = Integer.parseInt(sMes);
	       }

	       fecha = new Fecha( sDia, meses[iMes], sAgno );
	       correcto = true;

	   } catch (Exception ex) {
	       correcto = false;
	   }


       } while (!correcto);


       return fecha;
   }

    public Fecha fechaMasReciente(Fecha[] fechas) {

	Fecha fecha = null;

	if ((fechas != null) && (fechas.length > 0)) {
	    
	    int max = 0;
	    for (int i=1; i<fechas.length; i++) {
		if (fechas[max].compareTo(fechas[i]) < 0) {
		    max = i;
		}
	    }
	    fecha = fechas[max];
	}

	return fecha;
	
    }

}

	  

	      /**
 * La excepción FechaException se lanza cuando se intenta
 * generar un objeto Fecha con datos incorrectos
 */
public class FechaException extends Exception {

	/** 
	 * Constructor sin parámetros,
	 * genera una excepción sin mensaje explicativo específico.
	 */
	public FechaException() {
		super();	// se llama al constructor de la clase padre Exception
	}

	/** 
	 * Constructor con parámetros,
	 * genera una excepción con un mensaje explicativo del error.
	 *
	 * @param mensaje explicativo del error que ha generado la excepción
	 */
	public FechaException( String mensaje ) {
		super( mensaje );	// se llama al constructor de la clase padre Exception
	}
}
	  

Soluciones

Las soluciones del ejercicio se pueden ver en el siguiente listado:

// Clase Punto
// (c) 2008 IT

public class Punto {
  private double x;
  private double y;

  // Constructor
  public Punto(double x, double y) {
    this.x = x;
    this.y = y;
  }

  // toString: devuelve una cadena con la representación del objeto
  public String toString() {
    // el signo + para cadenas no significa "suma matemática" sino concatenación
    return "("+x+", "+y+")";
  }

  // devuelve la distancia al origen
  // NOTA: se podría haber hecho con la distancia a (0,0):
  //   return calcularDistancia(new Punto(0,0));
  public double distanciaAlOrigen() {
    return Math.sqrt(x*x+ y*y);
  }

  // métodos de acceso
  public double getX() {
    return x;
  }
  public double getY() {
   return y;
  }

  // devuelve la distancia a otro punto
  public double calcularDistancia(Punto otroPunto) {
    double x1;
    double y1;
    
    x1 = x-otroPunto.getX();
    y1 = y-otroPunto.getY();
    return Math.sqrt(x1*x1+y1*y1);
  }

  // devuelve el cuadrante
  public int calcularCuadrante() {
    if(x>0.0 && y>0.0)
      return 1;
    else if(x<0.0 && y>0.0)
      return 2;
    else if(x<0.0 && y<0.0)
      return 3;
    else if(x>0.0 && y<0.0)
      return 4;
    else // (x==0.0 || y==0.0)
      return 0;
  }

  // calcula el punto más cercano del array
  public Punto calcularMasCercano(Punto[] otrosPuntos) {
    Punto puntoMasCercano = null;
    double distanciaMinima;
    double distancia;

    if(otrosPuntos!=null && otrosPuntos.length>0) {
      // me guardo el primero como más cercano
      distanciaMinima = calcularDistancia(otrosPuntos[0]);
      puntoMasCercano = otrosPuntos[0];

      for(int i=1; i<otrosPuntos.length; i++) {
        // si encuentro otro más cercano, lo sustituyo
        distancia = calcularDistancia(otrosPuntos[i]);
        if(distancia<distanciaMinima) {
          distancia = distanciaMinima;
          puntoMasCercano = otrosPuntos[i];
        }
      }
    }
    // devuelve el punto encontrado si el array contiene puntos, null en caso contrario
    return puntoMasCercano;
  }
}

	  

// Clase de prueba de Punto
// (c) 2007 IT
public class Prueba {

  public static void main(String args[]) {
    double x;
    double y;
    Punto p;
    Punto arrayPuntos[];

    // Comprobar el número de argumentos (el nombre de programa más las dos coordenadas)
    if(args.length!=2) {
      System.out.println("Uso:");
      System.out.println("  java Prueba x y");
      System.out.println("donde x e y son las cooordenadas de un punto en el espacio.");
      return;
    }

    // Manejador de excepciones
    try {
      x = Double.parseDouble(args[0]);
      y = Double.parseDouble(args[1]);
    } catch(Exception e) {
      System.out.println("Error en los argumentos de la línea de comandos.");
      return;
    }

    p = new Punto(x, y);
    System.out.println("El punto es "+p.toString());
    System.out.println("Su distancia al origen es "+p.distanciaAlOrigen());
    System.out.println("Su coordenada x es "+p.getX()+" y su coordenada y es "+p.getY());

    System.out.println("Está ubicado en el cuadrante "+p.calcularCuadrante());

    arrayPuntos = new Punto[5];
    arrayPuntos[0] = new Punto(1,1);
    arrayPuntos[1] = new Punto(5,3);
    arrayPuntos[2] = new Punto(10,10);
    arrayPuntos[3] = new Punto(-3,2);
    arrayPuntos[4] = new Punto(-4,-5);

    for(int i=0; i<arrayPuntos.length; i++)
      System.out.println("Su distancia al punto "+arrayPuntos[i].toString()+" es "+p.calcularDistancia(arrayPuntos[i]));

    System.out.println("El punto más cercano es "+p.calcularMasCercano(arrayPuntos));

  }
}
	  

// Clase de prueba de Triangulo
// (c) 2007 IT
public class PruebaTriangulo {

  public static void main(String args[]) {
    double x1;
    double y1;
    double x2;
    double y2;
    double x3;
    double y3;
    Punto v1;
    Punto v2;
    Punto v3;
    Triangulo t;
    double longitudLados[];

    // Comprobar el número de argumentos (el nombre de programa más las dos coordenadas)
    if(args.length!=6) {
      System.out.println("Uso:");
      System.out.println("  java PruebaTriangulo x1 y1 x2 y2 x3 y3");
      System.out.println("donde (xi,yi) son las cooordenadas de cada vértice del triángulo.");
      return;
    }

    // Manejador de excepciones
    try {
      x1 = Double.parseDouble(args[0]);
      y1 = Double.parseDouble(args[1]);
      x2 = Double.parseDouble(args[2]);
      y2 = Double.parseDouble(args[3]);
      x3 = Double.parseDouble(args[4]);
      y3 = Double.parseDouble(args[5]);
    } catch(Exception e) {
      System.out.println("Error en los argumentos de la línea de comandos.");
      return;
    }

    // Se crean los tres vértices y el triángulo
    v1 = new Punto(x1, y1);
    v2 = new Punto(x2, y2);
    v3 = new Punto(x3, y3);
    t = new Triangulo(v1, v2, v3);

    // Presentación de la información
    System.out.println("El triángulo tiene como vértices "+v1.toString()+", "+v2.toString()+", "+v3.toString());

    longitudLados = t.calcularLongitudLados();
    System.out.println("Sus lados miden "+longitudLados[0]+", "+longitudLados[1]+", "+longitudLados[2]);
  }
}
	  

// Clase Triangulo
// (c) 2007 IT
public class Triangulo {

  private Punto vertice1;
  private Punto vertice2;
  private Punto vertice3;

  public Triangulo(Punto vertice1, Punto vertice2, Punto vertice3) {
    this.vertice1 = vertice1;
    this.vertice2 = vertice2;
    this.vertice3 = vertice3;
  }

  public double[] calcularLongitudLados() {
    double longitudLados[] = new double[3];
 
    // longitud 1->2
    longitudLados[0] = vertice1.calcularDistancia(vertice2);  
    // longitud 2->3
    longitudLados[1] = vertice2.calcularDistancia(vertice3);
    // longitud 3->1
    longitudLados[2] = vertice3.calcularDistancia(vertice1);

    return longitudLados;
  }
}