Desde sus comienzos, el desarrollo de software ha estado en constante evolución, y en las últimas décadas han surgido varios paradigmas de programación que han contribuido a hacerlo más eficiente. Cada etapa de la evolución se vio marcada por nuevos enfoques para ayudar a los desarrolladores a manejar programas cada vez más complejos. Los primeros programas se crearon mediante procesos a través de conmutadores ubicados en el panel frontal de la computadora. Este enfoque sólo era adecuado para programas pequeños. Seguidamente se inventó el lenguaje ensamblador que permitió escribir programas más largos, luego otro avance importante ocurrió en los años 50 cuando se inventó el primer lenguaje de alto nivel (FORTRAN) [9]. 

Con los lenguajes de alto nivel, un programador estaba capacitado para escribir programas con una longitud de varios de miles de líneas; sin embargo, este enfoque presentaba el inconveniente de tener un código ilegible y difícil de tratar que se convertía en “código espagueti”. La eliminación del “código espagueti” se consiguió con la creación de los lenguajes de programación estructurados en los años sesenta como Algol y Pascal. Con la programación estructurada se hicieron programas basados en estructuras de control bien definidas, bloques de código, la ausencia (o mínimo uso) de la instrucción GOTO, y subrutinas independientes que soportan recursividad y variables locales [9]. 

Aunque la programación estructurada ha obtenido excelentes resultados cuando se aplica a programas moderadamente complejos, nuevos enfoques que promueven la reutilización futura, reducción de posteriores errores y futuro mantenimiento han aperturado la evolución hacia nuevos paradigmas. A partir de este punto surge la Programación Orientada a Objetos (POO), con lenguajes como SmalTalk y recientemente con lenguajes como C++ y Java, que toma las mejores ideas incorporadas en la programación estructurada y las combina con nuevos y potentes conceptos que permiten organizar los programas de forma más efectiva. La POO permite descomponer un problema en subgrupos relacionados. Cada subgrupo pasa a ser un objeto que contiene sus propias instrucciones y datos, de esta manera la complejidad se reduce y el programador puede tratar programas más largos. Este enfoque cuyas principales características son el encapsulamiento, el polimorfismo y la herencia y cuyos objetivos son la abstracción, la modularidad y la reusabilidad, se consolidó hasta hoy como el último paradigma en el desarrollo de software [9] [10]. 

En este contexto y en la búsqueda de resolver múltiples dificultades presentadas durante el ciclo de vida de desarrollo de software, han surgido durante los últimos años nuevas propuestas entre las que se destaca, el enfoque de Desarrollo de Software Orientado a Aspectos (DSOA) [12]; el cual extiende las técnicas tradicionales de desarrollo y en particular las orientadas a objetos, permitiendo a los desarrolladores encapsular en módulos separados las propiedades comunes o áreas de interés que atraviesan el sistema.  Este nuevo paradigma orientado a aspecto surge a partir de la Programación Orientada a Aspectos (POA) [12]. 

La POA, es un enfoque de programación presentado a finales de 1996 por Gregor Kiczales en el Centro de Investigación de XEROX en Palo Alto [28]  (Palo Alto Research Center o PARC), tratando de solucionar el enmarañamiento del código y la dispersión de conceptos originados en la POO de los sistemas. En particular, la POA introduce un término denominado “Aspecto” para separar  o tratar los diferentes conceptos o puntos de interés que se distribuyen a lo largo del código. Se dice por tanto que la POA no rompe con las técnicas de POO, por el contrario las complementa y extiende [28]. 

En el desarrollo de sistemas de software, el modelado, el diseño y la implementación de la funcionalidad básica, recogen aspectos que en muchos casos no son propios al dominio de la aplicación, pero incrementan su complejidad. Estas funcionalidades apuntan hacia el cumplimiento de requisitos no funcionales e inciden sobre la calidad del producto final. Estas incumbencias generalmente delimitan las condiciones en que el sistema presta servicios a los usuarios y se especifican como seguridad, tolerancia a fallos, persistencia, eficiencia, entre otras. En muchos casos estas incumbencias se entrecruzan a la funcionalidad principal, este problema es referido en la bibliografía como incumbencias transversales (“crosscutting concerns”) [29], dificultando el mantenimiento y evolución del sistema de software. La POA plantea la solución al problema de las incumbencias transversales, sin embargo no está muy claro y definido las tecnologías asociadas a este nuevo paradigma. Ante una diversidad de posiciones y criterios de parte de la comunidad internacional y nacional resulta importante resaltar que para lograr el dominio y posterior adopción del paradigma, se hace necesario estimular estudios tendientes al análisis y desarrollo del conocimiento tecnológico necesario que gira alrededor de la POA. El objetivo de este trabajo es estudiar las tecnologías propias a la POA para el tratamiento de requisitos no funcionales, como un punto de partida que permita consolidar este enfoque como la nueva generación en la evolución de los sistemas de software.

Bibliografía: 

Córdova T., Carlos A. IMPLEMENTACIÓN DE REQUISITOS NO FUNCIONALES A TRAVÉS DE LA PROGRAMACIÓN ORIENTADA A ASPECTOS. Trabajo de Grado UNA. Cumaná, Venezuela. 2007.

 

Capítulo Nº 4 (Lección 03)

4.3. TRABAJAR CON BARRA DE MENÚ EN JAVA 

Los menús forman parte importante en cualquier aplicación. En Java se cuenta con las clases JMenuBar, JMenu y JMenuItem para diseñar menús de opciones. También están otras clases para elementos de menús con checkboxes y radiobotones, en este Curso Práctico se trabajará con JMenuBar, JMenu y JMenuItem, por ser los más comunes. 

 

4.3.1. Crear e insertar una Barra de Menú 

La clase JMenuBar contiene los métodos necesarios para administrar una barra de menú, mientras que JMenu y JMenuItem contienen los métodos necesarios para administrar menús y elementos de menús. 

Para crear una barra de menú en Java, se hace a partir de la clase JMenuBar. Por ejemplo, con la siguiente línea de código se crea el objeto Barra a partir de la clase JMenuBar. 

JMenuBar Barra = new JMenuBar(); 

Para asignar la barra de menú Barra a la ventana creada en el apartado 4.1 de este capítulo, se hace a través del método setJMenuBar: setJMenuBar(Barra); 

 

4.3.2. Crear e insertar un Menú y elementos de Menú 

Para crear un menú en Java, se hace a partir de la clase JMenu. Por ejemplo, con la siguiente línea de código se crea el objeto Archivo con la etiqueta "Archivo" a partir de la clase JMenu. 

JMenu Archivo = new JMenu("Archivo"); 

Para asignar el menú Archivo en la barra de menú Barra, se hace a través del método add: Barra.add(Archivo); 

Para crear un ítem menú en Java, se hace a partir de la clase JMenuItem. Por ejemplo, con la siguiente línea de código se crea el objeto RegistrarAsignaturas con la etiqueta "Asignaturas"a partir de la clase JMenuItem. 

JMenuItem RegistrarAsignaturas = new JMenuItem("Asignaturas"); 

Para asignar el ítem de menú RegistrarAsignaturas al menú Archivo, se hace a través del método add: Archivo.add(RegistrarAsignaturas);

Para crear el menú principal de la aplicación (clase MenuAdministrador.java), sólo basta con agregar después de la instrucción add(EtiquetaMenu); del punto 4.2.2 la siguiente línea de código: 

//*** Se crean los objetos para crear una barra de menú, opciones de menú

//*** en items de menú a partir de las clases de Java: JMenuBar, JMenu y

//*** JMenuItem 

JMenuBar Barra = new JMenuBar(); 

JMenu Archivo = new JMenu("Archivo");

JMenuItem RegistrarAsignaturas = new JMenuItem("Asignaturas");

JMenuItem RegistrarPensum = new JMenuItem("Pensum");

JMenuItem Salir = new JMenuItem("Salir"); 

JMenu Estudiantes = new JMenu("Estudiantes");

JMenuItem RegistrarEstudiante = new JMenuItem("Registrar datos estudiante...");

JMenuItem CambiarEstudiante = new JMenuItem("Cambiar datos estudiante...");

JMenuItem EliminarEstudiante = new JMenuItem("Eliminar datos estudiante...");

JMenuItem ConsultarEstudiante = new JMenuItem("Consultar estudiantes..."); 

JMenu Historico = new JMenu("Histórico");

JMenuItem HistoricoCalificaciones = new JMenuItem

      ("Histórico calificaciones estudiante...");

JMenuItem ConsultarHistorico = new JMenuItem("Consultar histórico estudiante..."); 

JMenu Inscripciones = new JMenu("Inscripciones");

JMenuItem SeleccionarAsignaturas = new JMenuItem

      ("Seleccionar asignaturas de estudiante..");

JMenuItem RegistrarInscripción = new JMenuItem

      ("Registrar y validar inscripción de estudiante...");

JMenuItem ConsultarInscripciones = new JMenuItem

      ("Consultar estudiantes inscritos..."); 

JMenu UsuariosSistema = new JMenu("Usuarios");

JMenuItem RegistrarUsuario = new JMenuItem("Registrar usuario y contraseña...");

JMenuItem CambiarUsuario = new JMenuItem("Cambiar usuario y contraseña...");

JMenuItem EliminarUsuario = new JMenuItem("Eliminar usuario y contraseña...");

JMenuItem ConsultarUsuario = new JMenuItem("Consultar usuarios..."); 

JMenu Ayuda = new JMenu("Ayuda");

JMenuItem AyudaGeneral = new JMenuItem("Ayuda general...");

JMenuItem Acercade = new JMenuItem("Acerca de..."); 

//*** Se asigna la barra de menú a través del método setJMenuBar y se le

//*** agregan las opciones definidas anteriormente     

setJMenuBar(Barra); 

Barra.add(Archivo);

Archivo.add(RegistrarAsignaturas);

Archivo.add(RegistrarPensum);

Archivo.addSeparator();

Archivo.add(Salir); 

Barra.add(Estudiantes);

Estudiantes.add(RegistrarEstudiante); 

Estudiantes.add(CambiarEstudiante);

Estudiantes.add(EliminarEstudiante);

Estudiantes.add(ConsultarEstudiante); 

Barra.add(Historico);

Historico.add(HistoricoCalificaciones);

Historico.add(ConsultarHistorico); 

Barra.add(Inscripciones);

Inscripciones.add(SeleccionarAsignaturas);

Inscripciones.add(RegistrarInscripción);

Inscripciones.add(ConsultarInscripciones); 

Barra.add(UsuariosSistema);

UsuariosSistema.add(RegistrarUsuario);

UsuariosSistema.add(CambiarUsuario);

UsuariosSistema.add(EliminarUsuario);

UsuariosSistema.add(ConsultarUsuario); 

Barra.add(Ayuda);

Ayuda.add(AyudaGeneral);

Ayuda.add(Acercade);     

//*** Se asignan las teclas calientes a las opciones del menú     

Archivo.setMnemonic('A'); 

RegistrarAsignaturas.setMnemonic('n');

RegistrarPensum.setMnemonic('P');

Salir.setMnemonic('S'); 

Estudiantes.setMnemonic('E'); 

RegistrarEstudiante.setMnemonic('R');

CambiarEstudiante.setMnemonic('C');

EliminarEstudiante.setMnemonic('m');

ConsultarEstudiante.setMnemonic('o'); 

Historico.setMnemonic('H'); 

HistoricoCalificaciones.setMnemonic('n');

ConsultarHistorico.setMnemonic('C'); 

Inscripciones.setMnemonic('I'); 

SeleccionarAsignaturas.setMnemonic('S');

RegistrarInscripción.setMnemonic('R');

ConsultarInscripciones.setMnemonic('C'); 

UsuariosSistema.setMnemonic('s'); 

RegistrarUsuario.setMnemonic('R');

CambiarUsuario.setMnemonic('C');

EliminarUsuario.setMnemonic('E');

ConsultarUsuario.setMnemonic('o'); 

Ayuda.setMnemonic('u'); 

AyudaGeneral.setMnemonic('A');

Acercade.setMnemonic('c'); 

//*** Se asignan los Textos Tips a las opciones del menú     

RegistrarAsignaturas.setToolTipText("Tabla de asignaturas");

RegistrarPensum.setToolTipText("Tabla de pensum por carrera");

Salir.setToolTipText("Salir de la aplicación"); 

RegistrarEstudiante.setToolTipText

      ("Registrar los datos personales del estudiante");

      CambiarEstudiante.setToolTipText("Cambiar los datos personales del estudiante");

EliminarEstudiante.setToolTipText("Eliminar los datos personales del estudiante");

ConsultarEstudiante.setToolTipText("Consultar listado de estudiantes"); 

HistoricoCalificaciones.setToolTipText

      ("Histórico de calificaciones del estudiante");

ConsultarHistorico.setToolTipText

      ("Consultar el histórico de calificaciones del estudiante"); 

SeleccionarAsignaturas.setToolTipText

      ("Oferta de asignaturas para la inscripción del estudiante");

RegistrarInscripción.setToolTipText

      ("Registrar y validar la inscripción del estudiante");

ConsultarInscripciones.setToolTipText

      ("Consultar las inscripciones que han sido validadas"); 

RegistrarUsuario.setToolTipText("Registra los datos de un usuario en el sistema");

CambiarUsuario.setToolTipText("Cambia los datos de un usuario en el sistema");

EliminarUsuario.setToolTipText("Elimina un usuario del sistema");

ConsultarUsuario.setToolTipText("Consultar los usuario del sistema"); 

AyudaGeneral.setToolTipText("Muestra la ayuda general");

Acercade.setToolTipText("Muestra el diálogo acerca de..."); 

//*** Eventos producidos por las opciones del menú 

//*** Cuando se pulsa la opción "Salir" ejecuta el método "CierraVentana" 

Salir.addActionListener(new ActionListener()

{

   public void actionPerformed(ActionEvent evt)

   {

   //*** Se ejecuta el método CierraVentana

          

   CierraVentana();

   }

}); 

Al compilar: javac MenuAdministrador.java

Al ejecutar: java MenuAdministrador 

Se obtendrá una ventana como la figura siguiente:

Código fuente aquí: Curso Práctico De Java-02.rar