Programación Orientada a Aspectos (POA)

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.

 

Curso Práctico de Java - Capítulo Nº 4 (Lección 03)

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

Curso Práctico de Java - Capítulo Nº 4 (Lección 02)

 

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

4.2. TRABAJAR CON IMAGEN E ICONO EN JAVA 

Java incluye una serie de herramientas para insertar imágenes, iconos, videos, sonidos, gráficos y animaciones. En este apartado veremos cómo cargar los objeto Image e ImageIcon a partir del paquete javax.swing para insertar una imagen y un icono en la ventana del menú del proyecto. 

 

4.2.1. Insertar un icono al Menú 

Para cambiar el icono por defecto que inserta Java en el menú principal de la aplicación (clase MenuAdministrador.java), se utilizará el objeto ImageIcon y el método setIconImage, sólo basta con agregar después de la instrucción setResizable(false); la siguiente línea de código: 

//*** Se cambia el icono de la ventana     

setIconImage (new ImageIcon(getClass().getResource("UN.gif")).getImage()); 

Se utilizará para este fin, una imagen de 16 x 16 pixeles, previamente diseñada para la aplicación, en formato gif llamada "UN. gif".

4.2.2. Insertar una imagen en el centro la de pantalla del Menú 

Para insertar una imagen en el menú principal de la aplicación (clase MenuAdministrador.java), se utilizará el objeto ImageIcon, el objeto JLabel y el método add, sólo basta con agregar después de la instrucción del punto anterior la siguiente línea de código: 

//*** Se crea el objeto imagen para colocar una imagen en una etiqueta

//*** Se crea el objeto EtiquetaMenu para colocar la etiqueta con la

//*** imagen en el centro del menú 

ImageIcon imagen = new ImageIcon(getClass().getResource("FondoUN.jpg"));

JLabel EtiquetaMenu = new JLabel(imagen); 

//*** Se agrega la etiqueta con la imagen en la ventana del menú     

add(EtiquetaMenu); 

Se utilizará para este fin una imagen de 800 x 600 pixeles, previamente diseñada para la aplicación, en formato jpg llamada "FondoUN.jpg". 

Al compilar: javac MenuAdministrador.java

Al ejecutar: java MenuAdministrador 

Se obtendrá una ventana como la figura siguiente:

Código fuente y archivos de imágenes aquí: Curso Práctico De Java-01.rar

Guía para la solución del Cubo de Rubik

 

NOTAS PRELIMINARES: 

1.- La pieza del centro de cada cara va a designar el color de toda la cara, por ejemplo: si la pieza del centro de una cara es de color blanco, el color de toda esa cara será al final de color blanco. Si la pieza del centro de una cara es de color verde, el color de toda esa cara será al final de color verde, y así sucesivamente.

 

2.-  Para efectos de esta guía tomaremos en consideración lo siguiente:  

 

- Cara superior (color blanco)

- Cara frontal (color naranja)

- Cara lateral derecha (color verde)

- Cara lateral izquierda (color azul)

- Cara posterior (color rojo)

- Cara inferior (color amarillo)                                                                                                                      

                                                                                   

                           

                 

- Centro (pieza del centro de cada cara)

- Esquina (pieza de las esquinas de cada cara)

- Arista (pieza que no es ni centro ni esquina de cada cara)

 

 

 

  

Para descargar la guía completa pulse el botón DESCARGAR:

Curso Práctico de Java - Capítulo Nº 4

Capítulo Nº 4

Cómo hacer el menú del proyecto  

4.1. HACER UN FORMULARIO EN JAVA 

Toda aplicación de escritorio se maneja a través de menús para mayor comodidad, en este caso se va a desarrollar en Java una clase definida por el usuario llamada MenuAdministrador.java, donde se puedan apreciar todas las opciones que brinda el sistema. 

 

4.1.1. Formulario del Menú Principal 

Para crear el menú nivel administrador con todas las opciones de la aplicación, primero se debe construir un formulario base. En este caso esta ventana tendrá unas dimensiones de 800 pixeles de ancho por 600 pixeles de alto. Para construir formularios en Java se usa la clase JFrame del paquete java.awt. Simplemente se instancia una clase definida por el usuario  a partir de esta clase. Por ejemplo: 

public class MenuAdministrador extends JFrame

Aquí se instancia (crea) una clase pública definida por el usuario llamada MenuAdministrador a partir de la clase JFrame de Java. Esta nueva clase puede tener características propias definidas por el usuario como tamaño, color, formas, iconos, imágenes, etc. 

 

4.1.2. Clase MenuAdministrador.java 

Para hacer el menú principal de la aplicación, primero se debe crear un archivo de texto (clase) llamado MenuAdministrador.java, este archivo debe estar estructurado de la siguiente manera: 

1.- Como cabecera importará los paquetes de clases de Java que se van a utilizar.

2.- Se instanciará la clase a partir de la clase JFrame

3.- Se definirá el método principal (main)

4.- Se declarará el constructor de la clase con las características propias de la clase

5.- Fin de la clase 

 

Cómo se importan los paquetes de Java 

Cuando se crea una clase en Java, como cabecera, se debe colocar la instrucción import para hacer uso de los paquetes de clases de Java. Por ejemplo: 

import java.awt.*; 

Esta instrucción importa toda la librería del paquete Abstract Window Toolkit de Java que contiene las clases e interfaces requerida para crear y manipular GUIs en Java, en este caso para poder usar la clase JFrame para hacer una ventana. 

 

MenuAdministrador.java 

//**************************************************************************

//**** Universidad Nacional Sistema de Inscripción Regular 

//**** (UNSIR 3.0.0)  

//**** CLASE: MenuAdministrador (Para crear el menú nivel administrador 

//**** con todas    las opciones de la aplicación) 

//**** AUTOR: CARLOS CÓRDOVA - CC DESARROLLO DE SOFTWARE 2007-2022  

//***************************************************************************

 

//***************************************************************************

// Paquetes de la librería estándar de clases de Java que 

// se usarán en esta clase

//***************************************************************************

import java.awt.*;

import java.awt.event.*;

import javax.swing.*; 

//***************************************************************************

// Inicio de la clase MenuAdministrador. Se instancia la 

// clase definida por el usuario

// MenuAdministrador a partir de la clase JFrame de Java 

// para crear ventanas

// (paquete java.awt). También se implementa la interface

// ActionListener de Java

// (paquete java.awt.event y paquete javax.swing) para detectar 

// y manejar eventos de acción en esta clase

//*************************************************************************** 

public class MenuAdministrador extends JFrame implements ActionListener

{ 

   //*** Se define el método principal "main" de la Clase

   //*** MenuAdministrador 

   public static void main(String[] args)

   { 

      //*** Se define el aspecto de ventanas propio del sistema

      //*** operativo (windows, Mac, Linux, etc.) 

      try

      {

         UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());

      }     

      catch (Exception e)

      {

         e.printStackTrace();

      } 

      //*** Se ejecuta el constructor MenuAdministrador de la clase 

      new MenuAdministrador();

   }   

   //*** Inicio del constructor MenuAdministrador 

   public MenuAdministrador()

   {

      //*** Se define el título y tamaño de la ventana en pixeles.

      //*** Ancho = 800 Alto = 600 y se inhabilita la función

      //*** redimensionar ventana 

      setTitle("Universidad Nacional: Sistema de Inscripción Regular");

      setBounds( 0, 0, 800, 600 );

      setResizable(false); 

      //*** Se centra la ventana del menú en la pantalla usando 

      //*** la clase Dimension     

      Dimension pantalla, cuadro;

      pantalla = Toolkit.getDefaultToolkit().getScreenSize();

      cuadro = this.getSize();

      this.setLocation(((pantalla.width - cuadro.width)/2),(pantalla.height -

      cuadro.height)/2); 

      //*** Se muestra la ventana (menú) en pantalla     

      setVisible( true ); 

      //*** Captura cuando se quiere cerrar la ventana y ejecuta el método

      addWindowListener(new WindowAdapter()

      {

         public void windowClosing(WindowEvent e)

         {

            CierraVentana();

         }

      });

   }

   //*** Fin del constructor MenuAdministrador 

   //*** Ejecuta el método actionPerformed de la interfaz ActionListener 

   //*** para detectar y manejar eventos de acción 

   public void actionPerformed(ActionEvent e)

   {

      Object s = e.getSource();

   } 

   //*** Método cerrar ventana (menú). Oculta la ventana, libera

   //*** los recursos y termina      

   public void CierraVentana()

   {

      setVisible( false );

      dispose();

      System.exit(0);

   }

} 

//***************************************************************************

// Fin Clase MenuAdministrador

//***************************************************************************

 

Resumen: 

1.- Se define la clase: public class MenuAdministrador extends JFrame

2.- Se define el método principal: public static void main(String[] args)

3.- Se define el tamaño de la ventana: setBounds( 0, 0, 800, 600 );

4.- Se define el método CierraVentana(); para cerrar y finalizar de forma correcta

5.- Fin de la clase  

 

Al compilar: javac MenuAdministrador.java

Al ejecutar: java MenuAdministrador

 

Se obtendrá una ventana como la figura siguiente: