1Modelo visto Controlador e
Interfaz Gráfica de Usuario
Fernandez Cruz Ivan de Jesus
Parrazal Triana Gael Alessandro
Centro de Bachillerato Tecnológico Industrial y de Servicios #79 “Maria Soto la Marina”
3°A Programación
Aplica la Metodología Espiral con Programación Orientada a Objetos
Introducción ii
Dentro de esta investigación recopilatoria encontraremos temas como, el Modelo-
Vista-Controlador (MVC) el cual es un patrón de diseño esencial en el desarrollo de aplicaciones
Java con interfaces gráficas de usuario (GUI) utilizando la biblioteca Swing. En este aspecto, la
GUI se compone de componentes Swing, como botones y campos de texto, organizados en
contenedores. Los eventos, como clics de ratón, desencadenan acciones. MVC separa la
aplicación en tres partes: el Modelo, que administra los datos y la lógica oculta; la Vista,
encargada de la presentación visual de la GUI; y el Controlador, que maneja las interacciones del
usuario y mantiene la comunicación entre el Modelo y la Vista. Esta organización clara y
modular facilita el desarrollo y el mantenimiento de aplicaciones Java con GUI eficientes y
flexibles. Espero esta investigación sea de su agrado, Gracias.
Tabla de Contenidos iii
Capítulo 1 Modelo Vista Controlador.................................................................................1
Definición........................................................................................................................1
Ventajas y Desventajas del Uso del Patrón.....................................................................2
Ventajas.......................................................................................................................2
Desventajas..................................................................................................................3
Funcionamiento...............................................................................................................4
Capítulo 2 Interfaz Grafica de Usuario.............................................................................10
Componentes swing.......................................................................................................11
Clasificacion de los componentes..............................................................................12
Contenedores.................................................................................................................17
Window......................................................................................................................19
Frame.........................................................................................................................20
Dialog........................................................................................................................21
Panel..........................................................................................................................21
Eventos..........................................................................................................................23
Tipos de Eventos........................................................................................................23
Eventos definidos por los componentes....................................................................24
Capítulo 3 Conclusion......................................................................................................27
Lista de Referencias...........................................................................................................28
Lista de figuras iv
Figura 1. Imagen Concepto MVC.......................................................................................2
Figura 2. Creación Paquetería Controller............................................................................4
Figura 3. Código que agregar a la clase Modelo.................................................................5
Figura 4. Diseño de la Interfaz............................................................................................6
Figura 5. Código que agregar a la clase Controller.. 7
Figura 6. Código que agregar a la clase Principal...............................................................8
Figura 7. Interfaces del programa........................................................................................9
Figura 8. Imagen Concepto de GUI.................................................................................. 11
Figura 9. Contenedores Java Swing.................................................................................. 13
Figura 10. Componentes Atómicos Java Swing............................................................... 14
Figura 11. Componentes de Texto Java Swing................................................................ 15
Figura 12. Componentes de Menú Java Swing................................................................ 16
Figura 13. Ejemplo de Window........................................................................................ 19
Figura 14. Ejemplo de Frame........................................................................................... 20
Figura 15. Ejemplo de Dialog........................................................................................... 21
Figura 16. Ejemplo de Panel............................................................................................. 22
Figura 17. Imagen Concepto de Evento........................................................................... 23
Figura 18. Eventos JFrame............................................................................................... 24
Figura 19. Eventos JLabel................................................................................................ 25
Figura 20. Eventos JTextField.......................................................................................... 25
Figura 21. Eventos JButton............................................................................................... 26
1
Capítulo 1
Modelo Visto Controlador
Definición
El patrón MVC (Modelo, Vista, Controlador), es un patrón de arquitectura de
software que separa los datos de una aplicación, la interfaz que ve el usuario de la lógica
del negocio en tres componentes distintos. Es más frecuente en aplicaciones Web que en
aplicaciones de escritorio, sin embargo, es aplicable también a este, sin ningún problema,
Java ya contaba hace rato con Observer y Observable, herramientas que nos ayudan a la
interacción entre la interfaz y el modelo, sin embargo, el ejemplo que dejamos a
continuación no hace uso de estas herramientas.
La descripción del patrón MVC es:
Vista (View): Representa la interfaz de usuario y todas las herramientas con las
cuales el usuario hace uso del programa.
Modelo (Model): Es donde esta toda la lógica del negocio, la representación de
todo el sistema incluido la interacción con una base de datos, si es que el
programa así lo requiere.
Controlador (Controller): Este componente es el que responde a la interacción
(eventos) que hace el usuario en la interfaz y realiza las peticiones al modelo para
pasar estos a la vista. Aún no está del todo claro, pero con el siguiente ejemplo, lo
comprenderemos mejor.
2
Figura 1. Imagen Concepto MVC.
Ventajas y desventajas del uso del patrón
Ventajas:
La implementación se realiza de forma modular.
Sus vistas muestran información actualizada siempre. El programador no debe
preocuparse de solicitar que las vistas se actualicen, ya que este proceso es
realizado automáticamente por el modelo de la aplicación.
Cualquier modificación que afecte al dominio, como aumentar métodos o datos
contenidos, implica una modificación sólo en el modelo y las interfaces del
mismo con las vistas, no todo el mecanismo de comunicación y de actualización
entre modelos.
Las modificaciones a las vistas no afectan al modelo de dominio, simplemente
se modifica la representación de la información, no su tratamiento.
3
MVC esta demostrando ser un patrón de diseño bien elaborado pues las
aplicaciones que lo implementan presentan una extensibilidad y una
mantenibilidad únicas comparadas con otras aplicaciones basadas en otros
patrones.
Desventajas:
Para desarrollar una aplicación bajo el patrón de diseño MVC es necesario una
mayor dedicación en los tiempos iniciales del desarrollo. Normalmente el
patrón exige al programador desarrollar un mayor número de clases que, en
otros entornos de desarrollo, no son necesarias. Sin embargo, esta desventaja
es muy relativa ya que posteriormente, en la etapa de mantenimiento de la
aplicación, una aplicación MVC es mucho más mantenible, extensible y
modificable que una aplicación que no lo implementa.
MVC requiere la existencia de una arquitectura inicial sobre la que se deben
construir clases e interfaces para modificar y comunicar los módulos de una
aplicación. Esta arquitectura inicial debe incluir, por lo menos, un mecanismo
de eventos para poder proporcionar las notificaciones que genera el modelo de
aplicación; una clase Modelo, otra clase Vista y una clase Controlador
genéricas que realicen todas las tareas de comunicación, notificación y
actualización que serán luego transparentes para el desarrollo de la aplicación.
MVC es un patrón de diseño orientado a objetos por lo que su implementación
es sumamente costosa y difícil en lenguajes que no siguen este paradigma.
4
Funcionamiento
Para entender mejor el funcionamiento del MVC, utilizaremos un ejemplo
práctico, mediante el cual se comprende la función del MVC.
1. Crea un nuevo proyecto en netbeans, para este ejemplo, el proyecto se llama
"jc_mvc_demo". Crea una estructura de paquetes (Controller, Model, View),
hacemos esto para separar cada componente, ser más organizados. Debes
tener algo como esto.
Figura 2. Creación Paquetería Controller.
2. Empecemos creando la lógica de la aplicación, crea una nueva clase en el
paquete Model, llámalo "modelo.java" y añade el siguiente código:
5
Figura 3. Código que agregar a la clase Modelo.
Como vemos, nuestra modelo es sencillo, es nada más que la suma de dos valores
enteros, con sus respectivos métodos. continuemos.
3. Diseñemos ahora la interfaz de usuario, nuestra VISTA. Añade un JFrame al
paquete VIEW, llamalo "vista.java", OJO los recuadros marcados con rojo,
son los componentes que tendrán interacción con el modelo, asi que para
evitar confusiones, es mejor renombrarlos, coloca los nombres tal como se
ven en la imagen de abajo.
6
Figura 4. Diseño de la interfaz.
Netbeans, al añadir objetos a nuestro JFrame, automáticamente los coloca como
PRIVATE, debemos cambiar esto, para ello selecciona el objeto "vtxt1" y ve a sus
propiedades, en la pestaña CODIGO, elige el campo MODIFICADORES DE
VARIABLE, en la ventana que sale, cambia el atributo PRIVATE, por PUBLIC y dale a
aceptar. Repite esta acción para todos los objetos que están marcados con rojo en la
imagen anterior.
4. Ahora continuamos con el CONTROLADOR de nuestra aplicación, crea una
clase "controlador.java" en el paquete CONTROLLER, el Código que debes
colocar, es:
7
Figura 5. Código que agregar en la clase Controller.
Explicación: nuestra clase controlador, implementa el ActionListener, esto para
responder desde esta clase, los eventos realizados desde la interfaz (VISTA), además en
el constructor de la clase, vemos que se pasan como parámetros, la clase VISTA y la
clase MODELO, nuestra clase además cuenta las funciones, INICIAR() la cual inicializa
los valores de la interfaz, como ser el atributo título del JFrame, posicionamiento en
pantalla, valores iniciales de los jtextbox, etc. tambien tenemos el método actión
performed el cual captura el evento realizado desde la interfaz, en nuestro ejemplo es solo
un CLICK EN EL BOTON DE MENU CMDSUMAR, obtiene los datos
correspondientes e invoca al modelo para procesar la información y obtener una
8
respuesta. Pues bueno, eso es todo, fíjese como la interfaz para llegar al modelo, pasa por
el controlador y viceversa, cuando el modelo necesita mostrar un dato, pasa por el
controlador hasta llegar a la vista, esto claro no es una regla, puedes buscar en google y
encontraras varias variaciones de este modelo.
5. Para terminar, debemos implementar todo esto en nuestro main.java:
Figura 6. Código que agregar a la clase Principal.
Finalmente, al ejecutar el programa se muestran las siguientes interfaces dentro
del programa.
9
Figura 7. Interfaces del programa.
El patrón MVC, nos permite cambiar la interfaz de usuario (VISTA), sin tocar en
lo absoluto el MODELO de la aplicación, y realizar pequeños cambios en el controlador,
mínimos cambios, como podemos observar en la imagen superior, tenemos la interfaz 1,
la cual creamos en este tutorial, y además una segunda interfaz, totalmente distinta, sin
embargo, funciona bajo el mismo MODELO
10
Capítulo 2
Interfaz Gráfica de Usuario
La GUI es una interfaz entre la persona y la máquina. El objetivo de esta interfaz
gráfica es representar el código del backend de un sistema de la forma más clara posible
para el usuario para simplificarle las tareas diarias. Para esto, son muy importantes los
iconos y las imágenes, ya que solo estos permiten una aplicación universal e
independiente del texto. Por ejemplo, casi todo el mundo sabe cómo es un icono de wifi,
mientras que la palabra varía mucho en los distintos idiomas.
La GUI es una interfaz de usuario que permite a los usuarios comunicarse con el
ordenador. Suele estar basada en la interacción a través del ratón y el teclado (aunque el
control a través de gestos es cada vez más común): al mover el ratón, el puntero se
desplaza en la pantalla. La señal del dispositivo se transmite al ordenador, que luego la
traduce en un movimiento equivalente en la pantalla. Por ejemplo, si un usuario hace clic
en un determinado icono de programa en el menú, se ejecuta la instrucción
correspondiente y se abre el programa.
La GUI es, por lo tanto, una especie de traductor en la comunicación entre el
humano y la máquina. Sin la GUI, tendrías que utilizar la línea de comandos para llamar
a programas y aplicaciones. Esto podría representarse así (el ejemplo muestra cómo abrir
el explorador):
11
Figura 8. Imagen Concepto GUI.
Componentes swing.
El paquete Swing es parte de la JFC (Java Foundation Classes) en la plataforma
Java. La JFC provee facilidades para ayudar a la gente a construir GUIs. Swing abarca
componentes como botones, tablas, marcos, etc.
Las componentes de Swing utilizan la infraestructura de AWT, incluyendo el
modelo de eventos AWT, el cual rige cómo una componente reacciona a eventos tales
como, eventos de teclado, mouse, etc... Es por esto, que la mayoría de los programas
Swing necesitan importar dos paquetes AWT: java.awt.* y java.awt.event.*.
Los componentes gráficos son estos elementos que permiten brindar una
interacción con el usuario del sistema. Cada componente corresponde a una clase en Java,
por esta razón cuando desarrollamos y queremos vincular uno de estos elementos
simplemente instanciamos la clase que necesitamos, es decir, si queremos un Área de
texto debemos crear un objeto de la clase JTextArea.
12
Clasificación de los componentes
A continuación, se explican brevemente cada uno de los componentes acorde a su
clasificación:
Contenedores:
Un contenedor es el tapiz donde pintaremos nuestros componentes gráficos,
existen contenedores principales, entre estos se encuentran JFrame y JDialog, pero
también existen otros contendedores incluidos dentro de los mencionados.
JFrame – Es la Ventana de aplicación, el contenedor principal
JDialog – Una ventana de tipo Ventana de diálogo, también puede ser un
contenedor principal.
JPanel – Permite la creación de paneles independientes donde se almacenan
otros componentes.
JScrollPane – permite la vinculación de barras de desplazamiento en un
contenedor.
JSplitPane – permite la creación de un contenedor dividido en 2 secciones.
JTabbedPane – Permite la creación de pestañas, cada pestaña representa un
contenedor independiente.
JDesktopPane – Permite crear ventanas dentro de una ventana principal
JToolBar – Permite introducir una Barra de herramientas
13
Figura 9. Contenedores Java Swing
Componentes Atómicos:
Los componentes atómicos son los elementos que no pueden almacenar otros
objetos o componentes gráficos, por ejemplo, un JPanel no es Atómico, ya que en el
podemos almacenar JButtons, JTextField entre otros.
JLabel – Permite Vincular Etiquetas, tanto de texto como de imágenes
JButton – Permite vincular Botones simples.
JCheckBox – Son Casilla de verificación, ideal para selección múltiples.
JRadioButton – Permite presentar opciones de selección similares a las
checkbox, solo que el enfoque de estas es de única selección.
JToggleButton – Botón que al oprimirlo se quedará presionado hasta que
se ejecute otro evento.
JComboBox – Permite mostrar una lista de elementos como un combo de
selección.
14
JScrollBar – Permite mostrar una barra de desplazamiento, regularmente
usada en Áreas de texto o paneles donde el contenido es mayor que el
tamaño del componente.
JSeparator – Permite separar opciones, es una barra simple.
JSlider - Permite vincular un Deslizador en nuestra ventana.
JSpinner – permite vincular una caja de texto con botones integrados para
seleccionar algún valor.
JProgressBar – Establece una barra de progreso.
Figura 10. Componentes Atómicos Java Swing.
Componentes de texto:
Son todos aquellos que nos permiten procesar cadenas de texto, sea como entrada
o salida de información.
JTextField – Permite introducir un campo de texto simple.
15
JFormattedTextField – Permite introducir un campo de texto con
formato, (si definimos que solo recibe números no permitirá letras...)
JPasswordField – Campo de texto que oculta los caracteres ingresados.
JTextArea – Permite vincular un área de texto donde el usuario ingresara
información o simplemente para presentar cadenas de texto.
JEditorPane –Permite vincular un área de texto con propiedades de
formato.
JTextPane – Similar al anterior, permitiendo otras opciones de formato,
colores, iconos entre otros.
Figura 11. Componentes de Texto Java Swing.
Componentes de menús:
Estos componentes permiten vincular opciones de menú en nuestras ventanas,
tipo menú principal, como por ejemplo el conocido Inicio, Archivo, Edición etc.
16
JMenuBar – Permite vincular una barra de menús.
JMenu– Permite vincular botones o enlaces que al ser pulsados
despliegan un menú principal.
JMenuItem – Botón u opción que se encuentra en un menú.
JCheckBoxMenuItem– Elemento del menú como opciones de checkbox.
JRadioButtonMenuItem– Elemento del menú como botón de selección.
JPopupMenu– Opciones de menú emergentes.
Figura 12. Componentes de Menú Java Swing.
Componentes complejos:
Estos son componentes un poco más avanzados, cumplen con funciones más
enfocadas a procesos específicos y complejos, como por ejemplo obtener gran cantidad
de información de una base de datos, trabajo con nodos, colores entre otros.
JTable – Permite vincular una tabla de datos con sus respectivas filas y
columnas.
17
JTree - Carga un árbol donde se establece cierta jerarquía visual, tipo
directorio.
JList – Permite cargar una lista de elementos, dependiendo de las
propiedades puede tenerse una lista de selección múltiple.
JFileChooser – Es un componente que permite la búsqueda y selección de
ficheros entre otras.
JColorChooser – Componente que permite cargar un panel selector de
color
JOptionPane – No es algo complejo sino más un componente
independiente que permite mostrar un cuadro de diálogo personalizable.
Contenedores
Los contenedores permiten generar la estructura de una ventana y el espacio
donde se muestra el resto de los componentes contenidos en ella y que conforman la
interfaz de usuario. Los contenedores de alto nivel más utilizados de Swing son:
La clase JFrame, que proporciona una ventana principal de aplicación con
su funcionalidad normal (por ejemplo, borde, título, menús) y un panel de
contenido.
La clase JDialog proporciona una ventana de diálogo auxiliar en una
aplicación, normalmente utilizada para pedir datos al usuario o configurar
elementos.
18
La clase Container es una clase abstracta derivada de Component, que representa
a cualquier componente que pueda contener otros componentes. Se trata, en esencia, de
añadir a la clase Component la funcionalidad de adición, sustracción, recuperación,
control y organización de otros Componentes.
Al igual que la clase Component, no dispone de constructores públicos y, por lo
tanto, no se pueden instanciar objetos de la clase Container. Sin embargo, sí se puede
extender para implementar la nueva característica incorporada a Java en el JDK 1.1, de
los componentes Lightweight.
El AWT proporciona varias clases de Contenedores:
Panel
Applet
ScrollPane
Window
Dialog
FileDialog
Frame
19
Aunque los que se pueden considerar como verdaderos Contenedores con
Window, Frame, Dialog y Panel, porque los demás son subtipos con algunas
características determinadas y solamente útiles en circunstancias muy concretas.
Window:
Es una superficie de pantalla de alto nivel (una ventana). Una instancia de la clase
Window no puede estar enlazada o embebida en otro Contenedor.
El controlador de posicionamiento de Componentes por defecto, sobre un objeto
Window, es el BorderLayout.
Una instancia de esta clase no tiene ni título ni borde, así que es un poco difícil de
justificar su uso para la construcción directa de un interfaz gráfico, porque es mucho más
sencillo utilizar objetos de tipo Frame o Dialog. Dispone de varios métodos para alterar el
tamaño y título de la ventana, o los cursores y barrar de menús.
Figura 13. Ejemplo de Window.
20
Frame:
Es una superficie de pantalla de alto nivel (una ventana) con borde y título. Una
instancia de la clase Frame puede tener una barra de menú. Una instancia de esta clase es
mucho más aparente y más semejante a lo que se entiende por ventana.
Y, a no ser que el lector haya comenzado su estudio por esta página, ya se habrá
encontrado en varias ocasiones con la clase Frame, que es utilizada en gran parte de los
ejemplos de este Tutorial. Su uso se debe en gran parte a la facilidad de su instanciación
y, lo que tampoco deja de ser interesante, su facilidad de conclusión.
La clase Frame extiende a la clase Window, y su controlador de posicionamiento
de Componentes por defecto es el BorderLayout.
Figura 14. Ejemplo de Frame.
Dialog:
21
Es una superficie de pantalla de alto nivel (una ventana) con borde y título, que
permite entradas al usuario. La clase Dialog extiende la clase Window, que extiende la
clase Container, que extiende a la clase Component; y el controlador de posicionamiento
por defecto es el BorderLayout.
De los constructores proporcionados por esta clase, destaca el que permite que el
diálogo sea o no modal. Todos los constructores requieren un parámetro Frame y,
algunos de ellos, permiten la especificación de un parámetro booleano que indica si la
ventana que abre el diálogo será modal o no.
Figura 15. Ejemplo de Dialog.
Panel:
La clase Panel es un Contenedor genérico de Componentes. Una instancia de la
clase Panel, simplemente proporciona un Contenedor al que ir añadiendo Componentes.
El controlador de posicionamiento de Componentes sobre un objeto Panel, por
defecto es el FlowLayout; aunque se puede especificar uno diferente en el constructor a la
22
hora de instanciar el objeto Panel, o aceptar el controlador de posicionamiento
inicialmente, y después cambiarlo invocando al método setLayout().
Panel dispone de un método addNotify(), que se utiliza para crear un observador
general (peerPerr) del Panel. Normalmente, un Panel no tiene manifestación visual
alguna por sí mismo, aunque puede hacerse notar fijando su color de fondo por defecto a
uno diferente del que utiliza normalmente.
Figura 16. Ejemplo de Panel.
23
Eventos.
Los eventos son acciones o sucesos que se generan en aplicaciones gráficas
definidas en los componentes y ocasionado por los usuarios, como presionar un botón ,
ingresar un texto, cambiar de color, etc.
Los eventos les corresponden a las interacciones del usuario con los
componentes
Los componentes están asociados a distintos tipos de eventos
Un evento será un objeto que representa un mensaje asíncrono que tiene
otro objeto como destinatario
Figura 17. Imagen Concepto de Evento.
Tipos de eventos:
ActionEvent : generado por activación de componentes
AdjustmentEvent : generado por ajuste de componentes ajustables como barras
de desplazamiento
24
ContainerEvent : generado cuando los componentes se agregan o se quitan de
un contenedor
FocusEvent : generado cuando un componente entra o sale del foco
ItemEvent : generado cuando un artículo se selecciona de una lista, opción, o
caja de chequeo
KeyEvent : generado por actividad del teclado
MouseEvent : generado por actividad del ratón
PaintEvent : generado cuando un componente se pinta
TextEvent : generado cuando un componente del texto se modifica
WindowEvent : generado por actividad de la ventana (como cerrar, abrir,
minimizar).
Eventos definidos de los componentes:
Eventos de JFrame:
Figura 18. Eventos JFrame.
25
Eventos de JLabel
Figura 19. Eventos JLabel.
Eventos de JTextField
Figura 20. Eventos JTextField.
26
Eventos de JButton
Figura 21. Eventos JButton.
27
Capítulo 3
Conclusión
Para concluir, en resumen, el uso del patrón Modelo-Vista-Controlador (MVC) en
el desarrollo de aplicaciones Java con interfaz gráfica de usuario (GUI) y la utilización de
componentes Swing, contenedores y eventos son fundamentales para crear aplicaciones
amplias y fáciles de mantener. El MVC permite una clara separación de
responsabilidades, mejorando la organización y progreso del código. Los componentes
Swing proporcionan una amplia variedad de elementos para diseñar interfaces visuales
atractivas y funcionales. Los contenedores ayudan a organizar estos componentes de
manera eficiente. Los eventos permiten la interacción del usuario y la respuesta adecuada.
En conjunto, estos conceptos y herramientas hacen posible el desarrollo de aplicaciones
Java GUI sofisticadas y amigables, adecuadas para una amplia gama de aplicaciones.
Gracias.
28
Lista de referencias
Google Code Archive - long-term storage for Google Code project hosting. (s. f.). Patrón
MVC de Java con netBeans. Recuperado de:
https://code.google.com/archive/p/gestion-matricula/wikis/MVC.wiki
Patrón Modelo Vista Controlador | Marco de Desarrollo de la Junta de Andalucía. (s. f.).
Patrón Modelo Vista Controlador. Recuperado de:
https://www.juntadeandalucia.es/servicios/madeja/contenido/recurso/122
Equipo editorial de IONOS. (2021, 28 enero). ¿Qué es una interfaz gráfica de usuario
(GUI)? IONOS Digital Guide. Recuperado de:
https://www.ionos.mx/digitalguide/paginas-web/desarrollo-web/que-es-una-gui/ .
Henao, C. (s. f.). Componentes Java Swing. Recuperado de:
https://codejavu.blogspot.com/2013/09/componentes-java-swing.html
Swing, (s. f.). Swing, la solución actual de Java para crear GUIs. Recuperado de:
https://users.dcc.uchile.cl/~lmateu/CC60H/Trabajos/edavis/swing.html#:~:text=L
as%20componentes%20de%20Swing%20utilizan,importar%20dos%20paquetes
%20AWT%3A%20java.
Tutorial de Java - AWT (Contenedores). (s. f.). Java AWT. Recuperado de:
https://dis.um.es/~bmoros/Tutorial/parte13/cap13-5.html
De Gorka Elorduy, V. T. L. E. (2016, 6 octubre). Contenedores y componentes en Java.
Java a tu alcance. Recuperado de:
https://javaparajavatos.wordpress.com/2016/10/06/contenedores-y-componentes-
en-java/
Eventos en java. (2018, 13 octubre). PROGRAMACION. Recuperado de:
https://victomanolo.wordpress.com/eventos-en-java/
