Método de las 6`D Modelamiento - Algoritmo - Programación.

Método de las 6`D Modelamiento - Algoritmo - Programación. Tomo III. Enfoque orientado a los arreglos de objetos, listas enlazadas y archivos de datosAutores: Juan José Flores Cueto y Carlos Chris an Acuña Flores

© Derechos de autor registrados:Empresa Editora Macro EIRL

© Derechos de edición, arte gráfi co y diagramación reservados:Empresa Editora Macro EIRL

Corrección de es lo: Milton A. Gonzales M.

Coordinación de arte y diseño: Alejandro Marcas León

Diagramación:Sebas an Alvarez Sanchez

Edición a cargo de:© Empresa Editora Macro EIRLAv. Paseo de la República N.° 5613, Mirafl ores, Lima, Perú

Teléfono: (511) 748 0560E-mail: [email protected]ágina web: www.editorialmacro.com

Primera edición: se embre de 2014Tiraje: 1000 ejemplares

ImpresiónTalleres gráfi cos de la Empresa Editora Macro EIRLJr. San Agus n N.° 612-624, Surquillo, Lima, Perú

ISBN N.° 978-612-304-219-6 Hecho el depósito legal en la Biblioteca Nacional del Perú N.° 2014 -12579

Prohibida la reproducción parcial o total, por cualquier medio o método, de este libro sin previa autorización de la Empresa Editora Macro EIRL.

Juan José Flores Cueto

Ingeniero de Computación y Sistemas, magister en Administración con mención en Gerencia Estratégica de Organización; doctor en Educación por la Universidad de San Mar n de Porres (USMP). Además, obtuvo el tulo de Especialista y el Diploma de Estudios Avanzados (DEA) en Integración de las Tecnologías de la Información en las Organizaciones (ITIO), por la Universidad Politécnica de Valencia (UPV), España. Actualmente, es doctorando del Programa ITIO de la UPV.

Se ha desempeñado profesionalmente en diversas empresas nacionales, ocupando las funciones de desarrollador de so ware, analista de sistemas, auditor de sistemas y jefe de proyectos. Desde mayo del 2009 ocupa el cargo de director de la USMP Virtual, donde además ejerce la docencia. También se desempeña como catedrá co en la Facultad de Ingeniería y Arquitectura (FIA) de la Universidad de San Mar n de Porres (USMP), y en la Universidad Nacional José Faus no Sánchez Carrión (UNJFSC).

Es autor de diversos libros, como guías y manuales, los cuales se u lizan para la enseñanza universitaria. También ha colaborado con ar culos para revistas nacionales e internacionales, y ha par cipado en diversos congresos.

La página personal del autor es: h p://jjfl orescueto.googlepages.com/. Y sus publicaciones se pueden encontrar en: h p://www.lulu.com/spotlight/jjfl orescueto, y en la red: h p://www.reddolac.org

Carlos Chris an Acuña Flores

Ingeniero de Computación y Sistemas por la Universidad San Mar n de Porres (USMP), con estudios de maestría en Ingeniería de Sistemas con mención en Ges ón de Tecnologías de la Información. Doctorando en Ingeniería de Sistemas de información en la USMP. Cuenta con un diplomado en Docencia Virtual y en Ges ón Universitaria por la misma casa de estudios. Asimismo, ha sido becario de la Organización de Estados Americanos (OEA) en Estrategias de Gobierno Electrónico.

Se desempeña como catedrá co en la Facultad de Ingeniería y Arquitectura (FIA) de la USMP, y en otras ins tuciones de educación superior. Es consultor en sistemas de información, tecnologías de información y gobierno electrónico. También se desempeña como consultor en acreditación de programas profesionales de ingeniería y tecnología con los estándares de ABET, ASIIN, ICACIT, ACSUG y CONEAU. Es auditor de Acreditación ICACIT y experto en desarrollo organizacional, ges ón de procesos, aseguramiento de la calidad y medios sociales.

Agradecimientos

Nuestro agradecimiento a todas las personas que de una u otra forma contribuyeron en el desarrollo de la presente obra. Muchas gracias.

Índice

Capítulo 1

Procesamiento de datos (PD). Uso de arreglo de objetos ................................................................. 13

1.1 Arreglo de datos ................................................................................................................161.1.1 Conceptos básicos .....................................................................................................161.1.2 Arreglos unidimensionales – vectores .......................................................................161.1.3 Arreglos bidimensionales – matrices .........................................................................191.1.4 Arreglos en paralelo ...................................................................................................201.1.5 Arreglos de gran tamaño ...........................................................................................21

1.2 Arreglo de objetos ............................................................................................................221.3 Método de inserción de datos .........................................................................................541.4 Modelo Vista Controlador (MVC) ......................................................................................581.5 Inténtalo ............................................................................................................................891.6 Problemas propuestos ......................................................................................................94

Capítulo 2

Procesamiento de datos (PD). Uso de listas enlazadas ..................................................................... 97

2.1 Lista enlazada simple .......................................................................................................1002.1.1 Conceptos básicos .....................................................................................................1002.1.2 Iden fi cación de clases ..............................................................................................1012.1.3 Ingresar datos en la lista ............................................................................................1042.1.4 Mostrar datos en la lista ............................................................................................1112.1.5 Eliminar datos del inicio y fi nal de la lista ..................................................................1262.1.6 Modifi car datos de la lista ..........................................................................................1282.1.7 Insertar datos en una lista simple ..............................................................................1452.1.8 Eliminar datos de una lista simple .............................................................................1492.1.9 Métodos para cambiar la posición de los elementos de una lista .............................151

2.2 Lista enlazada doble con un enlace...................................................................................1582.3 Lista enlazada doble con dos enlaces ...............................................................................1692.4 Lista enlazada circular simple ...........................................................................................1722.5 Lista enlazada circular doble .............................................................................................1752.6 Inténtalo ............................................................................................................................1782.7 Problemas propuestos ......................................................................................................179

Capítulo 3

Procesamiento de datos (PD). Uso de archivos .................................................................................. 181

3.1 Archivos de texto .............................................................................................................1843.1.1 Conceptos básicos .....................................................................................................1843.1.2 Clase RandomAccessFile ............................................................................................1893.1.3 Clase File ....................................................................................................................1943.1.4 Clase System ..............................................................................................................200

3.2 Archivos de datos .............................................................................................................2073.2.1 Generalidades ............................................................................................................2073.2.2 Estructura ..................................................................................................................207

3.3 Soluciones desarrolladas ..................................................................................................2093.4 Inténtalo ...........................................................................................................................2763.5 Problemas propuestos ......................................................................................................282

Bibliogra a .............................................................................................................................................. 284

Apéndice *

Clase Lectura .......................................................................................................................................... 291

Clase LE (versión 2.2) ............................................................................................................................. 293

* El presente apéndice solo se encuentra disponible en la página web de la editorial: www.editorialmacro.com

Introducción

En este libro se trata, en forma detallada y dinámica, conceptos y temas avanzados para el desarrollo de soluciones; estas u lizan el Método de las 6´D para el desarrollo de sus capacidades lógicas y de programas de computadoras medianamente complejos. Se presentan un total de tres capítulos con nuevos temas, y en cada uno de ellos se profundiza en el desarrollo de soluciones u lizando las estructuras lógicas (if. if / else, do, while, switch, for) y las estructuras de datos (arreglo de objetos, listas enlazadas y archivos de datos). Se u lizan conceptos de la Teoría Orientada a Objetos (TOO), del Lenguaje de Modelamiento Unifi cado UML (Unifi ed Modeling Language) y del desarrollo de Interfaces Gráfi cas de Usuario GUI (Graphics User Interface).

Se tratan los aspectos relacionados a los arreglos de objetos como parte de la teoría de arreglos; también se aborda el desarrollo de soluciones u lizando dos o tres clases, esta úl ma como una introducción al desarrollo de soluciones basadas en el Modelo Vista Controlador (MVC - Model View Controller). Se presentan en forma detallada los aspectos teóricos y prác cos que rodean a las listas enlazadas y sus diferentes pos (listas simples, listas dobles y listas circulares), y se aplica detalladamente el concepto de “referencia de objetos”, base de la lógica empleada en cada uno de los métodos desarrollados para el manejo de los datos en listas enlazadas.

Se realiza una revisión de los aspectos fundamentales de la teoría de archivos y del uso de las clases RandomAccessFile, File y System de Java, para luego profundizar en el desarrollo de soluciones u lizando archivos con arreglos en paralelo, archivos con arreglos de objetos y archivos con listas enlazadas, basados en estructuras de archivos de registro de longitud fi ja y de longitud variable. También, se incluye la sección “inténtalo” al fi nal de cada uno de los capítulos, con problemas propuestos y/o problemas resueltos, los cuales se han desarrollado con nuevos temas o algoritmos no expuestos en la presente obra. Estamos convencidos de que esta sección contribuirá a fomentar la inves gación en temas relacionados a los tratados en el presente libro.

Todos los conceptos que se desarrollan en la presente publicación están codifi cados en el lenguaje de programación java. En cada capítulo se presentan problemas resueltos que van aumentando en complejidad conforme se avanza con la lectura del libro. La can dad de problemas desarrollados (50 en total) garan zan un aprendizaje progresivo y adecuado de todos los temas tratados.

PROCESAMIENTO DE PROCESAMIENTO DE DATOS (PD) . Uso de DATOS (PD) . Uso de a r reg lo de ob jetos a r reg lo de ob jetos

1CAP.

CAP. 1: PROCESAMIENTO DE DATOS (PD). USO DE ARREGLO DE OBJETOS 15

La clase cons tuye la base de la programación orientada a objetos, y es el núcleo o unidad fundamental de encapsulación en Java. Cualquier concepto que desee desarrollar en Java debe ser encapsulado en una clase. Una clase se usa para crear objetos.

Etapa 02

Etapa 03

Etapa 04

Defi nición

Diseño

Desarrollo

ENUNCIADO

DEL

PROBLEMA

MARCO DE TRABAJO

MODELAMIENTOMODELAMIENTOALGORITMOALGORITMO

CODIFICACIÓNCODIFICACIÓN

Es importante mencionar que, para iniciar el estudio del libro en general, es indispensable el conocimiento del Método de las 6’D, así como de las estructuras lógicas. Si no ene conocimiento de dichos temas le sugerimos consultar el siguiente libro: MÉTODO DE LAS 6’D. Modelamiento – Algoritmos – Programación. (enfoque orientado a las estructuras lógicas). También es necesario el conocimiento de los arreglos en su forma básica, de los conceptos que rodean a la Teoría Orientada a Objetos TOO y al diseño y programación de Interfaces Gráfi cas de Usuario GUI. Si no ene conocimiento sobre estos temas le sugerimos consultar el libro MÉTODO DE LAS 6’D. Modelamiento – Algoritmos – Programación. (Enfoque orientado a los Arreglos y a la TOO).

En el presente capítulo se tratarán las estructuras de datos conocidas como arreglo de objetos, y se estudiará, en profundidad, los métodos necesarios para manejar los datos almacenados en este po de estructuras de datos. Estos métodos servirán para: ingresar datos, mostrar información, buscar datos, ordenarlos, modifi carlos y eliminarlos. También se estudiarán métodos que permiten mostrar información valiosa para la toma de decisiones.

MÉTODO DE LAS 6’D - ENFOQUE ORIENTADO A LOS ARREGLOS DE OBJETOS, LISTAS ENLAZADAS Y ARCHIVOS DE DATOS16

Es importante indicar que en este primer capítulo se desarrollan soluciones con dos clases, y luego soluciones con tres clases, como una introducción al Modelo Vista Controlador MVC. Finalmente, en la sección “INTÉNTALO” se plantea el desarrollo de tres soluciones u lizando arreglo de objetos con GUI y gráfi cos, con la Clase de Colección ArrayList, y con archivos de po PDF, lo cual le permi rá con nuar con su inves gación en el tema y profundizar en otros, como clases de colección de Java y manejo de archivos PDF.

1.1 ARREGLO DE DATOS

1.1.1 Conceptos básicos

A. Defi nición:

Los arreglos, conocidos también como arrays, son estructuras de datos que permiten almacenar más de un dato del mismo po a la vez. Es decir, un arreglo con ene un conjunto de datos, todos del mismo po. Un arreglo puede almacenar un conjunto limitado de datos. Cada dato perteneciente al arreglo se almacena en una posición y puede ser mostrado, modifi cado o eliminado.

B. Ventajas: Los datos están almacenados en una sola estructura de datos, lo cual hace más fácil el acceso a

los mismos.

Se u liza un único nombre (nombre del arreglo) para referirse al conjunto de datos almacenados en el arreglo. Esto nos permite reducir el uso de variables y constantes.

Los arreglos permiten almacenar datos de entrada y datos u lizados durante el procesamiento.

Al igual que otras estructuras de datos (como las variables y constantes), los arreglos enen un empo de vida, por lo que pueden ser considerados como globales o locales.

C. Desventajas: Un arreglo no puede almacenar datos de diferente po. Se puede tener un arreglo de números

enteros, o un arreglo de cadenas, pero no se puede tener un arreglo que contenga, por ejemplo, cadenas y números enteros a la vez.

Dependiendo del po de arreglo, unidimensional o bidimensional, se necesitará uno o dos índices para acceder a los datos almacenados en el arreglo.

Antes de crear un arreglo es necesario conocer el número exacto de datos que se necesitan almacenar (aunque esto no es tan cierto, ya que se pueden crear algoritmos que permitan redimensionar los arreglos. También, existe una clase en Java, denominada Vector, que pertenece al paquete java.u l, que ene métodos que permiten crear un vector y redefi nir su tamaño cada vez que sea necesario).

1.1.2 Arreglos unidimensionales - vectores

A. Defi nición:

Los arreglos unidimensionales, conocidos también como vectores o registros, son estructuras de datos que permiten almacenar más de un dato del mismo po a la vez. Es decir, un vector con ene un conjunto de datos, todos del mismo po, a los cuales se puede acceder a través de un índice.


B. Representación gráfi ca:

A con nuación se muestra la representación gráfi ca de un arreglo unidimensional llamado nombre:

Nombre

Donde:

Nombre = Nombre del vector.X0...Xi-1 = Datos almacenados en el vector.i = Tamaño del vector.

C. Declaración:

Para declarar un arreglo unidimensional es necesario, en primer lugar, defi nir un nombre. Para defi nir un nombre de un arreglo unidimensional se deben respetar las mismas reglas u lizadas para la defi nición de nombres de variables y constantes.

En segundo lugar, se debe determinar qué po de dato podrá almacenar el arreglo unidimensional. Este sólo puede almacenar datos del mismo po. Los pos de datos válidos para declarar un arreglo unidimensional son los mismos pos de datos válidos defi nidos para declarar variables y constantes.

En general, para declarar un arreglo unidimensional se u liza el siguiente formato:

En Java:

TipoDeDato arreglo[ ] ;

TipoDeDato[ ] arreglo;

En Pseudocódigo y Diagrama de Flujo:

Donde TipoDeDato debe ser un po de arreglo o po de dato válido; y arreglo es el nombre del arreglo unidimensional (puede exis r más de un arreglo, los cuales serán separados por comas).

Para declarar un arreglo unidimensional se u liza sólo un corchete de apertura y cierre “[ ]” al fi nal del nombre del arreglo.

También se puede declarar un arreglo unidimensional colocando los corchetes de apertura y cierre después del po de dato, y no después del nombre del arreglo unidimensional, según se muestra a con nuación:

En Java:

TipoDeDato[ ] arreglo ;


En Pseudocodigo y Diagrama de Flujo:

D. Creación:

Para crear un arreglo unidimensional es necesario que dicho arreglo haya sido previamente declarado, tal y como se explicó anteriormente.

Antes de crear un arreglo unidimensional se debe determinar cuál va ser el tamaño del mismo. Es decir, cuál va a ser la can dad total de datos que se podrá almacenar en él.

Para crear un arreglo unidimensional se u liza el siguiente formato:

En Java:

En Pseudocodigo y Diagrama de Flujo:

Donde TipoDeDato debe ser un po de arreglo unidimensional o po de dato válido; y arreglo es el nombre del arreglo.

El operador new nos permite crear un arreglo unidimensional. Cuando se crea un arreglo unidimensional con el operador new, se debe indicar el tamaño, es decir la can dad de datos que podrá almacenar.

Es importante mencionar que el po de dato u lizado para crear un arreglo unidimensional deberá ser el mismo po con el cual se declaró, y para crearlo es necesario especifi car un índice.

En Java, existe también una forma directa para declarar y crear arreglos unidimensionales, u lizando el siguiente formato:

En Java:

Donde TipoDeDato debe ser un po de arreglo unidimensional o po de dato válido; y arreglo es el nombre del arreglo unidimensional.

U lizando este formato se declara y crea el arreglo unidimensional en forma directa (esto es conocido como “Defi nición de un arreglo”).

TipoDeDato[ ] arreglo;

arreglo = new TipoDeDato [tamaño] ;

CREAR arreglo[tamaño]

TipoDeDato arreglo[ ] = new TipoDeDato [tamaño];


E. Inicialización:

Cuando se crea un arreglo unidimensional u lizando el operador new es recomendable, aunque no necesario, inicializar todas las posiciones del mismo. Esto signifi ca que se debe asignar un valor a cada posición con la fi nalidad de evitar que se produzca un error si se intenta acceder a una posición del arreglo unidimensional que todavía no con ene un dato.

Generalmente, los arreglos numéricos ( po NUMERO) se inicializan con cero (0), los arreglos lógicos ( po LOGICO) o booleanos se inicializan con false, los arreglos de caracteres con ‘0’ y los arreglos de objetos con null.

F. Ingreso de datos:

Después de crear un arreglo unidimensional, inicialice o no el arreglo unidimensional, se deberán ingresar datos.

Es necesario que se ingresen datos a todas las posiciones del arreglo unidimensional. Si no se ingresan datos a todas las posiciones del arreglo unidimensional deberá asegurarse de inicializarlo o, en su defecto, de mantener un adecuado control de las posiciones que enen datos almacenados y aquellas que no. Recuerde que tratar de acceder a una posición que no ene un dato, o que no ha sido inicializada, produce un error que ocasiona una interrupción en la ejecución del programa.

1.1.3 Arreglos bidimensionales - matrices

A. Defi nición:

Los arreglos bidimensionales, conocidos también como matrices o tablas, son estructuras de datos que permiten almacenar más de un dato del mismo po a la vez. Es decir, una matriz con ene un conjunto de datos, todos del mismo po, a los cuales se puede acceder a través de dos índices.

B. Representación gráfi ca:

A con nuación se muestra la representación gráfi ca de un arreglo bidimensional llamado nombre:

Es importante indicar que para declarar, crear, inicializar e ingresar datos en un arreglo bidimensional o matriz, se siguen las mismas reglas defi nidas para los arreglos unidimensionales o vectores. La diferencia radica en el número de índices que se u lizarán.

Nombre = Nombre de la matriz.X00...Xi-1, j-1 = Datos almacenados en la matriz.i * j = Tamaño de la matriz.

Nombre

Donde:


1.1.4 Arreglos en paralelo

Cuando se plantean soluciones a diversos problemas es necesario u lizar variables, vectores y matrices en forma simultánea para almacenar los datos. Es decir, en una solución se pueden u lizar algunas variables, un vector, dos vectores o muchos vectores. También se pueden u lizar variables, un vector y una matriz, o dos vectores y una matriz. En términos generales, se puede afi rmar que en una solución se u lizan variables, vectores y matrices en forma simultánea y en el número que se necesiten. Esto va a depender de la complejidad y po de problema que se necesite resolver.

Cuando en una solución se u liza más de un arreglo, y el orden en que se disponen los datos entre los arreglos ene un signifi cado, se les denomina vectores paralelos.

Ejemplos:En la siguiente gráfi ca de estructura de datos se u liza una variable y dos vectores en forma simultánea (en paralelo). En la variable (numTrab) se almacena el número de trabajadores y con este valor se crean los dos vectores (los arreglos en paralelo deben tener el mismo tamaño). En uno de los vectores (nombre[ ]) se almacenan los nombres de todos los trabajadores, y en el otro vector (sueldo[ ]) se almacenan sus respec vos sueldos. Se puede observar que un dato almacenado en una posición de un vector está relacionado con el dato almacenado en la misma posición del otro vector.

Dados los vectores:

Donde numTrab permite almacenar el número de trabajadores.

La pregunta lógica que se puede formular sería la siguiente: ¿Por qué en vez de crear dos vectores en paralelo no creamos una matriz con dos columnas? Y la respuesta sería que en una matriz solo se pueden almacenar datos del mismo po, mientras que usando dos vectores en paralelo se pueden almacenar datos de diferente po. En el planteamiento de la solución anterior, en uno de los vectores se almacenan datos de po TEXTO mientras que en el otro vector se almacenan datos de po NUMERO.

En la siguiente gráfi ca de estructura de datos se u liza una variable y tres vectores en forma simultánea (en paralelo). En la variable (numSoc) se almacena el número de socios de un club y con este valor se crean los tres vectores. En uno de ellos (nombre[ ]) se almacenan los nombres de los socios, en otro (sexo[ ]) se almacena el sexo de cada uno de los socios, y en el tercer vector (edad[ ]) sus respec vas edades. Como ejemplo se puede observar que todos los datos del socio “Rodrigo” están almacenados en la posición cero de los vectores en paralelo.


Dados los vectores:

Donde numSoc permite almacenar el número de socios.

Finalmente, en la siguiente gráfi ca de estructura de datos se u liza una variable, un vector y una matriz con dos columnas en forma simultánea (en paralelo).

Dados los vectores:

Donde: numArt permite almacenar el número de Ar culos. PC = Precio de compra. PV = Precio de venta.

1.1.5 Arreglos de gran tamaño

Un arreglo de gran tamaño es aquel que se crea con una capacidad mayor a la can dad de datos que va a almacenar. Los arreglos de gran tamaño se u lizan cuando no se puede determinar desde un inicio cuál debe ser el tamaño con el que se debe crear un arreglo. Observe la siguiente gráfi ca de Estructuras de Datos:

Dado el vector:

Donde numAlu indica el número de códigos de alumnos almacenados.


En la gráfi ca mostrada se especifi ca que el vector codigo[ ] se creará con un tamaño de 1000. Tamaño sufi ciente para poder almacenar todos los códigos de los alumnos de un salón de clase (se supone que en un salón de clase no habrá tal can dad de alumnos). Para manejar los datos almacenados en un arreglo de gran tamaño se necesita una variable que indique el tamaño lógico del arreglo. En este caso, la variable numTrab nos indicará el total de códigos de alumnos que se han almacenado en el vector en un determinado momento. Al inicio, el valor de la variable numAlu deberá ser cero (esto signifi ca que cuando se inicia la ejecución de la aplicación no se ene almacenado ningún código de alumno). Esto también puede ser aplicado en arreglos en paralelo. Observe e interprete la siguiente gráfi ca de Estructuras de Datos:

Dados los vectores:

Donde numTrab indica el número de trabajadores cuyos datos se han almacenado.

1.2 ARREGLO DE OBJETOS

A. D :

Un arreglo de objetos es una estructura de datos que permiten almacenar objetos del mismo po, en lugar de almacenar datos simples. Es decir, un arreglo de objetos con ene un conjunto de objetos, todos del mismo po, a los cuales se puede acceder u lizando uno o dos índices. Es importante considerar que se podrá acceder a los datos almacenados en los objetos u lizando los métodos defi nidos en su clase.

B. R :

A con nuación se muestra la representación gráfi ca de un arreglo de objetos. Observe que un arreglo de objetos almacena objetos, y los objetos, a su vez, almacenan datos y métodos, los cuales han sido defi nidos en su clase:


A con nuación se muestra un conjunto de arreglos en paralelo defi nidos para una determinada solución, en comparación con su equivalente en arreglo de objetos:

Analice ambos diagramas e intente establecer las diferencias.


Problema 001

Etapa 01 – Descripción del problema

Enunciado: Desarrolle una solución que permita almacenar el código, nombre y sueldo de todos los empleados de una empresa tex l, teniendo en cuenta el diagrama de clase y la gráfi ca de estructura de datos mostrados. También desarrolle los métodos para agregar datos, mostrar los datos de todos los empleados y mostrar los datos de un empleado en base al código. U lice dos clases para el desarrollo de la solución.

Etapa 03 – Diseño de la lógica

Nombre del proyecto: ProyEmpleado1 Diagrama de clases:

Gráfi ca de estructura de datos:

Donde: numEmp = Número de empleados de la empresa.

Empleado()getCodigo()setCodigo()getNombre()setNombre()setSueldo()getSueldo()


Etapa 04 – Desarrollo de la codifi cación

Clase Empleado

package domPro;

public class Empleado {

private long codigo; private String nombre; private double sueldo; public Empleado(){ codigo = 0; nombre = null; sueldo = 0; }

public long getCodigo() { return codigo; } public void setCodigo(long codigo) { this.codigo = codigo; }

public String getNombre() { return nombre; }

public void setNombre(String nombre) { this.nombre = nombre; }

public double getSueldo() { return sueldo; }

public void setSueldo(double sueldo) { this.sueldo = sueldo; }}

Clase PrgEmpleado

package domApli;

import biblioteca.LE;import domPro.Empleado;

public class PrgEmpleado {

public Empleado datos[];private int numEmp;

public PrgEmpleado() {datos = new Empleado[5];numEmp = 0;

}


public void ingresarDatos() {int rpta;long codigo;String nombre;

double sueldo;

do {codigo = LE.leerLong("Ingrese el código");nombre = LE.leerString("Ingrese el nombre");sueldo = LE.leerDouble("Ingrese el sueldo");

Empleado objEmp = new Empleado();objEmp.setCodigo(codigo);objEmp.setNombre(nombre);objEmp.setSueldo(sueldo);

datos[numEmp] = objEmp;numEmp++;

rpta = LE.mostrarPreguntaOpcion2("Desea continuar? ");} while (rpta == 0);

}

public void mostrarDatos() {String listaDatos = "";for (int i = 0; i < numEmp; i++) {

listaDatos = listaDatos + datos[i].getCodigo() + " "+ datos[i].getNombre() + " " + datos[i].getSueldo() + "\n";

}LE.mostrarInformacion("Datos de los Empleados\n\n" + listaDatos);

}

public void mostrarDatosEmpleado() {long codigo = LE.leerLong("Ingrese código a buscar");int pos = -1;

for (int i = 0; i < numEmp; i++) {if (datos[i].getCodigo() == codigo) { pos = i;}

}if (pos > -1) {

LE.mostrarInformacion("Empleado " + datos[pos].getNombre() + "\nSueldo: " + datos[pos].getSueldo());

} else {LE.mostrarInformacion("Código de empleado no existe");

}}

public static void main(String arg[]) {PrgEmpleado x = new PrgEmpleado();x.ingresarDatos();x.mostrarDatos();x.mostrarDatosEmpleado();

}}


Observe y analice las siguientes líneas de codifi cación del método ingresarDatos ( ):

public void ingresarDatos ( ) {int rpta ; long codigo ;String nombre ;double sueldo ;

do {codigo = LE.leerLong ( “Ingrese el código” ) ;nombre = LE.leerString ( “Ingrese el nombre” ) ;sueldo = LE.leerDouble ( “Ingrese el sueldo” ) ;

Empleado objEmp = new Empleado ( ) ;objEmp.setCodigo ( codigo ) ;objEmp.setNombre ( nombre ) ;objEmp.setSueldo ( sueldo ) ;

datos [numEmp ] = objEmp ;numEmp ++ ;

rpta = LE.mostrarPreguntaOpcion2 ( "Desea continuar? " ) ;} while ( rpta == 0 ) ;

}

Primero se solicitan los datos del empleado, los cuales se almacenan en las variables codigo, nombre y sueldo. Imagínese que se ingresan los datos de un empleado que ene código 10, su nombre es “Juan José” y su sueldo es 1000.00.

… codigo = LE.leerLong ( "Ingrese el código" ) ; nombre = LE.leerString ( "Ingrese el nombre" ) ; sueldo = LE.leerDouble ( "Ingrese el sueldo" ) ;

…

Luego, se crea un objeto de la clase Empleado llamado objEmp:

… Empleado objEmp = new Empleado ( ) ;…

Al crearse el objeto se ejecuta en forma automá ca el método constructor, con el cual el objeto se inicializa. La siguiente fi gura muestra una representación, en forma gráfi ca, de la creación del objeto.


Una vez creado el objeto objEmp se procede a almacenar los datos ingresados y almacenados en las variables codigo, nombre y sueldo en el objeto objEmp. Para ello, u lizamos los métodos se er, tal y como se muestra a con nuación:

… objEmp.setCodigo ( codigo ) ; objEmp.setNombre ( nombre ) ; objEmp.setSueldo ( sueldo ) ; …

Ahora, el objeto objEmp con ene los datos ingresados, lo cual se representa en la fi gura siguiente:

Finalmente, el objeto objEmp de la clase Empleado se almacena en el arreglo de objetos llamado datos (observe que el arreglo datos solo puede almacenar datos de po Empleado, es decir, solo puede almacenar objetos de la clase Empleado).

Para almacenar el objeto objEmp en el arreglo datos u lizamos la siguiente sentencia:

… datos [numEmp ] = objEmp ;…

Es decir, el objeto objEmp se almacena en el arreglo datos en la posición especifi cada por numEmp (recuerde que un objeto con ene datos y una copia de los métodos especifi cados en la clase a la que pertenece).

Finalmente, es necesario incrementar la variable numEmp con la fi nalidad de que el próximo objeto se pueda almacenar en la siguiente posición del arreglo.


… numEmp ++ ;…

En resumen, para almacenar un objeto en un arreglo, hay que seguir los siguientes pasos:

1. Ingresar los datos a almacenar.

2. Crear un objeto de la clase que se desea almacenar en el arreglo de objetos.

3. Almacenar los datos ingresados en el objeto creado.

4. Almacenar el objeto creado en el arreglo de objetos.

5. Incrementar el valor de la variable que controla la posición donde se almacenará el siguiente objeto.

public void ingresarDatos ( ) {int rpta ; long codigo ;String nombre ;double sueldo ;do {

codigo = LE.leerLong ( “Ingrese el código” ) ;nombre = LE.leerString ( “Ingrese el nombre” ) ;sueldo = LE.leerDouble ( “Ingrese el sueldo” ) ;

Empleado objEmp = new Empleado ( ) ;

objEmp.setCodigo ( codigo ) ;objEmp.setNombre ( nombre ) ;objEmp.setSueldo ( sueldo ) ;

datos [numEmp ] = objEmp ;

numEmp ++ ;


}

Paso 1

Paso 2

Paso 3

Paso 4

Paso 5

Es posible codifi car y u lizar un segundo método constructor de la clase Empleado, el cual reciba los datos necesarios para inicializar los atributos del objeto creado. Para ello, modifi que la clase Empleado agregando el método constructor (cuando existe más de un método constructor en una clase se denomina sobrecarga de métodos constructores) que se muestra a con nuación:

Clase Empleado

package domPro ;public class Empleado {

private long codigo ;private String nombre ;private double sueldo ;

public Empleado ( ) {

codigo = 0 ;nombre = null ;


sueldo = 0 ;}public Empleado ( long codigo, String nombre, double sueldo ) {

this.codigo = codigo ;this.nombre = nombre ;this.sueldo = sueldo ;

}

/* … Incluir los métodos setter y getter …

*/ }

Si se cuenta con un método constructor en la clase Empleado que reciba datos para que los valores de los atributos sean inicializados, se podría reducir las líneas de código u lizadas para almacenar un objeto de la clase Empleado en el arreglo datos [ ], y solo se u lizarían las siguientes sentencias:

public void ingresarDatos ( ) {int rpta ; long codigo ;String nombre ;double sueldo ;

do {codigo = LE.leerLong ( “Ingrese el código” ) ;nombre = LE.leerString ( “Ingrese el nombre” ) ;sueldo = LE.leerDouble ( “Ingrese el sueldo” ) ;

Empleado objEmp = new Empleado (codigo, nombre sueldo ) ;datos [numEmp ] = objEmp ;numEmp ++ ;


}

Ahora, para poder mostrar los datos almacenados en un arreglo de objetos es necesario u lizar los métodos ge er. Imagínese que se han ingresado los códigos, nombres y sueldos de tres empleados, los cuales se muestran en la siguiente gráfi ca de estructura de datos:

codigo = 10nombre = “Juan José”sueldo = 1000.00-----------setCodigo()getCodigo()setNombre()getNombre()setSueldo()getSueldo()

Datos

0


codigo = 20nombre = “Carmen”sueldo = 2000.00-----------setCodigo()getCodigo()setNombre()getNombre()setSueldo()getSueldo()

codigo = 30nombre = “Danae”sueldo = 500.00-----------setCodigo()getCodigo()setNombre()getNombre()setSueldo()getSueldo()

1

2

3

4

(Empleado)

Si se desea recuperar el código del empleado almacenado en la posición 1 del arreglo de objetos datos [ ], debería u lizar la siguiente sentencia:

… long codigo = datos [ 1 ].getCodigo ( ) ;…

Nombre delarreglo

Método a ejecutar

Especifi ca la posición del arreglo

Observe que se ejecuta el método getCodigo( ) del objeto de la clase Empleado almacenado en la posición 1 del arreglo datos[ ]. El valor que el método getCodigo( ) devuelve, se almacena en la variable codigo. Esto permite que la variable codigo almacene el valor 20, según el ejemplo planteado.

Si se desea recuperar todos los datos almacenados en el arreglo de objetos, se podría u lizar la estructura de repe ción for, tal y como se emplea en el método mostrarDatos( ) de la clase PrgEmpleado. En este contexto, observe y analice las siguientes líneas de codifi cación del método mostrarDatos ( ):


public void mostrarDatos ( ) {

String listaDatos = " " ;

for ( int i = 0 ; i < numEmp ; i ++ ) { listaDatos = listaDatos + datos[i].getCodigo ( ) + " "

+ datos[i].getNombre ( ) + " " + datos[i[.getSueldo ( ) + "\n" ; }

LE.mostrarInformacion ( "Datos de los Empleados \n\n" + listaDatos) ;

}

Primero se debe declarar una variable de po String denominada listaDatos, donde se almacenarán los datos de los tres empleados (en base al ejemplo planteado). Los datos de los tres empleados se ob enen accediendo al arreglo de objetos y u lizando los métodos ge er. Para ello, cada vez que se ejecuta la sentencia for se ob enen los datos de un empleado, y se colocan en la variable listaDatos. Los datos del primer empleado se colocan dentro de la variable listaDatos en la primera fi la, los del segundo empleado en la segunda fi la y así sucesivamente hasta poder colocar los datos de cada empleado en una fi la diferente dentro de la variable listaDatos.

Luego se muestra el contenido de la variable listaDatos, con lo que se ob enen los datos de cada empleado en una fi la diferente.

Volviendo al análisis del método ingresarDatos ( ) es posible desarrollar la codifi cación del método u lizando una forma alterna va. Observe y analice las siguientes líneas de codifi cación:

public void ingresarDatos ( ) {int rpta ;long codigo ;String nombre ; double sueldo ;

do { codigo = LE.leerLong ( "Ingrese el código" ) ;nombre = LE.leerString ( "Ingrese el nombre" ) ;sueldo = LE.leerDouble ( "Ingrese el sueldo" ) ;

datos [numEmp] = new Empleado ( ) ;datos [numEmp].setCodigo ( codigo ) ;datos [numEmp].setNombre ( nombre ) ;datos [numEmp].setSueldo ( sueldo ) ;

numEmp ++ ;


}

En la codifi cación presentada se crea un objeto anónimo de la clase Empleado, el cual es almacenado directamente en el arreglo de objetos denominado datos [ ] u lizando la siguiente sentencia:


datos [numEmp] = new Empleado ( ) ;

Luego se manipula el objeto almacenado en el arreglo de objetos, referenciando al arreglo y ejecutando los métodos se er. Para ello, se u lizan las siguientes sentencias:

datos [numEmp].setCodigo (codigo ) ; datos [numEmp].setNombre (nombre ) ; datos [numEmp].setSueldo (sueldo ) ;

Alterna vamente, en caso de que la clase Empleado tenga un método constructor que reciba datos para que los valores de los atributos sean inicializados, se podrían u lizar las siguientes sentencias:

public void ingresarDatos ( ) {int rpta ;long codigo ;String nombre ; double sueldo ;

do { codigo = LE.leerLong ( "Ingrese el código" ) ;nombre = LE.leerString ( "Ingrese el nombre" ) ;sueldo = LE.leerDouble ( "Ingrese el sueldo" ) ;

datos [numEmp] = new Empleado ( codigo, nombre, sueldo ) ;

numEmp ++ ;


}

Finalmente, se recomienda que intente modifi car la aplicación anterior e incluya un método que permita aumentar el tamaño del arreglo, un método que permita ordenar por código los datos, un método para eliminar datos y otro para modifi carlos. También incluya un método menu( ) desde el cual se puedan ejecutar los métodos creados.

Tenga presente que si incluye un método que permita eliminar datos (eliminarDatos ( )) y un método que permita modifi car datos (modifi carDatos ( )), el criterio de búsqueda de datos será a través del código, el cual deberá ser único (los códigos no se pueden repe r). Para ello, deberá crear un método que permita buscar un código (buscarCodigo ( )) que devuelva un valor -1 si el código no es encontrado, o un valor igual a la posición del arreglo donde fue encontrado el código. De ser este el caso, el método ingresarDatos ( ) y el método mostrarDatosEmpleado ( ) deberán modifi carse para que puedan u lizar el método de búsqueda creado.

Todas las recomendaciones mencionadas se han desarrollado en la solución del siguiente problema.


Problema 002


Enunciado: Desarrolle una solución que permita almacenar el código, nombre y la nota fi nal de todos los alumnos de un salón de clase, teniendo en cuenta el diagrama de clase y la gráfi ca de estructura de datos mostrados. También desarrolle todos los métodos necesarios para actualizar y controlar los datos almacenados. U lice dos clases para el desarrollo de la solución.


Nombre del proyecto: ProyAlumnos1 Diagrama de clases:


Donde:

numAlu = Número de alumnos del salón de clase.



Clase Alumno

package domPro ;

public class Alumno {

private long codigo ;private String nombre ;private double nota ;

public Alumno ( long codigo, String nombre, double nota ) {

this.codigo = codigo ;this.nombre = nombre ;this.nota = nota ;

}

public long getCodigo ( ) {return codigo ;

}

public void setCodigo ( long codigo ) {this.codigo = codigo ;

}public String getNombre ( ) {

return nombre ;}

public void setNombre ( String nombre ) {this.nombre = nombre ;

}

public double getNota ( ) {return nota ;

}

public void setNota ( double nota ) {this.nota = nota ;

}}

Clase PrgAlumno

package domApli ;

import java.awt.Color ;import biblioteca.LE ;import domPro.Alumno ;

public class PrgAlumno {

public Alumno datos [ ] ;private int numAlu ;

public PrgAlumno ( ) { datos = new Alumno [5] ; numAlu = 0 ;

}


public static void main ( String arg [ ] ) {PrgAlumno x = new PrgAlumno ( ) ;x.menu ( ) ;

}

public void menu ( ) {int opc ;String opciones1 = "************MENU PRINCIPAL ************\n"

+ "-------------------------------------\n"+ "[1] Ingreso de Datos \n" + "[0] Finalizar \n"+ "-------------------------------------\n"+ "Elija opción deseada:\n" ;

String opciones2 = "************MENU PRINCIPAL ************\n"+ "-------------------------------------\n"+ "[1] Ingreso de datos \n" + "[2] Mostrar datos \n"+ "[3] Mostrar datos de un alumno \n"

+ "[4] Modifi car datos \n" + "[5] Eliminar datos \n"+ "[6] Ordenar datos \n" + "[0] Finalizar \n"+ "-------------------------------------\n"+ "Elija opción deseada:\n" ;

boolean acceso = false;String opciones = opciones1;

do {

opc = LE.leerInt(opciones);switch (opc) {

case 1:ingresarDatos( ) ;acceso = true ;opciones = opciones2 ;break ;

case 2:if ( acceso ) {

mostrarDatos( ) ;} else {

LE.mostrarError("La opción ingresada no es válida");}break;


mostrarDatosAlumno( ) ;} else {

LE.mostrarError ( "La opción ingresada no es válida" ) ;}break ;


modifi carDatos();} else {

LE.mostrarError("La opción ingresada no es válida");}break;


case 5:if (acceso) {

eliminarDatos();if (numAlu == 0) { acceso = false; opciones = opciones1;}

} else {LE.mostrarError("La opción ingresada no es válida");

}break;

case 6:if (acceso) {

ordenarDatos();mostrarDatos();

} else {LE.mostrarError("La opción ingresada no es válida");

}break;

case 0:break;

default:LE.mostrarError("La opción ingresada no es válida");

}} while (opc != 0);

}

public void ingresarDatos() {int rpta, pos;long codigo;String nombre;double nota;

do {

if (datos.length == numAlu) {aumentar();

}do {

codigo = LE.leerLong("Ingrese el código del alumno");pos = buscarCodigo(codigo);

if (pos != -1) {LE.mostrarInformacion("El código ingresado ya existe!..,

verifi que\n\n");}

} while (pos != -1);

nombre = LE.leerString("Ingrese el nombre del alumno");nota = LE.leerDouble("Ingrese la nota del alumno");

Alumno objAlu = new Alumno(codigo, nombre, nota);datos[numAlu] = objAlu;numAlu++;



}

public void mostrarDatos() {String listaDatos = "";for (int i = 0; i < numAlu; i++) {

listaDatos += datos[i].getCodigo() + " " + datos[i].getNombre()+ " " + datos[i].getNota() + "\n";

}LE.mostrarInformacion("Datos de los alumnos",

"Codigo - Nombre - Notas", listaDatos, " - Aceptar - ", Color.cyan);}

public void mostrarDatosAlumno() {long codigo = LE

.leerLong("Ingrese el código del alumno cuyos datos deseas mostrar");int pos = buscarCodigo(codigo);

if (pos > -1) {LE.mostrarInformacion("El nombre del alumno es "

+ datos[pos].getNombre() + " y tiene " + datos[pos].getNota() + " de nota");

} else { LE.mostrarInformacion("Elcódigo del alumno no existe");

}}

public void modifi carDatos() {long codigo = LE

.leerLong("Ingrese el código del alumno cuyos datos deseas modifi car");int pos = buscarCodigo(codigo);if (pos > -1) {

int rpta = LE.mostrarPreguntaOpcion2("Está usted"+ " seguro que desea modifi car los datos del alumno "+ datos[pos].getNombre() + " cuya nota es "+ datos[pos].getNota());

if (rpta == 0) {String nombre = LE.leerString("Ingrese el nombre del alumno");double nota = LE.leerDouble("Ingrese la nota del alumno");datos[pos].setNombre(nombre);datos[pos].setNota(nota);

}

} else {LE.mostrarInformacion("El código del alumno no existe");

}}

public void eliminarDatos() {long codigo = LE

leerLong("Ingrese el código del alumno cuyos datos deseas eliminar");int pos = buscarCodigo(codigo);


if (pos > -1) {

int rpta = LE.mostrarPreguntaOpcion2("Está usted"+ " seguro que desea eliminar los datos del alumno "+ datos[pos].getNombre() + " cuya nota es "+ datos[pos].getNota());

if (rpta == 0) {for (int i = pos; i < numAlu - 1; i++) {

datos[i] = datos[i + 1];}numAlu--;

}} else {

LE.mostrarInformacion("El código del alumno no existe");}

}

public void ordenarDatos() {for (int i = 0; i < numAlu - 1; i++) {

for (int j = i + 1; j < numAlu; j++) {if (datos[i].getCodigo() > datos[j].getCodigo()) {

Alumno tmp = datos[i];datos[i] = datos[j];datos[j] = tmp;

}}

}}

public int buscarCodigo(long codigo) {for (int i = 0; i < numAlu; i++) {

if (codigo == datos[i].getCodigo()) {return i;

}}return -1;

}public void aumentar() {

Alumno datosTmp[] = new Alumno[datos.length + 5];for (int i = 0; i < numAlu; i++) {

datosTmp[i] = datos[i];}datos = datosTmp;

}

}


Analice el método ordenarDatos ( ) el cual se muestra a con nuación:




}

}}

}

Observe que para el ordenamiento de datos se ha u lizado el Algoritmo de Intercambio o Método de Burbuja, el cual se basa en el uso de dos sentencias for, una sentencia if (cuya condición lógica se considera el criterio de ordenamiento) y tres sentencias para el intercambio de la posición de los datos almacenados en el arreglo. Las sentencias u lizadas para el intercambio de datos son:


Es importante comprender que al ejectuar estas sentencias se intercambian de posición objetos de po Alumno alcemacenados en el arreglo datos [ ].

Ahora analice los métodos mostrarDatosAlumnos ( ), modifi carDatos ( ), eliminarDatos ( ), los cuales se muestran a con nuación:

public void mostrarDatosAlumno() {long codigo = LE.leerLong("Ingrese el código del alumno cuyos datos deseas mostrar");

int pos = buscarCodigo(codigo);

if (pos > -1) {

LE.mostrarInformacion("El nombre del alumno es "+ datos[pos].getNombre() + " y tiene "+ datos[pos].getNota() + " de nota");

} else {

LE.mostrarInformacion("El código del alumno no existe");}

}


public void modifi carDatos() {long codigo = LE.leerLong("Ingrese el código del alumno cuyos datos deseas modifi car");


if (pos > -1) {

int rpta = LE.mostrarPreguntaOpcion2("Está usted"+ " seguro que desea modifi car los datos del alumno "+ datos[pos].getNombre() + " cuya nota es "+ datos[pos].getNota() + " ?" );

if (rpta == 0) {String nombre = LE.leerString("Ingrese el nombre del alumno");double nota = LE.leerDouble("Ingrese la nota del alumno");

datos[pos].setNombre(nombre);datos[pos].setNota(nota);

}


}}

public void eliminarDatos() {long codigo = LE.leerLong("Ingrese el código del alumno cuyos datos deseas eliminar");


if (pos > -1) {

int rpta = LE.mostrarPreguntaOpcion2("Está usted"+ " seguro que desea eliminar los datos del alumno "+ datos[pos].getNombre() + " cuya nota es "+ datos[pos].getNota() + " ?" );

if (rpta == 0) {for (int i = pos; i < numAlu - 1; i++) {


}


}}

En los tres métodos, en primer lugar, se solicita el código del alumno pero se modifi ca ligeramente el mensaje que se muestra para solicitar el código. Luego, se busca el código ingresado u lizando el método buscarCodigo( ), y se verifi ca si el código existe o no existe. Si el código existe, los métodos cambian de magnitud. El método mostrarDatosAlumnos ( ) ob ene y muestra el nombre y la nota del alumno, cuyo código fue ingresado. El método modifi carDatos ( ), al igual que el método eliminarDatos ( ), ob ene y muestra el nombre y la nota del alumno, pero se modifi ca ligeramente el mensaje, el cual aparece en forma de pregunta para confi rmar si el usuario esta seguro de que desea modifi car o eliminar los datos de alumno, según sea el caso.


Específi camente para el método modifi carDatos ( ) si el usuario confi rma su decisión de modifi car el nombre y la nota, se solicitan los nuevos datos y se actualizan u lizando los métodos se er, tal y como se muestra en las siguientes sentencias:

String nombre = LE.leerString("Ingrese el nombre del alumno");double nota = LE.leerDouble("Ingrese la nota del alumno");datos[pos].setNombre(nombre);datos[pos].setNota(nota);

for (int i = pos; i < numAlu - 1; i++) {datos[i] = datos[i + 1];

}numAlu--;

Para el caso del método eliminarDatos ( ), si el usuario confi rma su decisión de eliminar los datos de un alumno se procede a realizar el algoritmo de eliminación u lizando las siguientes sentencias:

En conclusión, los tres métodos: mostrarDatosAlumno ( ), modifi carDatos ( ) y elminarDatos ( ) enen mucha similitud. A su vez, los métodos modifi carDatos ( ) y elminarDatos ( ) se basan en el

método mostrarDatosAlumno ( ). Los algoritmos de modifi cación y eliminación de datos se pueden apreciar claramente luego de que el usuario confi rma su decisión de efectuar la respec va acción.

Por otro lado, el método eliminarDatos ( ) podría ser codifi cado de la siguiente manera:

public void eliminarDatos() {long codigo = LE

leerLong("Ingrese el código del alumno cuyos datos deseas eliminar");int pos = buscarCodigo(codigo);

if (pos > -1) {

int rpta = LE.mostrarPreguntaOpcion2("Está usted"+ " seguro que desea eliminar los datos del alumno"+ datos[pos].getNombre() + " cuya nota es "+ datos[pos].getNota() + “?” ) ;

if (rpta == 0) {eliminar (pos)

}


}}

public void eliminar (int pos) { for (int i = pos; i < numAlu - 1; i++) {


}


De esta forma, se podría tener un método denominado eliminar ( ) que sería u lizado por todos los métodos que de una u otra manera realicen una eliminación de datos. En base a esto, se podría desarrollar un método que permita eliminar los datos de todos los alumnos que tengan el mismo nombre, tal y como se muestra a con nuación:

public void eliminarNombres()

String nombre = LE.leerString ("Ingrese el nombre del alumno cuyos datos desea eliminar");

for ( int i = 0 ; i < numAlu ; i++ ) { if ( nombre.equalsIgnoreCase ( datos[ i ].getNombre ( ) ) ) {

// aquí podría agregar la confi rmación del usuarioeliminar ( i ) ;

i -- ;}

} }

En la codifi cación del método eliminarNombres ( ) se solicita el nombre del alumno, y en base a él (que en este caso puede estar repe do) se recorre el arreglo, y cada vez que se encuentre el nombre ingresado se eliminarán los datos haciendo uso del método eliminar ( ). En este punto sería recomendable incluir una confi rmación del usuario antes de proceder a eliminar los datos del alumno.

Problema 003


Enunciado: Desarrollar una solución que permita almacenar el código, el nombre, el precio de compra, el precio de venta y la can dad de productos almacenados de cada uno de los ar culos de una bodega, u lizando arreglo de objetos. También, desarrolle todos los métodos necesarios para manejar los datos almacenados. Adicionalmente desarrolle un método que permita registrar la venta de ar culos. U lice el lenguaje de programación Java para la codifi cación de la solución.

Etapa 02 – Descripción de la solución propuesta

Resultado deseado: Registrar y mantener actualizados los datos de los ar culos de una bodega. Registrar la venta de ar culos.

Datos necesarios: Código de cada ar culo Nombre de cada ar culo Precio de compra de cada ar culo Precio de venta de cada ar culo Can dad de productos de cada ar culo


Procesamiento: Los datos serán ingresados y almacenados en un objeto de la Clase Tienda, el cual a su vez será

almacenado en un arreglo de objetos denomiando datos [ ].

Para el control y mantenimiento de los datos se crearán los métodos que permi rán visualizar información, calcular la u lidad de los ar culos, ordenar datos, eliminar y modifi car datos, así como un método que permita registrar la venta de ar culos. El usuario interactuará con la aplicación a través de un menú de opciones.


Nombre del proyecto: ProyTienda1 Diagrama de paquetes:

Diagrama de clases:


Diseño de la Intarfaz Gráfi ca de Usuario (GUI):


Donde: numArt = Número de ar culos existentes en la bodega


Clase Tienda

package domPro;

public class Tienda {private long codigo;private String nombre;private double precioVenta, precioCompra;private int cantidad;

public Tienda() {codigo = 0;nombre = " ";precioCompra = 0;precioVenta = 0;cantidad = 0;

}


public Tienda(long codigo, String nombre, double precioCompra,double precioVenta, int cantidad) {

this.codigo = codigo;this.nombre = nombre;

this.precioCompra = precioCompra;this.precioVenta = precioVenta;this.cantidad = cantidad;

}

public long getCodigo() {return codigo;

}

public void setCodigo(long codigo) {this.codigo = codigo;

}

public String getNombre() {return nombre;

}

public void setNombre(String nombre) {this.nombre = nombre;

}

public double getPrecioCompra() {return precioCompra;

}

public void setPrecioCompra(double precioCompra) {this.precioCompra = precioCompra;

}

public double getPrecioVenta() {return precioVenta;

}

public void setPrecioVenta(double precioVenta) {this.precioVenta = precioVenta;

}

public int getCantidad() {return cantidad;

}public void setCantidad(int cantidad) {

this.cantidad = cantidad;}

}


Clase PrgTienda

package domApli;

import biblioteca.LE;import java.awt.Color;import domPro.Tienda;

public class PrgTienda {

Tienda datos[];private int numArt;

public static void main(String[] args) {PrgTienda x = new PrgTienda();x.menu();

}

public PrgTienda() {datos = new Tienda[5];numArt = 0;

}

public void menu() {int rpta = 0;do {

rpta = LE.leerInt( "- Artículos de una bodega -\n"+ "------------------------------------------------\n"+ "[1] Ingresar datos\n"+ "[2] Mostrar datos\n"+ "[3] Mostrar datos de un artículo\n"+ "[4] Mostrar utilidad por artículo\n"+ "[5] Realizar una venta\n"+ "[6] Modifi car datos de un artículo\n"+ "[7] Modifi car un dato de un artículo\n"+ "[8] Eliminar datos\n"+ "[9] Ordenar datos\n"+ "[0] Finalizar\n"

+ "-------------------------------------------------\n"+ "Seleccione una opción:");

switch (rpta) {case 1:

ingresarDatos();break;

case 2:mostrarDatos();break;

case 3:mostrarDatosDeUnArticulo();break;

case 4:mostrarUtilidad();break;

case 5:venta();break;

case 6:modifi carDatos();break;


Case 7:modifi carUnDatoDeUnArticulo();break;

case 8:eliminarDatos();break

case 9:ordenarDatos();mostrarDatos();break;

case 0:break;

default:LE.mostrarError("Opcion no válida, ..,reintente!!!");

}

} while (rpta != 0);}

public void ingresarDatos() {long cod;String nom;double prec, prev;int cant, rpta;

do {

if (datos.length == numArt) {aumentar();

} do {

cod = LE.leerLong("Ingrese el código del artículo:");rpta = buscarCodigo(cod);if (rpta != -1) {

LE.mostrarError("El código ya existe...REINTENTAR!!!!");}

} while (rpta != -1);

nom = LE.leerString("Ingresar nombre del artículo:");prec = LE.leerDouble("Ingresar precio de compra del artículo:");prev = LE.leerDouble("Ingresar precio de venta del artículo:");cant = LE.leerInt("Ingresar cantidad del artículo:");

Tienda objArt = new Tienda (cod, nom, prec, prev, cant);

datos[numArt] = objArt;numArt++;rpta = LE.mostrarPreguntaOpcion2("¿Desea continuar ingresando datos?");

} while (rpta == 0);

}

public void mostrarDatos() {String texto = "";texto += "Código \tNombre \tPC \tPV \tCantidad\n";for (int i = 0; i < numArt; i++) {

texto = texto + datos[i].getCodigo()+ "\t" + datos[i].getNombre() + " \t"+ datos[i].getPrecioCompra() + "\t" + datos[i].getPrecioVenta() + " \t" + datos[i].getCantidad() + "\t" + "\n";


}texto = texto + "\nEl total de artículos es: " + numArt;LE.mostrarInformacion("Datos de los artículos", "Datos:", texto, "Aceptar",

Color.white);}

public void mostrarDatosDeUnArticulo() {long cod = LE.leerLong("Ingrese el código del artículo cuyos datos desea mostrar: ");int pos = buscarCodigo(cod);if (pos != -1) {

LE.mostrarInformacion("Datos de un artículo", "Los datos del artículo cuyo código es \t"

+ cod + "\t son: ","\nNombre :" + datos[pos].getNombre()+ "\nPrecio de Compra :" + datos[pos].getPrecioCompra()+ "\nPrecio de Venta :" + datos[pos].getPrecioVenta()+ "\nCantidad:" + datos[pos].getCantidad(),"Aceptar",Color.white);

} else { LE.mostrarInformacion("El código ingresado no existe.., verifi que");

} }

public void mostrarUtilidad() {double ganancia = 0;double utilidad = 0;String listaDatos = "Artículo \tUtilidad\n";

for (int i = 0; i < numArt; i++) {

ganancia = datos[i].getPrecioVenta() - datos[i].getPrecioCompra();utilidad = ganancia * datos[i].getCantidad();listaDatos += datos[i].getNombre() + " \t" + utilidad + "\n";

}LE.mostrarInformacion("UTILIDAD","Utilidad por artículo",listaDatos, "Aceptar",

Color.white);}

public void modifi carDatos() {long cod = LE.leerLong("Ingrese el código del artículo cuyos datos desea modifi car: ");int pos = buscarCodigo(cod);if (pos == -1) {

LE.mostrarInformacion("El código ingresado no existe.., verifi que");} else {


int rpta = LE.mostrarPreguntaOpcion2("Está usted seguro que desea modifi car los datos del artículo \t"+ datos[pos].getNombre() +

"\n cuyo precio de compra es: \t" + datos[pos].getPrecioCompra() + "\n , su precio de venta es : \t" + datos[pos].getPrecioVenta()+ "\n y la cantidad e : \t" + datos[pos].getCantidad() + " ?");

if (rpta == 0) { String nom = LE.leerString("Ingrese nuevo nombre: ");double prec = LE.leerDouble("Ingrese nuevo precio de compra: ");double prev = LE.leerDouble("Ingrese nuevo precio de venta: ");int cant = LE.leerInt("Ingrese nueva cantidad: ");

modifi car(pos, nom, prec, prev, cant);}

}}

public void modifi car(int pos, String nom, double prec, double prev, int cant) {datos[pos].setNombre(nom);datos[pos].setPrecioCompra(prec);datos[pos].setPrecioVenta(prev);datos[pos].setCantidad(cant);

}

public void modifi carUnDatoDeUnArticulo() {long cod = LE.leerLong("Ingrese el código del artículo cuyo dato desea modifi car:");int pos = buscarCodigo(cod);if (pos == -1) {


String datos = "Seleccione el dato que desea modifi car :\n"+ "[1] Código \n"+ "[2] Nombre \n"+ "[3] Precio de Compra\n"+ "[4] Precio de Venta\n"+ "[5] Cantidad\n"+ "[0] Finalizar\n";

int opc = LE.leerInt(datos);modifi carCampo(opc, pos);

}}

public void modifi carCampo(int opc, int pos) {int rpta = 1;switch (opc) {

case 1:long cod = LE.leerLong("Ingrese nuevo código");rpta = LE.mostrarPreguntaOpcion2("Está usted seguro que desea modifi car el código?");if (rpta == 0) {

datos[pos].setCodigo(cod);}break;


case 2:String nom = LE.leerString("Ingrese nuevo nombre");rpta = LE.mostrarPreguntaOpcion2("Está usted seguro que desea modifi car el nombre?");if (rpta == 0) {

datos[pos].setNombre(nom);}break;

case 3:double prec = LE.leerDouble("Ingrese nuevo precio de compra");rpta = LE.mostrarPreguntaOpcion2("Está usted seguro que desea modifi car el precio de compra?");if (rpta == 0) {

datos[pos].setPrecioCompra(prec);}break;

case 4:double prev = LE.leerDouble("Ingrese nuevo precio de venta");rpta = LE.mostrarPreguntaOpcion2("Está usted seguro que desea modifi car el precio de venta?");if (rpta == 0) {

datos[pos].setPrecioVenta(prev);}break;

case 5:int cant = LE.leerInt("Ingrese nueva cantidad");rpta = LE.mostrarPreguntaOpcion2("Está usted seguro que desea modifi car lacantidad?");if (rpta == 0) {

datos[pos].setCantidad(cant);}break;

}}public void eliminarDatos() {

long cod = LE.leerLong("Ingrese el código del artículo cuyos datos desea eliminar: ");int pos = buscarCodigo(cod);if (pos == -1) {


int rpta = LE.mostrarPreguntaOpcion2("Está usted seguro que desea eliminar los datos del artículo\t" + datos[pos]. getNombre() + "\n cuyo precio de compra es: \t" + datos[pos].getPrecioCompra() + "\n , su precio de venta es : \t" + datos[pos]. getPrecioVenta()+ "\n y la cantidad en el stock es de: \t" + datos[pos].getCantidad() + " ?");if (rpta == 0) {

eliminar(pos);}

}}public void eliminar(int pos) {

for (int i = pos + 1; i < numArt; i++) {datos[i - 1] = datos[i];

}numArt--;

}


public void venta() {int rpta, stock = 0, cant = 0;String nom;double costo = 0, costoTotal = 0;

String text = "";do {

do {

nom = LE.leerString("Ingrese el nombre del artículo que desea comprar:");rpta = buscarNombre(nom);

if (rpta == -1) {LE.mostrarError("El artículo que desea comprar no está en stock.., verifi que!!!");

}} while (rpta == -1);do {

cant = LE.leerInt("Ingrese la cantidad de productos del artículo que desea comprar:");

if (cant > datos[rpta].getCantidad()) {LE.mostrarError("La cantidad que desea comprar excede el stock...\n "+ "Ingrese una cantidad menor");

} else {stock = datos[rpta].getCantidad() - cant;datos[rpta].setCantidad(stock);costo = (datos[rpta].getPrecioVenta()) * cant;costoTotal += costo;

}} while (cant > datos[rpta].getCantidad());

text += "Artículo:\t" + nom + "\t Cantidad:\t" + cant + "\t Costo:\t" + costo + "\n";rpta = LE.mostrarPreguntaOpcion2("¿Desea Continuar?");


text += "Total a pagar:\t" + costoTotal; LE.mostrarInformacion("Venta", "Boleta de Venta", text, "Aceptar", Color. white);

}public void ordenarDatos() {

Tienda tmp;for (int i = 0; i < numArt - 1; i++) {

for (int j = i + 1; j < numArt; j++) {if (datos[i].getCodigo() < datos[j].getCodigo()) {

tmp = datos[j];datos[j] = datos[i];datos[i] = tmp;

}}

}}


public int buscarCodigo(long cod) {for (int i = 0; i < numArt; i++) {

if (cod == datos[i].getCodigo()) {return i;

}}return -1;

}public int buscarNombre ( String nom ) {

for (int i = 0; i < numArt; i++) {if (nom.equalsIgnoreCase(datos[i].getNombre())) {

return i;}

}return -1;

} public void aumentar() {

Tienda datosTmp[] = new Tienda [datos.length + 5];for (int i = 0; i < numArt; i++) {


}}

public void venta() {int rpta, stock = 0, cant = 0;String nom;double costo = 0, costoTotal = 0;

String text = "";do {

do {

nom =LE.leerString("Ingrese el nombre del artículo que desea comprar:");rpta = buscarNombre(nom);

if (rpta == -1) {LE.mostrarError("El artículo que desea comprar no está enstock.., verifi que!!!");

}

En el desarrollo de las soluciones de los problemas anteriores, se puede observar diferentes pos de métodos. Por un lado, se pueden apreciar los métodos que permiten registrar y mantener actualizados los datos, tales como: ingresarDatos ( ), modifi carDatos ( ), eliminarDatos ( ) y ordenarDatos ( ). Por otro lado, se pueden apreciar los métodos que permiten consultar los datos, tales como: mostrarDatos( ), mostrarDatosDeUnAr culo ( ) y buscarCodigo ( ).

También, existen otros pos de métodos, los cuales se desarrollan en base a la situación o problemá ca planteada. En la solución del presente problema se han desarrollado dos de estos métodos, conocidos como métodos de negocio, los cuales son: mostrarU lidad ( ) y venta ( ).

Analice el método venta ( ), el cual se muestra a con nuación:


} while (rpta == -1);do {

cant = LE.leerInt("Ingrese la cantidad de productos del artículo que desea comprar:");

if (cant > datos[rpta].getCantidad()) {LE.mostrarError("La cantidad que desea comprar excede el Stock...\n"

+ "Ingrese una cantidad menor");

} else {stock = datos[rpta].getCantidad() - cant;datos[rpta].setCantidad(stock);costo = (datos[rpta].getPrecioVenta()) * cant;costoTotal += costo;

}} while (cant > datos[rpta].getCantidad());

text += "Artículo:\t" + nom + "\t Cantidad:\t" + cant + "\t Costo:\t" + costo + "\n";rpta = LE.mostrarPreguntaOpcion2("¿Desea Continuar?");


text += "Total a pagar:\t" + costoTotal;LE.mostrarInformacion("Venta", "Boleta de Venta", text, "Aceptar", Color.white);

}

Observe el desarrollo del método venta ( ), en el cual se simula una venta de ar culos en forma muy básica. Primero se solicita el nombre del ar culo y, si existe, se solicita la can dad que se desea comprar. Si la can dad a comprar no excede el stock se procede a registrar la venta. Este proceso se desarrolla varias veces hasta que no se desea comprar más ar culos. Al fi nal se muestra cuál es el total que se ene que pagar por los ar culos comprados.

Considere analizar qué es lo que se realiza en el método mostrarU lidad ( ).

1.3 MÉTODO DE INSERCIÓN DE DATOS

También es posible desarrollar un método que permita ingresar los datos al arreglo de objetos de tal forma que los datos se mantengan siempre ordenados en base a un criterio de ordenamiento. Es decir, los datos se insertarían en el arreglo en la posición que les corresponda. Para poder desarrollar este po de método debemos tener presente los siguientes pasos:

1. Verifi car el tamaño del arreglo para determinar si existe la capacidad para almacenar más datos.

2. Ingresar los datos a almacenar (para nuestro ejemplo son el código, el nombre, el precio de compra, el precio de venta y la can dad).

3. Ubicar la posición (la posición de inserción) donde deben ser almacenados los datos, lo cual dependerá del criterio de inserción determinado.


4. Realizar la copia de los datos almacenados, desde la posición de inserción hasta el fi nal del arreglo. A par r de la posición de inserción y hasta la úl ma posición del arreglo, todos los datos almacenados deberán ser copiados a la siguiente posición empezando desde el fi nal del arreglo hasta los datos almacenados en la posición de inserción.

5. Crear un objeto de la clase que se desea almacenar en el arreglo de objetos, y almacenar los datos ingresados en el arreglo creado.

6. Almacenar el objeto creado en el arreglo de objetos en la posición de inserción determinada.

7. Incrementar el valor de la variable que controla la posición donde se almacenará el siguiente objeto.

Ahora, imagine que se ene los siguientes datos almacenados en el arreglo de datos [ ]:

Y se desea insertar los siguientes datos:

Código = 15Nombre = “Gaseosa”Precio de compra = 1.0Precio de venta = 1.5Can dad = 100

Para insertar los datos anteriores se debe ubicar la posición de inserción de tal forma que se mantengan los datos ordenados por código de menor a mayor (criterio de inserción), tal y como se muestra en la siguiente fi gura:

En el ejemplo, la posición de inserción sería la posición 2. En consecuencia, los datos almacenados desde la posición 2 hasta la 3 deberán ser copiados a la siguiente posición empezando desde el fi nal, es decir, los datos almacenados en la posición 3 se copian a la posición 4, y los datos almacenados en la posción 2 se copian a la posición 3. Finalizada la copia se procede a almacenar los nuevos datos en la posición 2 del arreglo de objetos y a aumentar en 1 la variable numArt, que indica la can dad de datos almacenados. Lo descrito anteriormente se puede observar en las siguientes fi guras:


El desarrollo del método insertar datos sería el siguiente:

public void insertarDatos() {int pos, rpta;long cod;String nom;double prec, prev;int cant;

do {if ( datosArticulo.length == numArt ) {

aumentar() ;}

do {

cod = LE.leerLong ( "Ingrese el código del artículo" ) ;pos = buscarCodigo ( cod ) ;if (pos != -1) {

LE.mostrarInformacion ("El código ingresado ya existe... verifi que \n!!!!" ) ;

}

while ( pos!= -1 ) ;

nom = LE.leerString ( "Ingrese nombre del artículo" ) ;prec = LE.leerDouble ( "Ingrese precio de compra del artículo" );prev = LE.leerDouble ( "Ingrese precio de venta del artículo" );cant = LE.leerInt ( "Ingrese la cantidad" ) ;

// ubicamos la posición donde se deben insertar los datos

pos = numArt ;

for ( int i = 0 ; i < numArt -1 ; i ++ ) {if ( cod < datosArticulo [ i ].getCodigo ( ) ) {

pos = i ;break;

}}// copiamos a la siguiente posición todos los datos a partir de // la posición donde se// deben insertar los nuevos datos.

for ( int i = numAlu -1 ; i > = pos ; i -- ) { datos [ i + 1 ] = datos [ i ] ;

}

Tienda objTienda = new Tienda ( cod, nomb, prec, prev, cant ) ;

datos [ pos ] = objTienda ;

numArt ++ ;rpta = LE.mostrarPreguntaOpcion2 ( "¿Desea continuar?" ) ;

} while ( rpta == 0 ) ;}

Paso 1

Paso 2

Paso 3

Paso 4

Paso 5

Paso 6Paso 7


1.4 MODELO VISTA CONTROLADOR (MVC)

El Modelo Vista Controlador (MVC) es un patrón de arquitectura de so ware que separa los datos de una aplicación, la interfaz gráfi ca de usuario, y la lógica de control en tres componentes dis ntos.

Modelo: Esta es la representación específi ca de la información con la cual el sistema opera. En resumen, el modelo se limita a lo rela vo de la vista y su controlador facilitando las presentaciones visuales complejas. El sistema también puede operar con más datos no rela vos a la presentación, haciendo uso integrado de otras lógicas de negocio y de datos afi nes con el sistema modelado.

Vista: Este presenta el modelo en un formato adecuado para interactuar con el usuario, usualmente es la interfaz de usuario o GUI

Controlador: Este responde a eventos, usualmente acciones del usuario, e invoca pe ciones al Modelo y, probablemente, a la Vista. En el Controlador no debe exisi r sentencias de ingreso de datos ni de visualización de información, ya que estas acciones se deben realizar en la Vista.

Problema 004


Enunciado: Desarrolle una solución que permita almacenar el código, nombre y sueldo de todos los empleados de una empresa tex l, teniendo en cuenta el diagrama de clase y la gráfi ca de estructura de datos mostrados. También desarrolle los métodos para agregar datos, mostrar los datos de todos los empleados, y mostrar los datos de un empleado en base al código. U lice tres clases para el desarrollo de la solución (MVC).


Nombre del proyecto: ProyEmpleado2 Diagrama de clases:

View ControlerModel





Clase Empleado

package modelo;


private long codigo;private String nombre;

private double sueldo;

public Empleado(){codigo = 0;nombre = null;sueldo = 0;

}

public Empleado(long codigo, String nombre, double sueldo){this.codigo = codigo;this.nombre = nombre;this.sueldo = sueldo;

}


Clase Empleado


}


}


}


}

public double getSueldo() {return sueldo;

}

public void setSueldo(double sueldo) {this.sueldo = sueldo;

}}

Clase ArregloEmpleado

package controlador;

import modelo.Empleado;

public class ArregloEmpleado {Empleado datos[];int numEmp;

public ArregloEmpleado() {numEmp = 0;datos = new Empleado[5];

}

public int agregarDatos(long codigo, String nombre, double sueldo) {int pos = buscarCodigo(codigo);

if (pos != -1) {return -1;

} else {

if (numEmp == datos.length) {aumentar();

}Empleado objEmp = new Empleado(codigo, nombre, sueldo);datos[numEmp] = objEmp;numEmp++;return 0;

}}



public String obtenerDatos() {String listaDatos = "";for (int i = 0; i < numEmp; i++) {

listaDatos = listaDatos + "Código-->" + datos[i].getCodigo()+ " " + "Nombre-->" + datos[i].getNombre() +"+ "Sueldo-->" + datos[i].getSueldo() + "\n";

}return listaDatos;

}

public String obtenerDatosEmpleado(long codigo) {String listaDatos = "";for (int i = 0; i < numEmp; i++) {

if (codigo == datos[i].getCodigo()) {listaDatos = "Informacion encontrada : \n" + "Código-->"

+ datos[i].getCodigo() + " "+ "Nombre-->"+ datos[i].getNombre() + " " + "Sueldo-->"+ datos[i].getSueldo();

return listaDatos;}

}return listaDatos;

}

public int buscarCodigo(long codigo) {for (int i = 0; i < numEmp; i++) {


}}return -1;

}

public void aumentar() {Empleado datosTmp[] = new Empleado[datos.length + 3];for (int i = 0; i < numEmp; i++) {


}}

Clase PrgEmpleado

package vista;

import biblioteca.LE;import controlador.ArregloEmpleado;


ArregloEmpleado objArray;

public PrgEmpleado() {objArray = new ArregloEmpleado();

}


Clase PrgEmpleado

public void ingresarDatos() {int rpta;long codigo;String nombre;double sueldo;

do {codigo = LE.leerLong("Ingrese el código");nombre = LE.leerString("Ingrese el nombre");sueldo = LE.leerDouble("Ingrese el sueldo");

objArray.agregarDatos(codigo, nombre, sueldo);


}

public void mostrarDatos() {String listaDatos = objArray.obtenerDatos();

if (listaDatos != "") {

LE.mostrarInformacion("Datos de los Empleados\n\n" + listaDatos);} else {

LE.mostrarInformacion("No existen datos registrados");}

}

public void mostrarDatosEmpleado() {long codigo = LE

.leerLong("Ingrese el código del empleado cuyos datos deseas mostrar");

String listaDatos = objArray.obtenerDatosEmpleado(codigo);

if (listaDatos != "") {LE.mostrarInformacion("Datos del Empleado\n\n" + listaDatos);

} else {LE.mostrarInformacion("Código de empleado no existe");

}}

public static void main(String arg[]) {PrgEmpleado x = new PrgEmpleado();x.ingresarDatos();x.mostrarDatos();x.mostrarDatosEmpleado();

}}

Observe la declaración del atributo datos [ ] de la clase ArregloEmpleado, y refl exione sobre las implicancias de declarar al atributo datos [ ] sin el modifi cador de acceso public:




}…

public int agregarDatos ( long codigo, String nombre, double sueldo ) {


if (pos != -1) {return -1;

} else {if (numEmp == datos.length) {

aumentar();}Empleado objEmp = new Empleado(codigo, nombre, sueldo);datos[numEmp] = objEmp;numEmp++;return 0;

}}

public void aumentar ( ) {Empleado datosTmp [ ] = new Empleado [ datos.length + 5 ] ;

for ( int i = 0 ; i < numEmp ; i++ ) {datosTmp [i] = datos [i] ;

}datos = datosTmp ;

}

public void aumentar ( ) {

Empleado datosTmp [ ] = new Empleado [ datos.length + 5 ] ;System.ArrayCopy ( datos, 0, datosTmp, datos.length ) ;datos = datosTmp ;

}

Por otro lado, es importante mencionar algo sobre la necesidad de aumentar el tamaño del arreglo de objetos cuando se ingresen más datos de los que se pueden almacenar. Analice la modifi cación en el método agregarDatos ( ) y la codifi cación del método aumentar ( ).

Cada vez que se ingresen más datos de los que se pueden almacenar, se ejecutará él método aumentar ( ) para permi r el ingreso y almacenamiento de los datos de cinco empleados más. El método aumentar ( ) también puede ser codifi cado u lizando el método ArrayCopy de la clase System de Java.


Tambien es importante mencionar que en las clases po controlador y po modelo no deberán exisi r sentencias de ingreso de datos y/o visualización de información. Esto como norma para fomentar el reuso de los métodos de estas clases.

Finalmente, podemos extender la codifi cación de la clase ArregloEmpleado desarrollando los métodos modifi carDatos ( ), ordenarCodigo ( ) y eliminarDatos ( ), tal y como se muestra a con nuación:

public void modifi carDatos ( int pos, String nombre, double sueldo ) {datos [pos].setNombre ( nombre ) ;datos [pos].setSueldo ( sueldo ) ;

}

public void eliminarDatos ( int pos ) {if ( pos != -1 ) {

for ( int i = pos ; i < numEmp ; i++ ) {datos[i] = datos[i + 1] ;

}numEmp -- ;

}}

public void ordenarCodigo ( ) {for ( int i = 0 ; i < numEmp - 1 ; i++ ) {

for ( int j = i + 1 ; j < numEmp ; j++ ) {

// Mayor por ser en forma ascendenteif ( datos[i].getCodigo ( ) > datos[j].getCodigo ( ) ) {

// IntercambioEmpleado tmp = datos[i] ;datos[i] = datos[j] ;datos[j] = tmp ;

}}

}}

Una pregunta que sería importante formularse ene que ver con la forma en que se podría o debería u lizarse los métodos modifi carDatos ( ), eliminarDatos ( ) y ordenarDatos ( ) desde la clase PrgEmpleado. ¿Cuál es su opinión al respecto?

Analice las soluciones de los siguientes problemas para poder responder la pregunta planteada.


Problema 005


Enunciado: Desarrolle una solución que permita almacenar el código, nombre y la nota fi nal de todos los alumnos de un salón de clase, teniendo en cuenta el diagrama de clase y la gráfi ca de estructura de datos mostrados. También desarrolle todos los métodos necesarios para actualizar y controlar los datos almacenados. U lice tres clases para el desarrollo de la solución (MVC).


Nombre del proyecto: ProyAlumnos2 Diagrama de paquetes:

Diagrama de clases:


Donde: numAlu = Número de alumnos del salón de clase.



Clase Alumno

package modelo;

public class Alumno {

private long codigo;private String nombre;private double nota;

public Alumno(){

codigo = 0;nombre = null;nota = 0;

}

public Alumno(long codigo, String nombre, double nota){this.codigo = codigo;this.nombre = nombre;this.nota = nota;

}


}


}


}


}

