Java - Alguien me ayuda?

 
Vista:
sin imagen de perfil

Alguien me ayuda?

Publicado por freddy (2 intervenciones) el 11/10/2021 22:46:39
Hola, quería saber si alguien me pudiera decir como se puede programar en java lo que me pide un ejercicio:

Crear una clase Vector, que almacena el representante del vector con origen en el origen de coordenadas, por lo que, bastará con conocer (y almacenar) su extremo.

Esta clase tendrá tres constructores:
1ºcreará un vector conocidas sus dos componentes;
2º lo hará conociendo el punto extremo;
3º lo creará conociendo un punto origen y un punto extremo (en este caso se realizarán los cálculos necesarios para almacenar únicamente el extremo del vector equivalente con origen en el origen de coordenadas).

Un vector con componentes x e y se expresará como V(x,y).

Un vector ortogonal (perpendicular) al vector V(x,y) es el vector V(-y,x) (Éste está girado 90 grados en sentido contrario a las agujas del reloj con respecto al anterior). Dos vectores V(vx,vy) y V(ux,uy) son paralelos si verifican vx*uy == vy*ux. Esto quiere decir que los vectores tienen la misma dirección (aunque pueden tener diferente sentido).

Estoy muy perdido y no encuentro ejemplos ni parecidos donde consultar

Gracias y bendiciones a todos
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Alguien me ayuda?

Publicado por Kabuto (1082 intervenciones) el 12/10/2021 01:42:50
Mmmhh.. yo también me siento un poco confuso a primera vista..

Vamos a clarificar ideas:

Un Vector, en este caso, se trata de una línea imaginaria que une dos puntos de un eje de coordenadas.

Es decir, para crear un Vector, necesitamos localizar dos puntos en el eje. Cada punto tiene dos coordenadas, una para el eje X (horizontal) y otra para el eje Y(vertical)

Ejemplo:
vectores-y-coordenadas

Los vectores tienen un "sentido", es decir, comienzan en un punto y acaban en el otro. En esa imagen, el Vector va de punto A(origen) hacia el punto B(extremo)

Y además tienen una propiedad llamada "las componentes", que es el resultado de restar las coordenadas del punto extremo menos las del punto origen.
Es decir, si un vector tiene origen en (2, 3) y extremo en (10, 7), sus "componentes" serán (10-2, 7-3) = (8, 4)
Es importante aclarar que aunque las "componentes" se expresan con dos valores como los puntos de coordenadas, en realidad NO SON PUNTOS DE COORDENADAS
Las coordenadas indican un punto concreto en el eje cartesiano. Las "componentes" NO, solo indican la diferencia entre las coordenas del vector.
Podríamos decir que nos indican la "longitud" del vector, pero no nos dicen donde se sitúa el vector dentro del eje de coordenadas.

Todas estas explicaciones son necesarias para poder entender luego qué es lo que tenemos que escribir con código.


Bien, pues en este ejercicio se nos dice que todos los Vectores tienen origen, en el origen de coordenadas, es decir, en (0, 0)
1
2
3
Crear una clase Vector, que almacena el representante
del vector con origen en el origen de coordenadas, por lo que,
bastará con conocer (y almacenar) su extremo.

Así que para modelar una clase Vector, solo necesitamos guardar el punto extremo, porque ya sabemos que el origen siempre será (0, 0)
Podríamos modelarlo usando dos atributos de tipo int
1
2
3
4
5
6
7
public class Vector {
 
	//Coordenadas del punto extremo. Origen siempre es 0, 0
	private int x;
	private int y;
 
}

Por ahora, lo dejamos así. Sin embargo, ahora veremos que si lo hacemos así se nos va a presentar un problema con los constructores..

Nos piden estos constructores:
1
2
3
4
5
6
1ºcreará un vector conocidas sus dos componentes;
2º lo hará conociendo el punto extremo;
3º lo creará conociendo un punto origen y un punto extremo
(en este caso se realizarán los cálculos necesarios para almacenar
únicamente el extremo del vector equivalente con origen en el origen
de coordenadas).

El primer y segundo constructor, si es que los estoy entendiendo bien..., nos van a crear un conflicto.
El primero nos pide sus dos componentes, que ya hemos dicho que, es la resta de las coordenadas extremas menos las coordenadas origen.
El segundo nos pide el punto extremo, es decir, las dos coordenadas extremas.

