TECNOLÓGICO DE ESTUDIOS SUPERIORES DE SAN FELIPE DEL PROGRESO

DIVISIÓN DE INGENIERÍA INFORMÁTICA

Prácticas de apoyo para programación

Septiembre-enero 2022

ING. Luis Angel González Flores

Septiembre 30
 Índice
Índice de ilustraciones ....................................................................................................................................... 3
Práctica 1: Nombre “ Clase libro” .................................................................................................................. 7
Práctica 2: “ Uso de arraylist con clases y tablas” ....................................................................................... 11
Práctica 3: Nombre “ Vista con método para validar casillas vacías” Código ASCII” ................................... 17
Práctica 4: Nombre “ Vista con método para validar datos ingresados” ...................................................... 21
Práctica 5: Nombre “ Modificaciones, eliminaciones de aarraylist con formularios” ..................................... 25
Practica 6: Nombre “ Uso del evento keylistener para validar casillas” ........................................................ 31
Práctica 7: Juego Gato................................................................................................................................. 33
Práctica 8: Juego Buscaminas ..................................................................................................................... 42
Práctica 9: Juego Piedra Papel o Tijeras...................................................................................................... 56
Práctica 10: Telégrafo .................................................................................................................................. 60
Práctica 11: Sudoku ..................................................................................................................................... 64
Práctica 12: Cuadro mágico ......................................................................................................................... 70
Práctica 13:Juego Black Jack ...................................................................................................................... 76
 Índice de ilustraciones
