Está en la página 1de 20

UNIVERSIDAD TÉCNICA DE AMBATO

FACULTAD DE INGENIERÍA EN SISTEMAS ELECTRÓNICA E INDUSTRIAL


“PERÍODO ACADÉMICO: OCTUBRE 2021 – FEBRERO 2022”

TÍTULO:

CALCULADORA DE VECTORES

CARRERA:

INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN

UNIDAD DE ORGANIZACIÓN CURRICULAR:

BÁSICA

NIVEL Y PARALELO:

SEGUNDO “B”

ALUMNOS PARTICIPANTES:

PADILLA HIDALGO PAOLA VANESSA


TENE HUGO FRANCISCO JAVIER
SALAZAR RAMOS ARIEL SEBASTIAN

ASIGNATURA:

PROGRAMACION ORIENTADA A OBJETOS

DOCENTE:

SANDRA LUCRECIA CARRILLO RIOS


MAGISTER EN TECNOLOGIA DE LA INFORMACION Y MULTIMEDIA
EDUCATIVA INGENIERO EN SISTEMAS
Contenido

2.1 TITULO........................................................................................................................3

2.2 CONTEXTUALIZACIÓN..........................................................................................3

2.3 OBJETIVOS.................................................................................................................4

OBJETIVO GENERAL....................................................................................................4

OBJETIVOS ESPECÍFICOS...........................................................................................4

2.4 JUSTIFICACIÓN........................................................................................................5

JUSTIFICACIÓN TEÓRICA..........................................................................................5

JUSTIFICACIÓN METODOLÓGICA..........................................................................5

JUSTIFICACIÓN PRÁCTICA.......................................................................................5

2.5 FUNDAMENTO TEÓRICO.......................................................................................6

Figura 1. Tabla de modificadores de Acceso en Java.........................................................7

Figura 2. Tipos de Clases.......................................................................................................8

Figura 3. Ejemplo de constructor en Java...........................................................................9

Figura 4. Ejemplo con la palabra reservada: Super...........................................................9

Figura 5. Ejemplo de uso de This en Java.........................................................................10

Figura 6. Ejemplo de polimorfismo en Java......................................................................11

Figura 7. Abstract en Java..................................................................................................12

Figura 8. Interfaz en Java...................................................................................................13

Figura 9. Representación de un Vector..............................................................................14

2.6 DESARROLLO..........................................................................................................14

2.7 REFERENCIAS BIBLIOGRÁFICAS.....................................................................15


2.1 TITULO

CALCULADORA DE VECTORES

2.2 CONTEXTUALIZACIÓN
2.3 OBJETIVOS

OBJETIVO GENERAL

 Mostrar lo que es capaz de realizar el lenguaje de programación JAVA en un


problema muy común existente en diversos campos del algebra lineal, demostrando lo
importante que es el aprender este lenguaje en la vida cotidiana.

OBJETIVOS ESPECÍFICOS

 Solucionar un problema soluble de forma algorítmica haciendo el programa lo más


entendible posible tanto para el usuario que lo utilice, así como para el programador o
ingeniero que esté trabajando en este.

 Diseñar un menú para poder hacer el ingreso, visualización e impresión de los datos
de un vector y sus cálculos correspondientes.

 Aplicar los conocimientos vistos en clase, así como en diferentes videos y libros a un
problema en específico.
2.4 JUSTIFICACIÓN

JUSTIFICACIÓN TEÓRICA
La desinformación por parte de los estudiantes (generalmente en su mayoría), en temas
referentes a ejercicios con vectores es una de las causas más relevantes para que se
produzca errores en la resolución de estas, ya que a pesar de los conocimientos adquiridos
en el colegio o en la Universidad se desconoce algunos temas o diferentes alternativas de
soluciones para su desarrollo ya que como bien sabemos para un ejercicio pueden existir
una o varias formas de resolverlos.