Es un poco absurdo, porque si todos estos Vectores se originan en 0, 0, pues los valores de las componentes siempre serán iguales a los valores del punto extremo.

Es decir, un Vector con origen (0, 0) y extremo (4, 5)
Los valores de su punto extremo son (4, 5)
Y sus componentes son (4-0, 5-0) = (4, 5)

Así que es redundante. Pero el verdadero problema viene que para ambos casos, a los constructores habría que darle dos enteros.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Vector {
 
	//Coordenadas del punto extremo. Origen siempre es 0, 0
	private int x;
	private int y;
 
	public Vector(int componenteX, int componenteY) {
		x = componenteX;
		y = componenteY;
	}
 
	public Vector(int extremoX, int extremoY) {
		x = extremoX;
		y = extremoY;
	}
}

Y esto el compilador Java no lo admite, considera que estamos duplicando el mismo constructor (lo cuál es cierto).

Lo lógico y práctico sería dejar solo uno, porque como ya hemos explicado y estamos viendo, van a hacer la misma operación tanto si le pasamos las componentes, como si le pasamos los valores del punto extremo.

Pero el enunciado nos pide un constructor para cada caso, así que para cumplir con ello, seguiremos otra estrategia distinta (y menos práctica)

Podemos crear otra clase llamado Punto, que será quien tenga los atributos de las coordenadas X e Y.
1
2
3
4
5
6
7
8
9
10
11
public class Punto {
 
	public int x;
	public int y;
 
	public Punto(int x, int y) {
		this.x = x;
		this.y = y;
	}
 
}

Y la clase Vector, ahora lo que tendrá será un atributo Punto. Así, podemos usar un constructor con dos int para construir un Vector conociendo sus componentes.
Y otro constructor que reciba un Punto, que sería el punto Extremo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Vector {
 
	//Punto extremo. Origen siempre es 0, 0
	private Punto extremo;
 
	//1º Creará un vector conocidas sus dos componentes;
	public Vector(int componenteX, int componenteY) {
		//Como origen es 0, 0.. las componentes equivalen a las coordenadas del extremo
		extremo = new Punto(componenteX, componenteY);
	}
 
	//2º lo hará conociendo el punto extremo;
	public Vector(Punto extremo) {
		this.extremo = extremo;
	}
}

Resuelto el conflicto de los dos primeros constructores, queda un tercero:

1
2
3
4
3º lo creará conociendo un punto origen y un punto extremo
(en este caso se realizarán los cálculos necesarios para almacenar
únicamente el extremo del vector equivalente con origen en el origen
de coordenadas).

Según creo entender, nos darían los dos puntos de un Vector que quizás no tenga origen 0, 0
Y digamos que hemos de "trasladarlo" para que se origine en 0, 0, respetando su "longitud" y así calcular su punto extremo.
¿Suena muy difícil hace esto?

Pues no lo es, basta con calcular sus "componentes". Y como nuestros Vectores siempre se originan en 0, 0, pues las "componentes" coinciden con las coordenadas del Punto extremo, que es precisamente lo que tenemos que calcular.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class Vector {
 
	//Punto extremo. Origen siempre es 0, 0
	private Punto extremo;
 
	//1º Creará un vector conocidas sus dos componentes;
	public Vector(int componenteX, int componenteY) {
		//Como origen es 0, 0.. las componentes equivalen a las coordenadas del extremo
		extremo = new Punto(componenteX, componenteY);
	}
 
	//2º lo hará conociendo el punto extremo;
	public Vector(Punto extremo) {
		this.extremo = extremo;
	}
 
	//3º lo creará conociendo un punto origen y un punto extremo
	//(en este caso se realizarán los cálculos necesarios para almacenar
	//únicamente el extremo del vector equivalente con origen en el origen de coordenadas).
	public Vector (Punto origen, Punto extremo) {
		//Calculamos las componentes
		int componenteX = extremo.x - origen.x;
		int componenteY = extremo.y - origen.y;
		extremo = new Punto(componenteX, componenteY);
	}
}

Bien, pues ya tendríamos los tres constructores.