Ilustración 1: Creación del proyecto _____________________________________________________________________________ 7
Ilustración 2: Estructura general del proyecto______________________________________________________________________ 7
Ilustración 3: Clase libro ______________________________________________________________________________________ 8
Ilustración 4: Diseño de la interface de vista _______________________________________________________________________ 8
Ilustración 5: Código de la clase ControladorL _____________________________________________________________________ 9
Ilustración 6: Continuación de la clase ControladorL _______________________________________________________________ 9
Ilustración 7: Codigo de la clase Main ____________________________________________________________________________ 9
Ilustración 8: funcionalidad del programa ________________________________________________________________________ 10
Ilustración 9: Estructura del proyecto ___________________________________________________________________________ 11
Ilustración 10: Estructura del proyecto __________________________________________________________________________ 11
Ilustración 11: Código de la clase libro __________________________________________________________________________ 11
Ilustración 12: continuación Código anterior _____________________________________________________________________ 12
Ilustración 13: Vista del Jframe ________________________________________________________________________________ 12
Ilustración 14: Importación de vistas y modelos. ___________________________________________________________________ 12
Ilustración 15: Constructor de nuestro objeto inicial de la clase controlador ____________________________________________ 13
Ilustración 16: Método que permite llenar la tabla con los datos alojados en el arrayList de objetos libro_____________________ 13
Ilustración 17. implementación de la clase ActionListener ___________________________________________________________ 13
Ilustración 18: código en el que se evalúa sobre que botón se hizo clic _________________________________________________ 14
Ilustración 19: Clase main ____________________________________________________________________________________ 14
Ilustración 20: Ingreso al programa _____________________________________________________________________________ 15
Ilustración 21: Ingreso de nuevo libro ___________________________________________________________________________ 15
Ilustración 22: Creación del proyecto ___________________________________________________________________________ 17
Ilustración 23: Estructura del proyecto __________________________________________________________________________ 17
Ilustración 24: Clase del objeto libro ____________________________________________________________________________ 18
Ilustración 25: Diseño de la interface de vista _____________________________________________________________________ 18
Ilustración 26: Código de la clase controlador ____________________________________________________________________ 19
Ilustración 27: Continuación del Código de la clase controlador______________________________________________________ 19
Ilustración 28: Código de la clase Main __________________________________________________________________________ 20
Ilustración 29: Validacion de casillas vacías ______________________________________________________________________ 20
Ilustración 30: Funcionalidad del programa ______________________________________________________________________ 20
Ilustración 31:Creación del proyecto ____________________________________________________________________________ 21
Ilustración 32: Estructura del proyecto __________________________________________________________________________ 21
Ilustración 33: Clase del objeto libro ____________________________________________________________________________ 22
Ilustración 34: Diseño de la interface de vista _____________________________________________________________________ 22
Ilustración 35: Código de la clase controlador ____________________________________________________________________ 23
Ilustración 36: Continuación de la clase controlador _______________________________________________________________ 23
Ilustración 37: Continuación del Código de la clase controlador______________________________________________________ 24
Ilustración 38: Fin del código clase controlador ___________________________________________________________________ 24
Ilustración 39: Creación de proyecto nuevo_______________________________________________________________________ 25
Ilustración 40: Estructura del proyecto __________________________________________________________________________ 25
Ilustración 41: Clase del objeto libro ____________________________________________________________________________ 26
Ilustración 42: Diseño de la interface de vista _____________________________________________________________________ 27
Ilustración 43: Código de la clase controladorL ___________________________________________________________________ 28
Ilustración 44: Continuación del Código de la clase controladorL ____________________________________________________ 28
Ilustración 45: Continuación del Código de la clase controladorL ____________________________________________________ 29
Ilustración 46: Continuación de la clase controladorL ______________________________________________________________ 29
Ilustración 47: Fin del código de la clase controladorL _____________________________________________________________ 30
Ilustración 48: Clase main ____________________________________________________________________________________ 30
Ilustración 49: Código de validación con uso de Keylistener _________________________________________________________ 31
Ilustración 50: Continuación del Código de la validación. ___________________________________________________________ 32
Ilustración 51: Constructor de la clase controladorL. _______________________________________________________________ 32
Ilustración 52: Creación del proyecto. ___________________________________________________________________________ 33
Ilustración 53: Estructura del proyecto. __________________________________________________________________________ 33
Ilustración 54: Código de la clase funciones ______________________________________________________________________ 34
Ilustración 55: Continuación del código de la clase funciones ________________________________________________________ 34
Ilustración 56: Continuación del código de la clase funciones. _______________________________________________________ 35
Ilustración 57: Continuación del código de la clase funciones. _______________________________________________________ 35
Ilustración 58: Continuación del código de la clase funciones ________________________________________________________ 36
Ilustración 59: Fin del Código de clase funciones __________________________________________________________________ 36
Ilustración 60: Diseño de la vista "inicio" ________________________________________________________________________ 37
Ilustración 61: Diseño de la vista "interfaz" ______________________________________________________________________ 37
Ilustración 62: Código de la clase "ControladorInicio". _____________________________________________________________ 38
Ilustración 63: Código de la clase ControladorInterfaz. _____________________________________________________________ 38
Ilustración 64: Continuación del Código de la clase ControladorInterfaz. ______________________________________________ 39
Ilustración 65: Continuación del Código de la clase ControladorInterfaz. ______________________________________________ 39
Ilustración 66: Continuación del Código de la clase ControladorInterfaz. ______________________________________________ 40
Ilustración 67: Fin del Código de la clase ControladorInterfaz._______________________________________________________ 40
Ilustración 68: Código de la clase main. __________________________________________________________________________ 41
Ilustración 69: Creación de proyecto _____________________________________________________________________________ 42
Ilustración 70: Estructura general del proyecto ____________________________________________________________________ 42
Ilustración 71: Diseño de la vistaJuego ___________________________________________________________________________ 43
Ilustración 72: Código de la clase ControladorJuego. ________________________________________________________________ 43
Ilustración 73: Continuación del código de la clase ControladorJuego. __________________________________________________ 44
Ilustración 74: Fin del : Código de la clase ControladorJuego. _________________________________________________________ 44
Ilustración 75: Código de la clase BotonAccion. ____________________________________________________________________ 45
Ilustración 76: continuación de la clase BotonAccion________________________________________________________________ 46
Ilustración 77: Fin del codigo de la clase BotonAccion _______________________________________________________________ 46
Ilustración 78: Código de la clase Celda. __________________________________________________________________________ 47
Ilustración 79: Continuacón código clase Celda ____________________________________________________________________ 48
Ilustración 80: Fin del codigo clase Celda _________________________________________________________________________ 48
Ilustración 81: Código de la clase Estadisticas. _____________________________________________________________________ 49
Ilustración 82: Continuación de la clase Estadísticas ________________________________________________________________ 50
Ilustración 83: Fin de la clase Estadisticas. ________________________________________________________________________ 50
Ilustración 84:Código clase Tablero. _____________________________________________________________________________ 51
Ilustración 85: Continuación clase Tablero ________________________________________________________________________ 52
Ilustración 86: Continuación clase Tablero. _______________________________________________________________________ 53
Ilustración 87: Continuación clase Tablero. _______________________________________________________________________ 54
Ilustración 88: Fin del código de la clase Tablero. __________________________________________________________________ 54
Ilustración 89: Clase Main _____________________________________________________________________________________ 55
Ilustración 90: Creación del proyecto. ____________________________________________________________________________ 56
Ilustración 91: Estructura del proyecto. __________________________________________________________________________ 56
Ilustración 92: Diseño de la vista del juego. _______________________________________________________________________ 57
Ilustración 93: Código de la clase Control _________________________________________________________________________ 58
Ilustración 94: Continuación de la clase Control ____________________________________________________________________ 58
Ilustración 95: Fin de la clase Control ____________________________________________________________________________ 59
Ilustración 96: Clase Main _____________________________________________________________________________________ 59
Ilustración 97: Creación del proyecto. ____________________________________________________________________________ 60
Ilustración 98: Estructura del proyecto. __________________________________________________________________________ 60
Ilustración 99: Diseño de la vista del programa.____________________________________________________________________ 61
Ilustración 100: Código de la clase ControladorInicio. _______________________________________________________________ 61
Ilustración 101: Continuación de la clase ControladorInicio. __________________________________________________________ 62
Ilustración 102: Fin de la clase ControladorInicio. __________________________________________________________________ 63
Ilustración 103: Creación del proyecto. ___________________________________________________________________________ 64
Ilustración 104: Estructura del proyecto. _________________________________________________________________________ 64
Ilustración 105: Diseño de la vista del juego. ______________________________________________________________________ 65
Ilustración 106: Código de la clase ControladorJuego. _______________________________________________________________ 66
Ilustración 107: Continuación del Código de la clase ControladorJuego. ________________________________________________ 66
Ilustración 108: Código de la clase Celda. _________________________________________________________________________ 67
Ilustración 109: Fin del código de la clase Celda. ___________________________________________________________________ 67
Ilustración 110: Código de la clase Tablero________________________________________________________________________ 68
Ilustración 111: Continuación de la clase Tablero. __________________________________________________________________ 68
Ilustración 112: continuación de la clase Tablero ___________________________________________________________________ 69
Ilustración 113: fin de la clase tablero ___________________________________________________________________________ 69
Ilustración 114: Creación del proyecto. ___________________________________________________________________________ 70
Ilustración 115: Estructura del proyecto. _________________________________________________________________________ 70
Ilustración 116: Diseño de la vista del juego, las etiquetas mostrarán la suma de renglones y columnas ______________________ 71
Ilustración 117: código de la clase ControladorJuego _______________________________________________________________ 71
Ilustración 118: Fin de clase ControladorJuego ____________________________________________________________________ 72
Ilustración 119: Código de la clase Celda _________________________________________________________________________ 72
Ilustración 120: Fin del código de la clase Celda____________________________________________________________________ 73
Ilustración 121: Código de la clase Tablero________________________________________________________________________ 73
Ilustración 122: Continuación de la clase Tablero __________________________________________________________________ 74
Ilustración 123: Continuación de la clase Tablero. __________________________________________________________________ 74
Ilustración 124: Continuación de la clase Tablero __________________________________________________________________ 75
Ilustración 125: Fin de la clase Tablero ___________________________________________________________________________ 75
Ilustración 126: Diseño de la vista del juego. ______________________________________________________________________ 76
Ilustración 127: Código de la clase Cartas ________________________________________________________________________ 76
Ilustración 128: Código de la clase ControladorJuego _______________________________________________________________ 77
Ilustración 129: Continuación de la clase ControladorJuego.__________________________________________________________ 77
Ilustración 130: Continuación de la clase ControladorJuego __________________________________________________________ 78
Ilustración 131: Continuación de la clase ControladorJuego.__________________________________________________________ 78
Ilustración 132: Continuación clase ControladorJuevo _______________________________________________________________ 79
Ilustración 133: Continuación ClaseJugador _______________________________________________________________________ 79
Ilustración 134: Continuación de la clase ControladorJuego.__________________________________________________________ 80
Ilustración 135: continuación clase ControladorJuego _______________________________________________________________ 80
Ilustración 136: Fin de la clase ControladorJuego. __________________________________________________________________ 81
 Introducción
El presente documento recaba prácticas de programación, las cuales los alumnos deben desarrollar
para nivelar el conocimiento en programación, específicamente en el patrón de arquitectura de
software MVC, el cual tiene la característica de separar en 3 componentes el programa, la vista tiene
la finalidad de recabar y mostrar información al usuario a través de métodos gráficos, texto, etc., el
modelo, tiene la característica de contener el aspecto lógico del programa como la conexión a la base
de datos, clases de objetos, etc., Por último el controlador realiza el control entre el modelo y la vista,
realizando operaciones entre los datos recuperados la interacción del programa con el usuario.

El presente manual de prácticas es únicamente de nivelación, es decir, refrescar los conocimientos

del alumno, al realizar cada una de las prácticas el alumno recibirá un sello, al finalizar los sellos será
sumados para ser parte de la escala de evaluación, la condición para obtener el sello es que el alumno
comprenda la funcionalidad del programa, el docente realizara una o dos preguntas acerca del
programa si el alumno no responde no será acreedor al sello, hasta que demuestre conocimiento dicho
software.
 Práctica 1: Nombre “ Clase libro”
Instrucciones:
1. Abrir e iniciar un nievo proyecto con el nombre de “Libro” ver ilustracion1

Ilustración 1: Creación del proyecto

2. Crear los paquetes de modelo vista controlador como se observa en la ilustracion2, esta será la estructura
que se llevará durante el proyecto.

Ilustración 2: Estructura general del proyecto

3. En el paquete modelo, se creará una clase que se llamará “LibroM”, la cual contendrá todos los atributos
propios de un libro, esto se puede observar en la ilustracion3, en la cual también se observa el código que
deberá ir dentro de la clase.
Ilustración 3: Clase libro
4. Siguiente paso, crear dentro del paquete VistaLibro un JFrame el cual servirá para visualizar los datos que
se desean guardar ve ilustracion4, recordar que: todos los campos de texto y botones deberán tener un
nombre de la variable de acuerdo a la acción y a lo que guarden, ejemplo: “btnGuardar”, “txtNombre”.
Posterior a ello cada uno de lo antes mencionado se le deberá cambiar el acceso, cambiar de private a
public.

Ilustración 4: Diseño de la interface de vista

5. El siguiente paso es crear la clase que se llame “ControladorL”, la cual contendrá toda la lógica del
programa, siendo esta el proceso de recuperar la información introducida en los campos de texto, esto
anterior al dar click en el botón, el codigo necesario se obsserva en la ilustracion5 e ilustracion6
Ilustración 5: Código de la clase ControladorL

Ilustración 6: Continuación de la clase ControladorL

6. Por último hace falta crear la clase en la cual se ejecute el programa para ello se coloca en código en la
clase principal llamada main, el objeto controlador, así como el objeto vista, inicializando ambos, el
código necesario se ve en la ilustracion7.

Ilustración 7: Codigo de la clase Main

7. La función del programa es la siguiente, al ingresar los datos en el formulario y darle clic en el botón
guardar en la consoa del IDE se muestra repetidaente los datos ingresados, esto se observa en la
ilustracion8
Ilustración 8: funcionalidad del programa
 Práctica 2: “ Uso de arraylist con clases y tablas”
Instrucciones:
1. Abrir e iniciar un nievo proyecto con el nombre de Libro
2. Crear las carpetas de modelo vista controlador como se observa en la ilustracion9

Ilustración 9: Estructura del proyecto

3. Crear en la carpeta de controlador una clase llamada controladorLibro, en el paquete de modelo crear
la clase de libro y en la clase de vista crear el jframe llamada libro, vea ilustracion10

Ilustración 10: Estructura del proyecto

4. Dentro da la clase libro colocar el código que se observa en la ilustracion11 e ilustracion12

Ilustración 11: Código de la clase libro

Ilustración 12: continuación Código anterior
5. En el formulario colocar el diseño siguiente:
a. Recordando cambiar el nombre de las variables de cada objeto que se coloca
b. Recordando colocar cada objeto colocado como público, tal cual se observa en la ilustracion13.

Ilustración 13: Vista del Jframe

6. Ahora dentro de la clase se controladorLibro se integrará el siguiente Código, el cual se observa en la
ilustracion14, dicho Código será parte vital del funcionamiento, este es la importación de las clases
alojadas en las otras carpetas.

Ilustración 14: Importación de vistas y modelos.

7. Agregaremos el constructor necesario para poder manipular el formulario así como los datos del objeto
libro, tal como se observa en la ilustracion15
Ilustración 15: Constructor de nuestro objeto inicial de la clase controlador
8. Se creará un método llamado llenar Tabla, el cual llenara la tabla con los datos que se encuentran
almacenados en el ArrayList, el Código se observa en la ilustracion16, el método que se crea se manda
llamar en el constructor el cual permitirá tener la tabla llena al iniciar el programa.

Ilustración 16: Método que permite llenar la tabla con los datos alojados en el arrayList de objetos libro
9. El siguiente paso es asignar el evento listener a cada uno de los botones que se tiene dentro del
programa, para ello se tiene que realizar la herencia de una clase padre empleando el implements, el
código se observa en la ilustracion17

Ilustración 17. implementación de la clase ActionListener

10. Ahora hay que agregar la condición para escuchar el botón, es decir saber sobre que botón está
haciendo clics, para ello se implementa la instrucción de if que se observa en la ilustracion18, además
dentro de la misma se observa el procedimiento para recuperar la información de los campos de texto
para así crear un nuevo objeto y guardarlo dentro del araylist al final se llama al método de llenar tabla
para actualizar la cantidad de registros y se observe el cambio en la tabla.
Ilustración 18: código en el que se evalúa sobre que botón se hizo clic
11. Para poder correr el programa de manera correcta se requiere colocar el siguiente código en la clase
que se encuentra en la carpeta de pruebas, llamada libro.java, dicho código lo que realiza es inicializar
los valores necesarios para el funcionamiento de la vista y el controlador, en donde se encuentra el
inicio del arraylist, inicio de la vista, y de cada uno de los objetos que integran al arraylist, esto se
observa en la ilustracion19

Ilustración 19: Clase main

Por ultimo se agregan como referencia algunas capturas de pantalla del funcionamiento.
a. Inicio del programa ver ilustracion20 e ilustracion21
Ilustración 20: Ingreso al programa

Ilustración 21: Ingreso de nuevo libro

Anexo Práctica2. Código completo de clase controlador

import Vista.VistaLibro;
import Modelo.Librom;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import javax.swing.table.DefaultTableModel;
public class ControladorLibro implements ActionListener {
private int ISBN;
private String titulo;
private String autor;
private int numPag;
VistaLibro vistaL = new VistaLibro();
ArrayList<Librom> ListaLibros = new ArrayList<>();
public ControladorLibro(ArrayList listaLibros, VistaLibro vista) {
this.vistaL = vista;
this.ListaLibros = listaLibros;
this.vistaL.btnGuardar.addActionListener(this);
llenarTablaLibros();
 }
@Override
public void actionPerformed(ActionEvent e) {
if (e.getSource() == vistaL.btnGuardar) {
ISBN = Integer.parseInt(vistaL.txtISBN.getText());
titulo = vistaL.txtTitulo.getText().toUpperCase();
autor = vistaL.txtAutor.getText().toUpperCase(); // se recupern los datos de los campos de texto
numPag = Integer.parseInt(vistaL.txtNumPag.getText());
/// una vez recuperados estos se regresan a vacios para evitar problemas
vistaL.txtISBN.setText("");
vistaL.txtTitulo.setText("");
vistaL.txtAutor.setText("");
vistaL.txtNumPag.setText("");
ListaLibros.add(new Librom(ISBN, titulo, autor, numPag));
llenarTablaLibros();
}
}
public void llenarTablaLibros() {
DefaultTableModel modeloT = new DefaultTableModel();
vistaL.tblLibros.setModel(modeloT);
modeloT.addColumn("ISBN");
modeloT.addColumn("Titulo");
modeloT.addColumn("Autor");
modeloT.addColumn("Num. Paginas");
Object[] columna = new Object[4];
for (Librom aux : ListaLibros) {
columna[0] = "" + aux.getISBN();
columna[1] = "" + aux.getTitulo();
columna[2] = "" + aux.getAutor();
columna[3] = "" + aux.getNumPaginas();
modeloT.addRow(columna);
}
}
}
 Práctica 3: Nombre “ Vista con método para validar casillas vacías” Código ASCII”
Instrucciones
Este programa hace uso del programa anterior, unicamente dentro de la clase controlador se le agrega la función
que evalua si las casillas de texto no están vacías, de ser así regresa un mensaje de texto donde indica que hace
falta ingresar información.
1. Abrir e iniciar un nievo proyecto con el nombre de “Libro” ver ilustracion22

Ilustración 22: Creación del proyecto

2. Crear los paquetes de modelo vista controlador como se observa en la ilustracion23, esta será la estructura
que se llevará durante el proyecto.

Ilustración 23: Estructura del proyecto

3. En el paquete modelo, se creará una clase que se llamará “LibroM”, la cual contendrá todos los atributos
propios de un libro, esto se puede observar en la ilustracion24, en la cual también se observa el código
que deberá ir dentro de la clase.
Ilustración 24: Clase del objeto libro
4. Siguiente paso, crear dentro del paquete VistaLibro un JFrame el cual servirá para visualizar los datos que
se desean guardar ve ilustracion25, recordar que: todos los campos de texto y botones deberán tener un
nombre de la variable de acuerdo con la acción y a lo que guarden, ejemplo: “btnGuardar”, “txtNombre”.
Posterior a ello cada uno de lo antes mencionado se le deberá cambiar el acceso, cambiar de private a
public.

Ilustración 25: Diseño de la interface de vista

5. El siguiente paso es crear la clase que se llame “ControladorL”, la cual contendrá toda la lógica del
programa, siendo esta el proceso de recuperar la información introducida en los campos de texto, esto
anterior al dar click en el botón, el código necesario se observa en la ilustracion26 e ilustracion27
Ilustración 26: Código de la clase controlador

Ilustración 27: Continuación del Código de la clase controlador

6. Por último hace falta crear la clase en la cual se ejecute el programa para ello se coloca en código en la
clase principal llamada main, el objeto controlador, así como el objeto vista, inicializando ambos, el
código necesario se ve en la ilustracion28.
Ilustración 28: Código de la clase Main
7. La función del programa es la siguiente, al ingresar los datos en el formulario y darle clic en el botón
guardar, si las casillas están vacías se observara un mensaje de error, en caso contrario se guarda el dato
en el arraylist, para posteriormente mostrarlo en la tabla, mediante el método llenartabla, esto se observa
en la ilustracion29, ilustracion30 e ilustracion31.

Ilustración 29: Validacion de casillas vacías

Ilustración 30: Funcionalidad del programa

 Práctica 4: Nombre “ Vista con método para validar datos ingresados”
Instrucciones
Este programa hace uso del programa anterior, en el uso de un programa existe la posibilidad de ingresar datos
erróneos en los campos, por ejemplo ntroducir números en algún nombre, o al revés, introducir texto en un numero
telefónico, para ello se realiza la validación de texto, para identificar si se desea introducir algún numero o texto
o algo en especial como por ejemplo una curp, un correo electrónico, etc.
1. Abrir e iniciar un nievo proyecto con el nombre de “Libro” ver ilustracion31

Ilustración 31:Creación del proyecto

2. Crear los paquetes de modelo vista controlador como se observa en la ilustracion32, esta será la estructura
que se llevará durante el proyecto.

Ilustración 32: Estructura del proyecto

3. En el paquete modelo, se creará una clase que se llamará “LibroM”, la cual contendrá todos los atributos
propios de un libro, esto se puede observar en la ilustracion33, en la cual también se observa el código
que deberá ir dentro de la clase.
Ilustración 33: Clase del objeto libro
4. Siguiente paso, crear dentro del paquete VistaLibro un JFrame el cual servirá para visualizar los datos que
se desean guardar ve ilustracion34, recordar que: todos los campos de texto y botones deberán tener un
nombre de la variable de acuerdo con la acción y a lo que guarden, ejemplo: “btnGuardar”, “txtNombre”.
Posterior a ello cada uno de lo antes mencionado se le deberá cambiar el acceso, cambiar de private a
public.

Ilustración 34: Diseño de la interface de vista

5. El siguiente paso es crear la clase que se llame “ControladorL”, la cual contendrá toda la lógica del
programa, siendo esta el proceso de recuperar la información introducida en los campos de texto, esto
anterior al dar click en el botón, si la información introducida no coincide con lo que se solicita arrojara
un mensaje de error, el código necesario se observa en la ilustracion35, ilustracion36, ilustracion37 e
ilustracion38
Ilustración 35: Código de la clase controlador

Ilustración 36: Continuación de la clase controlador

Ilustración 37: Continuación del Código de la clase controlador

Ilustración 38: Fin del código clase controlador

 Práctica 5: Nombre “ Modificaciones, eliminaciones de aarraylist con formularios”
Instrucciones
Este programa hace uso del programa anterior, en el uso de un programa existe la posibilidad de ingresar datos
erróneos en los campos, por ejemplo introducir números en algún nombre, o al revés, introducir texto en un
número telefónico, para ello se realiza la validación de texto, para identificar si se desea introducir algún número
o texto o algo en especial como por ejemplo una curp, un correo electrónico, etc.
Este programa permite guardar datos y a su vez buscarlos para poder eliminarlos o en su defecto modificarlos
1. Abrir e iniciar un nuevo proyecto con el nombre de “Libro” ver ilustracion39

Ilustración 39: Creación de proyecto nuevo

2. Crear los paquetes de modelo vista controlador como se observa en la ilustracion40, esta será la estructura
que se llevará durante el proyecto.

Ilustración 40: Estructura del proyecto

3. En el paquete modelo, se creará una clase que se llamará “LibroM”, la cual contendrá todos los atributos
propios de un libro, esto se puede observar en la ilustracion41, en la cual también se observa el código
que deberá ir dentro de la clase.
Ilustración 41: Clase del objeto libro
4. Siguiente paso, crear dentro del paquete VistaLibro un JFrame el cual servirá para visualizar los datos que
se desean guardar ve ilustracion43, recordar que: todos los campos de texto y botones deberán tener un
nombre de la variable de acuerdo con la acción y a lo que guarden, ejemplo: “btnGuardar”, “txtNombre”.
En este ejemplo se manipularan etiquetas para mostrar los datos del libro buscado, para ello se recomienda
colocarle a cada equiqueta que cambiara el texto un nombre de la variable referente a cada apartado
ejemplo: “lblISBN”, “lblAutor”.
Posterior a ello cada uno de lo antes mencionado se le deberá cambiar el acceso, cambiar de private a
public.
Ilustración 42: Diseño de la interface de vista
5. El siguiente paso es crear la clase que se llame “ControladorL”, la cual contendrá toda la lógica del
programa, siendo esta el proceso de recuperar la información introducida en los campos de texto, esto
anterior al dar click en el botón y de acuerdo al botón que se oprima este deberá realizar lo solicitado, el
código necesario se observa en la ilustracion43, ilustracion44, ilustracion45 e ilustracion46.
Ilustración 43: Código de la clase controladorL

Ilustración 44: Continuación del Código de la clase controladorL

Ilustración 45: Continuación del Código de la clase controladorL

Ilustración 46: Continuación de la clase controladorL

Ilustración 47: Fin del código de la clase controladorL

6. Por último hace falta crear la clase en la cual se ejecute el programa para ello se coloca en código en la
clase principal llamada main, el objeto controlador, así como el objeto vista, inicializando ambos, el
código necesario se ve en la ilustracion48

Ilustración 48: Clase main

 Practica 6: Nombre “ Uso del evento keylistener para validar casillas”
Para la elaboración de este proyecto únicamente se indicar la función que se va a agregar en un campo de texto,
con la finalidad de que el alumno practique indague y pregunte al profesor.
Instrucciones
1. En la clase de controlador se agregará un método para verificar que no se introduzcan datos contrarios a
los solicitados algo similar a la practica 4, sin embargo la diferencia será que se ocupara el evento de
Keylistener para identificar cuando se oprime una tecla e inmediatamente averiguar si la información es
del tipo solicitado o no.
2. Para ello se modificará únicamente la función de validarCasillas que se encuentra en la clase controladorL,
y ese método se reemplazará por el siguiente mostrado en la ilustracion49 e ilustracion50.

Ilustración 49: Código de validación con uso de Keylistener

Ilustración 50: Continuación del Código de la validación.
3. Además se agregará o se mandará llamar esa función al momento de crear el constructor esto se observa
en la ilustracion51.

Ilustración 51: Constructor de la clase controladorL.

 Práctica 7: Juego Gato
La dinámica de este programa es jugar al famoso juego llamado “GATO” la finalidad es tener 3 en línea de su
figura que puede ser “X” o “O”, el juego deberá tener la posibilidad de jugar contra CPU y contra usuario.
Instrucciones:
1. Primer paso crear el proyecto, el cual tendrá el nombre de “MVCGATO”, tal como se observa en la
ilustracion52.

Ilustración 52: Creación del proyecto.

2. Lo siguiente es crear la estructura necesaria para poder realizar el proyecto, la estructura será la misma
que los primeros proyectos, crear 3 paquetes con el nombre de “ControladorGato”,
“VistaGato”,”ModeloGato” y por último el paquete de “PruebaGato” donde cambiaremos la clase main
allí. Esto se observa en la ilustracion53.

Ilustración 53: Estructura del proyecto.

3. El primer paso de codificación es crear dentro del paquete ControladorGato la clase llamada “funciones”
la cual contendrá todas las funciones necesarias para el correcto funcionamiento del programa, el código
se observa en la ilustracion54, ilustracion55, ilustracion56,ilustracion57, ilustracion58 e ilustracion59
Ilustración 54: Código de la clase funciones

Ilustración 55: Continuación del código de la clase funciones

Ilustración 56: Continuación del código de la clase funciones.

Ilustración 57: Continuación del código de la clase funciones.

Ilustración 58: Continuación del código de la clase funciones

Ilustración 59: Fin del Código de clase funciones

 4. El siguiente paso es crear la vista del juego, la cual se creara en el paquete VistaGato, y para este juego se
obtendrán 2 vistas una es la bienvenida y la segunda es el juego propio, cada una tiene el nombre de:
“Inicio” e “interfaz” respectivamente, esto se observa en la ilustracion60 e ilustracion61, recordar que
cada elemento manipulado deberá tener un nombre de variable de acuerdo a lo que realiza, y que deberá
tener un modo de acceso tipo público.
En este ejemplo se manejan botones para simular cada uno de los espacios del juego gato, en clase se
resolverán las dudas que surjan.

Ilustración 60: Diseño de la vista "inicio"

Ilustración 61: Diseño de la vista "interfaz"

5. El paso siguiente es crear la clase controlador la cual manipulara los formularios, para este caso como se
tienen 2 formularios es decir dos vistas, se crearan dos clases de controlador en el paquete
 ControladorGato, estas son: “ControladorInicio” y “ControladorInterfaz” respectivamente, la primer clase
unicamente realizara el proceso de manejar botones la segunda clase realiza toda la lógica del programa,
esto se observa en la ilustracion62, ilustracion63, ilustracion64, ilustracion65, ilustracion66, e
ilustracion67.

Ilustración 62: Código de la clase "ControladorInicio".

Ilustración 63: Código de la clase ControladorInterfaz.

Ilustración 64: Continuación del Código de la clase ControladorInterfaz.

Ilustración 65: Continuación del Código de la clase ControladorInterfaz.

Ilustración 66: Continuación del Código de la clase ControladorInterfaz.

Ilustración 67: Fin del Código de la clase ControladorInterfaz.

6. Por último se coloca en la clase principal el código necesario para ejecutar el juego, esto se observa en la
ilustrcion68.
Ilustración 68: Código de la clase main.
 Práctica 8: Juego Buscaminas
Instrucciones
Ejecuta el juego conocido como buscaminas, el cual realiza exactamente las funciones del juego, para ello se
deberá realizar lo siguiente mostrado en la lista de instrucciones.
1. Abrir e iniciar un nuevo proyecto con el nombre de “MVCMINA” ver ilustracion69

Ilustración 69: Creación de proyecto

2. Crear dentro del proyecto los paquetes llamados “ModeloMina”, “ControladorMina”, “VistaMina”
respectivamente, esto se aprecia en la ilustracion70