public double getNota() {return nota;

}

public void setNota(double nota) {this.nota = nota;

}}

Clase ArregloAlumno

package controlador ;

import modelo.Alumno ;

public class ArregloAlumno {Alumno datos[ ] ;int numAlu ;

public ArregloAlumno( ) {numAlu = 0 ;datos = new Alumno[5] ;


}

public int agregarDatos(long codigo, String nombre, double nota) {int pos = buscarCodigo(codigo);if (pos != -1) {

return -1;} else {

if (numAlu == datos.length) {aumentar();

}Alumno objAlu = new Alumno(codigo, nombre, nota);datos[numAlu] = objAlu;numAlu++;return 0;

}}

public String obtenerDatos ( ) {String listaDatos = "" ;for ( int i = 0 ; i < numAlu ; i++ ) {

listaDatos = listaDatos + datos[i].getCodigo( ) + " \t"+ datos[i].getNombre( ) + " \t" + datos[i].getNota( ) + " \n" ;

}return listaDatos ;

}

public String obtenerDatosAlumno ( long codigo ) {String listaDatos = "" ;for ( int i = 0 ; i < numAlu ; i++ ) {

if ( codigo == datos[i].getCodigo( ) ) {listaDatos = "\nCodigo: " + datos[i].getCodigo() + "\nNombre: "+ datos[i].getNombre( ) + "\ nNota: " + datos[i].getNota( ) ;

}}return listaDatos ;

}public void modifi carDatos(int pos, String nombre, double nota) {

datos[pos].setNombre(nombre);datos[pos].setNota(nota);

}

public void eliminarDatos(int pos) {if (pos > -1) {

for (int i = pos; i < numAlu - 1; i++) {datos[i] = datos[i + 1];

}numAlu--;

}}





} } }

}public int buscarCodigo(long codigo) {

for (int i = 0; i < numAlu; i++) {if (codigo == datos[i].getCodigo()) {

return i;}

}return -1;

}public void aumentar() {

Alumno datosTmp[] = new Alumno[datos.length + 3];for (int i = 0; i < numAlu; i++) {


}public int getNumAlu() {

return numAlu;}

}

package vista;import java.awt.Color;import biblioteca.LE;import controlador.ArregloAlumno;

public class PrgAlumno {

ArregloAlumno objArray;

public PrgAlumno() {objArray = new ArregloAlumno();

}

public static void main(String arg[]) {PrgAlumno x = new PrgAlumno();x.menu();

}public void menu() {

int opc;String opciones1 = "************MENU PRINCIPAL ************\n"

+ "-------------------------------------\n"+ "[1] Ingreso de Datos \n" + "[0] Finalizar \n"+ "-------------------------------------\n"+ "Elija opción deseada:\n";

String opciones2 = "************MENU PRINCIPAL ************\n"+ "-------------------------------------\n"+ "[1] Ingreso de datos \n" + "[2] Mostrar datos \n"+ "[3] Mostrar datos de un alumno \n"+ "[4] Modifi car datos \n" + "[5] Eliminar datos \n"+ "[6] Ordenar datos \n" + "[0] Finalizar \n"+ "-------------------------------------\n"+ "Elija opción deseada:\n";


boolean acceso = false;String opciones = opciones1;

do {opc = LE.leerInt(opciones);switch (opc) {

case 1:ingresarDatos();acceso = true;opciones = opciones2;break;

case 2:if (acceso) { mostrarDatos();} else { LE.mostrarError("La opción ingresada no es válida");}break;

case 3:if (acceso) { mostrarDatosAlumno();} else { LE.mostrarError("La opción ingresada no es válida");}break;

case 4:if (acceso) { modifi carDatos();} else { LE.mostrarError("La opción ingresada no es válida");}break;

case 5:if (acceso) { eliminarDatos(); if (objArray.getNumAlu() == 0) { acceso = false; opciones = opciones1; }} else { LE.mostrarError("La opción ingresada no es válida");}break;

case 6:if (acceso) { ordenarDatos(); mostrarDatos();} else { LE.mostrarError("La opción ingresada no es válida");}break;

case 0:break;

default:LE.mostrarError("La opción ingresada no es válida");

}} while (opc != 0);

}


public void ingresarDatos() {int rpta;long codigo;String nombre;double nota;

do {codigo = LE.leerLong("Ingrese el código");nombre = LE.leerString("Ingrese el nombre");nota = LE.leerDouble("Ingrese la nota");

objArray.agregarDatos(codigo, nombre, nota);


}

public void mostrarDatos() {String listaDatos = objArray.obtenerDatos();

if (listaDatos != "") {LE.mostrarInformacion("Datos de los alumnos","Código Nombre

Notas",listaDatos, "Ok", Color.cyan);} else {

LE.mostrarInformacion("No existen datos registrados");}

}

public void mostrarDatosAlumno() {long codigo = LE

.leerLong("Ingrese el código del alumno cuyos datos deseas mostrar");String listaDatos = objArray.obtenerDatosAlumno(codigo);if (listaDatos != "") {

LE.mostrarInformacion("Datos del alumno\n" + listaDatos);

} else {LE.mostrarInformacion("Código de alumno no existe");

}}

public void modifi carDatos() {long codigo = LE.leerLong("Ingrese el código del alumno cuyos datos deseas

modifi car");int pos = objArray.buscarCodigo(codigo);

if (pos > -1) {

int rpta = LE.mostrarPreguntaOpcion2("Está usted seguro que desea + "modifi car los datos del siguiente alumno?\n" + objArray.obtenerDatosAlumno(codigo));

if (rpta == 0) {String nombre = LE.leerString("Ingrese el nombre del alumno");double nota = LE.leerDouble("Ingrese la nota del alumno");objArray.modifi carDatos(pos, nombre, nota);

}



}}

public void eliminarDatos() {long codigo = LE.leerLong("Ingrese el código del alumno cuyos datos deseas

eliminar"); int pos = objArray.buscarCodigo(codigo);

if (pos > -1) {int rpta=LE.mostrarPreguntaOpcion2("Está usted seguro que desea eliminar"

+ "los datos del siguiente alumno?\n"+ objArray.obtenerDatosAlumno(codigo));

if (rpta == 0) {objArray.eliminarDatos(pos);

}


}}

public void ordenarDatos() {objArray.ordenarDatos();

}

}

Considere la posibilidad de desarrollar un método que permita insertar datos en un arreglo de objeto, de tal forma que los datos ingresados se mantengan siempre ordenados. Para ello, es importante establecer un criterio de inserción.

Analice las siguientes líneas de codifi cación del método insertarDatos ( ), el cual puede u lizarse en lugar de los métodos agregarDatos ( ) y ordenar Datos ( ) desarrollados en la solución del presente problema.

public void insertarDatos ( long codigo, String nombre, double nota ) {if ( numAlu == datos.length) {

aumentar ( ) ;}Alumno x = new Alumno (codigo, nombre, nota ) ;int pos = buscarPosicionInsertar (codigo);

for (int i = numAlu -1 ; i > = pos ; i - - ) {

datos [ i + 1 ] = datos [ i ];

}datos [ pos ] = x ;numAlu + + ;


public int buscarPosicionInsertar (long codigo) {for ( int i = 0 ; i < numAlu - 1 ; i++ ) {

if ( codigo < datos [ i ] .getCodigo ( ) ) { return i ;

}}return numAlu ;

}

Problema 006


Enunciado: Desarrolle una solución que permita almacenar el código, el nombre y el sueldo de cada uno de los empleados de una empresa u lizando arreglo de objetos. También desarrolle algunos métodos para manejar los datos almacenados. U lice el lenguaje de programación Java para la codifi cación de la solución y el paquete javax.swing para crear la GUI.

Etapa 02 – Defi nición de la solución

Resultado Deseado: Almacenar y manipular los datos de los empleados de una empresa. Datos necesarios: Código, nombre y sueldo de los empleados. Procesamiento: Se ingresarán los datos de los empleados y se almacenarán en un arreglo de

objetos. Se desarrollarán métodos para poder manipular los datos almacenados.


Nombre del proyecto: ProyEmpleado3 Diagrama de paquetes:


Diagrama de clases:


Diseño de la Interfaz Gráfi ca de Usuario (GUI):



Etapa 04 - Desarrollo de la codifi cación

Clase Empleado

package modelo;

public class Empleado {private long codigo;private String nombre;private double sueldo;

public Empleado() {codigo = 0;nombre = "";sueldo = 0;

}

public Empleado(long codigo, String nombre, double sueldo) {this.codigo = codigo;this.nombre = nombre;this.sueldo = sueldo;

}



}


}


}


}


}


}

}