Sobre esta parte:
1
2
3
4
5
6
Un vector ortogonal (perpendicular) al vector V(x,y) es el vector V(-y,x)
 (Éste está girado 90 grados en sentido contrario a las agujas del reloj
 con respecto al anterior).
 Dos vectores V(vx,vy) y V(ux,uy) son paralelos si verifican vx*uy == vy*ux.
 Esto quiere decir que los vectores tienen la misma dirección
 (aunque pueden tener diferente sentido).

Supongo que desean que hagamos dos métodos, que reciban otro Vector para compararse y comprobar esas características.
Estas comparaciones, se hacen en base a las "componentes" del Vector:
1
Un vector con componentes x e y se expresará como V(x,y).
Y, repito una vez más, en nuestro caso las "componentes" coinciden con las coordenadas del Punto extremo, así que no necesitamos calcular las "componentes" porque en realidad ya las tenemos (el calculo sería restar 0 a las coordenadas del extremo, así que es innecesario)


Estos podrían ser los métodos:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
public class Vector {
 
	//Punto extremo. Origen siempre es 0, 0
	private Punto extremo;
 
	//1º Creará un vector conocidas sus dos componentes;
	public Vector(int componenteX, int componenteY) {
		//Como origen es 0, 0.. las componentes equivalen a las coordenadas del extremo
		extremo = new Punto(componenteX, componenteY);
	}
 
	//2º lo hará conociendo el punto extremo;
	public Vector(Punto extremo) {
		this.extremo = extremo;
	}
 
	//3º lo creará conociendo un punto origen y un punto extremo
	//(en este caso se realizarán los cálculos necesarios para almacenar
	//únicamente el extremo del vector equivalente con origen en el origen de coordenadas).
	public Vector (Punto origen, Punto extremo) {
		//Calculamos las componentes
		int componenteX = extremo.x - origen.x;
		int componenteY = extremo.y - origen.y;
		extremo = new Punto(componenteX, componenteY);
	}
 
 
	/*
	 * Un vector ortogonal (perpendicular) al vector V(x,y) es el vector V(-y,x)
	 * (Éste está girado 90 grados en sentido contrario a las agujas del reloj
	 * con respecto al anterior).
	 */
	public boolean esOrtogonal(Vector otroVector) {
		//Calculamos cuáles serían las componentes consideradas perpendiculares
		//para este Vector
		int xPerpendicular = extremo.y * -1;
		int yPerpendicular = extremo.x;
		//Comprobamos si coinciden con las del otro Vector
		return (xPerpendicular == otroVector.extremo.x && yPerpendicular == otroVector.extremo.y);
	}
 
	/*
	 * Dos vectores V(vx,vy) y V(ux,uy) son paralelos si verifican vx*uy == vy*ux.
	 * Esto quiere decir que los vectores tienen la misma dirección
	 * (aunque pueden tener diferente sentido).
	 */
 
	public boolean esParalelo(Vector otroVector) {
		//Calculamos primer producto de las componentes
		int producto1 = extremo.x * otroVector.extremo.y;
		//Segundo producto
		int producto2 = extremo.y * otroVector.extremo.x;
		//Si ambos productos son iguales, es que son vectores pararelos
		return producto1 == producto2;
	}
}


Y creo que ya está. Solo faltaría crear un main() para construir Vectores y probar a compararlos.
Por ejemplo aquí creo dos vectores ortogonales, pero no paralelos

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Test {
 
	public static void main(String[] args) {
 
		Vector v1 = new Vector(new Punto(5, 10));
		Vector v2 = new Vector(new Punto(-10, 5));
 
		System.out.println(v1.esOrtogonal(v2)?"Sí es ortogonal":"No es ortogonal");
		System.out.println(v1.esParalelo(v2)?"Sí es paralelo":"No es paralelo");
 
	}
 
}

Y la comparación parece funcionar según lo que vemos en pantalla:
1
2
Sí es ortogonal
No es paralelo


Y creo que eso es todo. Si lago no ha quedado claro, pregúntalo e intento explicarlo mejor.
Un saludo.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
sin imagen de perfil

Alguien me ayuda?

Publicado por freddy (2 intervenciones) el 12/10/2021 12:19:46
Mil gracias por tu ayuda! me ha servido mucho, perfectamente explicado, gracias por dedicarle tanto esfuerzo!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar