Guia G de Laboratorio

Universidad Nacional Mayor de San Marcos
Facultad de Ingeniera de Sistemas e Informtica

E.A.P. de Ingeniera de Sistemas
Algortmica II
GUIA G DE LABORATORIO
HERENCIA CLASES ABSTRACTAS INTERFACE
POLIMORFISMO
Objetivo:
Aplicar los conceptos de la Programacin Orientada a Objetos.
Aplicar las definiciones de Herencia, Clases Abstractas e Interface Java.
Aprender la herencia entre clases, utilizando el lenguaje de programacin Java.
Aplicar la definicin de Polimorfismo.
Descripcin:
A continuacin se presentan varias clases. Cada clase contiene mtodos de tipo SET
y GET, y mtodos operacionales. Los mtodos operacionales son mtodos que
implementan las operaciones FUNCIONALIDADES del objeto.
En esta gua de Laboratorio se va a trabajar con el paquete Clases, que contiene a
las clases Persona, Profesor, Alumno y Universidad. El objetivo es comprender como
se relacionan estas clases, especialmente como funciona el mecanismo del
Polimorfismo.
El alumno debe encontrar el mecanismo que utilizan las clases para el envi de
datos; as como las referencias entre objetos. Al finalizar esta gua, cada alumno
comprender cuando, donde, como y por que se instancian y se relacionan los
objetos.
Se debe mencionar que para el desarrollo de esta gua de laboratorio se ha utilizado
la librera grfica SWING de Java, la cual posee muchos componentes grficos tales
como JFrame (marco o contorno), JPanel (panel o lienzo), JLabel (etiqueta),
JTextField (caja de texto), JButton (botn), JTextArea (rea de texto), JScrollPane
(panel de scroll horizontal y vertical), JMenuBar (barra de men), JToolBar (barra
de herramientas), etc. Debo mencionar que uno de los objetivos de esta gua de
laboratorio es aprender a usar JTable, JTree, JSplitPane, JPopupMenu y sus dems
clases auxiliares. A su vez se ha utilizado la librera grfica AWT de Java, para el
uso de algunos de sus componentes grfico, como por ejemplo, la clase Color.
Recordar que nos encontramos en un entorno Orientado a Objetos. Eso quiere decir
que cada clase tiene atributos y mtodos PROPIOS de su correspondiente objeto
real. Se pide analizar el cdigo desarrollado, e implementar todas las
funcionalidades que se le pide al final de la gua, en la seccin denominada TAREA.
PAQUETE ClasesBase
Base
A continuacin se presenta la clase Base, que define varios mtodos de carcter
esttico. En esta ocasin se ha agregado DOS (2) nuevos mtodos a la clase base:
Algortmica II
Gua G de Laboratorio
Herencia, Clases Abstractas,
Interface Java y Polimorfismo en Java
public String retornarNombreDelDiaDeLaSemana(int dia)

public String retornarNombreDelMesDelAo(int mes)
Paso a seguir 1:
1. Escribir el siguiente cdigo Java, utilizando un Entorno de Desarrollo
Integrado.
2. Generar el archivo Base.class (Proceso de Compilacin)
La clase Base
/**
* Clase de Apoyo llamada Base.
* @version 1.0, 09/09/08
* @author Arn Elas Herrera Ponte
*/
//Nombre del paquete que agrupa a clases Java
//de utilidad general
package ClasesBase;
//Importamos clases Java para la lectura de
//Datos por consola
import java.io.BufferedReader;
import java.io.InputStreamReader;
//Implementacin de la clase Base
public class Base {
//Implementacin del mtodo esttico "leerDato"
//se utiliza para pedir el ingreso de datos por consola
public static String leerDato(){
String dato;
try{
BufferedReader teclado = new BufferedReader(new InputStreamReader(System.in));
dato = teclado.readLine();
}catch(Exception exception){
System.out.println("Error al momento de Leer el dato por consola.");
dato = "";
}
return dato;
}
//Este mtodo recibe por parmetro una variable 'cadena' de tipo de dato String
//Se hace uso del mtodo 'parseInt()' de la clase Integer
//Si sucede un error al momento de convertir el 'String' a 'int', se ir al bloque 'catch'
//Si todo es correcto, se retorna el entero 'dato'
public static int aEntero(String cadena){
int dato;
try{
dato = Integer.parseInt(cadena);
}catch(Exception e){
System.out.println("Error al convertir un String a Entero.");
Prof. Arn Elas Herrera Ponte
Pg. 2
Algortmica II
dato = 999;
}
return dato;
}
//Este mtodo recibe por parmetro una variable 'cadena' de tipo de dato String
//Se hace uso del mtodo 'parseDouble()' de la clase Double
//Si sucede un error al momento de convertir el 'String' a 'double', se ir al bloque 'catch'
//Si todo es correcto, se retorna el double 'dato'
public static double aReal(String cadena){
double dato;
try{
dato = Double.parseDouble(cadena);
System.out.println("Error al convertir un String a Real.");
dato = 999;
}
return dato;
}
//Este mtodo recibve por parmetro una cadena 'mensaje', la cual se va ha imprimir
//Se hace uso del mtodo 'leerDato()'
//Se debe escribir un texto no vacio. Debido a que existe el bucle 'do-while'
//este bucle, valida si lo ingresado es vacio
//Si todo es correcto, se retorna el String 'dato'
public static String ingresarDato(String mensaje){
String dato;
do{
System.out.print(mensaje);
dato = leerDato().trim();
}while(dato.length()==0);
return dato;
}
//Mtodo que devuelve una cadena en minscula
public static String convertirCadenaAMinuscula(String sPalabra){
return sPalabra.toLowerCase();
}
//Mtodo que devuelve una cadena en mayscula
public static String convertirCadenaAMayuscula(String sPalabra){
return sPalabra.toUpperCase();
}
//Este mtodo recibe por parmetro un arreglo de String 'mensaje'
//El mtodo construye un mnu de opciones, usando el bucle 'for'
//Se pide al usuario ingresar su opcin
//Se convierte a entero dicha opcin
//Se devuelve la opcion ingresada
public static int pintarMenu(String[] mensaje){
int opcion;
do{
for(String cadena : mensaje){
System.out.println(cadena);
}
System.out.println("Ingrese su opcion:");
opcion = aEntero(leerDato());
}while(opcion<1 || opcion>mensaje.length);
return opcion;
Pg. 3
Algortmica II
}
//Este mtodo recibe por parmetro un nmero entero entre [0-6]
//y retornar el nombre del da como un String (cadena de caracteres)
public String retornarNombreDelDiaDeLaSemana(int dia){
String diaEnCadena = "valorInicial";
switch(dia){
case 0 : diaEnCadena = "Domingo"; break;
case 1 : diaEnCadena = "Lunes"; break;
case 2 : diaEnCadena = "Martes"; break;
case 3 : diaEnCadena = "Miercoles"; break;
case 4 : diaEnCadena = "Jueves"; break;
case 5 : diaEnCadena = "Viernes"; break;
case 6 : diaEnCadena = "Sabado"; break;
}
return diaEnCadena;
}
//Este mtodo recibe por parmetro un nmero entero entre [0-11]
//y retornar el nombre del mes como un String (cadena de caracteres)
public String retornarNombreDelMesDelAo(int mes){
String mesEnCadena = "valorInicial";
switch(mes){
case 0 : mesEnCadena = "Enero"; break;
case 1 : mesEnCadena = "Febrero"; break;
case 2 : mesEnCadena = "Marzo"; break;
case 3 : mesEnCadena = "Abril"; break;
case 4 : mesEnCadena = "Mayo"; break;
case 5 : mesEnCadena = "Junio"; break;
case 6 : mesEnCadena = "Julio"; break;
case 7 : mesEnCadena = "Agosto"; break;
case 8 : mesEnCadena = "Setiembre"; break;
case 9 : mesEnCadena = "Octubre"; break;
case 10 : mesEnCadena = "Noviembre"; break;
case 11 : mesEnCadena = "Diciembre"; break;
}
return mesEnCadena;
}
}
PAQUETE Clases
Persona
A continuacin se presenta la clase Persona, que define los atributos y mtodos
ms importantes de una persona de la vida real. Es decir, esta clase Persona define
los atributos y mtodos mas importante de un persona, obtenidos mediante el
proceso de ABSTRACCIN.
Paso a seguir 2:
Integrado.
4. Generar el archivo Persona.class (Proceso de Compilacin)
Pg. 4
Algortmica II
La clase Persona
//Declaracin del nombre del paquete donde se encuentra la clase 'Persona'
package Clases;
//Declaracion de libreras o paquetes propias del java
import java.util.Date;
//Definimos la clase 'Persona'
public class Persona {
//Declaracin de los Atributos
protected String codigo;
protected String nombres;
protected String apellidos;
protected String categoria;
protected String sexo;
protected Date fechaDeNacimiento;
protected String foto;
//Constructor por defecto
public Persona(){
this.codigo = "1000";
this.nombres = "Juan";
this.apellidos = "Perez";
this.categoria = "Principal";
this.sexo = "Masculino";
this.fechaDeNacimiento = new Date();
this.foto = "C:\\";
}
//Mtodos de tipo SET y GET
public void setCodigo(String codigo) {
this.codigo = codigo;
}
public void setNombres(String nombres) {
this.nombres = nombres;
}
public void setApellidos(String apellidos) {
this.apellidos = apellidos;
}
public void setCategoria(String categoria) {
this.categoria = categoria;
}
public void setSexo(String sexo) {
this.sexo = sexo;
}
public void setFechaDeNacimiento(Date fechaDeNacimiento) {
this.fechaDeNacimiento = fechaDeNacimiento;
}
public void setFoto(String foto) {
this.foto = foto;
Pg. 5
Algortmica II
}
public String getCodigo() {
return (this.codigo);
}
public String getNombres() {
return (this.nombres);
}
public String getApellidos() {
return (this.apellidos);
}
public String getCategoria() {
return (this.categoria);
}
public String getSexo() {
return (this.sexo);
}
public Date getFechaDeNacimiento() {
return (this.fechaDeNacimiento);
}
public String getFoto() {
return (this.foto);
}
}
Profesor
A continuacin se presenta la clase Profesor, que define los atributos y mtodos
ms importantes de un profesor de la vida real. Es decir, esta clase Profesor define
los atributos y mtodos mas importante de un profesor.
OBSERVACION: Hemos aplicado HERENCIA. Es decir la clase Profesor HEREDA los
atributos y mtodos (de mbito protegido y pblico) de la clase Persona.
Paso a seguir 3:
Integrado.
6. Generar el archivo Profesor.class (Proceso de Compilacin)
La clase Profesor
//Declaracin del nombre del paquete donde se encuentra la clase 'Profesor'
package Clases;
//Definimos la clase 'Profesor'
//que HEREDA de la clase 'Persona'
public class Profesor extends Persona{
Pg. 6
Algortmica II
}
Alumno
A continuacin se presenta la clase Alumno, que define los atributos y mtodos ms
importantes de un alumno de la vida real. Es decir, esta clase Alumno define los
atributos y mtodos ms importantes de un alumno.
OBSERVACION: Hemos aplicado HERENCIA. Es decir la clase Alumno HEREDA los
atributos y mtodos (de mbito protegido y pblico) de la clase Persona.
Paso a seguir 4:
Integrado.
8. Generar el archivo Alumno.class (Proceso de Compilacin)
La clase Alumno
//Declaracin del nombre del paquete donde se encuentra la clase 'Alumno'
package Clases;
//Definimos la clase 'Alumno'
//que HEREDA de la clase 'Persona'
public class Alumno extends Persona{
}
Universidad
A continuacin se presenta la clase Universidad, que define los atributos y mtodos
ms importantes de una Universidad de la vida real, por ejemplo una coleccin de
Personas. Es decir, esta clase Universidad define los atributos y mtodos ms
importantes de para poder almacenar temporalmente (en Memoria RAM) a un
conjunto de Personas (que pueden Profesores y Alumnos).
Para ello la clase Universidad utiliza la clase ArrayList con especificador de tipo <>.
Ejemplo:
private ArrayList<Persona> arregloDePersonas;
Paso a seguir 5:
Integrado.
10. Generar el archivo Universidad.class (Proceso de Compilacin)
La clase Universidad
Pg. 7
Algortmica II
//Declaracin del nombre del paquete donde se encuentra la clase 'Universidad'