package controlador;

import modelo.Empleado;



}public int agregarDatos(long codigo, String nombre, double sueldo) {

int pos = buscarCodigo(codigo);if (pos != -1) {

return -1;} else {

if (numEmp == datos.length) { aumentar();

}Empleado objEmp = new Empleado(codigo, nombre, sueldo);datos[numEmp] = objEmp;numEmp++;return 0;

}}public String obtenerDatos() {

String listaDatos = "";for (int i = 0; i < numEmp; i++) {

listaDatos = listaDatos + "Código-->" + datos[i].getCodigo()+ " " + "Nombre-->" + datos[i].getNombre() + " "+ "Sueldo-->" + datos[i].getSueldo() + "\n";

}


return listaDatos;}

public int eliminarDatos(long codigo) {int pos = buscarCodigo(codigo);if (pos == -1) {

return -1;} else {

for (int i = pos; i < numEmp - 1; i++) {datos[i] = datos[i + 1];

}numEmp--;return 0;

}}

public void ordenarDatos() {for (int i = 0; i < numEmp - 1; i++) {

for (int j = i + 1; j < numEmp; j++) {

if (datos[i].getCodigo() > datos[j].getCodigo()) {

Empleado tmp = datos[i];datos[i] = datos[j];datos[j] = tmp;

} }

}}public String obtenerDatosEmpleado(long codigo) {

String listaDatos = "";for (int i = 0; i < numEmp; i++) {

if (codigo == datos[i].getCodigo()) {listaDatos = "Información encontrada : \n" + "Código-->"

+ datos[i].getCodigo() + " " + "Nombre-->"+ datos[i].getNombre() + " " + "Sueldo-->"+ datos[i].getSueldo();

return listaDatos;}

}return "Datos no encontrados";

}

