Universidad Carlos III de Madrid

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 representacion del objeto
  public String toString() {
    // el signo + para cadenas no significa "suma matematica" sino concatenacion
    return "(" + x + ", " + y + ")";
  }

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

  // metodos 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 = x - otroPunto.getX();
    double 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 mas cercano del array
  public Punto calcularMasCercano(Punto[] otrosPuntos) {
    Punto puntoMasCercano = null;

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

      for (int i = 1; i < otrosPuntos.length; i++) {
        // si encuentro otro mas cercano, lo sustituyo
        double 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[]) {

    // Comprobar el numero de argumentos (el nombre de programa mas 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 {
      double x = Double.parseDouble(args[0]);
      double y = Double.parseDouble(args[1]);

      Punto 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("Esta ubicado en el cuadrante "
          + p.calcularCuadrante());

      Punto[] 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 mas cercano es "
          + p.calcularMasCercano(arrayPuntos));
    } catch (NumberFormatException e) {
      System.out.println("Error en los argumentos de la linea de comandos.");
    }
  }
}
	  

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

  public static void main(String args[]) {

    // Comprobar el numero de argumentos (el nombre de programa mas 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 vertice del triangulo.");
      return;
    }

    // Manejador de excepciones
    try {
      double x1 = Double.parseDouble(args[0]);
      double y1 = Double.parseDouble(args[1]);
      double x2 = Double.parseDouble(args[2]);
      double y2 = Double.parseDouble(args[3]);
      double x3 = Double.parseDouble(args[4]);
      double y3 = Double.parseDouble(args[5]);

      // Se crean los tres vertices y el triangulo
      Punto v1 = new Punto(x1, y1);
      Punto v2 = new Punto(x2, y2);
      Punto v3 = new Punto(x3, y3);
      Triangulo t = new Triangulo(v1, v2, v3);

      // Presentacion de la informacion
      System.out.println("El triangulo tiene como vertices " + v1.toString()
          + ", " + v2.toString() + ", " + v3.toString());

      double[] longitudLados = t.calcularLongitudLados();
      System.out.println("Sus lados miden " + longitudLados[0] + ", "
          + longitudLados[1] + ", " + longitudLados[2]);
    } catch (Exception e) {
      System.out.println("Error en los argumentos de la linea de comandos.");
      return;
    }

  }
}
	  

// 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;
  }
}

	  

Solución

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

import java.io.*;

public class Fecha {

  /**
   * Meses del ano, ordenados, para facilitar la conversion de formato cadena a
   * numero y viceversa
   * 
   * El numero de mes coincidira con la posicion de su nombre en el array mas 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 ano 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 anos son iguales => comparar los meses

      if (mes < fecha.getMes()) {
        resultado = -1;
      } else if (mes > fecha.getMes()) {
        resultado = 1;
      } else { // los meses tambien son iguales => comparar los dias

        if (dia < fecha.getDia()) {
          resultado = -1;
        } else if (dia > fecha.getDia()) {
          resultado = 1;
        } else { // los dias tambien 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 numero de dias de un mes dado
   */
  private int getDiasMes(String mes) throws FechaException {
    return getDiasMes(getMes(mes));
  }

  /**
   * Metodo auxiliar para calcular el numero 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;

  }

  /**
   * Metodo 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 metodo getDiasMes ya comprueba que el mes sea correcto)
    if ((dia <= 0) || (dia > getDiasMes(mes))) {
      throw new FechaException("Dia incorrecto");
    }

  }

  /**
   * Comprueba si un ano es bisiesto Son bisiestos los anos multiplos de 4 que
   * no sean multiplos de 100 y los multiplos 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 ano: ");
        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 numero 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 excepcion FechaException se lanza cuando se intenta generar un objeto
 * Fecha con datos incorrectos
 */
public class FechaException extends Exception {

  /**
   * Constructor sin parametros, genera una excepcion sin mensaje explicativo
   * especifico.
   */
  public FechaException() {
    super(); // se llama al constructor de la clase padre Exception
  }

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