JUSTIFICACIÓN METODOLÓGICA
Hacer énfasis en este tema, es muy importante ya que refleja los distintos errores que
pueden cometer los estudiantes al ingresar con un lápiz o esfero los valores o signos, es
por eso que se pretende informar de mejor manera a los alumnos de segundo “B” de la
carrera de Tecnologías de la información, el uso de esta herramienta con una interfaz fácil
y sólida que podría ser de ayuda para su formación académica y profesional.
La ejecución de estos ejercicios es uno de los problemas que hoy en día en este campo se
trata de solucionar debido a que siempre existen errores o confusión en su realización, es
necesario tener en consideración que existen varias formas por las cuales las personas
pueden realizar un ejercicio, pero con la ayuda de esta herramienta lo haremos de una muy
entendible, directa y fácil para el usuario.

JUSTIFICACIÓN PRÁCTICA
El correcto procedimiento del problema o ejercicio será representado por el mejor y
entendible desarrollo para que el usuario pueda realizarlo sin ningún tipo de
inconvenientes.
Si se tiene en consideración la factibilidad de este proyecto, se puede añadir la facilidad
que conlleva su realización ya que al tratarse de un grupo pequeño de estudiantes, los
cálculos estadísticos se pueden dar de mejor manera, a más de ello se empleará como ya se
ha mencionado anteriormente, un modelo de encuesta que corroborará a determinar las
causas existentes de la desinformación por parte del alumnado ya delimitado, y a su vez
beneficiaría a los mismos en su conocimiento al cálculo de vectores.
2.5 FUNDAMENTO TEÓRICO

PROGRAMACION ORIENTADA A OBJETOS


La programación orientada a objetos es un modelo de programación informática que
organiza el diseño de software en torno a datos u objetos, en lugar de funciones y lógica.
Un objeto se puede definir como un campo de datos que tiene atributos y comportamiento
únicos.
La programación orientada a objetos se centra en los objetos que los desarrolladores
quieren manipular en lugar de enfocarse en la lógica necesaria para manipularlos. Este
enfoque de programación es adecuado para programas que son grandes, complejos y se
actualizan o mantienen activamente.
La organización de un programa orientado a objetos también hace que el método sea
beneficioso para el desarrollo colaborativo, donde los proyectos se dividen en grupos.
Los beneficios adicionales de la programación orientada a objetos incluyen la
reutilización, la escalabilidad y la eficiencia del código. Incluso cuando se utilizan
microservicios, los desarrolladores deben seguir aplicando los principios de la
programación orientada a objetos.
HERENCIA
La herencia es un pilar importante de OOP (Programación Orientada a Objetos). Es el
mecanismo en Java por el cual una clase permite heredar las características (atributos y
métodos) de otra clase. Aprenda más a continuación.
En el lenguaje de Java, una clase que se hereda se denomina superclase. La clase que
hereda se llama subclase. Por lo tanto, una subclase es una versión especializada de una
superclase. Hereda todas las variables y métodos definidos por la superclase y agrega sus
propios elementos únicos.
Terminología importante
 Superclase: la clase cuyas características se heredan se conoce como superclase
(o una clase base o una clase principal).
 Subclase: la clase que hereda la otra clase se conoce como subclase (o una clase
derivada, clase extendida o clase hija). La subclase puede agregar sus propios
campos y métodos además de los campos y métodos de la superclase.
 Reutilización: la herencia respalda el concepto de «reutilización», es decir,
cuando queremos crear una clase nueva y ya hay una clase que incluye parte del
código que queremos, podemos derivar nuestra nueva clase de la clase existente.
Al hacer esto, estamos reutilizando los campos/atributos y métodos de la clase
existente.

MODIFICADORES DE ACCESO
Como su nombre indica, los modificadores de acceso en Java ayudan a restringir el
alcance de una clase, constructor, variable, método o miembro de datos. Hay cuatro tipos
de modificadores de acceso disponibles en Java:
 Default – No se requiere palabra clave