public int buscarCodigo(long codigo) {for (int i = 0; i < numEmp; i++) {


}}return -1;

}

public void aumentar() {Empleado datosTmp[] = new Empleado[datos.length + 3];for (int i = 0; i < numEmp; i++) {


}}


Clase GUIEmpleado

package vista;

import java.awt.*;import java.awt.event.*;import javax.swing.*;

import controlador.ArregloEmpleado;

import biblioteca.LE;

public class GUIEmpleado extends JFrame implements ActionListener,WindowListener {

ArregloEmpleado objArray;

JLabel lblTitulo, lblCodigo, lblNombre, lblSueldo; JTextField txtCodigo, txtNombre, txtSueldo; JButton btnAgregar, btnMostrar, btnEliminar, btnOrdenar, btnBuscar; JTextArea txaResultados; JScrollPane scpResultados;

public GUIEmpleado() {

// Creación del objeto objArray = new ArregloEmpleado();

// Construcción de la GUI getContentPane().setLayout(null);

// Etiqueta lblTitulo lblTitulo = new JLabel("DATOS DE EMPLEADOS"); lblTitulo.setBounds(50, 20, 200, 30); getContentPane().add(lblTitulo);

// Etiqueta lblCodigo lblNombre = new JLabel("Codigo :"); lblNombre.setBounds(50, 60, 50, 30); getContentPane().add(lblNombre);

// Etiqueta lblNombre lblNombre = new JLabel("Nombre :"); lblNombre.setBounds(50, 85, 60, 30); getContentPane().add(lblNombre);

// Etiqueta lblSueldos lblSueldo = new JLabel("Sueldo :"); lblSueldo.setBounds(50, 110, 50, 30); getContentPane().add(lblSueldo);

// Etiqueta txtCodigo txtCodigo = new JTextField(); txtCodigo.setBounds(110, 65, 50, 20); getContentPane().add(txtCodigo);

// Etiqueta txtNombre txtNombre = new JTextField(); txtNombre.setBounds(110, 90, 100, 20); getContentPane().add(txtNombre);


// Etiqueta txtSueldo txtSueldo = new JTextField(); txtSueldo.setBounds(110, 115, 50, 20); getContentPane().add(txtSueldo);

// Boton Agregar btnAgregar = new JButton("Agregar"); btnAgregar.setBounds(370, 65, 130, 25); btnAgregar.addActionListener(this); getContentPane().add(btnAgregar);

// Boton Mostrar btnMostrar = new JButton("Mostrar"); btnMostrar.setBounds(370, 90, 130, 25); btnMostrar.addActionListener(this); getContentPane().add(btnMostrar);

// Boton Eliminar btnEliminar = new JButton("Eliminar"); btnEliminar.setBounds(370, 115, 130, 25); btnEliminar.addActionListener(this); getContentPane().add(btnEliminar);

// Boton Ordenar btnOrdenar = new JButton("Ordenar Codigo"); btnOrdenar.setBounds(370, 140, 130, 25); btnOrdenar.addActionListener(this); getContentPane().add(btnOrdenar);

// Boton Buscar btnBuscar = new JButton("Buscar"); btnBuscar.setBounds(370, 165, 130, 25); btnBuscar.addActionListener(this); getContentPane().add(btnBuscar);

// Caja de texto de multiples lineas : TextArea txaResultados = new JTextArea(); txaResultados.setBounds(50, 180, 310, 150); txaResultados.setFont(new Font("arial", Font.ITALIC, 12)); txaResultados.setBackground(Color.LIGHT_GRAY);

// ScrollPane para multiples Datos en JTextArea scpResultados = new JScrollPane(txaResultados); scpResultados.setBounds(50, 180, 310, 150); getContentPane().add(scpResultados);

this.addWindowListener(this); this.setTitle("Empresa TALENTOS"); this.setSize(550, 400); this.setLocationRelativeTo(null); this.setVisible(true); } public void actionPerformed(ActionEvent e) {

if (e.getSource() == btnAgregar) { if (txtCodigo.getText().equalsIgnoreCase("") || txtNombre.getText().equalsIgnoreCase("") || txtSueldo.getText().equalsIgnoreCase("")) { LE.mostrarError("Ingrese los datos solicitados!"); } else {


long codigo = Long.parseLong(txtCodigo.getText()); String nombre = txtNombre.getText(); double sueldo = Double.parseDouble(txtSueldo.getText());

int respuesta = objArray.agregarDatos(codigo, nombre, sueldo);

if (respuesta == -1) {LE.mostrarError("El código ingresado ya existe");

}limpiarCajas();txaResultados.setText("");

}

}

if (e.getSource() == btnMostrar) {mostrarDatos();

}

if (e.getSource() == btnEliminar) {

long codigo = LE.leerLong("Ingrese el código del empleado cuyos datos deseas eliminar");

int temp = objArray.eliminarDatos(codigo);if (temp == 0) {

LE.mostrarInformacion("Datos del empleado eliminados correctamente");mostrarDatos();

} else {LE.mostrarError("El código no existe o no hay datos almacenados actualmente");mostrarDatos();

}}

if (e.getSource() == btnOrdenar) {objArray.ordenarDatos();mostrarDatos();

}

if (e.getSource() == btnBuscar) {long codigo = LE.leerLong("Ingrese el código del empleado cuyos datos deseas

mostrar");String listaDatos = objArray.obtenerDatosEmpleado(codigo);if (listaDatos == null) {

LE.mostrarInformacion("Código no encontrado");} else {

txaResultados.setText("");txaResultados.append(listaDatos);

}}

}

public static void main(String[] args) {GUIEmpleado x = new GUIEmpleado();

}


public void limpiarCajas() {txtCodigo.setText("");txtNombre.setText("");txtSueldo.setText("");

}

public void mostrarDatos() {String listaDatos = objArray.obtenerDatos();txaResultados.setText("");txaResultados.append(listaDatos);

}

public void windowOpened(WindowEvent we) { }

public void windowClosing(WindowEvent we) {System.exit(0);

}

public void windowClosed(WindowEvent we) { }

public void windowIconifi ed(WindowEvent we) { }

public void windowDeiconifi ed(WindowEvent we) { }

public void windowActivated(WindowEvent we) { }

public void windowDeactivated(WindowEvent we) { }

}

Analice cómo se han implementado el método eliminarDatos ( ) de la clase ArregloAlumno del problema anterior, y el método eliminarDatos ( ) de la clase ArregloEmpleado de este problema. Ambos métodos se muestran a con nuación:

Clase ArregloAlumno

public void eliminarDatos (int pos ) {if (pos > -1) {

for ( int i= pos ; i < numAlu -1 ; i++) {datos [ i ] = datos [ i + 1] ;

}numAlu - - ;

}}


public int eliminarDatos(long codigo) {int pos = buscarCodigo(codigo);if (pos == -1) {

return -1;} else {

for (int i = pos; i < numEmp - 1; i++) {datos[i] = datos[i + 1];

}numEmp -- ;return 0 ;

}}


Como puede observar, ambos métodos son correctos, y serán u lizados dependiendo de la situación. Solo debe tener presente que en la implementación del método eliminarDatos ( ) de la clase ArregloEmpleado no se realiza la confi rmación de los datos del usuario antes de la eliminación (esto porque se puede suponer que el usuario puede visualizar los datos antes de decidir su eliminación).

Problema 007


Enunciado: Implemente una Interfaz Gráfi ca de Usuario (GUI) u lizando componentes del paquete java.awt para la clase GUIEmpleado, la cual se denominará FrmEmpleado y estará almacenada en el paquete vista, de tal forma que se pueda u lizar todos los métodos creados para la clase ArregloEmpleado.


Nombre del proyecto: ProyEmpleado4 Diseño de la Interfaz Gráfi ca de Usuario (GUI):

Etapa 04 - Desarrollo de la Codifi cación

Clase Empleado

package modelo ;


private long codigo ;private String nombre ;private double sueldo ;

public Empleado ( ) {codigo = 0 ;nombre = "" ;sueldo = 0 ;

}public Empleado ( long codigo, String nombre, double sueldo ) {

this.codigo = codigo;this.nombre = nombre;this.sueldo = sueldo;

}



}


}


}


}


}


}

}

Clase FrmEmpleado

package vista;import java.awt.Frame;import java.awt.Rectangle;import java.awt.Label;import java.awt.TextField;import java.awt.TextArea;import java.awt.Button;import java.awt.SystemColor;

import controlador.ArregloEmpleado;import biblioteca.LE;

public class FrmEmpleado extends Frame {

ArregloEmpleado objArray = new ArregloEmpleado(); private static fi nal long serialVersionUID = 1L; private Label lblCodigo = null; private Label lblNombre = null; private Label lblSueldo = null; private TextField txtCodigo = null; private TextField txtNombre = null; private TextField txtSueldo = null; private TextArea txASalida = null; private Button btnIngresar = null; private Button btnMostrar = null;

private Button btnOrdenar = null; private Button btnModifi car = null; private Button btnBuscar = null; private Button btnEliminar = null; private Button btnSalir = null;

public FrmEmpleado() {


lblCodigo = new Label(); lblCodigo.setBounds(new Rectangle(56, 70, 67, 23)); lblCodigo.setForeground(SystemColor.activeCaptionText); lblCodigo.setText("Código");

lblNombre = new Label(); lblNombre.setBounds(new Rectangle(56, 104, 67, 23)); lblNombre.setForeground(SystemColor.activeCaptionText); lblNombre.setText("Nombre");

lblSueldo = new Label(); lblSueldo.setBounds(new Rectangle(56, 138, 67, 23)); lblSueldo.setForeground(SystemColor.activeCaptionText); lblSueldo.setText("Sueldo");

this.add(lblCodigo, null); this.add(lblNombre, null); this.add(lblSueldo, null); this.add(getTxtCodigo(), null); this.add(getTxtNombre(), null); this.add(getTxtSueldo(), null); this.add(getTxaSalida(), null); this.add(getBtnIngresar(), null); this.add(getBtnMostrar(), null); this.add(getBtnOrdenar(), null); this.add(getBtnModifi car(), null); this.add(getBtnEliminar(), null); this.add(getBtnSalir(), null); this.add(getBtnBuscar(), null); this.setLayout(null); this.setSize(607, 437); this.setTitle("FrmEmpleado"); this.setLocationRelativeTo(null); this.setVisible(true);

}

public static void main(String args[]) { FrmEmpleado x = new FrmEmpleado();

}

private TextField getTxtCodigo() {

if (txtCodigo == null) { txtCodigo = new TextField(); txtCodigo.setBounds(new Rectangle(127, 70, 174, 23)); } return txtCodigo;

}private TextField getTxtNombre() {

if (txtNombre == null) { txtNombre = new TextField(); txtNombre.setBounds(new Rectangle(127, 105, 174, 23)); } return txtNombre; } private TextField getTxtSueldo() {

if (txtSueldo == null) { txtSueldo = new TextField(); txtSueldo.setBounds(new Rectangle(127, 140, 174, 23));

}


return txtSueldo; }

private TextArea getTxaSalida() {

if (txASalida == null) { txASalida = new TextArea(); txASalida.setBounds(new Rectangle(49, 185, 377, 212)); } return txASalida; }

private Button getBtnIngresar() { if (btnIngresar == null) { btnIngresar = new Button(); btnIngresar.setBounds(new Rectangle(466, 76, 98, 35)); btnIngresar.setLabel("Ingresar"); btnIngresar.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { ingresar(); } }); } return btnIngresar; }

private Button getBtnMostrar() { if (btnMostrar == null) { btnMostrar = new Button(); btnMostrar.setBounds(new Rectangle(466, 123, 98, 35)); btnMostrar.setLabel("Mostrar"); btnMostrar.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent e) { mostrar();

} }); } return btnMostrar; }

private Button getBtnOrdenar() { if (btnOrdenar == null) { btnOrdenar = new Button(); btnOrdenar.setBounds(new Rectangle(466, 217, 98, 35)); btnOrdenar.setLabel("Ordenar"); btnOrdenar.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent e) { ordenar();

} }); } return btnOrdenar; }

private Button getBtnModifi car() {

if (btnModifi car == null) { btnModifi car = new Button(); btnModifi car.setBounds(new Rectangle(466, 264, 98, 35));


btnModifi car.setLabel("Modifi car"); btnModifi car.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent e) { modifi car();

} }); } return btnModifi car; }

private Button getBtnBuscar() {

if (btnBuscar == null) { btnBuscar = new Button(); btnBuscar.setLabel("Buscar"); btnBuscar.setBounds(new Rectangle(466, 170, 98, 35)); btnBuscar.addActionListener(new java.awt.eventActionListener() {

public void actionPerformed(java.awt.event.ActionEvent e) { buscar();

} }); } return btnBuscar; }

private Button getBtnEliminar() {

if (btnEliminar == null) { btnEliminar = new Button(); btnEliminar.setBounds(new Rectangle(466, 311, 98, 35)); btnEliminar.setLabel("Eliminar"); btnEliminar.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent e) { eliminar();

} }); } return btnEliminar; }

private Button getBtnSalir() { if (btnSalir == null) { btnSalir = new Button(); btnSalir.setBounds(new Rectangle(466, 358, 98, 35)); btnSalir.setLabel("Salir"); btnSalir.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent e) { salir();

} }); } return btnSalir; }


void ingresar() { int codigo = Integer.parseInt(txtCodigo.getText()); String nombre = txtNombre.getText(); double sueldo = Double.parseDouble(txtSueldo.getText()); objArray.agregarDatos(codigo, nombre, sueldo); limpiar(); }

void mostrar() { txASalida.setText("Código Nombre Sueldo\n" + objArray.obtenerDatos()); }

void buscar() { long codigo = LE .leerLong("Ingrese el código del empleado cuyos datos deseas mostrar"); int pos = objArray.buscarCodigo(codigo);

if (pos > -1) { LE.mostrarInformacion(objArray.obtenerDatosEmpleado(codigo)); mostrar(); } else { LE.mostrarInformacion("Código de empleado no existe"); } }

void ordenar() { objArray.ordenarDatos(); }

void modifi car() { long codigo = LE .leerLong("Ingrese el código del empleado cuyos datos deseas modifi car"); int pos = objArray.buscarCodigo(codigo);

if (pos > -1) { String nombre = LE.leerString("Ingresa nuevo nombre"); double sueldo = LE.leerDouble("Ingresa nuevo sueldo");

objArray.modifi carDatos(pos, nombre, sueldo); mostrar(); } else { LE.mostrarError("El código a modifi car no existe"); }

}

void eliminar() { long codigo = LE .leerLong("Ingrese el código del empleado cuyos datos deseas eliminar");

int temp = objArray.eliminarDatos(codigo); if (temp == 0) {

LE.mostrarInformacion("Datos del empleado eliminados correctamente");mostrar();

} else {LE.mostrarError("El código no existe o no hay datos almacenados actualmente");mostrar();

} }


void salir() {System.exit(0);

}

void limpiar() {txtCodigo.setText("");txtNombre.setText("");txtSueldo.setText("");txtCodigo.requestFocus();

}}


package controlador;import modelo.Empleado;public class ArregloEmpleado { Empleado datos[]; int numEmp;

public ArregloEmpleado() { numEmp = 0; datos = new Empleado[5]; }

public int agregarDatos(long codigo, String nombre, double sueldo) { int pos = buscarCodigo(codigo); if (pos != -1) { return -1; } else { if (numEmp == datos.length) { aumentar(); } Empleado objEmp = new Empleado(codigo, nombre, sueldo); datos[numEmp] = objEmp;

numEmp++;return 0;

} } public String obtenerDatos() { String listaDatos = ""; for (int i = 0; i < numEmp; i++) { listaDatos = listaDatos + "Código-->" + datos[i].getCodigo() + " " + "Nombre-->" + datos[i].getNombre() + " " + "Sueldo-->" + datos[i].getSueldo() + "\n"; } return listaDatos; }

public int eliminarDatos(long codigo) { int pos = buscarCodigo(codigo); if (pos == -1) { return -1; } else {

for (int i = pos; i < numEmp - 1; i++) { datos[i] = datos[i + 1]; } numEmp--;

return 0; } }


public void modifi carDatos(int pos, String nombre, double sueldo) { datos[pos].setNombre(nombre); datos[pos].setSueldo(sueldo); } public void ordenarDatos() { for (int i = 0; i < numEmp - 1; i++) { for (int j = i + 1; j < numEmp; j++) {

if (datos[i].getCodigo() > datos[j].getCodigo()) { Empleado tmp = datos[i]; datos[i] = datos[j]; datos[j] = tmp; }

}}

} public String obtenerDatosEmpleado(long codigo) { String listaDatos = ""; for (int i = 0; i < numEmp; i++) { if (codigo == datos[i].getCodigo()) { listaDatos = "Información encontrada : \n" + "Código-->" + datos[i].getCodigo() + " " + "Nombre-->" + datos[i].getNombre() + " " + "Sueldo-->" + datos[i].getSueldo(); return listaDatos; } } return "Datos no encontrados"; } public int buscarCodigo(long codigo) { for (int i = 0; i < numEmp; i++) { if (codigo == datos[i].getCodigo()) { return i; } } return -1; } public void aumentar() { Empleado datosTmp[] = new Empleado[datos.length + 3]; for (int i = 0; i < numEmp; i++) { datosTmp[i] = datos[i]; } datos = datosTmp; }}

Observe que la clase ArregloEmpleado, desarrollada en el problema anterior, no implementa el método modifi carDatos ( ), por lo que, para un correcto funcionamiento de la clase FrmEmpleado, se debería implementar. El método modifi carDatos ( ) de la clase ArregloEmpleado se muestra en las siguientes líneas de código:

public void modifi carDatos(int pos, String nombre, double sueldo) { datos[pos].setNombre(nombre); datos[pos].setSueldo(sueldo); }


1.5 INTÉNTALO

Problema 008


Enunciado: Modifi que la Interfaz Gráfi ca de Usuario (GUI) creada anteriormente, de tal forma que u lice componentes javax.swing, tal y como se muestra a con nuación:

Etapa 03 – Diseño de la solución

Diseño de la Interfaz Gráfi ca de Usuario GUI

Problema 009


Enunciado: Desarrolle una solución que permita almacenar la nota de todos los alumnos de un salón de clase. U lice la clase de colección ArrayList del paquete java.u l del lenguaje de programación Java.


Clase PrgNota1

package ProyArrayList ;

import biblioteca.util.* ;import java.util.* ;


public class PrgNota1 {

// Se declara un ArrayList llamando nota ArrayList nota ; int numALu ;

PrgNota ( ) { numALu = 0 ; /* Construye un ArrayList con capacidad cero por defecto pero * aumentará su tamaño conforme agreguemos elementos. */ nota = new ArrayList ( ) ; }

public static void main ( String [ ] a ) { PrgNota1 x = new PrgNota1 ( ) ; x.menu ( ) ; }

public void menu ( ) {String opciones1 = “MENU DE OPCIONES\n\n”

+ “[1] Ingresar notas \n”+ “[9] Finalizar \n”+ “------------------------\n”+ “Seleccione opción” ;

String opciones2 = “MENU DE OPCIONES\n\n”+ “[1] Ingresar notas \n”+ “[2] Mostrar notas \n”+ “[9] Finalizar \n”+ “------------------------\n”+ “Seleccione opción” ;

String menu = opciones1 ;

int opc ;boolean centinela = false ;

do {

opc = LE.leerInt ( menu ) ;

switch ( opc ) {case 1 :

ingresar ( ) ;centinela = true ;menu = opciones2 ;break ;

case 2 :if ( centinela ) { mostrar ( ) ;} else {

LE.mostrarInformacion ( “Opción no valida, reintente!” ) ;}break ;

case 9 :break ;

default : LE.mostrarInformacion ( “Opción no valida, reintente!” ) ; }


} while ( opc != 9 ) ; }

public void ingresar ( ) { int rpta ; do { nota.add ( LE.leerDouble ( “Ingrese nota[” + ( numAlu + 1 ) + “]” ) ) ; numAlu ++ ; rpta = LE.mostrarPreguntaOpcion2 ( “¿Desea continuar?” ) ;

} while ( rpta == 0 ) ; }

public void mostrar ( ) { String lista = “Relación de notas\n” ;

for ( int i = 0 ; i < nota.size ( ) ; i++ ) { lista = lista + nota.get ( i ) + “\n” ; }

lista = lista + “----\nTotal de alumnos: ” + nota.size ( ) ; LE.mostrarInformacion ( lista ) ;

// Puede mostrar el ArrayList nota como texto. LE.mostrarInformacion ( nota.toString ( ) ) ; System.out.println ( nota ) ; }

}

Problema 010


Enunciado: Desarrolle una solución que permita almacenar el código, el nombre y el sueldo de cada uno de los empleados de una empresa u lizando arreglo de objetos. También desarrolle métodos para manejar los datos almacenados e implemente una solución para exportar los datos a un archivo de po PDF.


Clase Empleadopackage domPro;public class Empleado { private long codigo ; private String nombre ; private double sueldo ; public Empleado ( long codigo, String nombre, double sueldo ) { this .codigo = codigo ; this .nombre = nombre ; this .sueldo = sueldo ;


}

public Empleado ( ) {codigo = 0 ;nombre = null ;sueldo = 0 ;

}

public long getCodigo ( ) {return codigo ;

}

public void setCodigo ( long codigo ) {this.codigo = codigo ;

}

public String getNombre ( ) {return nombre ;

}

public void setNombre ( String nombre ) {this.nombre = nombre ;

}public double getSueldo ( ) {

return sueldo ;}

public void setSueldo ( double sueldo ) {this.sueldo = sueldo ;

}}

Clase PrgEmpleado

package domApli ;

import biblioteca.LE ;import domPro.Empleado ;


public Empleado datos [ ] ; private int numEmp ;

public PrgEmpleado ( ) { datos = new Empleado [ 5 ] ; numEmp = 0 ; }

public void ingresarDatos ( ) { int rpta ; long codigo ; String nombre ;

double sueldo ;

do {codigo = LE.leerLong ( " Ingrese el código " ) ;nombre = LE.leerString ( " Ingrese el nombre " ) ;sueldo = LE.leerDouble ( " Ingrese el sueldo " ) ;


Clase ArchivoPDF

package domApli ;

import java.io.FileOutputStream ;

import com.itextpdf.text.* ;import com.itextpdf.text.pdf.* ;

public class ArchivoPDF {

public static void mostrarPDF ( String texto ) { try {

Document d = new Document ( PageSize.A3 ) ;

PdfWriter.getInstance ( d, new FileOutputStream ( "datos.pdf" ) ) ;

d.open ( ) ; d.addAuthor ( "SISEMP " ) ;d.addCreator ( "JJFC" ) ;

Empleado objEmp = new Empleado ( ) ;objEmp.setCodigo ( codigo ) ;objEmp.setNombre ( nombre ) ;objEmp.setSueldo ( sueldo ) ;

datos[numEmp] = objEmp ;numEmp ++ ;


}

public void mostrarDatos ( ) { String listaDatos = "" ;

for ( int i = 0; i < numEmp; i++ ) {

listaDatos = listaDatos + datos[i].getCodigo ( ) + " " + datos[i].getNombre () + " " + datos[i]. getSueldo ( ) + "\n" ;

} ArchivoPDF.mostrarPDF ( listaDatos ) ;

}

public static void main ( String arg [ ] ) {

PrgEmpleado x = new PrgEmpleado ( ) ; x.ingresarDatos ( ) ; x.mostrarDatos ( ) ;

}}


d.addTitle ( "Datos de Empleados" ) ;d.addSubject ( "PDF" ) ;

d.add ( new Paragraph ( texto ) ) ; d.close ( ) ;

} catch ( Exception e ) {System.out.println ( e ) ;

} }}

1.6 PROBLEMAS PROPUESTOS

Para el desarrollo de los siguientes problemas propuestos u lice dos clases:

1. Desarrolle una solución que permita almacenar el código, el nombre, la nota1, nota2 y nota3 de todos los alumnos de un salón de clase u lizando arreglo de objetos. También, desarrolle todos los métodos necesarios para manejar los datos almacenados. Adicionalmente, desarrolle un método que permita determinar el promedio de cada alumno y su condición fi nal (aprobado o desaprobado). U lice el lenguaje de programación Java para la codifi cación de la solución.

2. Desarrolle una solución que permita almacenar el código, el nombre, el sueldo, el año de ingreso y el área donde labora cada uno de los empleados de una empresa u lizando arreglo de objetos. También, desarrolle todos los métodos necesarios para manejar los datos almacenados. Adicionalmente, desarrolle un método que permita determinar la can dad de años que ene cada empleado, y el área donde trabaja. U lice el lenguaje de programación Java para la codifi cación de la solución.

3. Desarrolle una solución que permita almacenar el código, el nombre, el precio de compra, el precio de venta y la can dad de productos almacenados de cada uno de los ar culos de una bodega u lizando arreglo de objetos. También, desarrolle todos los métodos necesarios para manejar los datos almacenados. Adicionalmente, desarrolle un método que permita determinar la u lidad que ene cada ar culo y la can dad de productos almacenados por cada ar culo. U lice el lenguaje de

programación Java para la codifi cación de la solución.

4. Desarrolle una solución que permita almacenar el código, el tulo, el ISBN, el número de páginas y el año de publicación de todos los libros de una biblioteca u lizando arreglo de objetos. También, desarrolle todos los métodos necesarios para manejar los datos almacenados. Adicionalmente desarrolle un método que permita determinar la an güedad de cada libro (en años). U lice el lenguaje de programación Java para la codifi cación de la solución.

5. Desarrolle una solución que permita almacenar el número de documento de iden dad, el nombre, el apellido, el año de nacimiento y el nombre del distrito de los habitantes de la provincia de Lima u lizando arreglo de objetos. También, desarrolle todos los métodos necesarios para manejar los datos almacenados. Adicionalmente, desarrolle un método que permita determinar cuántas personas viven en cada uno de los distritos de la provincia de Lima. U lice el lenguaje de programación Java para la codifi cación de la solución.


Para el desarrollo de los siguientes problemas propuestas u lice tres clases:

6. Desarrolle una solución que permita almacenar el código, el nombre, la nota1, nota2 y nota3 de todos los alumnos de un salón de clase u lizando arreglo de objetos. También, desarrolle todos los métodos necesarios para manejar los datos almacenados. Adicionalmente, desarrolle un método que permita determinar el promedio de cada alumno y su condición fi nal (aprobado o desaprobado). U lice el lenguaje de programación Java para la codifi cación de la solución.

7. Desarrolle una solución que permita almacenar el código, el nombre, el sueldo, el año de ingreso y el área donde labora cada uno de los empleados de una empresa u lizando arreglo de objetos. También, desarrolle todos los métodos necesarios para manejar los datos almacenados. Adicionalmente, desarrolle un método que permita determinar la can dad de años que ene cada empelado, y el área donde trabaja. U lice el lenguaje de programación Java para la codifi cación de la solución.

8. Desarrolle una solución que permita almacenar el código, el nombre, el precio de compra, el precio de venta y la can dad de productos almacenados de cada uno de los ar culos de una bodega u lizando arreglo de objetos. También, desarrolle todos los métodos necesarios para manejar los datos almacenados. Adicionalmente desarrolle un método que permita determinar la u lidad que ene cada ar culo y la can dad de productos almacenados por cada ar culo. U lice el lenguaje de

programación Java para la codifi cación de la solución.

9. Desarrolle una solución que permita almacenar el código, el tulo, el ISBN, el número de páginas y el año de publicación de todos los libros de una biblioteca u lizando arreglo de objetos. También, desarrolle todos los métodos necesarios para manejar los datos almacenados. Adicionalmente desarrolle un método que permita determinar la an güedad de cada libro (en años). U lice el lenguaje de programación Java para la codifi cación de la solución.

10. Desarrolle una solución que permita almacenar el número de documento de iden dad, el nombre, el apellido, el año de nacimiento y el nombre del distrito de los habitantes de la provincia de Lima u lizando arreglo de objetos. También, desarrolle todos los métodos necesarios para manejar los datos almacenados. Adicionalmente, desarrolle un método que permita determinar cuántas personas viven en cada uno de los distritos de la provincia de Lima. U lice el lenguaje de programación Java para la codifi cación de la solución.

Impreso en los talleres gráfi cos de

Surquillo

Método de las 6`D Modelamiento - Algoritmo - Programación.

Documents

Transcript of Método de las 6`D Modelamiento - Algoritmo - Programación.