Ilustración 70: Estructura general del proyecto

3. Dentro del paquete llamado VistaMina se creara el jFrame que contendrá todo lo visible del juego, el
diseño se observa en la ilustracion71, recordar las consideraciones de los proyectos anteriores. Ademas
considerar que el cuadro que se observa con bordes en color anaranjado en un JPanel uno es para los
datos estadísticos y el otro es para el juego, y que la barra superior es un JMenu.
 Ilustración 71: Diseño de la vistaJuego

4. Dentro del paquete llamado ControladorMina se creará la clase llamada “ControladorJuego”, en la cual
se programará toda la parte lógica del juego. Esto se observa en la ilustracion72, ilustracion73 e
ilustracion74

Ilustración 72: Código de la clase ControladorJuego.

Ilustración 73: Continuación del código de la clase ControladorJuego.

Ilustración 74: Fin del : Código de la clase ControladorJuego.

5. El siguiente paso es crear dentro del paquete llamado ModeloMina, las clases “BotonAccion”, “Celda”,
“Estadísticas”, Tablero”, cada una de ellas contiene funciones acordes al nombre que tienen, por medio
de estas se puede crear el tablero asignar las minas de manera aleatoria, cada una de ellas se presenta a
continuación, se recomienda poner atención ya que son varias clases y se mostraran únicamente las
imágenes con sus pies de imagen.
a. Clase llamada “BotonAccion”

Ilustración 75: Código de la clase BotonAccion.

Ilustración 76: continuación de la clase BotonAccion

Ilustración 77: Fin del codigo de la clase BotonAccion

b. Clase llamada “Celda”

Ilustración 78: Código de la clase Celda.

 Ilustración 79: Continuacón código clase Celda

Ilustración 80: Fin del codigo clase Celda

c. Codigo de la clase llamada “Estadísticas”

Ilustración 81: Código de la clase Estadisticas.
 Ilustración 82: Continuación de la clase Estadísticas

Ilustración 83: Fin de la clase Estadisticas.

d. Código de la clase llamada “Tablero”

Ilustración 84:Código clase Tablero.
Ilustración 85: Continuación clase Tablero
Ilustración 86: Continuación clase Tablero.
 Ilustración 87: Continuación clase Tablero.

Ilustración 88: Fin del código de la clase Tablero.

6. El ultimo paso para poder ejecutar el programa es crear nuestra clase main, y en ella colocar el
siguiente código mostrado en la ilustracion89
Ilustración 89: Clase Main
 Práctica 9: Juego Piedra Papel o Tijeras
Descripción: Este juego realiza una simulación del juego llamado piedra, papel o tijeras, la finalidad es simular
una aleatoriedad y el usuario elegir una de las 3 opciones y al último decidir quién gana si la PC o el usuario.
Instrucciones:
1. Crear el proyecto con nombre “MVCPPT”, observar la ilustracion90

Ilustración 90: Creación del proyecto.

2. Crear la estructura del proyecto conforme se observa en la ilustracion91, manteniendo el enfoque MVC,
creando el paquete llamado “ModeloJuego”, “VistaJuego” y “ControladorJuego”.

Ilustración 91: Estructura del proyecto.

3. Dentro del paquete de VistaJuego crear el JFrame llamado “Vista” que será la vista de nuestro juego, el
diseño se observa en la ilustracion92. Considerar que cada elección es un botón y la forma de colocar
la elección de la computadora es con un botón de igual forma.
 Ilustración 92: Diseño de la vista del juego.

4. El siguiente paso es crear una clase en el paquete de ControladorJuego llamada “Control”, esta clase
permitirá realizar las funciones necesarias para poder resolver el problema, este código se observa en
la ilustracion93, ilustracion94 e ilustracion95.
 Ilustración 93: Código de la clase Control

Ilustración 94: Continuación de la clase Control

 Ilustración 95: Fin de la clase Control

5. El último paso es crear la clase Main con la cual se ejecutará el programa, el código necesario se
presenta en la ilustracion96.

Ilustración 96: Clase Main

 Práctica 10: Telégrafo
Instrucciones:
1. Crear el proyecto con el nombre “Telegrafo” tal como se observa en la ilustacion97

Ilustración 97: Creación del proyecto.

2. Para el caso de este proyecto se crearan paquetes con los nombres de “Controlador” y “Vista”
respectivamente tal como se observa en la ilustracion98.

Ilustración 98: Estructura del proyecto.

3. Dentro el paquete de Vista se creará un Jframe con el nombre de “vista”, el diseño de la vista se
observa en la ilustracion99.
 Ilustración 99: Diseño de la vista del programa.

4. Dentro del paquete llamado Controlador se creará una clase llamada “ControladorInicio”, mediante la
cual se podrá realizar la finalidad del programa, el código necesario se observa en la ilustacion100 e
ilustracion101

Ilustración 100: Código de la clase ControladorInicio.

Ilustración 101: Continuación de la clase ControladorInicio.
Ilustración 102: Fin de la clase ControladorInicio.
 Práctica 11: Sudoku
Descripción: El proyecto ejecuta las mismas reglas que el juego de sudoku conocido.
Instrucciones:
1. El primer paso es crear el proyecto, el cual tendrá por nombre “MVCSodoku”, tal como se observa en la
ilustracion103

Ilustración 103: Creación del proyecto.

2. Dentro del proyecto se crearán 3 paquetes con los nombres de: “Vista”, “Controlador”, “Modelo”
respectivamente tal como se observa en la ilustracion104.

Ilustración 104: Estructura del proyecto.