Cuando no se especifica ningún modificador de acceso para una clase, método o miembro
de datos, se dice estar teniendo modificador de acceso default por defecto.
Los miembros de datos, clase o métodos que no se declaran utilizando ningún modificador
de acceso, es decir, que tengan un modificador de acceso predeterminado, solo son
accesibles dentro del mismo paquete.
 Private
El modificador de acceso privado se especifica con la palabra clave. Los métodos o los
miembros de datos declarados como privados solo son accesibles dentro de la clase en la
que se declaran. Cualquier otra clase del mismo paquete no podrá acceder a estos
miembros. Las clases e interfaces no se pueden declarar como privadas (private).
 Protected
El modificador de acceso protegido se especifica con la palabra clave. Los métodos o
miembros de datos declarados como son accesibles dentro del mismo paquete o sub-clases
en paquetes diferentes.
 Public
El modificador de acceso público se especifica con la palabra clave. El modificador de
acceso público tiene el alcance más amplio entre todos los demás modificadores de
acceso.
Las clases, métodos o miembros de datos que se declaran como públicos son accesibles
desde cualquier lugar del programa. No hay restricciones en el alcance de los miembros de
datos públicos.
Figura 1. Tabla de modificadores de Acceso en Java

OBJETOS
Los objetos corresponden a cosas que se encuentran en el mundo real. Por ejemplo, un
sistema de compra en línea podría tener objetos como: carrito de compras, cliente y
producto.
Los objetos en Java no tienen existencia física, no puedes tocarlos, pero sí que existe como
algo que contiene información sobre sí mismo y sobre su estado. Se puede interactuar con
él y se puede modificarlo para que responda a nuestras necesidades de programación.
Características de un objeto en Java
 Estado: Está representado por atributos de un objeto. También refleja las propiedades
de un objeto.
 Comportamiento: Se representa mediante métodos de un objeto. También refleja la
respuesta de un objeto con otros objetos.
 Identidad: Le da un nombre único a un objeto y permite que un objeto interactúe con
otros objetos.

Figura 2. Tipos de Clases

CONSTRUCTORES JAVA
Toda clase Java si no se le incluye ningún constructor el compilador añade un constructor
por defecto. Así pues, el código para el compilador sería el siguiente:
Figura 3. Ejemplo de constructor en Java

SUPER
La palabra clave super también se puede usar para acceder al constructor de la clase padre.
Una cosa más importante es que “super” puede llamar constructores tanto con parámetros
como sin parámetros dependiendo de la situación. A continuación, se muestra el
fragmento de código para explicar el concepto anterior:

Figura 4. Ejemplo con la palabra reservada: Super


THIS
Un método miembro de un objeto está asociado al objeto. Cuando este se está ejecutando
podemos usar this, para conseguir una referencia al objeto asociado.
Dentro del método, podemos usar this.nombre para acceder al nombre del objeto asociado.
La palabra clave this, funciona igual dentro de un constructor.
Ejemplo de uso de constructores y this:

Figura 5. Ejemplo de uso de This en Java

POLIMORFISMO
En programación orientada a objetos, polimorfismo es la capacidad que tienen los objetos
de una clase en ofrecer respuesta distinta e independiente en función de los parámetros
(diferentes implementaciones) utilizados durante su invocación. Dicho de otro modo, el
objeto como entidad puede contener valores de diferentes tipos durante la ejecución del
programa. En JAVA el término polimorfismo también suele definirse como ‘Sobrecarga
de parámetros’.
Ejemplo:
Un ejemplo clásico de polimorfismo es el siguiente. Podemos crear dos clases distintas:
Gato y Perro, que heredan de la superclase Animal. La clase Animal tiene el método
abstracto makesound() que se implementa de forma distinta en cada una de las subclases
(gatos y perros suenan de forma distinta). Entonces, un tercer objeto puede enviar el
mensaje de hacer sonido a un grupo de objetos Gato y Perro por medio de una variable de
referencia de clase Animal, haciendo así un uso polimórfico de dichos objetos respecto del
mensaje mover.

