Hola.
No necesitas tantos atributos para la clase Segmento. "Pendiente" no tiene porque ser un atributo, tan solo necesitamos un método que la calcule.
De hecho, solo necesitas dos atributos: el Punto izquierdo y el Punto derecho.
Sobre el constructor.
Para asignar los Puntos no es necesario que hagas hagas un new Punto con sus datos X e Y.
En principio, podría bastarnos con una simple asignacion:
Ahora bien, voy a explicar una cosa sin extenderme mucho (lo intentaré), que podría justificar el hecho de EVITAR una simple asignacion.
Espero no liarte más con esto que explico ahora...
En Java los objetos se pasan por REFERENCIA.
Esto significa que si al constructor de Segmento le paso un Punto y lo recojo con una simple asignacion, en realidad el atributo Punto de este Segmento no tiene una COPIA del Punto recibido, sino una REFERENCIA.. algo así como un enlace, un link...
Significa que si durante el programa yo modifico ese Punto, por algun motivo, también estaré modificando el atributo del Segmento sin darme cuenta. Y posiblemente yo no quiero que esto suceda.
Mira este pequeño código de ejemplo:
Primero creo un Punto.
Luego creo un Segmento, usando este Punto como primer parametro, y un Nuevo Punto como segundo parametro.
Luego muestro en pantalla los datos del Segmento, estos son, los valores X e Y de cada uno de sus Puntos.
Luego, modifico el Punto. Atención, yo no modifico el Segmento,
modifico el Punto
Y tras esta modificacion, vuelvo a mostrar otra vez los datos del Segmento que, repito, NO LO HE MODIFICADO.
Mira que salida obtengo:
Oh shit!!!
El Segmento también se ha visto modificado. Yo no lo he tocado, yo toqué el Punto.
Pero como el atributo del Segmento tiene una REFERENCIA a este Punto, todo lo que le ocurra a este Punto, se verá reflejado en el atributo del Segmento.
Lo normal es que yo no desee que esto ocurra. De hecho, se ha producido una inconsistencia. Al modificar el Punto y verse afectado el Segmento, ahora el Punto IZquierdo del Segmento tiene un valor X que en realidad le situaría en la Derecha y no en la Izquierda.
Total, que ha ocurrido un desastre. Y se debe a que en el constructor de Segmento, hemos usado una simple asignacion para recoger los parametros.
Para evitar este desastre, se puede justificar hacer lo que TU habías hecho. Crear nuevos Puntos a partir de los parametros recibidos, de este modo, ya no tenemos "peligrosas" REFERENCIAS, sino auténticas COPIAS de los valores recibidos.
Sin embargo, acuerdate de que la clase Punto ya le escribimos un metodo para crear copias de sí mismo (probablemente ya preveyendo este problema que he relatado aquí).
Así que tu constructor, siendo correcto, se puede simplificar de este modo.
Ahora ya no asignamos REFERENCIAS a los objetos recibidos por parametros.
Ahora lo que asignamos son COPIAS.
¿Volverá a ocurrir de nuevo el problema de que al modificar el Punto original se ve afectado también el Segmento?
Vamos a comprobarlo.
Si ejecutamos el mismo codigo de antes, ahora ya con el nuevo constructor para Segmento:
Obtenemos esta salida:
¡¡Aja!! Ahora sí está bien. Modificar el Punto ya no afecta para nada al Segmento.
Y bueno, aclarado este tema para el constructor, vamos a pasar a los metodos.
El de calcular la pendiente.
Como dije antes, no necesitamos que este valor sea un atributo.
Solo necesitamos un metodo que lo calcule.
Y este metodo no tiene que recibir "otros Puntos" por parametros. Ha de calcular la pendiente usando los Puntos que tenemos como atributos.
Ya está, es tan sencillo como esto. Yo he preferido que calcule el valor y lo retorne como un double.
Otra opcion puede ser que lo muestre en pantalla directamente con System.out.
Sin embargo, en teoría, es posible que un matemático quiera hacer calculos con el valor de la pendiente, así que necesitará recibir el valor numérico, y no un simple texto en pantalla.
Aún quedan dos metodos más por desarrollar.
El método sonConsecutivos.
Este método sí ha de recibir "otro Segmento" por parametro.
Y ha de comprobar si le punto Izquierdo del "otro Segmento", coincide con el punto Derecho de ESTE segmento.
Si coinciden, es que son consecutivos, porque donde acaba este, comienza el otro.
Pero para hacer esta comparacion se nos plantea un pequeño problema. ¿Cómo podemos ver los Puntos de "otro Segmento"?
Estos atributos son privados (private), es decir, un objeto Segmento puede ver sus propios Puntos, pero no puede ver los Puntos de otro objeto Segmento distinto.
Para que si puedan verse, tenemos que añadirle a la clase Segmento un par de getters que nos devuelvan los Puntos, para que así poder superar esta "privacidad" y que los objetos Segmento puedan mostrar sus Puntos a otros objetos y así poder compararlos.
Asi que , añadimos getters:
Y ahora sí, podemos comprobar si un segmento recibido por parametro, es consecutivo de ESTE segmento.
Que por cierto, para hacerlo, nos ayudamos el metodo sonIguales() que escribimos anteriormente para la clase Punto.
Si el punto Derecho de ESTE segmento, es igual al punto IZquierdo del OTRO Segmento, es que son CONSECUTIVOS.
El otro metodo nos pide comprobar si dos segmentos son iguales.
Es parecido a lo que acabamos de hacer.
Recibimos OTRO Segmento, comprobamos si sus puntos izquierdo y derecho son iguales a los de ESTE segmento.
En caso afirmativo, es que los Segmentos son IGUALES:
Por último, también nos puede venir bien crear un metodo toString() para la clase Segmento. Para facilitarnos mostrar su informacion luegoi por pantalla.
Nos ayudaremos del metodo toString() que escribimos para la clase Punto, para informar de los valores X e Y de cada atributo Punto.
Y además, ya puestos, podemos añadir que informe también de la Pendiente:
Con esto ya tenemos una clase Segmento completada.
Ahora podemos ponerla a prueba en una clase Test.
Y por ultimo te dejo la clase Segmento al completo
Cualquier duda, cosa rara que no haya entendido, lo que sea... pregúntalo por aquí y lo aclaramos.
Saludos.