3. Dentro de la carpeta de vista, se creara el JFrame llamado “VistaJuego”, el diseño que deberá tener se
observa en la ilustracion105, recordar que lo que se observa con borde color naranja es un JPanel el
cual sirve como contenedor, también recordar que todos los botones deberá tener un nombre respectivo
a lo que hacen y hacer publico de igual forma cada uno de los paneles.
 Ilustración 105: Diseño de la vista del juego.

4. Dentro del paquete llamado “Controlador” se creará una clase con el nombre “ControladorJuego”,
dentro de la cual se controlará las operaciones entre el modelo y la vista, este código se observa en la
ilustracion106 e ilustracion107
 Ilustración 106: Código de la clase ControladorJuego.

Ilustración 107: Continuación del Código de la clase ControladorJuego.

5. Dentro del paquete llamado “Modelo”, se crean 2 clases llamadas “Celda” y “Tablero” las cuales nos
permitirán realizar el juego, así como colocar y validar las casillas de texto del juego, estos códigos se
observan a continuación.
a. Clase llamada “Celda”, el código de dicha clase se observa en la ilustracion108 e ilustracion109
 Ilustración 108: Código de la clase Celda.

Ilustración 109: Fin del código de la clase Celda.

b. El Código de la clase llamada “Tablero” se observa en la ilustracion110, ilustracion111,

ilustracion112 e ilustracion113
 Ilustración 110: Código de la clase Tablero

Ilustración 111: Continuación de la clase Tablero.

Ilustración 112: continuación de la clase Tablero

Ilustración 113: fin de la clase tablero

 Práctica 12: Cuadro mágico
Descripción: El programa consta de resolver un cuadro mágico de 5x5, las instrucciones del juego son las
mismas.
Instrucciones:
1. El Primer paso es crear el proyecto con el nombre “MVCCUADRO”, tal como se observa en la
ilustracion114.

Ilustración 114: Creación del proyecto.

2. Se creará dentro del proyecto las 3 carpetas del patrón de arquitectura MVC, tal como se observa en la
ilustracion115.

Ilustración 115: Estructura del proyecto.

3. Dentro del paquete Vista se creará el JFrame con el diseño mostrado en la ilustracion116,recordando
las condiciones de los proyectos anteriores.
 Ilustración 116: Diseño de la vista del juego, las etiquetas mostrarán la suma de renglones y columnas

4. Dentro del paquete de Controlador se creará la clase llamada “ControladorJuego”, en donde se creará
la lógica del juego, el Código necesario se observa en la ilustracion117, ilustracion118.

Ilustración 117: código de la clase ControladorJuego

 Ilustración 118: Fin de clase ControladorJuego

5. En el paquete llamado Modelo, se crearan 2 clases llamadas “Celda” y “Tablero” mediante los cuales se
realizara el juego ademas de prestar los métodos para crear el tablero y cada una de las celdas del
juego, esto se describe a continuación.
a. Clase llamada “Celda”, el codigo para crear el objeto celda se muestra en la ilustracion119,
ilustracion120 e ilustracion121

Ilustración 119: Código de la clase Celda

 Ilustración 120: Fin del código de la clase Celda

b. Clase llamada “Tablero”, el Código para crear el tablero del juego se observa en la ilustracion121,
ilustracion122, ilustracion123 e ilustracion124

Ilustración 121: Código de la clase Tablero

Ilustración 122: Continuación de la clase Tablero

Ilustración 123: Continuación de la clase Tablero.

 Ilustración 124: Continuación de la clase Tablero

Ilustración 125: Fin de la clase Tablero

6. Por ultimo se crea la clase main en donde se ejecutará el juego, en este caso se omitirá el código.
 Práctica 13:Juego Black Jack
Descripción: Este juego realiza una simulación del famoso juego llamado Black Jack, o veintiuno, la finalidad
es tener el número más cercano a 21 con cartas de la baraja inglesa, pudiendo ser de diferentes palos.
Instrucciones:
1. En esta práctica se omitirá los primeros pasos para ir directamente a la programación de las clases
correspondientes que se observa a continuación.
2. Dentro del paquete llamado Vista se creará el JFrame con el nombre de “VistaCartas”, el diseño se
observa en la ilustracion126

Ilustración 126: Diseño de la vista del juego.

3. Dentro del paquete llamado Modelo se creará la clase llamada “Carta”, mediante la cual se podrá cargar
las imágenes de cada uno de los mazos, este código se observa en la ilustracion127, se omiten los get
y set, el alumno deberá colocarlos

Ilustración 127: Código de la clase Cartas

4. Por último dentro del paquete llamado Controlador, se crea la clase llamada “ControladorJuego”, en la
cual se tratan todos los modelos y algoritmos lógicos del programa, dicho Código se muestra en la
ilustracion128, ilustracion129, ilustracion130, ilustracion131, ilustracion132, ilustracion133,
ilustracion134, ilustracion135 e ilustracion136

Ilustración 128: Código de la clase ControladorJuego

Ilustración 129: Continuación de la clase ControladorJuego.

Ilustración 130: Continuación de la clase ControladorJuego

Ilustración 131: Continuación de la clase ControladorJuego.

Ilustración 132: Continuación clase ControladorJuevo

Ilustración 133: Continuación ClaseJugador

Ilustración 134: Continuación de la clase ControladorJuego.

Ilustración 135: continuación clase ControladorJuego

 Ilustración 136: Fin de la clase ControladorJuego.

5. Por ultimo se crea la clase Main, cabe resaltar que el juego ya funciona sin embargo hace falta algunas
condiciones para validar que el juego este terminado, por tanto ese será el objetivo del alumno, colocar
las instrucciones necesarias para terminar el juego.