Figura 6. Ejemplo de polimorfismo en Java

CLASES Y MÉTODOS ABSTRACTOS


Las clases abstractas suelen contener métodos abstractos: la situación es la misma. Para
que un método se considere abstracto ha de incluir en su signatura la palabra clave
abstract. Además, un método abstracto tiene estas peculiaridades:
a) No tiene cuerpo (llaves): sólo consta de signatura con paréntesis.
b) Su signatura termina con un punto y coma.
c) Sólo puede existir dentro de una clase abstracta. De esta forma se evita que haya
métodos que no se puedan ejecutar dentro de clases concretas. Visto de otra manera, si una
clase incluye un método abstracto, forzosamente la clase será una clase abstracta.
d) Los métodos abstractos forzosamente habrán de estar sobreescritos en las subclases. Si
una subclase no implementa un método abstracto de la superclase tiene un método no
ejecutable, lo que la fuerza a ser una subclase abstracta. Para que la subclase sea concreta
habrá de implementar métodos sobreescritos para todos los métodos abstractos de sus
superclases.

ABSTRACT
Un método abstracto para Java es un método que nunca va a ser ejecutado porque no tiene
cuerpo. Simplemente, un método abstracto referencia a otros métodos de las subclases.
¿Qué utilidad tiene un método abstracto? Podemos ver un método abstracto como una
palanca que fuerza dos cosas: la primera, que no se puedan crear objetos de una clase. La
segunda, que todas las subclases sobreescriban el método declarado como abstracto.

Sintaxis tipo: abstract public/private/protected TipodeRetorno/void (parámetros … );


Por ejemplo: abstract public void generarNomina (int diasCotizados, boolean
plusAntiguedad);

Figura 7. Abstract en Java

INTERFACES
Una interfaz () es sintácticamente similar a una clase abstracta, en la que puede especificar
uno o más métodos que no tienen cuerpo ({}). Esos métodos deben ser implementados por
una clase para que se definan sus acciones.
Por lo tanto, una interfaz especifica qué se debe hacer, pero no cómo hacerlo. Una vez que
se define una interfaz, cualquier cantidad de clases puede implementarla. Además, una
clase puede implementar cualquier cantidad de interfaces.
Para implementar una interfaz, una clase debe proporcionar cuerpos (implementaciones)
para los métodos descritos por la interfaz. Cada clase es libre de determinar los detalles de
su propia implementación. Dos clases pueden implementar la misma interfaz de diferentes
maneras, pero cada clase aún admite el mismo conjunto de métodos. Por lo tanto, el
código que tiene conocimiento de la interfaz puede usar objetos de cualquier clase, ya que
la interfaz con esos objetos es la misma.

Figura 8. Interfaz en Java

VECTORES
En matemáticas se define vector como un elemento de un espacio vectorial. Esta noción es
más abstracta y para muchos espacios vectoriales no es posible representar sus vectores
mediante el módulo y la dirección. En particular los espacios de dimensión infinita sin
producto escalar no son representables de ese modo. Los vectores en un espacio euclídeo
se pueden representar geométricamente como segmentos de recta R^2 , en el plano R^2
(bidimensional), o en el espacio R^3 (tridimensional).
Componentes:
Pues son los elementos que definen a un vector, ya que, sabiendo sus coordenadas, lo
sabemos todo sobre él: módulo, dirección y sentido.
Hablar de componentes del vector y de coordenadas del vector es lo mismo.

Figura 9. Representación de un Vector

2.6 DESARROLLO

package proyecto_final_objetos;

