Ejemplo 7 - Utilización de constructores y destructores

Objetivo

Comprender el uso de constructors y destructores para la creación de objetos compuestos

Enunciado

Construya una clase triángulo que tenga un método para visualizar sus coordenadas y otro para devolver su diametro.

Haga que el triángulo se componga de 3 líneas interconectadas. Cada línea se compondrá de dos puntos (origen y destino) con coordenadas reales. Implemente métodos constructores con parámetros para cada clase.
La clase línea deberá tener un método para saber su dimensión (distancia entre los dos puntos). La clase punto deberá tener un método que devuelve la distancia entre un punto y otro. Todas las clases deberán tener un método llamado toString() para devolver un String con los atributos de la figura.

Solución

/**
* Punto es una clase que representa un punto, con sus coordenadas X,Y.
*/
public class Punto{

int X;
int Y;

/**
* Constructor por defecto de la clase
*/
public Punto(){
this.X = 0;
this.Y = 0;
}

/**
* Constructor sobrecargado
*/
public Punto(int X, int Y){
this.X = X;
this.Y = Y;
}

/**
* Retorna el valor de la variable X
*/
public int getX(){
return this.X;
}

/**
* Retorna el valor de la variable Y
*/
public int getY(){
return this.Y;
}

/**
* Establece el valor de la variable X
*/
public void setX(int X){
this.X = X;
}

/**
* Establece el valor de la variable Y
*/
public void setY(int Y){
this.Y = Y;
}

/**
* Retorna la distancia entre 2 puntos, la cual es la hipotenusa del triángulo que forma en el plano
* junto al otro punto p2
* / |
* Distancia --> / |
* / |
* p1-------+
* Si ambos están en una misma Y o misma X se restan sus posiciones
*
* Misma Y p1-----------p2
*
* Misma X p1
* |
* |
* |
* p2
*/
public int distanciaEntrePuntos(Punto p1, Punto p2){
System.out.println("Sacando distancia PUNTO");
/**
* Caso en el cual la X es la misma
*/
if(p1.getX() == p2.getX()){
return (p2.getY() - p1.getY());
}
/**
* Caso en el cual la Y es la misma
*/
if(p1.getY() == p2.getY()){
return (p2.getX() - p1.getX());
}
/**
* Caso en el cual hay que encontrar la hipotenusa
*/
else{
System.out.println("Sacando distancia ELSE PUNTO");
Punto p3 = new Punto(p2.getX(), p1.getY());
int distanciaP1P3 = p3.getX() - p1.getX();
int distanciaP3P2 = p2.getY() - p3.getY();
int hipotenusa = (int)Math.sqrt((Math.pow(distanciaP1P3,2) + Math.pow(distanciaP3P2,2)));
return hipotenusa;
}
}
}

Punto es la clase que compone a Linea, sabe como calcular la distancia entre 2 puntos. Contiene las coordenadas X, Y.

/**
       * Linea representa un línea compuesta de 2 puntos.
       */
       public class Linea{
       /**
       * Punto de origen 
       */
       Punto origen;
       Punto destino; 
 
       /**
       * Constructor por defecto de la clase Linea 
       */
       public Linea(){
       this.origen = new Punto();
       this.destino = new Punto();
       }
 
       /**
       * Constructor sobrecargado
       */
       public Linea(Punto origen, Punto destino){
       this.origen = origen;
       this.destino = destino;
       }
 
       /**
       * Retorna la dimensión de la línea
       */
       public int getDimension(){ 
       Punto temporal = new Punto();
       System.out.println("Sacando dimension linea: "+temporal.distanciaEntrePuntos(origen,        destino));
       return temporal.distanciaEntrePuntos(origen, destino);
       }
       }

Linea está compuesta por 2 puntos, obtiene su dimension a traves de la clase Punto, específicamente a través de distanciaEntrePuntos.

temporal.distanciaEntrePuntos(origen, destino);

import javax.swing.*;
       /**
       * La clase Triangulo representa un triíangulo compuesto de 3        Lineas
       */
       public class Triangulo{
 
       /*
       * Lineas del triíngulo 
       */
       Linea linea1;
       Linea linea2;
       Linea linea3;
 
       /**
       * Constructor por omisión 
       */
       public Triangulo(){
       this.linea1 = new Linea();
       this.linea2 = new Linea();
       this.linea3 = new Linea();
       }
 
       /**
       * Constructor sobrecargado 
       *           
       *          /| 
       *         / |
       * Linea3 /  | Linea 2 
       *       /___|
       *       Linea1
       */
       public Triangulo(Linea linea1, Linea linea2, Linea linea3){
       if(linea1.getDimension() + linea2.getDimension() > linea3.getDimension()){
       System.out.println("Creando un triangulo válido");
       this.linea1 = linea1;
       this.linea2 = linea2;
       this.linea3 = linea3;
       }
       else{ 
       JOptionPane.showMessageDialog(null,"Error", "Error",        JOptionPane.ERROR_MESSAGE);
       System.out.println("Creando un triangulo canónico");
       this.linea1 = new Linea(new Punto(0,0),new Punto(0,0));
       this.linea2 = new Linea(new Punto(0,0),new Punto(0,1));
       this.linea3 = new Linea(new Punto(1,0),new Punto(0,0));
       } 
       } 
 
       }

Triangulo esta formado de 3 lineas, al intentar construir un nuevo Triangulo, se verifica si se cumple con una terna pitagórica.

/**
* Crea instancias de Triangulo.
*/
public class PruebaTriangulo{
public static void main(String args[]){
/**
* Triangulo v´lido.
*/
Punto origen1 = new Punto(1,5);
Punto destino1 = new Punto(3,5);
Linea linea1 = new Linea(origen1, destino1);
Punto origen2 = new Punto(3,5);;
Punto destino2 = new Punto(3,8);
Linea linea2 = new Linea(origen2, destino2);
Punto origen3 = new Punto(1,5);
Punto destino3 = new Punto(3,8);
Linea linea3 = new Linea(origen1, destino1);
Triangulo t1 = new Triangulo(linea1,linea2,linea3);

/**
* Triangulo inv´lido.
*/
origen1 = new Punto(1,5);
destino1 = new Punto(3,5);
linea1 = new Linea(origen1, destino1);
origen2 = new Punto(3,5);;
destino2 = new Punto(3,4);
linea2 = new Linea(origen2, destino2);
origen3 = new Punto(1,5);
destino3 = new Punto(3,8);
linea3 = new Linea(origen1, destino1);
t1 = new Triangulo(linea1,linea2,linea3);
}
}

PruebaTriangulo, crea 2 instancias diferentes de Triangulo, uno de ellos válido, el otro inválido.

La salida esperada es la siguiente:

Código Fuente

Punto.java

Linea.java

Triangulo.java

PruebaTriangulo.java