Guia Laboratorio Nº 04 - Arreglos - Modular

UNIMASTER
Fundamentos JAVA
Fundamentos Java
Laboratorio 04
Arreglos – Programación Modular
COMPETENCIAS:
Implementa aplicaciones Java usando Arreglos uni y bidimensional.
Implementa aplicación usando programacion modular.
-
ARREGLO UNIDIMENSIONAL
Caso desarrollado: Registro de Notas con arreglo unidimensional
Implementar una aplicación en Java que permite controlar las notas de un grupo de alumnos usando
arreglo unidimensional.
Para lo cual debemos crear 2 Clases: la clase ArregloRegistro (clase que manejo el arreglo
unidimensional) y la clase frmCalificacion (clase que interactúa con el usuario a través de la GUI).
Dentro de la clase ArregloRegistro:
-
Crear un arreglo para los Alumnos
Crear un arreglo para cada nota.
Crear un arreglo para sus promedios
La variable índice de tipo int que almacene la cantidad de alumnos registrados y determine la
posición del arreglo donde se almacenara el alumno.
Los siguientes métodos:
- El método constructor se encarga de crear el arreglo con 40 alumnos e inicialice la variable
índice en cero para el inicio del arreglo.
- El método calculaPromedio que devuelva el promedio de las 4 notas del alumno.
- El método registrar se encarga de almacenar el nombre del Alumno, sus cuatros notas y su
promedio en los arreglos respectivos e incremente la variable índice en uno.
- El método getIndice es un método de acceso para el atributo índice, ya que éste es privado.
Devuelve la cantidad de alumnos registrados.
- El método obtenerAlumno devuelve el nombre del Alumno que se encuentra en el arreglo en
la posición pos, ya que desde afuera de la clase no se tiene acceso al arreglo por ser privado.
- El método obtenerPromedio devuelve el promedio del Alumno que se encuentra en el arreglo
en la posición pos.
- El método obtenerNota1 devuelve la nota 1 del Alumno que se encuentra en el arreglo en la
posición pos.
Elaborado por: Lic. Manuel Torres Re.
UNIMASTER
-
Fundamentos JAVA
El método obtenerNota2 devuelve la nota 2 del Alumno que se encuentra en el arreglo en la
posición pos.
El método obtenerNota3 devuelve la nota 3 del Alumno que se encuentra en el arreglo en la
posición pos.
El método obtenerNota4 devuelve la nota 4 del Alumno que se encuentra en el arreglo en la
posición pos.
El método buscarAlumno localiza la posición de un determinado alumno.
GUI Propuesto:
Script de la clase ArregloRegistro:
package pClases;
public class ArregloRegistro {
private String alumno[];
private double promedio[];
private int n1[],n2[],n3[],n4[];
private int indice;
//Metodo constructor
public ArregloRegistro(){
alumno=new String[40];
promedio=new double[40];
Elaborado por: Lic. Manuel Torres Re.
UNIMASTER
Fundamentos JAVA
n1=new int[40];
n2=new int[40];
n3=new int[40];
n4=new int[40];
índice=0;
}
//Metodos propios
public double calcularPromedio(int n1,int n2,int n3,int n4){
return (n1+n2+n3+n4)/4;
}
//Método que registra un alumno y su promedio
public void registrar(String alumno,int n1,int n2,int n3,
int n4,double promedio){
this.alumno[indice]=alumno;
this.n1[indice]=n1;
this.n2[indice]=n2;
this.n3[indice]=n3;
this.n4[índice]=n4;
this.promedio[índice]=promedio;
índice++;
}
//Determinar el total de alumnos registrados
public int getIndice(){
return indice;
}
//Método que permite buscar un determinado alumno
public int buscarAlumno(String alumno){
for(int i=0;i<indice;i++){
if (this.alumno[i].equals(alumno))
return i;
}
return -1;
}
//Método que devuelve el nombre del alumno según la posición del arreglo
public String obtenerAlumno(int pos){
return alumno[pos];
}
public int
return
}
public int
return
}
public int
return
}
public int
return
}
obtenerNota1(int pos){
n1[pos];
obtenerNota2(int pos){
n2[pos];
obtenerNota3(int pos){
n3[pos];
obtenerNota4(int pos){
n4[pos];
Elaborado por: Lic. Manuel Torres Re.
UNIMASTER
Fundamentos JAVA
//Método que devuelve el promedio según la posición en el arreglo
public double obtenerPromedio(int pos){
return promedio[pos];
}
}
Script para crear el objeto del tipo arreglo:
//Creando el objeto de la clase ArregloRegistro
ArregloRegistro objAr = new ArregloRegistro();
Métodos de la aplicación:
//Imprimir los valores encontrados en el arreglo
void imprimir(){
limpiarTabla();
for(int i=0;i<objAr.getIndice();i++){
tRegistro.setValueAt(objAr.obtenerAlumno(i), i, 0);
tRegistro.setValueAt(objAr.obtenerNota1(i), i, 1);
tRegistro.setValueAt(objAr.obtenerNota2(i), i, 2);
tRegistro.setValueAt(objAr.obtenerNota3(i), i, 3);
tRegistro.setValueAt(objAr.obtenerNota4(i), i, 4);
tRegistro.setValueAt(objAr.obtenerPromedio(i), i, 5);
}
}
//Limpia el contenido de la tabla
void limpiarTabla(){
for (int i=0;i<20;i++){
tRegistro.setValueAt("", i,
tRegistro.setValueAt("", i,
tRegistro.setValueAt("", i,
tRegistro.setValueAt("", i,
tRegistro.setValueAt("", i,
tRegistro.setValueAt("", i,
}
}
0);
1);
2);
3);
4);
5);
Script del botón REGISTRAR:
private void btnRegistrarActionPerformed(java.awt.event.ActionEvent evt) {
//Capturando los valores desde el formulario
String alumno=getAlumno();
int n1=getN1();
int n2=getN2();
int n3=getN3();
int n4=getN4();
//Calculando el promedio de notas
double promedio=objAr.calcularPromedio(n1, n2, n3, n4);
//Enviándolo al Arreglo
objAr.registrar(alumno,n1,n2,n3,n4,promedio);
Elaborado por: Lic. Manuel Torres Re.
UNIMASTER
Fundamentos JAVA
//Imprimirlo en la tabla
imprimir();
}
Script del botón LISTAR:
private void btnListarActionPerformed(java.awt.event.ActionEvent evt) {
imprimir();
}
Script del botón BUSCAR:
private void btnBuscarActionPerformed(java.awt.event.ActionEvent evt) {
limpiarTabla();
String alumno = JOptionPane.showInputDialog(this,
"Ingrese nombre del alumno: ");
int pos= objAr.buscarAlumno(alumno);
tRegistro.setValueAt(objAr.obtenerAlumno(pos), 0, 0);
tRegistro.setValueAt(objAr.obtenerNota1(pos), 0, 1);
tRegistro.setValueAt(objAr.obtenerNota2(pos), 0, 2);
tRegistro.setValueAt(objAr.obtenerNota3(pos), 0, 3);
tRegistro.setValueAt(objAr.obtenerNota4(pos), 0, 4);
tRegistro.setValueAt(objAr.obtenerPromedio(pos), 0, 5);
}
Script del botón LIMPIAR:
private void btnLimpiarActionPerformed(java.awt.event.ActionEvent evt) {
limpiarTabla();
}
Elaborado por: Lic. Manuel Torres Re.
UNIMASTER
Fundamentos JAVA
Caso propuesto 01: Control de Venta Diaria
Se deberá crear 2 clases: la clase ArregloVenta (clase que maneje el arreglo unidimensional) y
la clase frmVenta (clase que interactúa con el usuario a través de la GUI).
Dentro de la clase ArregloVenta:
-
Crear un arreglo para el número de venta que inicie con el valor 1000.
Crear un arreglo para el nombre del vendedor
Crear un arreglo para el monto total vendido
Crear un arreglo para el monto de comisión
La variable índice de tipo int que almacene la cantidad de ventas registradas y determine
la posición del arreglo donde se almacenará dicha venta.
Los siguientes métodos:
- El método constructor se encarga de crear el arreglo para 50 ventas e inicialice la variable
índice en cero para el inicio del arreglo.
- El método calculaComision que devuelva el monto de comisión según el monto vendido:
MONTO VENDIDO
<1000
ENTRE 1000 y 2000
>2000
-
-
PORCENTAJE DE COMISION
2%
10%
15%
El método registrar se encarga de almacenar la venta es decir el numero de venta,
nombre del vendedor, monto vendido y el monto por comisión en los arreglos respectivos
e incremente la variable índice.
El método getIndice es un método de acceso para el atributo índice, ya que éste es
privado. Devuelve la cantidad de ventas registradas.
El método obtenerNumero que devuelve el numero de venta que se encuentra en el
arreglo en la posición pos.
El método obtenerVendedor que devuelve los datos del vendedor que se encuentra en
el arreglo en la posición pos.
El método obtenerMontoVendido que devuelva los montos vendidos que se encuentra
en el arreglo en la posición pos.
El método obtenerMontoComision que devuelve el monto de comisión que se encuentra
en el arreglo en la posición pos.
El método buscarVenta el cual localiza la venta registrada por medio del numero de venta
y devolverá los datos de la venta (numero, nombre del vendedor, monto vendido y monto
comisión).
Elaborado por: Lic. Manuel Torres Re.
UNIMASTER
Fundamentos JAVA
Caso propuesto 02: Control de Pago de Pensiones
Se deberá crear 2 clases: la clase ArregloPension (clase que maneje el arreglo unidimensional)
y la clase frmPension (clase que interactúa con el usuario a través de la GUI).
Dentro de la clase ArregloPension:
-
Crear un arreglo para el número autogenerado.
Crear un arreglo para los alumnos
Crear un arreglo para tipo de alumno
Crear un arreglo para el monto mensual
La variable índice de tipo int que almacene la cantidad de pensiones registradas y
determine la posición del arreglo donde se almacenará dicha pensión.
Los siguientes métodos:
- El método constructor se encarga de crear el arreglo para 30 alumnos e inicialice la
variable índice en cero para el inicio del arreglo.
- El método asignaMontoMensual que devuelva el monto mensual según el tipo de
alumno:
TIPO DE ALUMNO
MONTO MENSUAL
Regular
Media Beca
Beca
-
-
S/ 769.00
S/ 350.00
S/ 50.00
El método registrar se encarga de almacenar la pensión es decir el numero autogenerado,
nombre del alumno, tipo de alumno y el monto mensual en los arreglos respectivos e
incremente la variable índice.
El método getIndice es un método de acceso para el atributo índice, ya que éste es
privado. Devuelve la cantidad de pensiones registradas.
El método obtenerNumero que devuelve el numero autogenerado que se encuentra en
el arreglo en la posición pos.
El método obtenerAlumno que devuelve los datos del alumno que se encuentra en el
arreglo en la posición pos.
El método obtenerTipo que devuelva los tipos de alumnos que se encuentra en el arreglo
en la posición pos.
El método obtenerMonto que devuelve el monto mensual que se encuentra en el arreglo
en la posición pos.
El método buscarAlumno el cual localiza la pensión registrada por medio del numero de
registro y devolverá los datos de la pensión (numero autogenerado, nombre del alumno,
tipo y monto mensual).
Elaborado por: Lic. Manuel Torres Re.
UNIMASTER
Fundamentos JAVA
ARREGLO MULTIDIMENSIONAL
Caso Desarrollado 1: Control de ingreso de productos
Implemente una aplicación en Java que permita controlar el mantenimiento de los productos en una
tienda. Para lo cual se deberá considerar el ingreso de un producto, la modificación de algún dato y
la eliminación de un determinado productos. Así mismo deberá implementar la consulta para buscar
un determinado producto y un listado para mostrar todos los registros.
Solución:
1. Crear un proyecto llamado “pjMantenimientoProducto”
2. Añadir tres paquetes los cuales tienen la siguiente distribución:
PAQUETE
pClases
pFormularios
CLASE
Producto
DESCRIPCION
Contiene los métodos get/set de los atributos de
los productos como su código, descripción, precio,
stock y categoría; así como su método constructor.
ArregloProducto
Contiene los métodos que permiten agregar,
modificar o eliminar un registro de producto en el
ArrayList.
Contiene toda la interfaz que nos permite
gestionar los datos de los productos.
Contiene todas las imágenes usadas en el
formulario de mantenimiento de producto.
frmProducto
pImagenes
3. Los botones del formulario van a trabajar de la siguiente manera:
Elaborado por: Lic. Manuel Torres Re.
UNIMASTER
BOTON
AGREGAR
MODIFICAR
ELIMINAR
BUSCAR
LISTAR
Fundamentos JAVA
DESCRIPCION
Tiene como misión mostrar el nuevo número de producto, limpiar los
controles para un nuevo ingreso de productos. Así mismo deberá
ocultarse para mostrar un botón llamado GRABAR, el cual grabara los
nuevos datos del producto nuevo, una vez finalizado volverá a activarse
el botón Agregar y ocultarse el botón Grabar.
Tiene como misión mostrar una ventana de dialogo que solicite el número
de producto a modificar una vez encontrado mostrarlo en los controles.
Así mismo deberá ocultarse para mostrar un botón llamado GRABAR, el
cual grabara los datos modificados del producto, una vez finalizado
volverá a activarse el botón Modificar y ocultarse el botón Grabar.
Tiene como misión mostrar una ventana de dialogo que solicite el número
de producto a eliminar. Una vez encontrado deberá borrarlo del arreglo
y mostrar los nuevos elementos en la lista.
Tiene como misión mostrar una ventana de dialogo que solicite el número
de producto a buscar una vez encontrado lo mostrara en los controles y
en la lista de productos.
Tiene como misión mostrar información registrada dentro del arreglo.
Clase Producto:
package pClases;
public class Producto {
private int codigo;
private String descripcion;
private double precio;
private String categoria;
private int stock;
//Definir el constructor
public Producto(int codigo, String descripcion, double precio,
String categoria, int stock) {
this.codigo = codigo;
this.descripcion = descripcion;
this.precio = precio;
this.categoria = categoria;
this.stock = stock;
}
//Definir los metodos Get y Set
public int getCodigo() {
return codigo;
}
public void setCodigo(int codigo) {
this.codigo = codigo;
}
public String getDescripcion() {
return descripcion;
}
public void setDescripcion(String descripcion) {
this.descripcion = descripcion;
}
Elaborado por: Lic. Manuel Torres Re.
UNIMASTER
public double getPrecio() {
return precio;
}
public void setPrecio(double precio) {
this.precio = precio;
}
public String getCategoria() {
return categoria;
}
public void setCategoria(String categoria) {
this.categoria = categoria;
}
public int getStock() {
return stock;
}
public void setStock(int stock) {
this.stock = stock;
}
}
Clase ArregloProductos:
package pClases;
import java.util.ArrayList;
public class ArregloProductos {
//Definir el arreglo de productos
ArrayList<Producto> prod;
//Definir el metodo constructor
public ArregloProductos(){
prod = new ArrayList<Producto>();
}
//Metodo que devuelve el total de productos registrados
public int totalProductos(){
return prod.size();
}
//Metodo para agregar un nuevo producto
public void agregaProducto(Producto objP){
prod.add(objP);
}
//Metodo para obtener elementos del arreglo
public Producto obtener(int pos){
return prod.get(pos);
}
//Metodo para buscar un producto desde el arreglo
public Producto buscarProducto(int cod){
for(Producto p:prod){
if (p.getCodigo()==cod)
return p;
Elaborado por: Lic. Manuel Torres Re.
Fundamentos JAVA
UNIMASTER
Fundamentos JAVA
}
return null;
}
//Metodo para eliminar un producto del arreglo
public void eliminaProducto(Producto objP){
prod.remove(objP);
}
}
Clase frmProducto:
package pFormularios;
import javax.swing.JOptionPane;
import pClases.ArregloProductos;
import pClases.Producto;
public class frmProducto extends javax.swing.JFrame {
ArregloProductos aProductos = new ArregloProductos();
int n;
public frmProducto() {
initComponents();
//Ocultar los botones de grabacion
btnGrabarA.setVisible(false);
btnGrabarM.setVisible(false);
//Llenar de productos
cboCategoria.addItem("Bebidas");
cboCategoria.addItem("Lacteos");
cboCategoria.addItem("Abarrotes");
cboCategoria.addItem("Golosinas");
}
void generaCodigo() {
n++;
lblCodigo.setText("" + n);
}
private void btnAgregarActionPerformed(java.awt.event.ActionEvent evt) {
generaCodigo();
limpiarCajas();
//Habilitando los botones
btnAgregar.setVisible(false);
btnGrabarA.setVisible(true);
}
private void btnGrabarAActionPerformed(java.awt.event.ActionEvent evt) {
try {
int codigo = Integer.parseInt(lblCodigo.getText());
String descripcion = txtDescripcion.getText();
String categoria = String.valueOf(cboCategoria.getSelectedItem());
double precio = Double.parseDouble(txtPrecio.getText());
int stock = Integer.parseInt(txtStock.getText());
//Objeto de la clase Producto
Producto objP = new Producto(codigo,descripcion,precio,categoria,stock);
Elaborado por: Lic. Manuel Torres Re.
UNIMASTER
Fundamentos JAVA
aProductos.agregaProducto(objP);
listar();
} catch (Exception ex) {
JOptionPane.showMessageDialog(null,
"Ocurrió un error al intentar agregar",
"Confirmación",
JOptionPane.INFORMATION_MESSAGE);
}
//Habilitando los botones
btnAgregar.setVisible(true);
btnGrabarA.setVisible(false);
limpiarCajas();
}
private void btnModificarActionPerformed(java.awt.event.ActionEvent evt) {
int cod = Integer.parseInt(JOptionPane.showInputDialog(null,
"Ingrese codigo de producto:"));
Producto objP = aProductos.buscarProducto(cod);
if (objP != null) {
lblCodigo.setText("" + objP.getCodigo());
txtDescripcion.setText("" + objP.getDescripcion());
txtPrecio.setText("" + objP.getPrecio());
cboCategoria.setSelectedItem("" + objP.getCategoria());
txtStock.setText("" + objP.getStock());
}
btnModificar.setVisible(false);
btnGrabarM.setVisible(true);
}
private void btnGrabarMActionPerformed(java.awt.event.ActionEvent evt) {
try {
Producto pro = aProductos.buscarProducto(
Integer.parseInt(lblCodigo.getText()));
pro.setDescripcion(txtDescripcion.getText());
pro.setPrecio(Double.parseDouble(txtPrecio.getText()));
pro.setStock(Integer.parseInt(txtStock.getText()));
pro.setCategoria(String.valueOf(cboCategoria.getSelectedItem()));
JOptionPane.showMessageDialog(null, "Producto modificada correctamente",
"Confirmación",
JOptionPane.INFORMATION_MESSAGE);
listar();
} catch (Exception ex) {
JOptionPane.showMessageDialog(null,
"Ocurrió un error al intentar modificar",
"Confirmación",
JOptionPane.INFORMATION_MESSAGE);
}
btnGrabarM.setVisible(false);
btnModificar.setVisible(true);
limpiarCajas();
}
private void btnEliminarActionPerformed(java.awt.event.ActionEvent evt) {
Elaborado por: Lic. Manuel Torres Re.
UNIMASTER
Fundamentos JAVA
limpiaTabla();
int cod = Integer.parseInt(JOptionPane.showInputDialog(null,
"Ingrese codigo de producto:"));
Producto objP = aProductos.buscarProducto(cod);
if (objP != null) {
aProductos.eliminaProducto(objP);
JOptionPane.showMessageDialog(null, "Producto eliminado correctamente",
"Confirmacion",
JOptionPane.INFORMATION_MESSAGE);
listar();
}
}
private void btnListarActionPerformed(java.awt.event.ActionEvent evt) {
limpiaTabla();
limpiarCajas();
listar();
}
private void btnBuscarActionPerformed(java.awt.event.ActionEvent evt) {
int cod = Integer.parseInt(JOptionPane.showInputDialog(null,
"Ingrese codigo de producto:"));
limpiaTabla();
Producto objP = aProductos.buscarProducto(cod);
if (objP != null) {
tProductos.setValueAt(objP.getCodigo(), 0, 0);
tProductos.setValueAt(objP.getDescripcion(), 0, 1);
tProductos.setValueAt(objP.getPrecio(), 0, 2);
tProductos.setValueAt(objP.getCategoria(), 0, 3);
tProductos.setValueAt(objP.getStock(), 0, 4);
lblCodigo.setText("" + objP.getCodigo());
txtDescripcion.setText("" + objP.getDescripcion());
txtPrecio.setText("" + objP.getPrecio());
cboCategoria.setSelectedItem("" + objP.getCategoria());
txtStock.setText("" + objP.getStock());
}
}
void listar() {
for (int i = 0; i < aProductos.totalProductos(); i++) {
Producto objP = aProductos.obtener(i);
tProductos.setValueAt(objP.getCodigo(), i, 0);
tProductos.setValueAt(objP.getDescripcion(), i, 1);
tProductos.setValueAt(objP.getPrecio(), i, 2);
tProductos.setValueAt(objP.getCategoria(), i, 3);
tProductos.setValueAt(objP.getStock(), i, 4);
}
}
//Metodo que limpia la tabla
void limpiaTabla() {
for (int i = 0; i < 20; i++) {
tProductos.setValueAt("", i,
tProductos.setValueAt("", i,
tProductos.setValueAt("", i,
tProductos.setValueAt("", i,
tProductos.setValueAt("", i,
}
Elaborado por: Lic. Manuel Torres Re.
0);
1);
2);
3);
4);
UNIMASTER
Fundamentos JAVA
}
void limpiarCajas() {
txtDescripcion.setText("");
txtPrecio.setText("");
txtStock.setText("");
cboCategoria.setSelectedIndex(-1);
}
Caso Propuesto 1: Mantenimiento de Empleados
Implemente una aplicación en Java que permita controlar el mantenimiento de los empleados en
una empresa. Para lo cual se deberá considerar el ingreso de un nuevo empleado, la modificación
de algún dato y la eliminación de un determinado empleado. Así mismo deberá implementar la
consulta para buscar un determinado empleado y un listado para mostrar todos los registros.
Tener en cuenta
1. Crear un proyecto llamado “pjMantenimientoEmpleado”
2. Añadir tres paquetes los cuales tienen la siguiente distribución:
PAQUETE
pClases
pFormularios
CLASE
Empleado
DESCRIPCION
Contiene los métodos get/set de los atributos de
los empleados como su código, nombre, fecha de
nacimiento, tipo de empleado y sueldo; así como
su método constructor.
ArregloEmpleado
Contiene los métodos que permiten agregar,
modificar buscar y eliminar un registro de
empleado en el ArrayList.
Contiene toda la interfaz que nos permite
gestionar los datos de los empleados.
Contiene todas las imágenes usadas en el
formulario de mantenimiento de empleados.
frmEmpleado
pImagenes
3. Los botones del formulario van a trabajar de la siguiente manera:
BOTON
AGREGAR
MODIFICAR
ELIMINAR
BUSCAR
LISTAR
DESCRIPCION
Tiene como misión mostrar el nuevo número de empleado, limpiar los
controles para un nuevo ingreso de empleado. Así mismo deberá
ocultarse para mostrar un botón llamado GRABAR, el cual grabara los
nuevos datos del empleado nuevo, una vez finalizado volverá a activarse
el botón Agregar y ocultarse el botón Grabar.
Tiene como misión mostrar una ventana de dialogo que solicite el número
de empleado a modificar una vez encontrado mostrarlo en los controles.
Así mismo deberá ocultarse para mostrar un botón llamado GRABAR, el
cual grabara los datos modificados del empleado, una vez finalizado
volverá a activarse el botón Modificar y ocultarse el botón Grabar.
Tiene como misión mostrar una ventana de dialogo que solicite el número
de empleado a eliminar. Una vez encontrado deberá borrarlo del arreglo
y mostrar los nuevos elementos en la lista.
Tiene como misión mostrar una ventana de dialogo que solicite el número
de empleado a buscar una vez encontrado lo mostrara en los controles y
en la lista de empleados.
Tiene como misión mostrar información registrada dentro del arreglo.
Elaborado por: Lic. Manuel Torres Re.
UNIMASTER
Fundamentos JAVA
Caso Propuesto 2: Mantenimiento de alumnos
Implemente una aplicación en Java que permita controlar el mantenimiento de los alumnos en una
institución privada de educación. Para lo cual se deberá considerar el ingreso de un nuevo alumno,
la modificación de algún dato y la eliminación de un determinado alumno. Así mismo deberá
implementar la consulta para buscar un determinado alumno y un listado para mostrar todos los
registros.
Tener en cuenta
1. Crear un proyecto llamado “pjMantenimientoAlumno”
2. Añadir tres paquetes los cuales tienen la siguiente distribución:
PAQUETE
pClases
CLASE
Alumno
ArregloAlumno
pFormularios
frmAlumno
pImagenes
DESCRIPCION
Contiene los métodos get/set de los atributos de
los alumnos como su código, nombre,
especialidad, y semestre; así como su método
constructor.
Contiene los métodos que permiten agregar,
modificar buscar y eliminar un registro de alumno
en el ArrayList.
Contiene toda la interfaz que nos permite
gestionar los datos de los alumnos.
Contiene todas las imágenes usadas en el
formulario de mantenimiento de alumnos.
3. Los botones del formulario van a trabajar de la siguiente manera:
BOTON
AGREGAR
MODIFICAR
ELIMINAR
BUSCAR
LISTAR
DESCRIPCION
Tiene como misión mostrar el nuevo número de alumnos, limpiar los
controles para un nuevo ingreso de alumno. Así mismo deberá ocultarse
para mostrar un botón llamado GRABAR, el cual grabara los nuevos datos
del alumno nuevo, una vez finalizado volverá a activarse el botón Agregar
y ocultarse el botón Grabar.
Tiene como misión mostrar una ventana de dialogo que solicite el número
de alumno a modificar una vez encontrado mostrarlo en los controles. Así
mismo deberá ocultarse para mostrar un botón llamado GRABAR, el cual
grabara los datos modificados del alumno, una vez finalizado volverá a
activarse el botón Modificar y ocultarse el botón Grabar.
Tiene como misión mostrar una ventana de dialogo que solicite el número
de alumno a eliminar. Una vez encontrado deberá borrarlo del arreglo y
mostrar los nuevos elementos en la lista.
Tiene como misión mostrar una ventana de dialogo que solicite el número
de alumno a buscar una vez encontrado lo mostrara en los controles y en
la lista de alumnos.
Tiene como misión mostrar información registrada dentro del arreglo.
Elaborado por: Lic. Manuel Torres Re.
UNIMASTER
Fundamentos JAVA
Programación Modular
La programación modular es una metodología de programación que permite construir un programa
grande descomponiéndolo en pequeños subprogramas o módulos. Para ello se parte de un módulo
principal que se descompone en varios submódulos que son controlados por el módulo principal. Si
la tarea asignada a un módulo es demasiado compleja este deberá descomponerse en otros módulos
más pequeños hasta lograr módulos que hagan tareas relativamente sencillas. A este proceso de
refinamiento sucesivo se conoce también como la técnica de “divide y vencerás”.
Las tareas asignadas a los subprogramas pueden ser de diversa índole: entrada, salida, cálculos,
control de otros módulos, etc. Para que un subprograma pueda efectuar su tarea tiene que ser
llamado o invocado por el programa principal o por algún otro módulo que considere necesario el
servicio del subprograma. Una vez que el subprograma termina su tarea, devuelve el control al punto
donde se hizo la llamada. Un subprograma puede llamar a su vez a otros subprogramas.
En el lenguaje Java a los módulos o subprogramas se denominan métodos, mientras que en el
lenguaje algorítmico se denominan subalgoritmos.
VARIABLES LOCALES Y GLOBALES
Los métodos pueden utilizar sus propias variables denominadas variables locales o variables de
uso compartido, comunes a todos los métodos, denominadas variables globales.
Elaborado por: Lic. Manuel Torres Re.
UNIMASTER
Fundamentos JAVA
A. Variables Locales
Una variable local es una variable que se declara en el interior de un método por lo que su
ámbito es el interior del método, es decir, sólo puede ser utilizada dentro del método donde
fue declarada. Este tipo de variable se crea al iniciar la ejecución del método y se destruye
al finalizar. Por otro lado, una variable local se crea vacía, es decir no recibe ninguna
inicialización automática.
B. Variables Globales
Una variable global es una variable que se declara dentro del programa, pero en el exterior
de todos los métodos, por lo que su ámbito es el interior de todo el programa, es decir,
puede ser utilizada desde cualquier parte del programa. Este tipo de variable se crea al iniciar
la ejecución del programa y se destruye al finalizar. Por otro lado, una variable global se
inicializa automáticamente: 0 si es de tipo int, 0.0 si es de tipo double, false si es de tipo
bolean, ‘\0’ si es de tipo char y null si es de tipo String.
METODOS TIPO void
Un método tipo void es un módulo de programa que puede recibir datos de entrada a través de
variables locales denominadas parámetros; pero, que no retorna ningún resultado al punto donde
es invocado, razón por el que se le conoce también como método sin valor de retorno. Este tipo de
método, al igual que los métodos que retornan un valor, puede recibir datos de entrada a través de
variables locales al método conocidas como parámetros.
Los métodos tipo void pueden dividirse a su vez en dos tipos:
 Métodos tipo void sin parámetros.
 Métodos tipo void con parámetros.
Método tipo void
sin parámetros
Definición
Invocación
Estos métodos no pueden recibir datos de entrada ni retornar ningún
resultado al punto de su invocación.
void nombreMetodo(){
Declaración de variables locales
Cuerpo del método
}
nombreMetodo();
Estos métodos reciben datos de entrada a través de variables locales al
método denominadas parámetros; pero, igual que en el caso anterior no
pueden retornar ningún resultado al punto de su invocación.
Método tipo void
con parámetros
Definición
Invocación
Donde p1, p2, p3, etc son los parámetros del método. El número de
parámetros es variable y depende de las necesidades del método.
void nombreMetodo( tipo1 p1, tipo2 p2, tipo3 p3, . . . ){
Declaración de variables locales
Cuerpo del método
}
nombreMetodo(v1, v2, v3, . . . );
Elaborado por: Lic. Manuel Torres Re.
UNIMASTER
Fundamentos JAVA
Caso Desarrollado
En una universidad, los alumnos están categorizados en cuatro categorías. A cada categoría le
corresponde una pensión mensual distinta dada en la siguiente tabla:
Semestralmente, la universidad efectúa rebajas en las pensiones de sus estudiantes a partir del
segundo ciclo en base al promedio ponderado del ciclo anterior en porcentajes dados en la tabla
siguiente:
Diseñe un programa que determine cuánto de rebaja recibirá un estudiante sobre su pensión actual
y a cuánto asciende su nueva pensión. Declare todas las variables como globales y use métodos tipo
void.
Solución:
Código:
// Declaración de variables globales para el algoritmo
int categoria;
double actualpen, nuevapen, descuento, promedio;
// Método del botón Procesar
void procesar(){
ingresarDatos();
calcularPensionActual();
calcularDescuento();
calcularNuevaPension();
mostrarResultados();
}
Elaborado por: Lic. Manuel Torres Re.
UNIMASTER
Fundamentos JAVA
// Método del botón Borrar
void borrar(){
txtS.setText("");
txtPromedio.setText("");
txtPromedio.requestFocus();
}
// Ingresa datos
void ingresarDatos(){
categoria = choCategoria.getSelectedIndex();
promedio = Double.parseDouble(txtPromedio.getText());
}
// Calcula la pensión actual
void calcularPensionActual(){
if( categoria == 0 )
actualpen = 550;
else if( categoria == 1 )
actualpen = 500;
else if( categoria == 2 )
actualpen = 460;
else
actualpen = 400;
}
// Cálcula el descuento
void calcularDescuento(){
if( promedio <= 13.99 )
descuento = 0;
else if( promedio <= 15.99 )
descuento = 0.10*actualpen;
else if( promedio <= 17.99 )
descuento = 0.12*actualpen;
else
descuento = 0.15*actualpen;
}
// Calcula la nueva pensión
void calcularNuevaPension(){
nuevapen = actualpen - descuento;
}
// Muestra resultados
void mostrarResultados(){
txtS.setText("");
imprimir("Pensión actual : " + actualpen);
imprimir("Descuento : " + descuento);
imprimir("Nueva pensión : " + nuevapen);
}
// Imprime una cadena de texto incluyendo un salto de línea al final
void imprimir(String cad){
txtS.append(cad + "\n");
}
Elaborado por: Lic. Manuel Torres Re.
UNIMASTER
Fundamentos JAVA
METODOS CON VALOR DE RETORNO
Un método con valor de retorno es un módulo de programa que puede recibir datos de entrada a
través de variables locales denominadas parámetros y que retorna un resultado al punto donde es
invocado. Este tipo de método se utiliza para efectuar cualquier tipo de proceso que produzca un
resultado.
Estos métodos pueden dividirse a su vez en dos tipos:
 Métodos con valor de retorno sin parámetros.
 Métodos con valor de retorno con parámetros.
Método con Valor
de Retorno sin
parámetros
Definición
Invocación
Este tipo de métodos no reciben datos de entrada; pero, retornan un
resultado al punto donde son invocados.
tipo nombre(){
Declaración de variables locales
Cuerpo del método
return valor;
}
variable = nombre();
Estos métodos reciben datos de entrada a través de parámetros y retornan
un resultado al punto de su invocación.
Método con Valor
de Retorno con
parámetros
Definición
Invocación
tipo nombre( tipo1 p1, tipo2 p2, tipo3 p3, . . .){
Declaración de variables locales
Cuerpo del método
return valor;
}
variable = nombre(v1, v2, v3, …);
Caso Desarrollado:
Una empresa evalúa a sus empleados bajo dos criterios: puntualidad y rendimiento. En cada caso
el empleado recibe un puntaje que va de 1 a 10, de acuerdo a los siguientes criterios:
Puntaje por puntualidad:- está en función a los minutos de tardanza de acuerdo a la siguiente tabla:
Puntaje por rendimiento:- está en función a la cantidad de observaciones efectuadas al empleado
por no cumplir sus obligaciones de acuerdo a la siguiente tabla:
Elaborado por: Lic. Manuel Torres Re.
UNIMASTER
Fundamentos JAVA
El puntaje total del empleado es la suma del puntaje por puntualidad más el puntaje por rendimiento.
En base al puntaje total, el empleado recibe una bonificación anual de acuerdo a la siguiente tabla:
Diseñe un programa que determine el puntaje por puntualidad, el puntaje por rendimiento, el
puntaje total y la bonificación que le corresponden a un empleado de la empresa.
Declare todas las variables como locales y use métodos con valor de retorno para cada una de las
entradas y para cada uno de los cálculos.
Solución:
public void actionPerformed( ActionEvent e ){
if( e.getSource() == btnProcesar )
procesar();
if( e.getSource() == btnBorrar )
borrar();
}
void procesar(){
// Declaración de variables locales
int minutosTar, numeroObs, puntajePun, puntajeRen, puntajeTot;
double bonificacion;
// Entrada de datos
minutosTar = getMinutos();
numeroObs = getObservaciones();
// Proceso de cálculo
puntajePun = determinarPuntajePuntualidad(minutosTar);
Elaborado por: Lic. Manuel Torres Re.
UNIMASTER
Fundamentos JAVA
puntajeRen = determinarPuntajeRendimiento(numeroObs);
puntajeTot = determinarPuntajeTotal(puntajePun, puntajeRen);
bonificacion = determinarBonificacion(puntajeTot);
// Salida de resultados
txtS.setText("");
imprimir("Puntaje por puntualidad : " + puntajePun);
imprimir("Puntaje por rendimiento : " + puntajeRen);
imprimir("Puntaje total : " + puntajeTot);
imprimir("Bonificación : " + bonificacion);
}
// Método del botón Borrar
void borrar(){
txtMinutosTar.setText("");
txtNumeroObs.setText("");
txtS.setText("");
txtMinutosTar.requestFocus();
}
// Lee y retorna los minutos de tardanza
int getMinutos(){
return Integer.parseInt(txtMinutosTar.getText());
}
// Lee y retorna el número de observaciones
int getObservaciones(){
return Integer.parseInt(txtNumeroObs.getText());
}
// Determina y retorna el puntaje por puntualidad
int determinarPuntajePuntualidad(int minutosTar){
if(minutosTar == 0)
return 10;
else if(minutosTar <= 2)
return 8;
else if(minutosTar <= 5)
return 6;
else if(minutosTar <= 9)
return 4;
else
return 0;
}
// Determina y retorna el puntaje por rendimiento
int determinarPuntajeRendimiento(int numeroObs){
if(numeroObs == 0)
return 10;
else if(numeroObs == 1)
return 8;
else if(numeroObs == 2)
return 5;
else if(numeroObs == 3)
return 1;
else
Elaborado por: Lic. Manuel Torres Re.
UNIMASTER
Fundamentos JAVA
return 0;
}
// Determina y retorna el puntaje total
int determinarPuntajeTotal(int puntajePun, int puntajeRen){
return puntajePun + puntajeRen;
}
// Determina y retorna la bonificación
double determinarBonificacion(int puntajeTot){
if(puntajeTot < 11)
return 2.5*puntajeTot;
else if(puntajeTot <= 13)
return 5.0*puntajeTot;
else if(puntajeTot <= 16)
return 7.5*puntajeTot;
else if(puntajeTot <= 19)
return 10.0*puntajeTot;
else
return 12.5*puntajeTot;
}
// Imprime una cadena de texto incluyendo un salto de línea al final
void imprimir(String cad){
txtS.append(cad + "\n");
}
Elaborado por: Lic. Manuel Torres Re.
UNIMASTER
Fundamentos JAVA
Casos Propuestos
1. Digite el número de teléfono, el tipo de llamada y la cantidad de minutos utilizados, muestre
el importe a pagar. Tome en cuenta la siguiente tabla para el cálculo del importe de pago.
2. Ingrese el nombre del cliente, su importe de compra y su tipo de tarjeta, visualice el recargo
(vea la tabla) y su importe de compra final.
3. Una tienda vende tres tipos de productos a los precios unitarios dados en la siguiente tabla:
Como oferta la tienda ofrece un regalo de acuerdo a la siguiente tabla:
4. Diseñe un programa que determine el importe a pagar y el regalo para un cliente de la
tienda. Ingrese el nombre del trabajador, su estado civil, el turno y sueldo; se deberá mostrar
el incremento (vea la tabla de abajo) y su sueldo final.
Elaborado por: Lic. Manuel Torres Re.
UNIMASTER
Fundamentos JAVA
5. En una empresa se acordó dar bonificaciones por única vez a sus trabajadores en función a
su grado de estudios, para esto se deberá Ingresar por teclado el nombre del empleado, su
grado de estudios y su sueldo en soles, se deberá mostrar el nombre del grado de estudios,
su bonificación y sueldo final, estos dos últimos en soles.
6. Una empresa calcula el sueldo bruto de sus trabajadores multiplicando las horas trabajadas
por una tarifa horaria que depende de la categoría del trabajador de acuerdo a la siguiente
tabla:
Por ley, todo trabajador se somete a un porcentaje de descuento del sueldo bruto: 20% si
el sueldo bruto es mayor que S/. 2500 y 15% en caso contrario.
Diseñe un programa que determine el sueldo bruto, el descuento y el sueldo neto que le
corresponden a un trabajador de la empresa. Declare todas las variables como globales y
use métodos tipo void diferentes para cada uno de los cálculos.
Elaborado por: Lic. Manuel Torres Re.