Facultad:
Ingeniería
Carrera:
Ingeniería de sistemas
Integrantes:
Campoverde Chang Erick Alberto
Gonzales Pacherrez Renzo Manuel
Gonzales Requena Estefani Geraldi
Valladolid Godos Brayan Nicolas
Curso:
Técnicas de programación.
Docente:
ING. José Santa Cruz Vera.
Ciclo:
II Sección: “B”
2019
CONTENIDO:
AGRADECIMIENTO: ........................................................................................................................................... 3
DEDICATORIA: ..................................................................................................................................................... 4
RESUMEN ............................................................................................................................................................... 5
ABSTRAC................................................................................................................................................................ 6
INTRODUCCION: ................................................................................................................................................. 7
CAPÍTULO 1 PRESENTACIÓN DEL PROBLEMA .......................................................................................... 8
1.1. Planteamiento del problema.......................................................................................................................... 8
1.2. Formulación del problema ............................................................................................................................ 8
1.3. Objetivos del proyecto................................................................................................................................... 9
1.3.1. Objetivo general........................................................................................................................................... 9
1.3.2. Objetivos específicos .................................................................................................................................... 9
CAPÍTULO 2 PROPUESTA ................................................................................................................................ 10
1. Explicación del programa: ............................................................................................................................ 10
1.1 Acciones que podrá desarrollar el programa. ............................................................................................... 10
2. Proyecto basado en:....................................................................................................................................... 11
2.1 Métodos ...................................................................................................................................................... 11
2.2 Recursividad .................................................................................................................................................... 11
2.3 Sobrecarga ....................................................................................................................................................... 11
2.4 Arrays ............................................................................................................................................................... 11
2.5 Clases y sus miembros ..................................................................................................................................... 12
2.6 Relación entre clases........................................................................................................................................ 12
2.7 de acceso a los miembros de un clase. .......................................................................................................... 12
2.8 Métodos constructores y la referencias This ................................................................................................. 12
2.9 Herencia de clase ............................................................................................................................................. 13
2.10 Clases abstractas............................................................................................................................................ 13
2.11 Interfaces ........................................................................................................................................................ 13
2.12 Herencia Múltiple De Interfaces .................................................................................................................. 13
2.13 Polimorfismo .................................................................................................................................................. 14
2.14 Paquetes ......................................................................................................................................................... 14
2.15 Excepciones .................................................................................................................................................... 14
REFERENCIAS BIBLIOGRÁFICAS .............................................................................................................. 23
Anexos ............................................................................................................... ¡Error! Marcador no definido.
AGRADECIMIENTO:
Agradezco en primer lugar a Dios, a mis padres y al ing. José A. Santa Cruz Vera por habernos
brindado su apoyo en todo momento y haber hecho que la culminación de este proyecto sea un
éxito rotundo.
DEDICATORIA:
Este trabajo está dedicado a Dios, mis padres, al ing. José A. Santa por la alta estimación que les
tengo y porque fueron mi motivo a finalizar este informe.
RESUMEN
Programa para una tienda encargada a la venta de vehículos
La necesidad de ahorra tiempo, dinero y el arduo trabajo de manejar un negocio surge la necesidad
de buscar una vía que nos facilite todo eso gracias hemos decidido elaborar un programa.
Seguramente te has preguntado cómo hacen las tiendas para mantener todo en orden y registrar
cada venta, pues para esto ellas utilizan un programa como el que se mostrará en este informe.
El programa que hemos elaborado facilitara el orden de los productos a través de calificación de
estos, el registro de la venta (ya sea al crédito o al contado) y ahorra el tiempo.
Este es útil para aquellas tiendas que se desempeñen en el ámbito del comercio de motos, su
reparación y la venta de repuestos y accesorios.
ABSTRAC
Program for a store responsible for the sale of vehicles
The need to save time, money and the hard work of running a business arises the need to
find a way that facilitates all that thanks to us we have decided to develop a program.
Surely you have wondered how stores do to keep everything in order and record each sale,
because for this they use a program like the one shown in this report.
The program we have developed will facilitate the order of the products through their
qualification, the registration of the sale (either on credit or cash) and saves time.
This is useful for those stores that work in the field of motorcycle trade, repair and sale of
spare parts and accessories.
INTRODUCCION:
En este se dará a conocer el paso a paso de la elaboración del sistema partiendo de la Programación
Orientada A Objetos, de manera que se pueda entender cómo se aplicó los conocimientos del
lenguaje de programación de Java, en particular en el entorno de desarrollo de NetBeans.
Antes de adentrarnos en la programación orientada a objetos debemos tener una idea acerca de lo
que trata por lo cual se dará una breve introducción. Actualmente una de las áreas más importantes
en la industria y en el ámbito académico es la orientación a objetos, la orientación a objetos
promete mejoras de amplio alcance en la forma de diseño, desarrollo y mantenimiento del
software ofreciendo una solución a largo plazo a los problemas y preocupaciones que han existido
desde el comienzo en el desarrollo de software; la falta de portabilidad del código y reusabilidad,
códigos que son difíciles de modificar, ciclos de desarrollos largos y técnicas de codificación no
intuitivas.
Un lenguaje orientado a objetos responde a estos problemas, por lo cual tiene tres características
básicas: debe estar basado en objetos, basado en clases y capaz de tener herencia de clases. El
elemento fundamental de la (POO) es, como su nombre lo indica el objeto, se puede definir un
objeto como un conjunto complejo de datos y programas que poseen estructura y forman parte de
una organización.
Ya establecida una idea de lo que se trata la POO en el presente proyecto está basado en la creación
de un programa para una tienda ligada a la venta de vehículos.
CAPÍTULO 1 PRESENTACIÓN DEL PROBLEMA
1.1. Planteamiento del problema
La programación desempeña un papel de elevada importancia de la informática, también en la
educación intelectual de todo programador y, como toda disciplina, presenta un sin fin de problemas
que por sí mismos, suponen un desafío en el avance de la misma. Por lo cual requiere de cualidades
indispensables como la lógica, el rigor, la abstracción, la formalización y el orden, las cuales ayudan a
discernir los conceptos e ideas.
Durante los últimos años se han propuesto varios modelos y técnicas para lograr que los programadores
mejoren su proceso cognitivo en esta área, para que la enseñanza se vuelva más agradable y adquiera
cada día más seguidores.
1.2. Formulación del problema
Desde siempre, la observación y el modelamiento han sido fuentes primarias del avance informático. Un
programador debe entender lo que realiza, por tanto, una resolución metódica y comprensible de
afirmaciones es necesaria para la correcta creación y ejecución de algún programa.
1.3. Objetivos del proyecto
1.3.1. Objetivo general
Explicar paso a paso, sin omitir detalles, el proceso para creación de un programa para
una tienda encargada a la venta de vehículos utilizando las técnicas de la Programación
Orientada a Objetos (POO). Estos mismos pasos podrían utilizarse para la
modificación de cualquier programa.
1.3.2. Objetivos específicos
Utilizar los conocimientos obtenidos en clase del programa de la tienda.
Implementar códigos para mejorar la presentación y versatilidad del
programa al momento de ejecutarlo.
Obtener nuevos conceptos acerca de programación de POO, a través de la
investigación personal y grupal para mejorar el programa.
Hacer un informe que nos permita mostrar toda la modificación que
logramos en el programa de la tienda.
CAPÍTULO 2 PROPUESTA
Este tema será de gran utilidad para el principiante en POO, pues se irá
explicando todo el
proceso paso a paso. Quizás para alguien experto no sea necesario dar tantos
detalles, pero para el que se inicia en la POO será muy útil. Esa misma metodología
le servirá para poder crear no solo programas de ventas, sino cualquier tipo de programa
orientado a objetos, sin importar el lenguaje que se utilice para ello.
1. Explicación del programa:
La necesidad de ahorra tiempo, dinero y el arduo trabajo de manejar un negocio
surge la necesidad de buscar una vía que nos facilite todo eso gracias hemos
decidido elaborar un programa.
Seguramente te has preguntado cómo hacen las tiendas para mantener todo en
orden y registrar cada venta, pues para esto ellas utilizan un programa como el
que se mostrará en este informe.
El programa que hemos elaborado facilitara registro del orden de los productos a
través de calificación de estos, el registro de la venta (ya sea al crédito o al
contado) y ahorra el tiempo.
1.1 Acciones que podrá desarrollar el programa.
1. Mostrará un menú de opciones para elegir (ventas de motos, reparación
de motos, mostrar todo, borrar todo, buscar datos y modificar datos.)
2. Permite ingresar los datos del cliente (nombre, apellido, dirección,
número de teléfono, fecha de compra)
3. Permite elegir ingresar los datos de la moto (tipo, código, el precio)
4. Permite ingresar a la opción de reparación de motos, en la cual piden
diferentes datos (fecha de entrega, código de la moto, el tipo de
reparación, el tipo de daño) y muestra un mensaje.
5. Tiene una opción que te muestra todo lo que se ha registrado y también
para poderlo borrarlo.
6. Permite buscar los datos registrados y modificarlos.
Y al finalizar te muestra una opción para salir del programa.
2. Proyecto basado en:
2.1 Métodos
Los métodos son funciones que determinan el comportamiento de los objetos. Un
objeto tendrá un comportamiento u otro según los métodos de que disponga. Los
métodos se declaran y definen en las clases. Así, cualquier objeto de esa clase
tendrá disponibles esos métodos y podrán ser invocados.(1,2)
2.2 Recursividad
Un método es recursivo cuando se llama a si mismo ya sea directamente e
indirectamente. Si un método recursivo se invoca con un caso base, simplemente
devuelve un resultado. Si el método se invoca con un problema más complejo,
divide el problema en dos o más partes conceptuales.(3,4)
2.3 Sobrecarga
La única limitación en la elección del nombre de un método es que, en una clase,
todos los métodos deben tener diferente signatura. Esto permite que existan
varios métodos con el mismo nombre, pero con diferentes parámetros o diferente
tipo de retorno.(2)
2.4 Arrays
En muchos programas existe la necesidad básica de disponer de muchas variables
u objetos del mismo tipo o de la misma clase. En este caso, es necesario poder
llamar a todo el grupo de variables o de objetos con un único nombre para todos
ellos. Además, debe ser posible manejar cada uno de ellos de forma individual
como se ha descrito en capítulos anteriores. La estructura de almacenamiento que
proporciona Java, y que existe en prácticamente todos los lenguajes de
programación es el array.(1)
2.5 Clases y sus miembros
Una clase es una plantilla o prototipo que define las variables y los métodos
comunes a todos los objetos de cierto tipo. Las clases definen estado (variables) y
comportamiento (métodos) de todos los objetos.
Una clase es una agrupación de datos y de código (métodos) que actúa sobre esos
datos, a la que se le da un nombre.
Una clase contiene:
Datos (se denominan Datos Miembro). Estos pueden ser de tipos primitivos o
referencias.
2.6 Relación entre clases
Las relaciones existentes entre las distintas clases nos indican cómo se comunican los
objetos de esas clases entre sí:
Los mensajes “navegan” por las relaciones existentes entre las distintas clases.
Existen distintos tipos de relaciones:
Asociación (conexión entre clases)
Dependencia (relación de uso)
Generalización/especialización (relaciones de herencia)(1,2)
2.7 de acceso a los miembros de un clase.
Los modificadores de acceso, como su nombre indica, determinan desde qué clases se
puede acceder a un determinado elemento. En Java tenemos 4 tipos: Public, Private,
Protected y el tipo por defecto, que no tiene ninguna palabra clave asociada, pero se
suele conocer como default o package-private.(2,3)
2.8 Métodos constructores y la referencias This
Un Constructor es una función, método, etc., de las clases, la cual es llamada
automáticamente cuando se crea un objeto de esa clase.
En el caso anterior, dentro del constructor se desea asignar valores a los campos de una
Clase, sin embargo, dentro del constructor son utilizados como parámetros de entrada los
mismos valores, para tener acceso a los campos de la Clase se utiliza el vocablo: this, al
emplear esta sintaxis se está haciendo alusión a los campos de la Clase.(3)
2.9 Herencia de clase
A través de la herencia, una clase nueva hereda los atributos y métodos de una superclase
previamente definida. En este caso decimos que la nueva clase es una subclase.
En la herencia simple, una clase se hereda de una superclase.
Las relaciones de herencia forman estructuras jerárquicas similares a un árbol.
Una superclase existe en una relación Jerárquica con sus subclases.(2,4)
2.10 Clases abstractas
Java proporciona un tipo especial de clase, llamada clase abstracta, que pueden ayudar a
la organización de clases basadas en métodos comunes. Una clase abstracta permite
colocar los nombres de los métodos comunes en una sola clase (sin tener que escribir el
código que los implemente). Después, al crear nuevas clases, éstas pueden derivar de una
clase abstracta que contiene una serie de métodos requeridos.(4)
2.11 Interfaces
El concepto de interface lleva un paso más adelante la idea de las clases abstractas. En
Java una interface es una clase abstracta pura, es decir una clase donde todos los métodos
son abstractos (no se implementa ninguno). Permite al diseñador de clases establecer la
forma de una clase (nombres de métodos, listas de argumentos y tipos de retorno, pero no
bloques de código). Una interface puede también contener datos miembro, pero estos son
siempre static y final. Una interface sirve para establecer un 'protocolo' entre clases.
Para crear una interface, se utiliza la palabra clave interface en lugar de class. La interface
puede definirse Public o sin modificador de acceso, y tiene el mismo significado que para
las clases. Todos los métodos que declara una interface son siempre Public.
Para indicar que una clase implementa los métodos de una interface se utiliza la palabra
clave implements. El compilador se encargará de verificar que la clase efectivamente
declare e implemente todos los métodos de la interface. Una clase puede implementar
más de una interface.(2,3,4)
2.12 Herencia Múltiple De Interfaces
Una clase puede implementar varios interfaces simultáneamente, pese a que, en
Java, una clase puede heredar de otra clase (herencia simple de implementación,
múltiple de interfaces).(2,4)
2.13 Polimorfismo
Mediante el polimorfismo, se pueden escribir programas que procesen genéricamente –
como objetos de superclase- objetos de todas las clases existentes en una jerarquía.(1)
2.14 Paquetes
Un package es una agrupación de clases afines. Equivale al concepto de librería existente
en otros lenguajes o sistemas. Una clase puede definirse como perteneciente a un package
y puede usar otras clases definidas en ese o en otros packages.
Los packages delimitan el espacio de nombres (space name). El nombre de una clase debe
ser único dentro del package donde se define. Dos clases con el mismo nombre en dos
packages distintos pueden coexistir e incluso pueden ser usadas en el mismo programa.(5)
2.15 Excepciones
Una excepción es un evento que ocurre durante la ejecución del programa que interrumpe
el flujo normal de las sentencias.
Muchas clases de errores pueden utilizar excepciones -- desde serios problemas de
hardware, como la avería de un disco duro, a los simples errores de programación, como
tratar de acceder a un elemento de un array fuera de sus límites. Cuando dicho error ocurre
dentro de un método Java, el método crea un objeto 'exception' y lo maneja fuera, en el
sistema de ejecución. Este objeto contiene información sobre la excepción, incluyendo su
tipo y el estado del programa cuando ocurrió el error. El sistema de ejecución es el
responsable de buscar algún código para manejar el error.(6)
DESCRIPCION DE SOLUCIONES
acciones
+String acelerar();
+ String frenar();
+ String claxon();
vehículos
String marca,modelo,placa,codigo;
int precio,ncuotas,pagomensual;
+ String acelerar();
+ String frenar();
+ String claxon();
carros motos
String combustible, String serie_catalina;
String marca,modelo,placa,codigo; String serie_cadena;
Int precio,ncuotas,pagomensual,Int
npuertas;
+ String acelerar();
+ String acelerar(); + String frenar();
+ String frenar(); + String claxon();
+ String claxon();
Carro_deportivo
Carro_normal String combustible,
String combustible, String
String marca,modelo,placa,codigo; serie_nitrogenomarca,modelo,placa
Int precio,ncuotas,pagomensual,Int ,código,serie_cilindrera;
npuertas, int numero_llanta; Int precio,ncuotas,pagomensual,Int
npuertas;
+ String acelerar();
+ String acelerar();
+ String frenar();
+ String frenar();
+ String claxon();
+ String claxon();
//CODIGO DEL PROGRAMA:
//Ejecucion del programa
//opción N°1
//Opción N°2:
//Opcion N°3
//Opcion N°4:
REFERENCIAS BIBLIOGRÁFICAS
1. Sánchez Allende J, Huecas Fernández-Toribio G, Moreno Díaz P.
Programación en Java 2. Madrid: McGraw-Hill España;
2005.
2. Azpitarte R., Jordá P., Devesa J., Miedes E., Ruiz M., Torres F :
Introducción a la Programación Orientada a Objetos con
Java, Departamentos de sistemas informáticos y }
computación, Universidad Politécnica de Valencia.
Marzo 2009.
3. González Marcos A, Elías FA, Meré JO. Ingeniería de proyectos.
Madrid: Dextra Editorial; 2014.
4. Moreno Pérez J. Programación orientada a objetos. Madrid: RA-
MA Editorial; 2015.
5. Luna Bermúdez JD. Programación y evaluación aplicadas a la
gestión cultural. Málaga: IC Editorial; 2015.
6. Antúnez Soria FM. Puesta en marcha de sistemas de
automatización industrial. ELEM0311. Málaga: IC
Editorial; 2016.