package Clases;
import java.util.ArrayList;
//Definimos la clase 'Universidad'
public class Universidad {
//Declaramos los atributos de la clase Univesidad
private String nombreLargo;
private String nombreCorto;
private String direccion;
private String ruc;
private String telefono;
private String nombreDeAtributosUniversidad[] = {"Nombre","Abrev.","Direccin","Ruc","Telfono"};
private String nombreDeAtributosPersona[] = {"Cdigo", "Nombres","Apellidos","Categora","Sexo","Fec.Nac"};
//Declaramos un objeto de tipo ArrayList, que almacenar objetos de tipo 'Persona'
private ArrayList<Persona> arregloDePersonas;
//Mtodo constructor por defecto
public Universidad(){
this.nombreLargo = "Universidad Nacional Mayor de San Marcos";
this.nombreCorto = "UNMSM";
this.direccion = "Av. Venezuela Cdra. 34 - Lima 1";
this.ruc = "20148092282";
this.telefono = "6197000";
//Instanciamos un objeto de tipo ArrayList, que almacenar objetos de tipo 'Persona'
arregloDePersonas = new ArrayList<Persona>();
}
//Retornamos la cantidad de objetos de tipo Persona dentro del arreglo
public int retornarCantidadDePersonasEnElArreglo(){
return arregloDePersonas.size();
}
//Ingresamos un nuevo objeto de tipo Persona dentro del arreglo
public void ingresarNuevaPersona(Persona nuevaPersona){
arregloDePersonas.add(nuevaPersona);
}
//Retornamos un nuevo objeto de tipo Persona
public Persona retornarUnaPersonaPorPosicion(int posicion){
return arregloDePersonas.get(posicion);
}
//Ingresamos un nuevo objeto de tipo Persona dentro del arreglo,
//Especificando la posicin donde se almacenar el nuevo objeto.
public void asignarUnaPersonaEnUnaPosicion(int posicion, Persona nuevaPersona){
arregloDePersonas.set(posicion, nuevaPersona);
}
//Este mtodo elimina un objeto de tipo 'Persona'
//que se encuentra dentro del arreglo de Personas
public void eliminarPersonaDelArreglo(int posicion){
arregloDePersonas.remove(posicion);
}
//Este mtodo busca dentro del arreglo de Personas, si existe algun objeto
//cuyo atributo 'codigo' tenga el valor de la variable 'codigo' que ingresa por parmetro
Pg. 8
Algortmica II
public int retornarPosicionDeLaPersonaEnElArreglo(String codigo){

Persona temporal;
for(int i=0; i<arregloDePersonas.size(); i++){
temporal = arregloDePersonas.get(i);
if(temporal.getCodigo().equals(codigo)){
return i;
}
}
return -1;
}
//Este mtodo cuenta la cantidad de objetos de tipo 'Profesor'
//que se encuentran almacenados en el arreglo de Personas
public int retornarLaCantidadDeProfesoresEnElArregloDePersonas(){
int contadorDeProfesores = 0;
for(Persona temporal: arregloDePersonas){
if(temporal instanceof Profesor){
contadorDeProfesores++;
}
}
return contadorDeProfesores;
}
//Este mtodo cuenta la cantidad de objetos de tipo 'Alumno'
//que se encuentran almacenados en el arreglo de Personas
public int retornarLaCantidadDeAlumnosEnElArregloDePersonas(){
int contadorDeAlumnos = 0;
for(Persona temporal: arregloDePersonas){
if(temporal instanceof Alumno){
contadorDeAlumnos++;
}
}
return contadorDeAlumnos;
}
//Mtodos de tipo Set y Get de la Universidad
public void setNombreLargo(String nombreLargo) {
this.nombreLargo = nombreLargo;
}
public void setNombreCorto(String nombreCorto) {
this.nombreCorto = nombreCorto;
}
public void setDireccion(String direccion) {
this.direccion = direccion;
}
public void setRuc(String ruc) {
this.ruc = ruc;
}
public void setTelefono(String telefono) {
this.telefono = telefono;
}
public String getNombreLargo() {
return (this.nombreLargo);
}
Pg. 9
Algortmica II
public String getNombreCorto() {

return (this.nombreCorto);
}
public String getDireccion() {
return (this.direccion);
}
public String getRuc() {
return (this.ruc);
}
public String getTelefono() {
return (this.telefono);
}
public String[] getNombreDeAtributosUniversidad(){
return nombreDeAtributosUniversidad;
}
public String[] getNombreDeAtributosPersona(){
return nombreDeAtributosPersona;
}
}
PAQUETE Formularios
jpanFondo
A continuacin se presenta la clase jpanFondo, que hereda de la clase JPanel
(javax.swing.JPanel). Esta clase se utiliza para crear el panel o lienzo de fondo del
formulario principal, as como de los dems formularios.
JPanel
Paso a seguir 6:
Pg. 10
Algortmica II

Integrado.
12. Generar el archivo jpanFondo.class (Proceso de Compilacin)
La clase jpanFondo
//Declaracin del nombre del paquete donde se encuentra la clase 'jpanFondo'
package Formularios;
import javax.swing.JPanel;
import java.awt.Color;
//Definimos la clase 'jpanFondo'
//que HEREDA de la clase 'JPanel'
public class jpanFondo extends JPanel{
//Declaracin de Atributos
//Declaramos un objeto de tipo 'Color'
protected Color coColorDeFondo;
//Atributo que almacenar la ruta donde se encuentran las imagenes
protected String rutaDeImagenes;
//Este es el Mtodo Constructor por defecto
public jpanFondo(){
this.setLayout(null);
//Instanciamos el objeto 'coColorDeFondo'
//se usan 3 nmeros enteros del rango [0-255]
//para crear un color en el sistema RGB
//codigo de colores del color 'lightyellow'
coColorDeFondo = new Color(255,255,224);
//Esta es la ruta por defecto, donde se encuentran las imagenes
//Esta ruta depender de la unidad de disco duro donde se encuentre
//tu projecto, debers de modificarla si es necesario
rutaDeImagenes = "D:/ClasesLabAlgoIIProfAron/RecursosHumanos/src/Imagenes/";
//Asignamos el objeto 'coColorDeFondo' como
//el color de fondo del jpanFondo
this.setBackground(coColorDeFondo);
}
}
jpanInicio
A continuacin se presenta la clase jpanInicio, que hereda de la clase jpanFondo.
Esta clase se utiliza para crear el panel o lienzo que se mostrar dentro de un
componente grfico swing llamado JTabbedPane.
Este ser el TAB de inicio.
Pg. 11
Algortmica II
Notar que se muestra una imagen en el panel. Esta imagen se carga en un

componente JLabel (javax.swing.JLabel) tambin llamado etiqueta.
OBSERVACIN: Esta clase hereda de la clase 'jpanFondo'.
JPanel
Paso a seguir 7:
Integrado.
14. Generar el archivo jpanInicio.class (Proceso de Compilacin)
La clase jpanInicio
//Declaracin del nombre del paquete donde se encuentra la clase 'jpanInicio'
import javax.swing.JLabel;
import javax.swing.ImageIcon;
//Definimos la clase 'jpanInicio'
//que HEREDA de la clase 'jpanFondo'
public class jpanInicio extends jpanFondo{
private JLabel jlblImagenDeFondo;
public jpanInicio(){
iniciarComponentes();
}
Pg. 12
Algortmica II
//Mtodo que crea y disea la GUI de este Panel

public void iniciarComponentes(){
jlblImagenDeFondo = new JLabel(new ImageIcon(rutaDeImagenes + "rrhh.jpg"));
jlblImagenDeFondo.setBounds(40,35,450,300);
this.add( jlblImagenDeFondo );
}
}
MiArbolSwing
A continuacin se presenta a la clase hija MiArbolSwing, que hereda de la clase
JTree. Esta clase se utiliza para crear los nodos del rbol.
Esta clase MiArbolSwing implementa DOS (2) interfaces llamadas ActionListener,
MouseListener respectivamente.
Mtodo de la interface ActionListener
public void actionPerformed(ActionEvent ae)
Mtodos de la interface MouseListener
public
public
public
public
public
void
void
void
void
void
mousePressed(MouseEvent evt)
mouseExited(MouseEvent evt)
mouseEntered(MouseEvent evt)
mouseClicked(MouseEvent evt)
mouseReleased(MouseEvent evt)
Pasos a seguir 8:
Integrado.
16. Generar el archivo MiArbolSwing.class (Proceso de Compilacin)
La clase MiArbolSwing
//Declaracin del nombre del paquete donde se encuentra la clase 'MiArbolSwing'
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseListener;
import java.awt.event.MouseEvent;
import javax.swing.JComponent;
import javax.swing.JTree;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
Pg. 13
Algortmica II
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeNode;
import javax.swing.tree.MutableTreeNode;
import javax.swing.JPopupMenu;
import javax.swing.JMenuItem;
import javax.swing.JSeparator;
import javax.swing.JOptionPane;
//Importamos las clases del paquete 'Clases'
import Clases.Universidad;
import Clases.Persona;
import Clases.Profesor;
import Clases.Alumno;
//Definimos la clase 'MiArbolSwing'
//que HEREDA de la clase 'JTree'
public class MiArbolSwing extends JTree implements ActionListener, MouseListener{
private JPopupMenu jpopupUnivesidad;
private JPopupMenu jpopupProfesor;
private JPopupMenu jpopupAlumno;
private JMenuItem
jmnuiMostrarDatosUniversidad;
private JMenuItem
jmnuiMostrarDatosProfesor;
private JMenuItem
jmnuiAniadirProfesor;
private JMenuItem
jmnuiEliminarProfesor;
private JMenuItem
jmnuiMostrarDatosAlumno;
private JMenuItem
jmnuiAniadirAlumno;
private JMenuItem
jmnuiEliminarAlumno;
private String
nombreNodo;
private jpanPanelDePestaas
panelDePestaasRelacionado;
private DefaultMutableTreeNode
dmtnRaizRelacionado;
//Declaramos un objeto de tipo Universidad
private Universidad universidadRelacionada;
//Mtodo constructor por parmetro
//Llega por parmetro el nodo raz del rbol, instanciado en la clase 'jpanArbol'
public MiArbolSwing (DefaultMutableTreeNode dmtn) {
//Usamos 'super' para invocar al constructor de la clase padre 'JTree'
//le enviamos el nodo raz del rbol, instanciado en la clase 'jpanArbol'
super(dmtn);
//Relacionamos a 'dmtnRaizRelacionado' con el nodo raz que viene por parmetro
dmtnRaizRelacionado = dmtn;
//Instanciamos el JPopupMenu de la Universidad
//el cual se comporta como si fuera una barra de men
jpopupUnivesidad = new JPopupMenu();
//Instanciamos los JMenuItem
jmnuiMostrarDatosUniversidad = new JMenuItem("Mostrar Universidad");
jmnuiMostrarDatosUniversidad.addActionListener(this);
jmnuiAniadirProfesor = new JMenuItem("Aadir Profesor");
jmnuiAniadirProfesor.addActionListener(this);
jpopupUnivesidad.add(jmnuiMostrarDatosUniversidad);
jpopupUnivesidad.add(new JSeparator());
jpopupUnivesidad.add(jmnuiAniadirProfesor);
Pg. 14
Algortmica II
//Asignamos caracteristicas al JPopupMenu de la Universidad

jpopupUnivesidad.setOpaque(true);
jpopupUnivesidad.setLightWeightPopupEnabled(true);
//Instanciamos el JPopupMenu del Profesor
jpopupProfesor = new JPopupMenu();
//Instanciamos al JMenuItem
jmnuiMostrarDatosProfesor = new JMenuItem("Mostrar Profesor");
jmnuiMostrarDatosProfesor.addActionListener(this);
jmnuiEliminarProfesor = new JMenuItem("Eliminar Profesor");
jmnuiEliminarProfesor.addActionListener(this);
jmnuiAniadirAlumno = new JMenuItem("Aadir Alumno");
jmnuiAniadirAlumno.addActionListener(this);
jpopupProfesor.add(jmnuiMostrarDatosProfesor);
jpopupProfesor.add(jmnuiEliminarProfesor);
jpopupProfesor.add(new JSeparator());
jpopupProfesor.add(jmnuiAniadirAlumno);
//Asignamos caracteristicas al JPopupMenu del Profesor
jpopupProfesor.setOpaque(true);
jpopupProfesor.setLightWeightPopupEnabled(true);
//Instanciamos el JPopupMenu del Alumno
jpopupAlumno = new JPopupMenu();
//Instanciamos al JMenuItem
jmnuiMostrarDatosAlumno = new JMenuItem("Mostrar Alumno");
jmnuiMostrarDatosAlumno.addActionListener(this);
jmnuiEliminarAlumno = new JMenuItem("Eliminar Alumno");
jmnuiEliminarAlumno.addActionListener(this);
jpopupAlumno.add(jmnuiMostrarDatosAlumno);
jpopupAlumno.add(jmnuiEliminarAlumno);
//Asignamos caracteristicas al JPopupMenu del Alumno
jpopupAlumno.setOpaque(true);
jpopupAlumno.setLightWeightPopupEnabled(true);
//Habilitamos el escuchar de evento para este JTree
//En este caso va ha escuchar los eventos del Mouse
this.addMouseListener(this);
}
//Mtodo que recibe por parmetro la referencia del objeto 'panelDePestaas'
//que ha sido creado en la clase 'jfrmPrincipal'
public void relacionarAlMiArbolConElPanelDePestaas(jpanPanelDePestaas objetoPorReferencia){
this.panelDePestaasRelacionado = objetoPorReferencia;
}
//Mtodo que recibe por parmetro la referencia del objeto 'unmsm'
//que ha sido creado en la clase 'RecursosHumanos'
public void relacionarMiArbolSwingConLaUniversidad(Universidad universidadPorReferencia){
//Establecemos la referencia al objeto de tipo 'Universidad'
//que se ha creado en el mtodo 'main' de la clase 'RecursosHumanos'
Pg. 15
Algortmica II
this.universidadRelacionada = universidadPorReferencia;
}
//Mtodo de la interface 'ActionListener'
public void actionPerformed(ActionEvent ae) {
DefaultMutableTreeNode dmtn, nodoProfesor, node;
TreePath path = this.getSelectionPath();
dmtn = (DefaultMutableTreeNode) path.getLastPathComponent();
//Verificamos si se hizo clic en la opcin 'Mostrar Universidad'
if(ae.getSource() == jmnuiMostrarDatosUniversidad){
//Muestra la Pestaa de Inicio
panelDePestaasRelacionado.cambiarDePestaa(0);
}
//Verificamos si se hizo clic en la opcin 'Mostrar Profesor'
if(ae.getSource() == jmnuiMostrarDatosProfesor){
//Muestra la Pestaa del Profesor
}
//Verificamos si se hizo clic en la opcin 'Mostrar Alumno'
if(ae.getSource() == jmnuiMostrarDatosAlumno){
//Muestra la Pestaa del Alumno
}
//Verificamos si se hizo clic en la opcin 'Aadir Profesor'
if(ae.getSource() == jmnuiAniadirProfesor){
//Enviamos la referencia del nuevo Nodo creado y de su Nodo Padre
//Lo enviamos al Panel de Ingreso de datos del Profesor
//que se encuentra dentro del Panel de Pestaas
if(panelDePestaasRelacionado.retornarCantidadDeNodosEnElArregloDeProfesores() == 0){
//Declaramos un objeto que tendr el nombre del nodo (IDENTIFICADOR del nodo)
//este nombre se visualizar en el rbol
//este nombre podr ser actualizado
//(Lo VAMOS A ACTUALIZAR EN EL PANEL DE Ingreso de Datos del Profesor)
Object child = "Nuevo Nodo";
//Declaramos un nodo que tendr la referencia del nodo Padre o del nodo raz
DefaultMutableTreeNode parent = null;
//Obtenemos la ruta del nodo al cual hemos hecho clic
TreePath parentPath = this.getSelectionPath();
//Verificamos si la ruta es 'null'
if(parentPath == null){
parent = dmtn;
}else{
//Obtenermos el Nodo Padre del nodo al cual se hizo clic
parent = (DefaultMutableTreeNode)(parentPath.getLastPathComponent());
}
//Creamos un nuevo Nodo Hijo
DefaultMutableTreeNode childNode = new DefaultMutableTreeNode(child);
//Verificamos si el Nodo Padre es 'null'
if(parent == null){
//Asignamos la referencia al nodo raz, creado en la clase 'jpanArbol'
parent = dmtn;
Pg. 16
Algortmica II
}
//Importante
//Enviamos el Nodo Padre y el Nodo Hijo, al panel de Pestaas,
//a la espera que el usuario ingrese los datos del Nuevo Profesor
panelDePestaasRelacionado.aadirNodoAlArregloDeProfesores(childNode);
panelDePestaasRelacionado.aadirNodoAlArregloDeProfesores(parent);
//Indicamos al Panel de Ingreso del Datos Del Profesor que hay un nuevo Nodo Profesor
//y por lo tanto se debe de ingresar sus datos
panelDePestaasRelacionado.indicarQueHayUnNuevoNodoListoParaIngresarLosDatosDelProfesor();
}else{
//Se muestra un mensaje de operacin incorrecta
//Esto significa que el usuario a querido aadir un nuevo nodo Profesor
//sin haber ingresado los datos del nodo Profesor anterior a este.
JOptionPane.showMessageDialog(null,
"Operacin incorrecta!\nComplete los datos del Profesor.",
"Mensaje del Sistema",
JOptionPane.WARNING_MESSAGE);
}
}
//Verificamos si se hizo clic en la opcin 'Eliminar Profesor'
if(ae.getSource() == jmnuiEliminarProfesor){
//Obtenemos la ruta del Nodo al cual hemos seleccionado
TreePath currentSelection = this.getSelectionPath();
//Declaramos una varible de tipo 'String'
String codigoDeLaPersona;
//Declaramos un variable de tipo 'int'
int posicionDeLaPersona;
//Verificamos que la ruta sea diferente de 'null'
if (currentSelection != null) {
//Obtenemos la referencia al Nodo seleccionado
DefaultMutableTreeNode currentNode = (DefaultMutableTreeNode)
(currentSelection.getLastPathComponent());
//Obtenemos la referencia de su Nodo Padre
MutableTreeNode parent = (MutableTreeNode)(currentNode.getParent());
//Verificamos que el Nodo Padre sea diferente de 'null'
if (parent != null) {
DefaultTreeModel treeModel =(DefaultTreeModel)this.getModel();
//Removemos el Nodo seleccionado
treeModel.removeNodeFromParent(currentNode);
//Nota: Como estamos eliminando un nodo del rbol,
//tambien tenemos que sacar el objeto de tipo 'Persona' que se encuentra
//en el arreglo de Personas de la clase 'Universidad'
//Obtenemos el cdigo del objeto de tipo 'Persona'
//Recordar que el IDENTIFICADOR es ta formado por:
// codigo + " .- " + apellidos + ", " + nombres
codigoDeLaPersona = currentNode.getUserObject().toString();
codigoDeLaPersona = codigoDeLaPersona.substring(0,codigoDeLaPersona.indexOf("
"));
Pg. 17
Algortmica II
//Obtenemos la posicin del objeto de tipo 'Persona' dentro del arreglo

posicionDeLaPersona =
universidadRelacionada.retornarPosicionDeLaPersonaEnElArreglo(codigoDeLaPersona);
//Removemos el objeto de tipo 'Persona' del arreglo de Personas
universidadRelacionada.eliminarPersonaDelArreglo( posicionDeLaPersona );
}
}
//Resfrescamos la estructura del Arbol, para reconozca los acambios
((DefaultTreeModel )this.getModel()).nodeStructureChanged((TreeNode)dmtn);
}
//Verificamos si se hizo clic en la opcin 'Aadir Alumno'
if(ae.getSource() == jmnuiAniadirAlumno){
//Enviamos la referencia del nuevo Nodo creado y de su Nodo Padre
//Lo enviamos al Panel de Ingreso de datos del Alumno
//que se encuentra dentro del Panel de Pestaas
if(panelDePestaasRelacionado.retornarCantidadDeNodosEnElArregloDeAlumnos() == 0){
//Declaramos un objeto que tendr el nombre del nodo (IDENTIFICADOR del nodo)
//este nombre se visualizar en el rbol
//este nombre podr ser actualizado
//(Lo VAMOS A ACTUALIZAR EN EL PANEL DE Ingreso de Datos del Alumno)
Object child = "Nuevo Nodo";
//Declaramos un nodo que tendr la referencia del nodo Padre o del nodo raz
DefaultMutableTreeNode parent = null;
TreePath parentPath = this.getSelectionPath();
//Verificamos si la ruta es 'null'
if(parentPath == null){
parent = dmtn;
}else{
//Obtenermos el Nodo Padre del nodo al cual se hizo clic
parent = (DefaultMutableTreeNode)(parentPath.getLastPathComponent());
}
//Creamos un nuevo Nodo Hijo
DefaultMutableTreeNode childNode = new DefaultMutableTreeNode(child);
//Verificamos si el Nodo Padre es 'null'
if(parent == null){
//Asignamos la referencia al nodo raz, creado en la clase 'jpanArbol'
parent = dmtn;
}
//Importante
//Enviamos el Nodo Padre y el Nodo Hijo, al panel de Pestaas,
//a la espera que el usuario ingrese los datos del Nuevo Alumno
panelDePestaasRelacionado.aadirNodoAlArregloDeAlumnos(childNode);
panelDePestaasRelacionado.aadirNodoAlArregloDeAlumnos(parent);
Pg. 18
Algortmica II
//Indicamos al Panel de Ingreso del Datos Del Profesor que hay un nuevo Nodo Profesor
//y por lo tanto se debe de ingresar sus datos
panelDePestaasRelacionado.indicarQueHayUnNuevoNodoListoParaIngresarLosDatosDelAlumno();
}else{
//Se muestra un mensaje de operacin incorrecta
//Esto significa que el usuario a querido aadir un nuevo nodo Alumno
//sin haber ingresado los datos del nodo Alumno anterior a este.
JOptionPane.showMessageDialog(null,
"Operacin incorrecta!\nComplete los datos del Alumno.",
"Mensaje del Sistema",
JOptionPane.WARNING_MESSAGE);
}
}
//Verificamos si se hizo clic en la opcin 'Eliminar Alumno'
if(ae.getSource() == jmnuiEliminarAlumno){
node = (DefaultMutableTreeNode)dmtn.getParent();
//Eliminamos a todos los nodos hijos del Padre
node.removeAllChildren();
}
}
//*******************************************************
//Mtodos de la interface 'MouseListener'
//*******************************************************
public void mousePressed(MouseEvent evt){ }
public void mouseExited(MouseEvent evt){
}
public void mouseEntered(MouseEvent evt){
}
public void mouseClicked(MouseEvent evt){
}
//Este mtodo reconoce el clic que hacemos a cualquier nodo del rbol
public void mouseReleased(MouseEvent evt){
//Si hacemos clic Derecho sobre un nodo del arbol debemos verificar
//si se ha desplegado su correspondiente JPopupMenu
if ( evt.isPopupTrigger()) {
TreePath path = this.getSelectionPath();
//Verificamos si la ruta es diferente de 'null'
//Recordar que si la ruta es 'null', es porque se ha hecho clic en otro lugar
//que no sea un nodo del rbol
if(path != null){
//Obtenemos la descripcin (IDENTIFICADOR) del nodo al cual hemos hecho clic
//Este IDENTIFICADOR de cada nodo se visualiza en el rbol
nombreNodo = path.getLastPathComponent().toString();
//Utilizamos el objeto de tipo 'Universidad'
//para comparar el valor de la variable 'nombreNodo' con todos los objetos
//almacenados en el arreglo 'arregloDePersonas' que se encuentra en la clase
Universidad
//Verificamos si se hizo clic en el nodo correspondiente a la Universidad
Pg. 19
Algortmica II
if(nombreNodo.equalsIgnoreCase( universidadRelacionada.getNombreLargo() )){

//Mostramos el JPopup para la Universidad
jpopupUnivesidad.show( (JComponent)evt.getSource(), evt.getX(), evt.getY() );
}else{
//Declaramos una variable temporal de tipo 'Persona'
//el cual referenciar a un objeto EXISTENTE
Persona temporal;
//Este bucle 'For' se recorre al arreglo de objetos Personas
for(int i=0; i<universidadRelacionada.retornarCantidadDePersonasEnElArreglo(); i++){
//Pedimos retornar UNO x UNO a los objetos de tipo Persona
temporal = universidadRelacionada.retornarUnaPersonaPorPosicion(i);
//Verificamos si la Persona es de tipo Profesor
//Verificamos si se hizo clic en el nodo correspondiente al Profesor
if(nombreNodo.startsWith( temporal.getCodigo() )){
//Mostramos el JPopup para el Profesor
jpopupProfesor.show( (JComponent)evt.getSource(),
evt.getX(), evt.getY() );
//Salimos del bucle 'For'
break;
}
}
//Verificamos si la Persona es de tipo Alumno
//Verificamos si se hizo clic en el nodo correspondiente al Alumno
if(nombreNodo.startsWith( temporal.getCodigo() )){
//Mostramos el JPopup para el Alumno
jpopupAlumno.show( (JComponent)evt.getSource(), evt.getX(),
evt.getY() );
break;
}
}
}
}
}
}
}
}
jpanArbol
A continuacin se presenta a la clase jpanArbol, que hereda de la clase jpanFondo
(javax.swing.JPanel). Esta clase se utiliza para crear el panel que contendr al rbol
JTree.
Pasos a seguir 9:
Integrado.
18. Generar el archivo jpanArbol.class (Proceso de Compilacin)
Pg. 20
Algortmica II
La clase jpanArbol
//jpanIngresoDeDatosDelProfesor
import java.awt.BorderLayout;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeNode;
import javax.swing.JScrollPane;
import javax.swing.ImageIcon;
//Importamos la clase Universidad
//Definimos la clase 'jpanArbol'
public class jpanArbol extends jpanFondo{
private DefaultMutableTreeNode
raiz;
private DefaultTreeModel
modelo;
private MiArbolSwing
miArbolSwing;
//Mtodo constuctor por parmetro
public jpanArbol(Universidad universidadPorReferencia){
}
setLayout( new BorderLayout() );
//Instanciamos el Nodo 'raiz' del rbol
//Le ponemos con IDENTIFICADOR el nombre largo de la Universidad
raiz = new DefaultMutableTreeNode( universidadRelacionada.getNombreLargo() );
//Instanciamos un objeto de tipo 'MiArbolSwing' que hereda de 'JTree'
//le pasamos por parmetro la referencia al nodo 'raiz'
//NOTA: Este objeto va ha escuchar los eventos del Mouse
//y podr desplegar los JPopupMenu
miArbolSwing = new MiArbolSwing( raiz );
//Indicamos las imagenes que se van a mostrar en cualquier nodo para:
//cuando se crea el Nodo
//cuando se abre el Nodo
//cuando se cierra el Nodo
Pg. 21
Algortmica II
DefaultTreeCellRenderer render= (DefaultTreeCellRenderer)miArbolSwing.getCellRenderer();

render.setLeafIcon(new ImageIcon(rutaDeImagenes + "folder.gif"));
render.setOpenIcon(new ImageIcon(rutaDeImagenes + "folderopen.gif"));
render.setClosedIcon(new ImageIcon(rutaDeImagenes + "folder.gif"));
//Enviamos la referencia al objeto de tipo 'Universidad'
//que se ha creado en el mtodo 'main'
miArbolSwing.relacionarMiArbolSwingConLaUniversidad(universidadRelacionada);
// Se aade el rbol y se hace sobre un ScrollPane, para
// que se controle automticamente la longitud del rbol
// cuando est desplegado, de forma que aparecer una
// barra de desplazamiento para poder visualizarlo en su
// totalidad
this.add( new JScrollPane( miArbolSwing ),BorderLayout.CENTER );
// Se obtiene el modelo del rbol
modelo =(DefaultTreeModel)miArbolSwing.getModel();
}
//IMPORTANTES
//Asociacin con la clase 'jpanPanelDePestaas'
public void relacionarAlArbolConElPanelDePestaas(jpanPanelDePestaas objetoPorReferencia){
this.miArbolSwing.relacionarAlMiArbolConElPanelDePestaas(objetoPorReferencia);
}
//Asociacin con la clase 'Universidad'
public void relacionarAlArbolConLaUniversidad(Universidad universidadPorReferencia){
}
//Este mtodo es el que INSERTA el Nuevo Nodo
//lo va isertar dentro de su nodo Padre
//este mtodo se invoca desde los paneles de ingreso de datos Profesor Alumno
public void insertarNodoAlArbol(DefaultMutableTreeNode childNode,
DefaultMutableTreeNode parent){
modelo.insertNodeInto(childNode, parent, parent.getChildCount());
//Resfrescamos la estructura del Arbol, para reconozca los acambios
((DefaultTreeModel )miArbolSwing.getModel()).nodeStructureChanged((TreeNode)raiz);
}
}
Pg. 22
Algortmica II
jpanIngresoDeDatos
A continuacin se presenta a la clase jpanIngresoDeDatos, que hereda de la clase
jpanFondo (javax.swing.JPanel). Esta clase se utiliza para crear el panel de ingreso
de datos de una Persona. Se debe indicar que esta clase, es una clase Abstracta, y
que se van a heredar de sta clases DOS clases hijas, las cuales implementarn los
mtodos abstractos y mtodos especficos.
Pasos a seguir 10:

Integrado.
20. Generar el archivo jpanIngresoDeDatos.class (Proceso de Compilacin)
La clase jpanIngresoDeDatos
//Declaracin del nombre del paquete donde se encuentra la clase 'jpanIngresoDeDatos'
import javax.swing.JLabel;
import javax.swing.JTextField;
import javax.swing.JComboBox;
import javax.swing.JRadioButton;
import javax.swing.JButton;
import javax.swing.ButtonGroup;
import java.awt.event.ActionEvent;
Pg. 23
Algortmica II
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.awt.Color;
//CLASE ABSTRACTA
//Definimos la clase 'jpanIngresoDeDatos'
//e IMPLEMENTA la interface 'ActionListener'
public abstract class jpanIngresoDeDatos extends jpanFondo implements ActionListener{
protected JLabel
jlblTitulo, jlblCodigo, jlblNombres;
protected JLabel
jlblApellidos, jlblCategoria;
protected JLabel
jlblSexo, jlblFechaDeNacimiento, jlblFoto;
protected JTextField
jtxfCodigo, jtxfNombres, jtxfApellidos;
protected JTextField
jtxfFechaDeNacimiento;
protected JComboBox
jcmbxCategoria;
protected JRadioButton jrbtnSexoMasculino, jrbtnSexoFemenino;
protected ButtonGroup btngSexo;
protected JButton
jbtnGrabarDatos, jbtnCargarFoto;
protected Universidad universidadRelacionada;
//Declaramos un objeto de tipo jpanTabla
protected jpanTabla tablaRelacionada;
//Declaramos un objeto de tipo jpanArbol
protected jpanArbol arbolRelacionado;
//Declaramos un ArrayList que almacene a nodos de tipo DefaultMutableTreeNode
protected ArrayList<DefaultMutableTreeNode> arregloDeNodos;
public jpanIngresoDeDatos(){
//Instanciamo el arreglo que almacenar a los nodos del Arbol
arregloDeNodos = new ArrayList<DefaultMutableTreeNode>();
//Invocamos al mtodo que crea la Interface Grfica de Usuario GUI
}
jlblTitulo = new JLabel("Registro de Datos");
jlblTitulo.setBounds(100,10,250,20);
jlblCodigo = new JLabel("Cdigo:");
jlblCodigo.setBounds(100,40,70,20);
jlblNombres = new JLabel("Nombres:");
jlblNombres.setBounds(100,70,70,20);
jlblApellidos = new JLabel("Apellidos:");
jlblApellidos.setBounds(100,100,70,20);
jlblCategoria = new JLabel("Categora:");
jlblCategoria.setBounds(100,130,70,20);
jlblSexo = new JLabel("Sexo:");
jlblSexo.setBounds(100,160,70,20);
Pg. 24
Algortmica II
jlblFechaDeNacimiento = new JLabel("Fec.Nac.:");

jlblFechaDeNacimiento.setBounds(100,190,70,20);
jtxfCodigo = new JTextField();
jtxfCodigo.setBounds(180,40,100,20);
jtxfNombres = new JTextField();
jtxfNombres.setBounds(180,70,150,20);
jtxfApellidos = new JTextField();
jtxfApellidos.setBounds(180,100,150,20);
jcmbxCategoria = new JComboBox();
jcmbxCategoria.setBounds(180,130,150,20);
jcmbxCategoria.addItem("Jefe de Practica");
jcmbxCategoria.addItem("Auxiliar");
jcmbxCategoria.addItem("Asociado");
jcmbxCategoria.addItem("Principal");
jrbtnSexoMasculino = new JRadioButton("Masculino");
jrbtnSexoMasculino.setBounds(180,160,100,20);
jrbtnSexoMasculino.setBackground(coColorDeFondo);
jrbtnSexoMasculino.setSelected(true);
jrbtnSexoFemenino = new JRadioButton("Femenino");
jrbtnSexoFemenino.setBounds(290,160,100,20);
jrbtnSexoFemenino.setBackground(coColorDeFondo);
btngSexo = new ButtonGroup();
btngSexo.add(jrbtnSexoMasculino);
btngSexo.add(jrbtnSexoFemenino);
jtxfFechaDeNacimiento = new JTextField();
jtxfFechaDeNacimiento.setBounds(180,190,100,20);
jbtnGrabarDatos = new JButton("Grabar");
jbtnGrabarDatos.setBounds(180,220,100,20);
jbtnGrabarDatos.addActionListener(this);
this.add(jlblTitulo);
this.add(jlblCodigo);
this.add(jlblNombres);
this.add(jlblApellidos);
this.add(jlblCategoria);
this.add(jlblSexo);
this.add(jlblFechaDeNacimiento);
this.add(jtxfCodigo);
this.add(jtxfNombres);
this.add(jtxfApellidos);
this.add(jcmbxCategoria);
this.add(jrbtnSexoMasculino);
this.add(jrbtnSexoFemenino);
this.add(jtxfFechaDeNacimiento);
this.add(jbtnGrabarDatos);
}
//Mtodo de la interface 'ActionListener'
public void actionPerformed(ActionEvent evt){
Pg. 25
Algortmica II
//Verificamos si se hizo clic en el botn 'jbtnGrabarDatos'

if(evt.getSource() == jbtnGrabarDatos){
grabarDatos();
}
}
//Mtodo ABSTRACTO
//Este mtodo ser implementado en la clase HIJA
public abstract void grabarDatos();
//Este mtodo se usa para mostrar un texto como ttulo
public void setJlblTitulo(String dato){
jlblTitulo.setText(dato);
}
//IMPORTANTES
//Asociacin con la clase 'Universidad'
public void relacionarElPanelDeIngresoConLaUniversidad(Universidad universidadPorReferencia){
}
//Asociacin con la clase 'jpanTabla'
public void relacionarElPanelDeIngresoConLaTabla(jpanTabla tablaPorReferencia){
//Establecemos la referencia al objeto de tipo 'jpanTabla'
this.tablaRelacionada = tablaPorReferencia;
}
//Asociacin con la clase 'jpanArbol'
public void relacionarElPanelDeIngresoConElArbol(jpanArbol arbolPorReferencia){
//Establecemos la referencia al objeto de tipo 'jpanArbol'
this.arbolRelacionado = arbolPorReferencia;
}
//Mtodo que recibe un nodo de tipo 'DefaultMutableTreeNode'
//y lo almacena en el arreglo llamado 'arregloDeNodos'
//Este mtodo simboliza la relacin entre el Nuevo Nodo creado en el Arbol
//con el Panel de Ingreso de Datos (Profesor Alumno) que se encuentra en la Pestaa
public void aadirNodoAlArreglo(DefaultMutableTreeNode nodoPorReferencia){
arregloDeNodos.add(nodoPorReferencia);
}
//Devuelve la cantidad de Nodos en el arreglo
public int retornarCantidadDeNodosEnElArreglo(){
return arregloDeNodos.size();
}
//Este mtodo muestra una mensaje al usuario, utiliza la clase 'JOptionPane'
public void mensaje(String msn, int tipo){
JOptionPane.showMessageDialog(null,msn,"Mensaje del Sistema",tipo);
}
//Este mtodo limpia los valores ingresados a cada componente grfico Swing
public void limpiarLosValoresDeLosObjetosGUIDelPanel(){
jtxfCodigo.setText("");
jtxfCodigo.setBackground( coColorDeFondo );
jtxfNombres.setText("");
Pg. 26
Algortmica II
jtxfApellidos.setText("");
jcmbxCategoria.setSelectedIndex(0);
jrbtnSexoMasculino.setSelected(true);
jtxfFechaDeNacimiento.setText("");
}
//Este mtodo indica al usuario que hay un Nuevo Nodo listo para ingresar sus datos
//Funciona como un semforo, es decir pintamos de color NARANJA la caja de texto
//correspondiente al cdigo, esto indicar que hay que ingresar datos
public void indicarQueHayUnNuevoNodoListoParaIngresarSusDatos(){
jtxfCodigo.setBackground(Color.ORANGE);
}
}
JPanel
jpanIngresoDeDatosDelProfesor
A continuacin se presenta a la clase jpanIngresoDeDatosDelProfesor, que hereda
de la clase jpanIngresoDeDatos. Esta clase se utiliza para ingresar los datos del
Profesor.
Pasos a seguir 11:

Integrado.
22. Generar el archivo jpanIngresoDeDatosDelProfesor.class (Proceso de
Compilacin)
La clase jpanIngresoDeDatosDelProfesor
//Declaracin del nombre del paquete donde se encuentra la clase 'jpanIngresoDeDatosDelProfesor'
Pg. 27
Algortmica II

//Importamos la clase Profesor
//Definimos la clase 'jpanIngresoDeDatosDelProfesor'
//que HEREDA de la clase 'jpanIngresoDeDatos'
public class jpanIngresoDeDatosDelProfesor extends jpanIngresoDeDatos{
//Este mtodo crea un Nuevo objeto de tipo 'Profesor' y devuelve la Referencia a este
public Profesor crearUnNuevoProfesor(){
Profesor profesor = new Profesor();
profesor.setCodigo( jtxfCodigo.getText() );
profesor.setNombres( jtxfNombres.getText() );
profesor.setApellidos( jtxfApellidos.getText() );
profesor.setCategoria( jcmbxCategoria.getSelectedItem().toString() );
if(jrbtnSexoMasculino.isSelected()){
profesor.setSexo("Masculino");
}
if(jrbtnSexoFemenino.isSelected()){
profesor.setSexo("Femenino");
}
try{
profesor.setFechaDeNacimiento( new Date(jtxfFechaDeNacimiento.getText()) );
profesor.setFechaDeNacimiento( new Date() );
}
return profesor;
}
//Implementacin del Mtodo abstracto
public void grabarDatos(){
//Obtenemos el cdigo ingresado en la caja de texto
String dato = jtxfCodigo.getText();
//Verificamos si se han almacenado los nodos Hijo y Padre
//Es decir, si se aadi un Nuevo Profesor desde el rbol
if(arregloDeNodos.size() > 0 ){
//Verificamos que el cdigo ingresado sea NICO
if(universidadRelacionada.retornarPosicionDeLaPersonaEnElArreglo( dato ) >= 0){
mensaje("CDIGO EXISTENTE!\nIngrese otro
Cdigo",JOptionPane.WARNING_MESSAGE);
}else{
//Declaramos un objeto profesor que har referencia al objeto de tipo Profesor
//instanciado dentro del mtodo 'crearUnNuevoProfesor()'
Profesor profesorReferencia = crearUnNuevoProfesor();
//Formamos el IDENTIFICADOR del Nuevo Nodo Hijo
//este se mostrar en el rbol, es importante que se muestre su cdigo
String identificadorDelNodo = profesorReferencia.getCodigo() + " .- " +
profesorReferencia.getApellidos() +
", " +
Pg. 28
Algortmica II
profesorReferencia.getNombres();
//Aadimos un nuevo Profesor en el ArrayList 'arregloDePersonas'
//que se encuentra dentro de la clase 'Universidad'
universidadRelacionada.ingresarNuevaPersona( profesorReferencia );
//Pedimos mostrar los datos del Profesor en la Tabla
tablaRelacionada.cargarDatosDeLosProfesoresEnLaTabla();
//Actualizando los Datos del Arbol
//Obtenemos el Nodo Hijo y el Nodo Padre, guardados en el arreglo de Nodos
//Nota: Estos nodos fueron guardados desde el rbol, al momento de
//aadir un Nuevo Profesor.
DefaultMutableTreeNode childNode = arregloDeNodos.get(0);
DefaultMutableTreeNode parent = arregloDeNodos.get(1);
//Indicamos el nombre que Identificar al nuevo nodo Hijo
childNode.setUserObject( identificadorDelNodo );
//Importante
//Invocamos al mtodo 'insertarNodoAlArbol' de la clase 'jpanArbol'
//para que inserte el nuevo nodo Hijo dentro de su nodo padre
arbolRelacionado.insertarNodoAlArbol(childNode, parent);
//Limpiar el arreglo de Nodos Profesor
arregloDeNodos.clear();
//Limpiamos los valores de nuestro Formulario de ingreso de datos
limpiarLosValoresDeLosObjetosGUIDelPanel();
}
}else{
//Indicamos que se debe aadir un nuevo Profesor desde el rbol, y luego
//ingresar los datos del profesor en este Panel
mensaje("Operacin incorrecta!\nPrimero se debe Aadir Profesor usando el
rbol",JOptionPane.WARNING_MESSAGE);
}
}
}
Pg. 29
Algortmica II
JPanel
jpanIngresoDeDatosDelAlumno
A continuacin se presenta a la clase jpanIngresoDeDatosDelAlumno, que hereda
de la clase jpanIngresoDeDatos. Esta clase se utiliza para ingresar los datos del
Alumno.
Pasos a seguir 12:

Integrado.
24. Generar el archivo jpanIngresoDeDatosDelAlumno.class (Proceso de
Compilacin)
La clase jpanIngresoDeDatosDelAlumno
//Declaracin del nombre del paquete donde se encuentra la clase 'jpanIngresoDeDatosDelAlumno'
//Importamos la clase Alumno
//Definimos la clase 'jpanIngresoDeDatosDelAlumno'
//que HEREDA de la clase 'jpanIngresoDeDatos'
public class jpanIngresoDeDatosDelAlumno extends jpanIngresoDeDatos{
//Este mtodo crea un Nuevo objeto de tipo 'Alumno' y devuelve la Referencia a este
public Alumno crearUnNuevoAlumno(){
Alumno alumno = new Alumno();
Pg. 30
Algortmica II
alumno.setCodigo( jtxfCodigo.getText() );
alumno.setNombres( jtxfNombres.getText() );
alumno.setApellidos( jtxfApellidos.getText() );
alumno.setCategoria( jcmbxCategoria.getSelectedItem().toString() );
if(jrbtnSexoMasculino.isSelected()){
alumno.setSexo("Masculino");
}
if(jrbtnSexoFemenino.isSelected()){
alumno.setSexo("Femenino");
}
try{
alumno.setFechaDeNacimiento( new Date(jtxfFechaDeNacimiento.getText()) );
alumno.setFechaDeNacimiento( new Date() );
}
return alumno;
}
//Implementacin del Mtodo abstracto
public void grabarDatos(){
//Obtenemos el cdigo ingresado en la caja de texto
String dato = jtxfCodigo.getText();
//Verificamos si se han almacenado los nodos Hijo y Padre
//Es decir, si se aadi un Nuevo Alumno desde el rbol
if(arregloDeNodos.size() > 0 ){
if(universidadRelacionada.retornarPosicionDeLaPersonaEnElArreglo( dato ) >= 0){
mensaje("CDIGO EXISTENTE!\nIngrese otro
Cdigo",JOptionPane.WARNING_MESSAGE);
}else{
//Declaramos un objeto profesor que har referencia al objeto de tipo Profesor
//instanciado dentro del mtodo 'crearUnNuevoProfesor()'
Alumno alumnoReferencia = crearUnNuevoAlumno();
//Formamos el IDENTIFICADOR del Nuevo Nodo Hijo
//este se mostrar en el rbol, es importante que se muestre su cdigo
String identificadorDelNodo = alumnoReferencia.getCodigo() + " .- " +
alumnoReferencia.getApellidos() +
", " +
alumnoReferencia.getNombres();
//Aadimos un nuevo Alumno en el ArrayList 'arregloDePersonas'
//que se encuentra dentro de la clase 'Universidad'
universidadRelacionada.ingresarNuevaPersona( crearUnNuevoAlumno() );
//Pedimos mostrar los datos del Profesor en la Tabla
tablaRelacionada.cargarDatosDeLosAlumnosEnLaTabla();
//Actualizando los Datos del Arbol
//Obtenemos el Nodo Hijo y el Nodo Padre, guardados en el arreglo de Nodos
//Nota: Estos nodos fueron guardados desde el rbol, al momento de
//aadir un Nuevo Alumno.
DefaultMutableTreeNode childNode = arregloDeNodos.get(0);
DefaultMutableTreeNode parent = arregloDeNodos.get(1);
//Indicamos el nombre que Identificar al nuevo nodo Hijo
Pg. 31
Algortmica II
childNode.setUserObject( identificadorDelNodo );
//Importante
//Invocamos al mtodo 'insertarNodoAlArbol' de la clase 'jpanArbol'
//para que inserte el nuevo nodo Hijo dentro de su nodo padre
arbolRelacionado.insertarNodoAlArbol(childNode, parent);
//Limpiar el arreglo de Nodos Profesor
arregloDeNodos.clear();
//Limpiamos los valores de nuestro Formulario de ingreso de datos
limpiarLosValoresDeLosObjetosGUIDelPanel();
}
}else{
//Indicamos que se debe aadir un nuevo Alumno desde el rbol, y luego
//ingresar los datos del alumno en este Panel
mensaje("Operacin incorrecta!\nPrimero se debe Aadir Alumno usando el
rbol",JOptionPane.WARNING_MESSAGE);
}
}
}
JPanel
jpanPanelDePestaas
A continuacin se presenta a la clase jpanPanelDePestaas, que hereda de la clase
jpanFondo. Esta clase se utiliza para disear la Interface Grfica de Usuario (GUI)
que muestre un componente grfico swing llamado JTabbedPane. Este componente
grfico almacena varios paneles en forma de Pestaas Tabuladas. En nuestra
aplicacin se tendr TRES (3) pestaas: Inicio, Profesor y Alumno.
Pasos a seguir 13:

Integrado.
26. Generar el archivo jpanPanelDePestaas.class (Proceso de Compilacin)
Pg. 32
Algortmica II
La clase jpanPanelDePestaas
//Declaracin del nombre del paquete donde se encuentra la clase 'jpanPanelDePestaas'
import javax.swing.JTabbedPane;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
//Definimos la clase 'jpanPanelDePestaas'
public class jpanPanelDePestaas extends jpanFondo implements ChangeListener{
private JTabbedPane panelDePestaas;
private jpanInicio panelDeInicio;
private jpanIngresoDeDatosDelProfesor panelDeIngresoDelProfesor;
private jpanIngresoDeDatosDelAlumno panelDeIngresoDelAlumno;
//Declaramos un objeto de tipo jpanTabla
private jpanTabla tablaRelacionada;
//Declaramos un objeto de tipo jpanArbol
private jpanArbol arbolRelacionado;
//Mtodo constructor por parmetro
public jpanPanelDePestaas(jpanTabla tablaPorReferencia){
//que se ha creado en la clase 'jpanPrincipal'
}
//Mtodo que crea y disela la GUI de este Panel
panelDePestaas = new JTabbedPane();
panelDePestaas.setBounds(0,0,550,400);
//Activamos el escuchador, para que este atento ante algn cambio de pestaa
panelDePestaas.addChangeListener(this);
panelDeInicio = new jpanInicio();
panelDeInicio.setBounds(0,0,550,400);
panelDeIngresoDelProfesor = new jpanIngresoDeDatosDelProfesor();
panelDeIngresoDelProfesor.setBounds(0,0,550,400);
panelDeIngresoDelProfesor.setJlblTitulo("Registro de Datos del Profesor");
panelDeIngresoDelAlumno = new jpanIngresoDeDatosDelAlumno();
panelDeIngresoDelAlumno.setBounds(0,0,550,400);
panelDeIngresoDelAlumno.setJlblTitulo("Registro de Datos del Alumno");
panelDePestaas.addTab("Inicio", panelDeInicio);
Pg. 33
Algortmica II
panelDePestaas.addTab("Profesor", panelDeIngresoDelProfesor);
panelDePestaas.addTab("Alumno", panelDeIngresoDelAlumno);
this.add(panelDePestaas);
}
//Este mtodo se invoca AUTOMATICAMENTE cuando hacemos clic en una pestaa
//Tiene un comportamiento muy parecido al mtodo 'actionPerformed'
//Este mtodo trabaja con un objeto de la clase 'JTabbedPane'
public void stateChanged(ChangeEvent changeEvent) {
JTabbedPane sourceTabbedPane = (JTabbedPane) changeEvent.getSource();
int indice = sourceTabbedPane.getSelectedIndex();
String etiquetaDeLaPestaa = sourceTabbedPane.getTitleAt(indice);
switch(indice){
case 0 : tablaRelacionada.cargarDatosDeLaUniversidadEnLaTabla(); break;
case 1 : tablaRelacionada.cargarDatosDeLosProfesoresEnLaTabla(); break;
case 2 : tablaRelacionada.cargarDatosDeLosAlumnosEnLaTabla(); break;
}
}
//Este mtodo se utiliza para activar (mostrar) el contenido de un 'Tab'
//En este caso tenemos 3 Tabs: Inicio, Profesor y Alumno
public void cambiarDePestaa(int indice){
panelDePestaas.setSelectedIndex(indice);
}
//IMPORTANTES
//Relacion Pestaa - Universidad
public void relacionarLasPestaasConLaUniversidad(Universidad universidadPorReferencia){
//Pasamos la referencia a los paneles de ingreso de datos del Profesor y Alumno
relacionarLasPestaaDeIngresoDelProfesorConLaUniversidad(universidadPorReferencia);
relacionarLasPestaaDeIngresoDelAlumnoConLaUniversidad(universidadPorReferencia);
}
//Asociacin entre la clase 'panelDeIngresoDelProfesor' y 'Universidad'
public void relacionarLasPestaaDeIngresoDelProfesorConLaUniversidad(Universidad
universidadPorReferencia){
this.panelDeIngresoDelProfesor.relacionarElPanelDeIngresoConLaUniversidad(universidadPorReferencia);
}
//Asociacin entre la clase 'panelDeIngresoDelAlumno' y 'Universidad'
public void relacionarLasPestaaDeIngresoDelAlumnoConLaUniversidad(Universidad
universidadPorReferencia){
this.panelDeIngresoDelAlumno.relacionarElPanelDeIngresoConLaUniversidad(universidadPorReferencia);
}
//Relacion Pestaa - Tabla
Pg. 34
Algortmica II
public void relacionarLasPestaasConLaTabla(jpanTabla tablaPorReferencia){

relacionarLasPestaaDeIngresoDelProfesorConLaTabla(tablaRelacionada);
relacionarLasPestaaDeIngresoDelAlumnoConLaTabla(tablaRelacionada);
}
//Asociacin entre la clase 'panelDeIngresoDelProfesor' y 'jpanTabla'
public void relacionarLasPestaaDeIngresoDelProfesorConLaTabla(jpanTabla tablaPorReferencia){
this.panelDeIngresoDelProfesor.relacionarElPanelDeIngresoConLaTabla(tablaPorReferencia);
}
//Asociacin entre la clase 'panelDeIngresoDelAlumno' y 'jpanTabla'
public void relacionarLasPestaaDeIngresoDelAlumnoConLaTabla(jpanTabla tablaPorReferencia){
this.panelDeIngresoDelAlumno.relacionarElPanelDeIngresoConLaTabla(tablaPorReferencia);
}
//Relacion Pestaa - Arbol
public void relacionarLasPestaasConElArbol(jpanArbol arbolPorReferencia){
this.arbolRelacionado = arbolPorReferencia;
relacionarLasPestaaDeIngresoDelProfesorConElArbol(arbolRelacionado);
relacionarLasPestaaDeIngresoDelAlumnoConElArbol(arbolRelacionado);
}
//Asociacin entre la clase 'panelDeIngresoDelProfesor' y 'jpanArbol'
public void relacionarLasPestaaDeIngresoDelProfesorConElArbol(jpanArbol arbolPorReferencia){
this.panelDeIngresoDelProfesor.relacionarElPanelDeIngresoConElArbol(arbolPorReferencia);
}
//Asociacin entre la clase 'panelDeIngresoDelAlumno' y 'jpanArbol'
public void relacionarLasPestaaDeIngresoDelAlumnoConElArbol(jpanArbol arbolPorReferencia){
this.panelDeIngresoDelAlumno.relacionarElPanelDeIngresoConElArbol(arbolPorReferencia);
}
//Aadimos Nodos
//Aadimos un Nuevo Nodo al arreglo de Nodos Profesores
public void aadirNodoAlArregloDeProfesores(DefaultMutableTreeNode nodoPorReferencia){
panelDeIngresoDelProfesor.aadirNodoAlArreglo(nodoPorReferencia);
}
//Aadimos un Nuevo Nodo al arreglo de Nodos Alumnos
public void aadirNodoAlArregloDeAlumnos(DefaultMutableTreeNode nodoPorReferencia){
panelDeIngresoDelAlumno.aadirNodoAlArreglo(nodoPorReferencia);
}
//Devuelve la cantidad de Nodos
//Devuelve la cantidad de Nodos en el Arreglo de Profesores
public int retornarCantidadDeNodosEnElArregloDeProfesores(){
return panelDeIngresoDelProfesor.retornarCantidadDeNodosEnElArreglo();
}
//Devuelve la cantidad de Nodos en el Arreglo de Alumnos
Pg. 35
Algortmica II
public int retornarCantidadDeNodosEnElArregloDeAlumnos(){

return panelDeIngresoDelAlumno.retornarCantidadDeNodosEnElArreglo();
}
//Indicar que hay que ingresar datos del nuevo Nodo
//Ingresar datos del Profesor
public void indicarQueHayUnNuevoNodoListoParaIngresarLosDatosDelProfesor(){
panelDeIngresoDelProfesor.indicarQueHayUnNuevoNodoListoParaIngresarSusDatos();
}
//Ingresar datos del Alumno
public void indicarQueHayUnNuevoNodoListoParaIngresarLosDatosDelAlumno(){
panelDeIngresoDelAlumno.indicarQueHayUnNuevoNodoListoParaIngresarSusDatos();
}
}
JTabbedPane
JPanel
Pg. 36
Algortmica II
JTabbedPane
JPanel
JTabbedPane
JPanel
Pg. 37
Algortmica II
jpanTabla
A continuacin se presenta a la clase jpanTabla, que hereda de la clase jpanFondo.
Esta clase se utiliza para mostrar los datos de la Universidad, de los Profesores y de
los Alumnos segn sea el caso. Esta clase muestra los datos utilizando el
componente grfico swing llamado JTable.
Pasos a seguir 14:

Integrado.
28. Generar el archivo jpanTabla.class (Proceso de Compilacin)
La clase jpanTabla
//Declaracin del nombre del paquete donde se encuentra la clase 'jpanTabla'
import javax.swing.JTable;
import javax.swing.JScrollPane;
//Importamos las clases del paquete 'Clases'
import Clases.Persona;
//Definimos la clase 'jpanTabla'
public class jpanTabla extends jpanFondo{
private JScrollPane jscrpanTablaDeDatos;
private JTable jtbTablaDeDatos;
private Object objetos[][];
private String titulosDeCabecera[] = {"Columna1","Columna2","Columna3"};
//Mtodo Constructor
public jpanTabla(){
}
//Instanciamos una matriz de 2x3 de objetos de tipo 'Object'
objetos = new Object[2][3];
//Instanciamos un objeto de tipo 'JTable'
//Por definicin un JTable est constituido por
//una matriz de tipo Object y un arreglo de tipo String
jtbTablaDeDatos = new JTable(objetos,titulosDeCabecera);
//Instanciamos un objeto de tipo 'JScrollPane'
//para que contenga a la tabla
jscrpanTablaDeDatos = new JScrollPane( jtbTablaDeDatos );
Pg. 38
Algortmica II
jscrpanTablaDeDatos.setBounds(0,0,550,200);
//Aadimos el objeto de tipo 'JScrollPane' dentro de este Panel
this.add(jscrpanTablaDeDatos);
}
//Importante
//Este mtodo recibe por parmetro a la Referencia del objeto de tipo 'Universidad'
public void relacionarLaTablaConLaUniversidad(Universidad universidadPorReferencia){
//Establecemos la referencia la objeto de tipo 'Universidad'
}
//Este mtodo crea una tabla
//para mostrar los datos de la Universidad
public void cargarDatosDeLaUniversidadEnLaTabla(){
//Obtenemos el arreglo que almacena el nombre de cada Atributo de la clase 'Universidad'
String titulo[] = universidadRelacionada.getNombreDeAtributosUniversidad();
//Instanciamos una matriz de UnoxTamanoDeColumna de objetos de tipo 'Object'
objetos = new Object[1][titulo.length];
//Asignamos el valor de cada Atributo del objeto 'universidadRelacionada'
//dentro de cada elemento de la matriz de tipo Object llamada 'objetos'
//Observar que trabajamos para la Primera Fila de ndice igual a CERO
objetos[0][0] = universidadRelacionada.getNombreLargo();
objetos[0][1] = universidadRelacionada.getNombreCorto();
objetos[0][2] = universidadRelacionada.getDireccion();
objetos[0][3] = universidadRelacionada.getRuc();
objetos[0][4] = universidadRelacionada.getTelefono();
jtbTablaDeDatos = new JTable(objetos,titulo);
jtbTablaDeDatos.setBackground( coColorDeFondo );
//Actualizamos el contenido del JScrollPane
//Es decir ahora le decimos que muestre la nueva tabla creada
jscrpanTablaDeDatos.setViewportView(jtbTablaDeDatos);
}
//para mostrar los datos de los Profesores
public void cargarDatosDeLosProfesoresEnLaTabla(){
//Obtenemos el arreglo que almacena el nombre de cada Atributo de la clase 'Persona'
String titulo[] = universidadRelacionada.getNombreDeAtributosPersona();
//Obtenemos la cantidad de objetos de tipo Personas existentes en el arreglo
int totalDePersonas = universidadRelacionada.retornarCantidadDePersonasEnElArreglo();
//Obtenemos la cantidad de objetos de tipo Profesor existentes en el arreglo
int fila = universidadRelacionada.retornarLaCantidadDeProfesoresEnElArregloDePersonas();
//Obtenemos la cantidad de elementos en el arreglo 'titulo'
int columa =titulo.length;
int indice = 0;
//Instanciamos una matriz de FilaxColumna de objetos de tipo 'Object'
objetos = new Object[fila][columa];
//Declaramos un objeto de tipo 'Persona'
Pg. 39
Algortmica II
//que har referencia a cada objeto almacenado en el areglo de Personas

Persona temporal;
//Este bucle 'For' recorre el arreglo de Personas, creado en la clase 'Universidad'
for(int i=0; i<totalDePersonas; i++){
//Obtenemos la referencia a un objeto de tipo 'Persona'
//Verificamos si el objeto es de tipo 'Profesor'
//Cargamos en la matriz de tipo 'Object' el valor de los atributos del objeto
objetos[indice][0] = temporal.getCodigo();
objetos[indice][1] = temporal.getNombres();
objetos[indice][2] = temporal.getApellidos();
objetos[indice][3] = temporal.getCategoria();
objetos[indice][4] = temporal.getSexo();
objetos[indice][5] = temporal.getFechaDeNacimiento().toString();
indice++;
}
//Verificamos si ya se han cargado todos los objetos de tipo 'Profesor'
if(fila == indice){
break;
}
}
}
//para mostrar los datos de los Alumnos
public void cargarDatosDeLosAlumnosEnLaTabla(){
//Obtenemos el arreglo que almacena el nombre de cada Atributo de la clase 'Persona'
String titulo[] = universidadRelacionada.getNombreDeAtributosPersona();
//Obtenemos la cantidad de objetos de tipo Personas existentes en el arreglo
int totalDePersonas = universidadRelacionada.retornarCantidadDePersonasEnElArreglo();
//Obtenemos la cantidad de objetos de tipo Alumno existentes en el arreglo
int fila = universidadRelacionada.retornarLaCantidadDeAlumnosEnElArregloDePersonas();
//Obtenemos la cantidad de elementos en el arreglo 'titulo'
int columa =titulo.length;
int indice = 0;
//Instanciamos una matriz de FilaxColumna de objetos de tipo 'Object'
objetos = new Object[fila][columa];
//Declaramos un objeto de tipo 'Persona'
//que har referencia a cada objeto almacenado en el areglo de Personas
Persona temporal;
//Este bucle 'For' recorre el arreglo de Personas, creado en la clase 'Universidad'
Pg. 40
Algortmica II
for(int i=0; i<totalDePersonas; i++){

//Obtenemos la referencia a un objeto de tipo 'Persona'
//Verificamos si el objeto es de tipo 'Alumno'
//Cargamos en la matriz de tipo 'Object' el valor de los atributos del objeto
objetos[indice][0] = temporal.getCodigo();
objetos[indice][1] = temporal.getNombres();
objetos[indice][2] = temporal.getApellidos();
objetos[indice][3] = temporal.getCategoria();
objetos[indice][4] = temporal.getSexo();
objetos[indice][5] = temporal.getFechaDeNacimiento().toString();
indice++;
}
//Verificamos si ya se han cargado todos los objetos de tipo 'Profesor'
if(fila == indice){
break;
}
}
}
}
Pg. 41
Algortmica II
jfrmPrincipal
A continuacin se presenta a la clase jfrmPrincipal, que hereda de la clase JFrame.
Esta clase se utiliza para crear y disear la interface grfica de usuario (GUI) de
nuestra aplicacin. Esta clase UTILIZA y UNE a las dems clases, dndole
finalmente la forma deseada.
Pasos a seguir 15:

Integrado.
30. Generar el archivo jfrmPrincipal.class (Proceso de Compilacin)
La clase jfrmPrincipal
//Declaramos el nombre del paquete donde se encuentra la clase 'jfrmPrincipal'
//Declaramos las librerias del Java que necesitamos usar
import javax.swing.JFrame;
import java.awt.Dimension;
import java.awt.Toolkit;
import javax.swing.JSplitPane;
import javax.swing.JButton;
//Definimos la clase 'jfrmPrincipal'
//que HEREDA de la clase 'JFrame'
public class jfrmPrincipal extends JFrame{
private jpanFondo panelDeFondo;
private jpanArbol panelArbol;
private jpanPanelDePestaas panelDePestaas;
private jpanTabla panelTabla;
private JSplitPane panelMovibleVertical;
private JSplitPane panelMovibleHorizontal;
private JButton jbtnAceptar;
public jfrmPrincipal(Universidad universidadPorReferencia){
//Establecemos la referencia la objeto de tipo 'Universidad'
Pg. 42
Algortmica II
//Invocamos al mtodo 'iniciarComponentes' para crear la interfaz de usuario
}
//Mtodo que crea y disea la GUI de esta ventana
//Indicamos el ttulo del formulario
this.setTitle("Recursos Humanos");
//Indicamos el tamao del formulario
this.setSize(800,600);
//Desactivamos el boton Maximizar
this.setResizable(false);
//Llamamos al mtodo que centra la ventana 'jfrmPrincipal'
centrarVentana();
//Indicamos que no tenga Administrador de Diseo
this.setLayout(null);
panelDeFondo = new jpanFondo();
panelDeFondo.setBounds(0,0,800,600);
panelArbol = new jpanArbol(universidadRelacionada);
panelArbol.setBounds(0,0,250,600);
panelTabla = new jpanTabla();
panelTabla.setBounds(0,0,550,200);
//Relacionamos la Tabla con la Universidad
panelTabla.relacionarLaTablaConLaUniversidad(universidadRelacionada);
panelTabla.cargarDatosDeLaUniversidadEnLaTabla();
panelDePestaas = new jpanPanelDePestaas(panelTabla);
panelDePestaas.setBounds(0,0,550,400);
//Relacionamos el Arbol con el panel de Pestaas
panelArbol.relacionarAlArbolConElPanelDePestaas(panelDePestaas);
//Relacionamos el Panel de Pestaas con la Universidad
panelDePestaas.relacionarLasPestaasConLaUniversidad(universidadRelacionada);
//Relacionamos los Paneles Ingresat de la Pestaa con la Tabla
panelDePestaas.relacionarLasPestaasConLaTabla(panelTabla);
//Relacionamos el panel de Pestaas con el Arbol
panelDePestaas.relacionarLasPestaasConElArbol(panelArbol);
//IMPORTANTES
//Se instancia un objeto de la clase 'JSplitPane'
panelMovibleVertical = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
panelMovibleVertical.setBounds(0,0,800,600);
//Se instancia un objeto de la clase 'JSplitPane'
panelMovibleHorizontal = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
panelMovibleHorizontal.setBounds(0,0,550,600);
//Colocamos dentro del objeto 'panelMovibleVertical'
//al 'panelArbol' a la izquierda y
//al 'panelMovibleHorizontal' a la derecha
Pg. 43
Algortmica II
panelMovibleVertical.setLeftComponent( panelArbol );
panelMovibleVertical.setRightComponent( panelMovibleHorizontal );
panelMovibleVertical.setDividerLocation(250);
//Colocamos dentro del objeto 'panelMovibleHorizontal'
//al 'panelDePestaas' en la parte SUPERIOR
//al 'panelTabla' en la parte INFERIOR
panelMovibleHorizontal.setLeftComponent( panelDePestaas );
panelMovibleHorizontal.setRightComponent( panelTabla );
panelMovibleHorizontal.setDividerLocation(400);
//Aadimos el objeto 'panelMovibleVertical' dento del panel de Fondo
panelDeFondo.add(panelMovibleVertical);
//Aadimos el panel de Fondo dentro del JFrame
this.add(panelDeFondo);
//Indicamos que al cerrar la ventana, se detengan todos los procesos
//iniciados para esta ventana
this.setDefaultCloseOperation(this.EXIT_ON_CLOSE);
}
//Este mtodo permite centrar la ventana en la pantalla del Monitor
public void centrarVentana(){
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
Dimension frameSize = this.getSize();
int x = (screenSize.width - frameSize.width)/2;
int y = (screenSize.height - frameSize.height)/2;
this.setLocation(x,y);
}
}
Pg. 44
Algortmica II
RecursosHumanos
A continuacin se presenta a la clase RecursosHumanos. En esta clase instanciamos
el objeto unmsm de tipo Universidad. Este objeto ser utilizado para almacenar los
datos de la Universidad, de los Profesores y de los Alumnos. De manera practica y
sencilla, podemos decir que este objeto es como nuestra BASE de DATOS, porque
guarda toda la informacin que ingresamos usando los formularios.
Esta clase RecursosHumanos tiene al mtodo main. Por lo tanto, es en clase, donde
tenemos que ejecutar el sistema (Proceso de Ejecucin - RUN)
Pasos a seguir 16:

Integrado.
32. Generar el archivo RecursosHumanos.class (Proceso de Compilacin)
La clase RecursosHumanos
Pg. 45
Algortmica II

import Formularios.jfrmPrincipal;
//Definimos la clase 'RecursosHumanos'
public class RecursosHumanos {
public static void main(String[] args) {
//Veremos la aplicacin del Polimorfismo con la
//declaracin del objeto 'unmsm' de tipo Universidad
//que se utiliza para almacenar a objetos de tipo 'Profesor' y 'Alumnos',
//los cuales heredan de la clase 'Persona'
//Es decir:
//'unmsm' ser el lugar donde almacenen los datos ingresados por teclado
//se comportara como una Base de Datos
//es por ello que lo creamos en el mtodo 'main', para INDEPENDIZARLO de la 'GUI'
Universidad unmsm = new Universidad();
//Instanciamos a un objeto de tipo 'jfrmPrincipal'
//enviandole por parmetro al objeto 'unmsm' de tipo Universidad
new jfrmPrincipal(unmsm).setVisible(true);
}
}
DISEO FINAL DE NUESTRA APLICACIN
Pg. 46
Algortmica II
TAREA
Se pide realizar las siguientes funcionalidades:
1. Validar de manera RIGUROSA el ingreso de datos del Profesor y el ingreso de datos
del Alumno. Por ejemplo: que no se ingresen valores vacos, que la fecha sea en
formato DD/MM/AAAA (DD = DIA [2 dgitos], MM = MES [2 dgitos], AAAA = AO [4
dgitos]).
2. Cambiar el contenido del JComboBox jcmbxCategoria al momento de hacer el ingreso
de datos del alumno. Tener en cuenta que para el alumno se debe mostrar slo las
categoras REGULAR y OBSERVADO. Tener en cuenta que para el profesor se
debe mostrar slo las categoras JEFE DE PRACTICA, AUXILIAR, ASOCIADO y
PRINCIPAL.
3. Cuando se haga clic en la opcin Mostrar Profesor Mostrar Alumno, se debe
mostrar los datos de dicho Profesor Alumno en su respectivo Panel de Ingreso de
Datos.
4. Terminar la implementacin que permita Eliminar un Nodo Alumno. El cdigo se

encuentra en la clase MiArbolSwing, especficamente en el mtodo actionPerformed.
Se recomienda revisar el cdigo que permite Eliminar a un Nodo Profesor.
//Verificamos si se hizo clic en la opcin 'Eliminar Alumno'
if(ae.getSource() == jmnuiEliminarAlumno){
node = (DefaultMutableTreeNode)dmtn.getParent();
//Eliminamos a todos los nodos hijos del Padre
node.removeAllChildren();
}
Pg. 47
Algortmica II
5. Implementar el cdigo que permita Eliminar a un Nodo Profesor que tiene a su vez Uno
o Varios Nodos Alumno. Es decir que si se elimina al Profesor, el programa elimine a
sus alumnos. Por lo tanto ya no existirn dichos alumnos en el arreglo de Personas y
ya no se mostrarn en la tabla de Alumnos.
6. Crear una ventana para la seleccin de la Fecha. Esta ventana deber usarse cuando
se pida ingresar la Fecha de Nacimiento.
Nota: El diseo de la ventana es a libre criterio de cada uno. Verificar si JAVA tiene una
ventana grfica que permita seleccionar una Fecha.
Pg. 48
Algortmica II
7. Crear un archivo .Jar, mediante el cual se pueda EJECUTAR nuestra aplicacin.

Nota: Se pide seguir los estndares de programacin empleados.
Por ejemplo:
- Utilizar acrnimos (jlbl, jtxf, jtxa, etc.) antes de los nombres de las variables.
- Escribir el nombre de los mtodos lo ms descriptible posible, como:
validarIngresoDelCampoCodigoDelFormulario()
- Utilizar referencias en vez de instanciar objetos, cuando sea posible.
- Reutilizar clases creadas en las Guas de Laboratorio anteriores, cumplir con el
principio de NO REINVENTAR LA RUEDA.
Pg. 49

Guia G de Laboratorio

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Guia G de Laboratorio

Transféré par

Droits d'auteur :

Formats disponibles

Universidad Nacional Mayor de San Marcos

Facultad de Ingeniera de Sistemas e Informtica

public String retornarNombreDelDiaDeLaSemana(int dia)

Prof. Arn Elas Herrera Ponte

private ArrayList<Persona> arregloDePersonas;

//Declaracin del nombre del paquete donde se encuentra la clase 'Universidad'

public int retornarPosicionDeLaPersonaEnElArreglo(String codigo){

public String getNombreCorto() {

11. Escribir el siguiente cdigo Java, utilizando un Entorno de Desarrollo

Prof. Arn Elas Herrera Ponte

Notar que se muestra una imagen en el panel. Esta imagen se carga en un

//Mtodo que crea y disea la GUI de este Panel

public void actionPerformed(ActionEvent ae)

Mtodos de la interface MouseListener

//Asignamos caracteristicas al JPopupMenu de la Universidad

//Obtenemos la posicin del objeto de tipo 'Persona' dentro del arreglo

if(nombreNodo.equalsIgnoreCase( universidadRelacionada.getNombreLargo() )){

Prof. Arn Elas Herrera Ponte

DefaultTreeCellRenderer render= (DefaultTreeCellRenderer)miArbolSwing.getCellRenderer();

Prof. Arn Elas Herrera Ponte

Pasos a seguir 10:

jlblFechaDeNacimiento = new JLabel("Fec.Nac.:");

//Verificamos si se hizo clic en el botn 'jbtnGrabarDatos'

Pasos a seguir 11:

Prof. Arn Elas Herrera Ponte

//Declaracion de libreras o paquetes propias del java

Prof. Arn Elas Herrera Ponte

Pasos a seguir 12:

Prof. Arn Elas Herrera Ponte

Pasos a seguir 13:

Prof. Arn Elas Herrera Ponte

public void relacionarLasPestaasConLaTabla(jpanTabla tablaPorReferencia){

public int retornarCantidadDeNodosEnElArregloDeAlumnos(){

Prof. Arn Elas Herrera Ponte

Prof. Arn Elas Herrera Ponte

Pasos a seguir 14:

//que har referencia a cada objeto almacenado en el areglo de Personas

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

Prof. Arn Elas Herrera Ponte

Pasos a seguir 15:

Prof. Arn Elas Herrera Ponte

Pasos a seguir 16:

Prof. Arn Elas Herrera Ponte

//Declaracion de libreras o paquetes propias del java

Prof. Arn Elas Herrera Ponte

4. Terminar la implementacin que permita Eliminar un Nodo Alumno. El cdigo se

Prof. Arn Elas Herrera Ponte

Prof. Arn Elas Herrera Ponte

7. Crear un archivo .Jar, mediante el cual se pueda EJECUTAR nuestra aplicacin.

Prof. Arn Elas Herrera Ponte

Vous aimerez peut-être aussi