/**
*
* @author Paola Padilla
*/
public class PROYECTO {

public static void main(String[] args) {


menuOpciones();
}

public static void menuOpciones() {


boolean valor = false;
int opcion;
while (!valor) {
System.out.println("1. Magnitud O Módulo De Un Vector ");
System.out.println("2. Normalización De Un Vector ");
System.out.println("3. Producto De Un Vector Por Un Escalar ");
System.out.println("4. Producto Punto Entre Vectores ");
System.out.println("5. Producto Cruz Entre Vectores ");
System.out.println("6. Proyección De Un Vector Sobre Otro ");
System.out.println("7. Salir Del Sistema ");
opcion = ControlDatos.leerEntero("\n> Escribe una de las opciones: ");
System.out.println("");
switch (opcion) {
case 1:
System.out.println("-------------------------------");
System.out.println("----- Módulo De Un Vector -----");
System.out.println("-------------------------------\n");
ModuloMagnitud();
break;
case 2:
System.out.println("--------------------------------");
System.out.println("--- Normalización Del Vector ---");
System.out.println("--------------------------------\n");
Normalizacion();
break;
case 3:
System.out.println("--------------------------------------------");
System.out.println("--- Producto De Un Vector Por Un Escalar ---");
System.out.println("--------------------------------------------\n");
ProductoDeUnVectorPorUnEscalar();
break;
case 4:
System.out.println("-----------------------------------------");
System.out.println("--- Producto Punto Entre Dos Vectores ---");
System.out.println("-----------------------------------------\n");
ProductoPuntoEntreVectores();
break;
case 5:
System.out.println("------------------------------------");
System.out.println("--- Producto Cruz Entre Vectores ---");
System.out.println("------------------------------------\n");
ProductoCruzEntreVectores();
break;
case 6:
System.out.println("----------------------------------------------------");
System.out.println("---- Proyección De Un Vector Vector Sobre Otro ----");
System.out.println("----------------------------------------------------\n");
ProyeccionDeUnVectorSobreOtro();
break;
case 7:
System.out.println("Gracias, vuelve pronto <3\n");
valor = true;
break;
default:
System.out.println("\nSolo números entre 1 y 7\n");
}
}
}

public static void ModuloMagnitud() {


int[] Vector = new int[ControlDatos.leerEntero("> Dimension Del Vector = ")];
Vector = llenar(Vector);
System.out.println("> El Módulo Del Vector Es: " + ModuloDeUnVector(Vector));
}

public static float ModuloDeUnVector(int[] VectorEntrante) {


float modulo = 0;
for (int i = 0; i < VectorEntrante.length; i++) {
modulo += VectorEntrante[i] * VectorEntrante[i];
}
modulo = (float) Math.sqrt(modulo);
return modulo;
}

public static void Normalizacion() {


int[] Vector = new int[ControlDatos.leerEntero("> Dimension Del Vector = ")];
Vector = llenar(Vector);
imprimirVector(Vector);
NormalVector(Vector);
System.out.println("");
}

public static void NormalVector(int[] Vector) {


double modulo = ModuloDeUnVector(Vector);
System.out.print("U= ");
for (int i = 0; i < Vector.length; i++) {
System.out.print((Vector[i] + "/" + (int) modulo + " "));
}
}

public static void ProductoDeUnVectorPorUnEscalar() {


int[] Vector1 = new int[ControlDatos.leerEntero("> Dimension Del Vector = ")];
int Escalar = ControlDatos.leerEntero("> Número Escalar = ");
System.out.println("");
Vector1 = llenar(Vector1);
Vector1 = VectorPorEscalar(Vector1, Escalar);
System.out.println("> Vector Con Producto Escalar\n");
imprimirVector(Vector1);
}

public static int[] VectorPorEscalar(int[] Vector, int Escalar) {


for (int i = 0; i < Vector.length; i++) {
Vector[i] = Vector[i] * Escalar;
}
return Vector;
}

public static void ProductoPuntoEntreVectores() {


int[] Vector1;
int[] Vector2;
float producto = 0;
boolean valor = true;

do {
Vector1 = new int[ControlDatos.leerEntero("> Dimension Del Vector 1 = ")];
Vector2 = new int[ControlDatos.leerEntero("> Dimension Del Vector 2 = ")];

if (Vector1.length != Vector2.length) {
System.out.println("Error EL producto Punto Necesita Que Los Vectores Sean De La
Misma Dimension");
} else {
Vector1 = llenar(Vector1);
Vector2 = llenar(Vector2);
producto = productoPuntoVectores(Vector1, Vector2, producto);
System.out.println("> El Producto Punto Entre Los Dos Vectores Es = " + producto);
valor = false;
}
} while (valor);
}

public static float productoPuntoVectores(int[] Vector1, int[] Vector2, float producto) {


for (int i = 0; i < Vector1.length; i++) {
producto += (Vector1[i] * Vector2[i]);
}
return producto;
}

public static void ProductoCruzEntreVectores() {


int[] Vector1;
int[] Vector2;
int[] ProductoCuz;
boolean valor = true;
do {

Vector1 = new int[ControlDatos.leerEntero("> Dimension Del Vector 1 = ")];


Vector2 = new int[ControlDatos.leerEntero("> Dimension Del Vector 2 = ")];
ProductoCuz = new int[Vector1.length];
if (Vector1.length != 3 && Vector2.length != 3) {
System.out.println("Error Producto Cruz Entre Dos Vectores Debe Ser De La Misma
Dimension ");
} else {

Vector1 = llenar(Vector1);
Vector2 = llenar(Vector2);
ProductoCuz = ProductoCruzEntreVectores(Vector1, Vector2, ProductoCuz);
System.out.println("> Vector Con Producto Cruz = ");
imprimirVector(ProductoCuz);
valor = false;
}
} while (valor);
}

public static int[] ProductoCruzEntreVectores(int[] Vector1, int[] Vector2, int[] ProductoCuz) {


int proPosI = 0;
int proPosJ = 0;
int proPosK = 0;

proPosI = (Vector1[1] * Vector2[2]) - (Vector1[2] * Vector2[1]);


proPosJ = (Vector1[0] * Vector2[2]) - (Vector1[2] * Vector2[0]);
proPosK = (Vector1[0] * Vector2[1]) - (Vector1[1] * Vector2[0]);
ProductoCuz[0] = proPosI;
ProductoCuz[1] = (-1 * proPosJ);
ProductoCuz[2] = proPosK;
return ProductoCuz;
}

public static void ProyeccionDeUnVectorSobreOtro() {


int[] Vector1;
int[] Vector2;
float proyeccion = 0;
boolean valor = true;
do {

Vector1 = new int[ControlDatos.leerEntero("> Dimension Del Vector 1 = ")];


Vector2 = new int[ControlDatos.leerEntero("> Dimension Del Vector 2 = ")];

if (Vector1.length != Vector2.length) {
System.out.println("Error La Proyeccion Entre Vectores Debe Ser De La Misma
Dimension");
} else {
Vector1 = llenar(Vector1);
Vector2 = llenar(Vector2);
proyeccion = ProyeccionVetorPorOtro(Vector1, Vector2, proyeccion);
System.out.println("> La Proyeción Del Vector 1 Sobre Otro Es = " + proyeccion);
valor = false;
}
} while (valor);
}

public static float ProyeccionVetorPorOtro(int[] Vector1, int[] Vector2, float producto) {


float productopunto = productoPuntoVectores(Vector1, Vector2, producto);
float modulo = ModuloDeUnVector(Vector2);
float proyeccion = (productopunto / modulo);
return proyeccion;
}

//METODOS PARA LOS VECTORES


public static int[] llenar(int[] VectorEntrante) {
for (int i = 0; i < VectorEntrante.length; i++) {
VectorEntrante[i] = ControlDatos.leerEntero("> Elemento N: [" + i + "] Del Vector: ");
}
System.out.println("");
return VectorEntrante;
}

public static void imprimirVector(int[] VectorEntrante) {


for (int i = 0; i < VectorEntrante.length; i++) {
System.out.println("> Elemento [" + VectorEntrante[i] + "] Posicion N: [" + i + "] Del
Vector ");
}
System.out.println("");
}

}
2.7 REFERENCIAS BIBLIOGRÁFICAS

También podría gustarte