Foro sobre Java SE > ejercicio sobre clase Punto y Punto3D
Y que es lo que lograr con el ejercicio?
Porque si tiras el codigo asi nomas dificil que se entienda su fin.
leojg
// Sobrescribe el metodo equals de la clase Punto
Ese método no devuelve ningún valor. Los return no están bien situados.
Siempre que se sobreescribe un equals, es conveniente, por no decir necesario, crear un método para el hashcode.
//sobrescribe el metodo toSTring de la clase Punto
No sobreescribe lo que pretende. Este método está fuera de la clase Punto3D
// clase OperarPuntos3D
Ninguna de las variables que usa está declarada.
Supongo que todas, o parte de, esas clases irán en archivos separados; porque veo dos métodos main. Si ese es el caso, no digo que se haga un post para cada archivo; pero al menos indicar qué va en cada cuál.
Todos los errores inmediatos son de compilación. Una de dos, o la salida del compilador te dice qué error tienes, y dónde, o te lo dice el IDE, si es que usas alguno.
choces
voy a explicar lo que me piden, la cuestion es que como estoy empezando pues no tengo muy claro todo lo que tengo que hacer:
1.
Creación de una clase que represente los puntos geométricos en dos
dimensiones. Esta clase deberá tener como atributos las propiedades
existentes en ese tipo de objetos, deberá contemplar uno o más
métodos para la asignación de valores a dichas propiedades y deberá
permitir también, mediante algún método, la obtención de los valores
de las propiedades.
Para ello, se debe implementar una clase denominada Punto. Está
compuesta de los atributos que modelizan la coordenada x y la
coordenada y de un punto en el espacio de dos dimensiones. Dichos
atributos debe ser private ya que, como se ha comentado, se trata de
que sólo puedan ser accedidos desde el exterior a través de los métodos
de la clase.
• Asimismo se debe crear el constructor de la clase que, mediante dos
argumentos, permita fijar los valores de x e y de un nuevo punto.
2.
Crear una clase OperarPuntos con un método main que contenga tres
Puntos: punto1, punto2 y punto3. Y las coordenadas del punto3 serán
iguales a las del punto1
• Comparar los puntos iguales y distintos de la siguiente manera.
Para el correcto funcionamiento, será necesario modificar la clase Punto para añadir la posibilidad de comparar puntos
entre sí, y de convertirlos correctamente en un String, para poder imprimirlos en pantalla.
- Para la comparación de los objetos debe emplearse un método existente en la clase Object, denominado equals. Este
método compara el objeto sobre el que se llama con el objeto que es pasado como parámetro.
El método que compara debe realizar la comparación en el dominio de los puntos, es decir, comprobar si la coordenada “x”
de un punto es igual a la de otro, e igual con las coordenadas “y”.
- Para imprimir en pantalla objetos debe utilizarse el método toString (también perteneciente a la clase Object) que
convierte un objeto en un String. Las llamadas a la sentencia println, realizan una llamada implícita al método toString del
objeto pasado por parámetro.
El método que convierte un punto en un String simplemente devuelverá un String formado por la concatenación (+) de un
paréntesis de apertura, el valor de la coordenada x del punto, una coma, el valor de la coordenada y del punto y un paréntesis de cierre. Por ejemplo (1,2)
3.
Crear una clase ImprimePuntos con un método imprimePunto
que reciba por parámetro un objeto Punto.
• Este método mostrará por pantalla que ha recibido un punto
de dos dimensiones y las coordenadas de este.
4.
Crear una clase Punto3D que modelizar objetos de tres
dimensiones, compuestos por las coordenadas X,Y y Z. En este
caso se trata de realizar el menor trabajo posible y, por tanto,
de reutilizar todo el código existente que sea posible. Esta
nueva clase deberá tener la misma funcionalidad que la de los
puntos de dos dimensiones
5.
Crear una clase OperarPuntos3D, que compare puntos de 3
dimensiones, de forma similar a la expuesta en el nº 2.
Observar que esta clase se diferencia de la del requisito II, en que los puntos son de 3 dimensiones. Por lo demás el
código es prácticamente el mismo. Siempre y cuando se hayan sobrescrito los métodos equals() y toString() del objeto
Punto3D
6.
Adaptar ImprimePuntos, sobrecargando el método
imprimePunto para que sea capaz de recibir puntos en 3
dimensiones y muestre por pantalla:
Punto de tres Dimensiones: (X,Y,Z)
En este caso se empleará el concepto de sobrecarga, ya que la clase
deberá tener un comportamiento diferente en función del objeto que
reciba por parámetro.
saciorlux
De momento, lo que te recomiendo es que cada clase esté en un archivo java diferente, y que crees una o varias clases para pruebas, que únicamente contengan los main.
Puedes colocar las clases de los "puntos" en el mismo package, para que estén mejor organizadas, y las clases con los main en otro package diferente.
Sobre todo, si estás empezando, cuanto más simples sean los archivos java, mejor que mejor: verás los problemas antes, y por separado.
choces
asi lo estoy haciendo ahora y no se si estará bien pero no me ha dado fallos lo que llevo realizado.
lo que no tengo muy claro es el paso 5 que a pesar de ser casi igual que el paso 2 no me sale
saciorlux
Veo que ya tienes creada una clase para puntos 3D. Una vez que sobreescribas los métodos equals y toString, te debería funcionar.
choces
ese es el problema que no me sale y no se como hacerlo, tampoco se si estan sobreescritos los metodos equals y toString aunque el programa (eclipse que es el que uso) me indica que estan sobreescritos.
saciorlux
Cuando lo ejecutas, ¿Qué resultados o errores tienes?
choces
no se como hacer que compare puntos de 3 dimensiones, he copiado el mismo codigo que el de OperarPuntos y no se como modificarlo para adaptarlo a puntos de 3 dimensiones
saciorlux
Siguiendo la misma idea de OperarPuntos, debes crear tres puntos del tipo Punto3D.
A continuación, defines el valor z para cada punto, puesto que necesitas la tercera dimensión.
Seguidamente, realizas la comparación, con el equals sobreescrito para Punto3D.
choces
No, no te hace falta definir aparte la dimensión z, puesto que ya la usas en el constructor.
choces
por fin lo he conseguido hacer, despues de muchas vueltas.
otra cosilla y perdonad por las preguntas pero es que me está costando entender esto:
el paso 3 como lo realizo, ya que haga lo que haga lo unico que me imprime es el resultado de las clases OperarPuntos y OperarPuntos3D
saciorlux
public class ImprimePuntos {
public void ImprimePunto(final Punto punto){
// código para mostrar por pantalla los datos de punto que pida
}
}
choces
a que se refiere cuando dice que para mostrar las coordenadas del punto, hacer uso del metodo toString() del objeto Punto
saciorlux
estoy haciendo un curso y tengo que realizar un ejercicio y me he quedado bloqueado por eso necesito que me intenteis corregir los fallos.
//clase Punto
class Punto {
private int X,Y;
// constructor
public Punto(int x, int y){
this.X=x;
this.Y=y;
}
public void setX(int x){
this.X=x;
}
public void setY(int y){
this.Y=y;
}
public int getX(){
return X;
}
public int getY(){
return Y;
}
public boolean equals(Object punto){
if (this==punto){
return true;
}
if (punto instanceof Punto){
Punto otro=(Punto)punto;
return ((X==otro.X) && (Y==otro.Y));
}
else {
return false;
}
}
public String toString(){
return "("+ getX() + "," + getY() + ") ";
}
}
// clase OperarPuntos
class OperarPuntos {
public static void main (String[] args){
Punto p1= new Punto(1,1);
Punto p2= new Punto(2,0);
Punto p3= new Punto(1,1);
if (p1.equals(p2)){
System.out.println("El punto1"+p1+"es igual al punto2"+p2);
}
else
{
System.out.println("El punto1"+p1+"es distinto al punto2"+p2);
}
if (p1.equals(p3)){
System.out.println("El punto1"+p1+"es igual al punto3"+p3);
}
else
{
System.out.println("El punto1"+p1+"es distinto al punto3"+p3);
}
if (p2.equals(p3)){
System.out.println("El punto2"+p2+"es igual al punto3"+p3);
}
else
{
System.out.println("El punto2"+p2+"es distinto al punto3"+p3);
}
}
//clase Punto3D
class Punto3D extends Punto {
private int Z;
public Punto3D (int x, int y, int z){
super(x,y);
this.Z=z;
}
public void setZ(int z) {
this.Z=z;
}
public int getZ(){
return Z;
}
// Sobrescribe el metodo equals de la clase Punto
public boolean equals(Object p3d){
Punto3D punto = null;
if(p3d instanceof Punto3D){
punto =(Punto3D) p3d;
if (punto.getX() == this.getX() && punto.getY() == this.getY() && punto.Z == this.Z)
return true;
}
else{
return false;
}
}
}
//sobrescribe el metodo toSTring de la clase Punto
public String toString() {
return "("+ getX() + "," + getY() + "," + getZ() +")";
}
}
// clase OperarPuntos3D
class OperarPuntos3D {
public static void main (String[] args){
if (p1.equals(p2)){
System.out.println("El punto1"+p1+"es igual al punto2"+p2);
}
else
{
System.out.println("El punto1"+p1+"es distinto al punto2"+p2);
}
if (p1.equals(p3)){
System.out.println("El punto1"+p1+"es igual al punto3"+p3);
}
else
{
System.out.println("El punto1"+p1+"es distinto al punto3"+p3);
}
if (p2.equals(p3)){
System.out.println("El punto2"+p2+"es igual al punto3"+p3);
}
else
{
System.out.println("El punto2"+p2+"es distinto al punto3"+p3);
}
}
}