PROGRAMACIÓN IV (LENGUAJE "C" ) - SA26-2
Diagrama de temas
- BIENVENIDA
BIENVENIDA
Bienvenidos a la clase de programación IV, es este curso veremos como programar con Java Eclipse
- COMPETENCIA ESPECíFICA
- DATOS DEL DOCENTE:Tema actual
- CRONOGRAMA DE EVALUACIÓN
- I CORTE: Desde 06-06-2026 hasta 08-08-2026
I CORTE: Desde 06-06-2026 hasta 08-08-2026
en este corte se realizará la explicación de ejercicios secuencueniales en Java y manejo de condciionales
- Semana No. 1 Desde 06-06-2026 hasta 12-06-2026
Semana No. 1 Desde 06-06-2026 hasta 12-06-2026
Introducción a java, por medio de la guía que se muestra a continuación, se explican los primeros pasos para trabajar con java
- Semana No. 2 Desde 13-06-2026 hasta 19-06-2026
Semana No. 2 Desde 13-06-2026 hasta 19-06-2026
En esta parte se explicará como se realizan programas seuenciales secuenciales en java
- Semana No. 3. desde 20-06-2026 hasta 26-06-2026
Semana No. 3. desde 20-06-2026 hasta 26-06-2026
Partiendo de las lases anteriores realizar los ejercicios que se muestran a continuación
- Partiendo de las clases anteriores por favor, intente realizar los siguientes ejercicios
- Semana No. 4 Desde 27-06-2026 hasta 03-07-2026
- Semana No. 5. Desde 04-07-2026 hasta 10-07-2026
- Semana No. 6. Desde 11-07-2026 hasta 17-07-2026
- Semana No. 7. Desde 18-07-2026 hasta 24-07-2026
- Semana No. 8..Desde 25-07-2026 hasta 31-07-2026
- Semana No. 9. desde 01-08-2026 hasta 07-08-2026
Semana No. 9. desde 01-08-2026 hasta 07-08-2026
Realice los siguientes ejercicios que se muestran a continuación
- Semana No. 10. Desde 08-08-2026 hasta 14-08-2026
- Semana 11. Desde 08-08-2026 hasta 14-08-2026
- Semana 12. Desde 17-08-2026 hasta 22-08-2026
- Semana 13. Desde 24-08-2026 hasta 29-08-2026
- Semana 14. Desde 31-08-2026 hasta 05-09-2026
Semana 14. Desde 31-08-2026 hasta 05-09-2026
ARRAYS EN JAVA
La clase Arrays en java.util es una clase de utilidad que proporciona métodos estáticos para realizar operaciones como ordenar, buscar, comparar y convertir arreglos. No se puede instanciar y se utiliza únicamente con fines de utilidad.
· Proporciona métodos estáticos como sort(), binarySearch(), equals(), toString()
· Extiende implícitamente Object y no está diseñado para ser instanciado.
Declaración de clase
Arrays es una clase de utilidad final en el paquete java.util que extiende la clase Object, que es la raíz de la jerarquía de clases de Java.
clase pública final Arrays
Para usar arreglos,
Arrays.<nombre de la función>;
Arrays.sort(nombre_del_array);
¿Por qué necesitamos la clase Arrays?
Java proporciona una clase de utilidad llamada java.util.Arrays para ayudar a los desarrolladores a realizar operaciones comunes con matrices de forma fácil y eficiente, como por ejemplo:
· Rellena una matriz con un valor específico.
· Ordenar una matriz
· Buscar en una matriz
· Y muchos más
Métodos en la clase Array de Java
La clase Arrays del paquete java.util contiene varios métodos estáticos que se pueden usar para llenar, ordenar, buscar, etc., en arreglos. Veamos los métodos y su implementación:
1. Método asList().
Este método convierte un array en una lista.
import java.util.Arrays ;
clase Geeks {
public static void main ( String [] args ){
// Obtener el arrayint intArr [] = { 10 , 20 , 15 , 22 , 35 };
// Para convertir los elementos en una lista
System.out.println ( " Arreglo de enteros como lista: " )
+ Arrays.asList ( intArr ) ) ;
}
}
ProducciónMatriz de enteros como lista: [[I@19469ea2]
Explicación: Este método convierte un array en una lista de tamaño fijo usando Arrays.asList(). Funciona correctamente con arrays de objetos (como Integer y String), pero con arrays de tipos primitivos, todo el array se convierte en un único elemento de lista en lugar de valores individuales.
Nota: la función asList() no funciona correctamente con matrices primitivas (como int[], char[]). Trata toda la matriz como un solo elemento en lugar de convertir cada valor en una lista.
2. Método binarySearch()
Este método busca el elemento especificado en el array con la ayuda del algoritmo de búsqueda binaria.
import java.util.Arrays ;
clase pública Geeks {public static void main ( String [] args ){
// Obtener el array
int intArr [] = { 10 , 20 , 15 , 22 , 35 };
Matrices.ordenar ( intArr ) ;
entero intKey = 22 ;
// Imprime la clave y el índice correspondiente.
Sistema.out.println (
intKey + " encontrado en el índice = "
+ Arrays.binarySearch ( intArr , intKey ) ) ;
}
}
Producción22 encontrado en el índice = 3
Explicación: Este método busca un elemento en un array ordenado mediante búsqueda binaria. Si se encuentra el elemento, devuelve su índice; de lo contrario, devuelve un valor negativo que indica el punto de inserción.
3. Método binarySearch(array, fromIndex, toIndex, key, Comparator)
Este método busca el objeto especificado en un rango del array indicado utilizando el algoritmo de búsqueda binaria.
import java.util.Arrays ;
clase pública Main {public static void main ( String [] args )
{
// Obtener el array
int intArr [] = { 10 , 20 , 15 , 22 , 35 };
Matrices.ordenar ( intArr ) ;
entero intKey = 22 ;
Sistema.out.println (
intKey
+ " encontrado en el índice = "
+ Matrices
.binarySearch ( intArr , 1 , 3 , intKey ) );
}
}
Producción22 encontrado en el índice = -4
Explicación: Este método busca un elemento dentro de un rango específico del array mediante un comparador. Es útil para lógicas de ordenación personalizadas o búsquedas parciales en el array.
4. Método compare (array 1, array 2)
Este método devuelve la diferencia como un número entero lexicográficamente.
import java.util.Arrays ;
clase pública Main {public static void main ( String [] args )
{
// Obtener el array
int intArr [] = { 10 , 20 , 15 , 22 , 35 };
// Obtener el segundo array
int intArr1 [] = { 10 , 15 , 22 };
// Para comparar ambos arrays
System.out.println ( " Comparación de matrices de enteros : " )
+ Matrices . comparar ( intArr , intArr1 ));
}
}
ProducciónMatrices de enteros en comparación: 1
Explicación: Este método compara dos arreglos lexicográficamente. Devuelve 0 si los arreglos son iguales, un valor negativo si el primer arreglo es menor y un valor positivo si el primer arreglo es mayor.
Métodos de la clase Array
La tabla siguiente contiene una lista de todos los métodos.
Métodos
Acción realizada
Devuelve una lista de tamaño fijo respaldada por los arrays especificados.
Busca el elemento especificado en el array con la ayuda del algoritmo de búsqueda binaria.
binarySearch(array, fromIndex, toIndex, key, Comparator)
Busca el objeto especificado en un rango de la matriz indicada utilizando el algoritmo de búsqueda binaria.
Compara dos matrices lexicográficamente: devuelve negativo, 0 o positivo si la primera matriz es menor, igual o mayor, respectivamente.
Copia la matriz especificada, truncando o rellenando con el valor predeterminado (si es necesario) para que la copia tenga la longitud especificada.
Copia el rango especificado de la matriz especificada en una nueva matriz.
Devuelve verdadero si los dos arrays especificados son profundamente iguales entre sí.
deepHashCode(Object[] a)
Devuelve un código hash basado en el "contenido profundo" de los arrays especificados.
Devuelve una representación en cadena de caracteres del "contenido profundo" de las matrices especificadas.
Comprueba si ambos arrays son iguales o no.
Asigna este valor de relleno a cada índice de esta matriz.
Devuelve un hashCode entero de esta instancia de matriz.
Encuentra y devuelve el índice del primer elemento que no coincide entre los dos arrays especificados.
parallelPrefix(originalArray, fromIndex, endIndex, functionalOperator)
Realiza parallelPrefix para el rango dado de la matriz con el operador funcional especificado.
Realiza parallelPrefix para el array completo con el operador funcional especificado.
Establece todos los elementos de este array en paralelo, utilizando la función generadora proporcionada.
Ordena el array especificado utilizando el método de ordenación paralela.
setAll(originalArray, functionalGenerator)
Establece todos los elementos del array especificado utilizando la función generadora proporcionada.
Ordena el array completo en orden ascendente.
Ordena el rango de datos especificado de la matriz en orden ascendente.
ordenar(T[] a, int fromIndex, int toIndex, Comparator< super T> c)
Ordena el rango especificado de la matriz de objetos especificada según el orden inducido por el comparador especificado.
Ordena la matriz de objetos especificada según el orden inducido por el comparador especificado.
Devuelve un objeto Spliterator que abarca todos los arrays especificados.
spliterator(originalArray, fromIndex, endIndex)
Devuelve un Spliterator del tipo de la matriz que abarca el rango especificado de las matrices especificadas.
Devuelve una secuencia de datos con la matriz especificada como origen.
Devuelve una representación en cadena del array, donde los elementos están encerrados entre corchetes [] y separados por una coma y un espacio.
- Semana 15. Desde 07-09-2026 hasta 12-09-2026
Semana 15. Desde 07-09-2026 hasta 12-09-2026
dada la clase se muestran los ejercicios resueltos del tema
Después de la clase y los ejercicios resueltos, realice la siguiente guía de ejercicios.
- SEMANA 16. DESDE 14-09-2026 HASTA 19-09-2026
SEMANA 16. DESDE 14-09-2026 HASTA 19-09-2026
PROGRAMAR EVENTOS EN FORMULARIOS JAVA
Para programar eventos en formularios de Java usando Eclipse, se utilizan los componentes de Java Swing mediante el uso de escuchadores (listeners) que reaccionan a las acciones del usuario, como hacer clic en un botón.
Pasos para programar un evento de clic en un botón
1. Crear el componente: Instancia el botón u otro elemento de la interfaz gráfica dentro de tu clase
JFrame.2. Añadir el escuchador: Usa el método
addActionListenerpara indicarle al componente que escuche cuando ocurra una acción.3. Implementar la acción: Sobrescribe el método
actionPerformedpara escribir el código que se ejecutará.Ejemplo básico de código
java
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class MiFormulario extends JFrame {
private JButton miBoton;
private JTextField miTexto;
public MiFormulario() {// Configuración básica de la ventana
setTitle("Ejemplo de Eventos");setSize(300, 200);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);setLayout(null);
// Inicializar componentes
miTexto = new JTextField();
miTexto.setBounds(30, 30, 200, 25);
add(miTexto);miBoton = new JButton("Saludar");
miBoton.setBounds(30, 70, 100, 30);
add(miBoton);// Programación del evento usando un ActionListener
miBoton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// Código que se ejecuta al hacer clicJOptionPane.showMessageDialog(null, "¡Hola, " + miTexto.getText() + "!");
}});}public static void main(String[] args) {
SwingUtilities.invokeLater(() -> {new MiFormulario().setVisible(true);
});}
}
- SEMANA 17. DESDE 21-09-2026 HASTA 26-08-2026
SEMANA 17. DESDE 21-09-2026 HASTA 26-08-2026
Cómo conectar Java con una base de datos MySQL
Conectar Java con MySQL es una habilidad fundamental para cualquier desarrollador backend o fullstack.
Esta es una guía paso a paso cómo establecer esa conexión usando JDBC (Java Database Connectivity), la API estándar de Java para comunicarse con bases de datos relacionales. Verás cómo ejecutar consultas, insertar registros, actualizar datos, eliminar filas y manejar correctamente los recursos y errores.
Qué es JDBC
JDBC es una API de Java que define un conjunto de interfaces y clases para conectarse a bases de datos relacionales, ejecutar sentencias SQL y procesar los resultados. No es específica de MySQL: el mismo código JDBC funciona con PostgreSQL, Oracle, SQLite o cualquier otra base de datos que tenga un driver compatible.
El driver es la pieza clave: es una biblioteca que implementa las interfaces de JDBC para una base de datos concreta. Para MySQL, el driver oficial se llama MySQL Connector/J.
El flujo de trabajo con JDBC es siempre el mismo:
- Cargar el driver de la base de datos.
- Establecer una conexión con la base de datos.
- Crear una sentencia SQL.
- Ejecutar la sentencia.
- Procesar los resultados (si los hay).
- Cerrar los recursos.
Requisitos previos
Antes de escribir código, necesitas tener instalado y configurado lo siguiente:
- Java JDK: versión 8 o superior.
- MySQL Server: corriendo localmente o en un servidor remoto.
- MySQL Connector/J: el driver JDBC de MySQL.
- Un IDE o editor: IntelliJ IDEA, Eclipse o VS Code.
Si no tienes MySQL instalado, puedes descargarlo desde el sitio oficial de MySQL o usar XAMPP, que incluye MySQL junto con Apache y PHP en una sola instalación.
Paso 1: Agregar el driver MySQL Connector/J
Tienes dos formas de agregar el driver a tu proyecto.
Con Maven (recomendado)
Si tu proyecto usa Maven, agrega esta dependencia en tu archivo pom.xml:
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<version>8.3.0</version>
</dependency>
Con Gradle
implementation 'com.mysql:mysql-connector-j:8.3.0'
Sin gestor de dependencias
Descarga el archivo .jar desde el sitio oficial de MySQL (dev.mysql.com/downloads/connector/j/) y agrégalo manualmente al classpath de tu proyecto. En IntelliJ IDEA: File → Project Structure → Libraries → el ícono + → Java → selecciona el .jar descargado.
Paso 2: Crear la base de datos y la tabla en MySQL
Antes de conectar, necesitas una base de datos con la que trabajar. Abre tu cliente MySQL (MySQL Workbench, DBeaver, o la terminal) y ejecuta:
-- Crear la base de datos
CREATE DATABASE tienda_java;
-- Seleccionar la base de datos
USE tienda_java;
-- Crear la tabla de productos
CREATE TABLE productos (
id INT AUTO_INCREMENT PRIMARY KEY,
nombre VARCHAR(100) NOT NULL,
precio DECIMAL(10, 2) NOT NULL,
stock INT DEFAULT 0,
categoria VARCHAR(50)
);
-- Insertar algunos datos de prueba
INSERT INTO productos (nombre, precio, stock, categoria) VALUES
('Laptop Pro 15', 1299.99, 25, 'Electrónica'),
('Teclado Mecánico', 89.99, 150, 'Periféricos'),
('Monitor 27"', 349.99, 40, 'Electrónica'),
('Mouse Inalámbrico', 45.50, 200, 'Periféricos'),
('Auriculares Bluetooth', 129.99, 75, 'Audio');
Paso 3: Establecer la primera conexión
La clase central de JDBC es DriverManager, que se encarga de establecer la conexión usando una URL de conexión, un usuario y una contraseña.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class ConexionMySQL {
// Datos de conexión
private static final String URL = "jdbc:mysql://localhost:3306/tienda_java";
private static final String USUARIO = "root";
private static final String PASSWORD = "tu_contraseña";
public static void main(String[] args) {
try (Connection conexion = DriverManager.getConnection(URL, USUARIO, PASSWORD)) {
System.out.println("¡Conexión exitosa a MySQL!");
System.out.println("Base de datos: " + conexion.getCatalog());
System.out.println("Driver: " + conexion.getMetaData().getDriverName());
} catch (SQLException e) {
System.out.println("Error al conectar: " + e.getMessage());
System.out.println("Código de error SQL: " + e.getErrorCode());
}
}
}
La URL de conexión tiene el formato:
jdbc:mysql://[host]:[puerto]/[nombre_base_datos]
- jdbc:mysql:// indica el protocolo y el tipo de base de datos.
- localhost:3306 es el host y el puerto. El puerto 3306 es el predeterminado de MySQL.
- tienda_java es el nombre de la base de datos.
Nota el uso de try-with-resources: la conexión se cierra automáticamente al salir del bloque, sin necesidad de llamar a conexion.close() manualmente.
Paso 4: Crear una clase de utilidad para la conexión
En lugar de repetir los datos de conexión en cada clase, lo mejor es centralizar la lógica en una clase utilitaria. En proyectos reales los datos sensibles se guardan en variables de entorno o archivos de configuración, nunca en el código fuente.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class DatabaseConnection {
private static final String URL = "jdbc:mysql://localhost:3306/tienda_java"
+ "?useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true";
private static final String USUARIO = "root";
private static final String PASSWORD = "tu_contraseña";
// Evita instanciar la clase
private DatabaseConnection() {}
public static Connection obtenerConexion() throws SQLException {
return DriverManager.getConnection(URL, USUARIO, PASSWORD);
}
}
Los parámetros adicionales en la URL son importantes:
- useSSL=false: desactiva SSL para conexiones locales de desarrollo.
- serverTimezone=UTC: evita problemas con zonas horarias.
- allowPublicKeyRetrieval=true: necesario en algunas versiones de MySQL 8.
Paso 5: Consultar datos con SELECT
Para ejecutar consultas que devuelven datos usas Statement o PreparedStatement y procesas los resultados con un ResultSet.
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class ConsultarProductos {
public static void main(String[] args) {
String sql = "SELECT id, nombre, precio, stock, categoria FROM productos";
try (
Connection conexion = DatabaseConnection.obtenerConexion();
Statement sentencia = conexion.createStatement();
ResultSet resultado = sentencia.executeQuery(sql)
) {
System.out.printf("%-5s %-25s %-10s %-8s %-15s%n",
"ID", "NOMBRE", "PRECIO", "STOCK", "CATEGORÍA");
System.out.println("-".repeat(65));
while (resultado.next()) {
int id = resultado.getInt("id");
String nombre = resultado.getString("nombre");
double precio = resultado.getDouble("precio");
int stock = resultado.getInt("stock");
String categoria = resultado.getString("categoria");
System.out.printf("%-5d %-25s $%-9.2f %-8d %-15s%n",
id, nombre, precio, stock, categoria);
}
} catch (SQLException e) {
System.out.println("Error en la consulta: " + e.getMessage());
}
}
}
El ResultSet funciona como un cursor que empieza antes del primer resultado. Cada llamada a resultado.next() avanza al siguiente registro y devuelve false cuando no hay más. Para leer los valores usas métodos como getString(), getInt(), getDouble(), etc., pasando el nombre de la columna o su posición.
Paso 6: PreparedStatement para consultas seguras
Statement funciona para consultas fijas, pero nunca debes usarlo para construir SQL concatenando valores del usuario. Eso abre la puerta a inyección SQL, una de las vulnerabilidades más graves y comunes en aplicaciones web.
// ❌ NUNCA hagas esto: vulnerable a inyección SQL
String nombre = request.getParameter("nombre"); // dato del usuario
String sql = "SELECT * FROM productos WHERE nombre = '" + nombre + "'";
// Un atacante podría enviar: ' OR '1'='1 y obtener todos los registros
La solución es PreparedStatement: precompila la consulta con marcadores de posición (?) y luego sustituye los valores de forma segura.
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class BuscarProductos {
public static void buscarPorCategoria(String categoria) {
String sql = "SELECT id, nombre, precio FROM productos WHERE categoria = ?";
try (
Connection conexion = DatabaseConnection.obtenerConexion();
PreparedStatement sentencia = conexion.prepareStatement(sql)
) {
// Sustituir el marcador ? con el valor real (índices empiezan en 1)
sentencia.setString(1, categoria);
try (ResultSet resultado = sentencia.executeQuery()) {
System.out.println("Productos en categoría: " + categoria);
System.out.println("-".repeat(40));
boolean hayResultados = false;
while (resultado.next()) {
hayResultados = true;
System.out.printf("ID: %d | %s | $%.2f%n",
resultado.getInt("id"),
resultado.getString("nombre"),
resultado.getDouble("precio"));
}
if (!hayResultados) {
System.out.println("No se encontraron productos.");
}
}
} catch (SQLException e) {
System.out.println("Error: " + e.getMessage());
}
}
public static void main(String[] args) {
buscarPorCategoria("Electrónica");
System.out.println();
buscarPorCategoria("Periféricos");
}
}
Paso 7: Insertar registros con INSERT
Para sentencias que modifican datos (INSERT, UPDATE, DELETE) usas executeUpdate() en lugar de executeQuery(). Este método devuelve el número de filas afectadas.
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class InsertarProducto {
public static int insertar(String nombre, double precio, int stock, String categoria) {
String sql = "INSERT INTO productos (nombre, precio, stock, categoria) VALUES (?, ?, ?, ?)";
try (
Connection conexion = DatabaseConnection.obtenerConexion();
PreparedStatement sentencia = conexion.prepareStatement(sql,
Statement.RETURN_GENERATED_KEYS) // para obtener el ID generado
) {
sentencia.setString(1, nombre);
sentencia.setDouble(2, precio);
sentencia.setInt(3, stock);
sentencia.setString(4, categoria);
int filasAfectadas = sentencia.executeUpdate();
if (filasAfectadas > 0) {
// Obtener el ID generado automáticamente por AUTO_INCREMENT
try (ResultSet claves = sentencia.getGeneratedKeys()) {
if (claves.next()) {
int idGenerado = claves.getInt(1);
System.out.println("Producto insertado con ID: " + idGenerado);
return idGenerado;
}
}
}
} catch (SQLException e) {
System.out.println("Error al insertar: " + e.getMessage());
}
return -1;
}
public static void main(String[] args) {
insertar("Webcam HD", 79.99, 60, "Periféricos");
insertar("Disco SSD 1TB", 119.99, 90, "Almacenamiento");
}
}
Paso 8: Actualizar registros con UPDATE
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class ActualizarProducto {
public static boolean actualizarPrecio(int id, double nuevoPrecio) {
String sql = "UPDATE productos SET precio = ? WHERE id = ?";
try (
Connection conexion = DatabaseConnection.obtenerConexion();
PreparedStatement sentencia = conexion.prepareStatement(sql)
) {
sentencia.setDouble(1, nuevoPrecio);
sentencia.setInt(2, id);
int filasAfectadas = sentencia.executeUpdate();
if (filasAfectadas > 0) {
System.out.println("Precio actualizado correctamente. ID: " + id);
return true;
} else {
System.out.println("No se encontró ningún producto con ID: " + id);
return false;
}
} catch (SQLException e) {
System.out.println("Error al actualizar: " + e.getMessage());
return false;
}
}
public static boolean actualizarStock(int id, int nuevoStock) {
String sql = "UPDATE productos SET stock = ? WHERE id = ?";
try (
Connection conexion = DatabaseConnection.obtenerConexion();
PreparedStatement sentencia = conexion.prepareStatement(sql)
) {
sentencia.setInt(1, nuevoStock);
sentencia.setInt(2, id);
int filasAfectadas = sentencia.executeUpdate();
return filasAfectadas > 0;
} catch (SQLException e) {
System.out.println("Error al actualizar stock: " + e.getMessage());
return false;
}
}
public static void main(String[] args) {
actualizarPrecio(1, 1199.99); // Laptop Pro 15 baja de precio
actualizarStock(2, 130); // Reducir stock del teclado
}
}
Paso 9: Eliminar registros con DELETE
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class EliminarProducto {
public static boolean eliminar(int id) {
String sql = "DELETE FROM productos WHERE id = ?";
try (
Connection conexion = DatabaseConnection.obtenerConexion();
PreparedStatement sentencia = conexion.prepareStatement(sql)
) {
sentencia.setInt(1, id);
int filasAfectadas = sentencia.executeUpdate();
if (filasAfectadas > 0) {
System.out.println("Producto eliminado. ID: " + id);
return true;
} else {
System.out.println("No existe ningún producto con ID: " + id);
return false;
}
} catch (SQLException e) {
System.out.println("Error al eliminar: " + e.getMessage());
return false;
}
}
public static void main(String[] args) {
eliminar(6); // Eliminar la Webcam HD que insertamos antes
eliminar(99); // ID que no existe
}
}
Paso 10: Transacciones
Una transacción agrupa varias operaciones en una unidad atómica: o todas se ejecutan con éxito, o ninguna se aplica. Es fundamental cuando realizas operaciones relacionadas que deben mantenerse consistentes, como transferir dinero entre dos cuentas o procesar un pedido que descuenta stock y crea un registro de venta.
Por defecto, JDBC trabaja en modo autocommit: cada sentencia se confirma automáticamente. Para usar transacciones debes desactivar ese modo.
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class TransaccionEjemplo {
public static void procesarVenta(int idProducto, int cantidadVendida, double precioTotal) {
String sqlDescontarStock = "UPDATE productos SET stock = stock - ? WHERE id = ? AND stock >= ?";
String sqlRegistrarVenta = "INSERT INTO ventas (id_producto, cantidad, total) VALUES (?, ?, ?)";
Connection conexion = null;
try {
conexion = DatabaseConnection.obtenerConexion();
// Desactivar autocommit para controlar la transacción manualmente
conexion.setAutoCommit(false);
// Operación 1: descontar stock
try (PreparedStatement stmtStock = conexion.prepareStatement(sqlDescontarStock)) {
stmtStock.setInt(1, cantidadVendida);
stmtStock.setInt(2, idProducto);
stmtStock.setInt(3, cantidadVendida);
int filasAfectadas = stmtStock.executeUpdate();
if (filasAfectadas == 0) {
throw new SQLException("Stock insuficiente para el producto ID: " + idProducto);
}
}
// Operación 2: registrar la venta
try (PreparedStatement stmtVenta = conexion.prepareStatement(sqlRegistrarVenta)) {
stmtVenta.setInt(1, idProducto);
stmtVenta.setInt(2, cantidadVendida);
stmtVenta.setDouble(3, precioTotal);
stmtVenta.executeUpdate();
}
// Si todo salió bien, confirmar la transacción
conexion.commit();
System.out.println("Venta procesada correctamente.");
} catch (SQLException e) {
// Si algo falló, revertir todos los cambios
System.out.println("Error en la transacción: " + e.getMessage());
if (conexion != null) {
try {
conexion.rollback();
System.out.println("Transacción revertida.");
} catch (SQLException ex) {
System.out.println("Error al hacer rollback: " + ex.getMessage());
}
}
} finally {
if (conexion != null) {
try {
conexion.setAutoCommit(true); // restaurar el modo autocommit
conexion.close();
} catch (SQLException e) {
System.out.println("Error al cerrar la conexión: " + e.getMessage());
}
}
}
}
}
Paso 11: Estructura completa con patrón DAO
En proyectos reales, el código de acceso a datos no va mezclado con la lógica de negocio ni con la interfaz de usuario. El patrón DAO (Data Access Object) organiza todo el código de base de datos en clases dedicadas, una por entidad.
// Clase que representa un producto (modelo)
public class Producto {
private int id;
private String nombre;
private double precio;
private int stock;
private String categoria;
public Producto(int id, String nombre, double precio, int stock, String categoria) {
this.id = id;
this.nombre = nombre;
this.precio = precio;
this.stock = stock;
this.categoria = categoria;
}
// Getters
public int getId() { return id; }
public String getNombre() { return nombre; }
public double getPrecio() { return precio; }
public int getStock() { return stock; }
public String getCategoria() { return categoria; }
@Override
public String toString() {
return String.format("Producto{id=%d, nombre='%s', precio=%.2f, stock=%d, categoria='%s'}",
id, nombre, precio, stock, categoria);
}
}
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
// Clase DAO: centraliza todo el acceso a datos de Producto
public class ProductoDAO {
// Listar todos los productos
public List<Producto> listarTodos() {
List<Producto> productos = new ArrayList<>();
String sql = "SELECT id, nombre, precio, stock, categoria FROM productos";
try (
Connection con = DatabaseConnection.obtenerConexion();
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery(sql)
) {
while (rs.next()) {
productos.add(mapearResultado(rs));
}
} catch (SQLException e) {
System.out.println("Error al listar productos: " + e.getMessage());
}
return productos;
}
// Buscar por ID
public Optional<Producto> buscarPorId(int id) {
String sql = "SELECT id, nombre, precio, stock, categoria FROM productos WHERE id = ?";
try (
Connection con = DatabaseConnection.obtenerConexion();
PreparedStatement ps = con.prepareStatement(sql)
) {
ps.setInt(1, id);
try (ResultSet rs = ps.executeQuery()) {
if (rs.next()) {
return Optional.of(mapearResultado(rs));
}
}
} catch (SQLException e) {
System.out.println("Error al buscar producto: " + e.getMessage());
}
return Optional.empty();
}
// Insertar un producto
public int insertar(Producto producto) {
String sql = "INSERT INTO productos (nombre, precio, stock, categoria) VALUES (?, ?, ?, ?)";
try (
Connection con = DatabaseConnection.obtenerConexion();
PreparedStatement ps = con.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)
) {
ps.setString(1, producto.getNombre());
ps.setDouble(2, producto.getPrecio());
ps.setInt(3, producto.getStock());
ps.setString(4, producto.getCategoria());
ps.executeUpdate();
try (ResultSet claves = ps.getGeneratedKeys()) {
if (claves.next()) return claves.getInt(1);
}
} catch (SQLException e) {
System.out.println("Error al insertar producto: " + e.getMessage());
}
return -1;
}
// Actualizar un producto
public boolean actualizar(Producto producto) {
String sql = "UPDATE productos SET nombre=?, precio=?, stock=?, categoria=? WHERE id=?";
try (
Connection con = DatabaseConnection.obtenerConexion();
PreparedStatement ps = con.prepareStatement(sql)
) {
ps.setString(1, producto.getNombre());
ps.setDouble(2, producto.getPrecio());
ps.setInt(3, producto.getStock());
ps.setString(4, producto.getCategoria());
ps.setInt(5, producto.getId());
return ps.executeUpdate() > 0;
} catch (SQLException e) {
System.out.println("Error al actualizar producto: " + e.getMessage());
return false;
}
}
// Eliminar un producto
public boolean eliminar(int id) {
String sql = "DELETE FROM productos WHERE id = ?";
try (
Connection con = DatabaseConnection.obtenerConexion();
PreparedStatement ps = con.prepareStatement(sql)
) {
ps.setInt(1, id);
return ps.executeUpdate() > 0;
} catch (SQLException e) {
System.out.println("Error al eliminar producto: " + e.getMessage());
return false;
}
}
// Método privado para mapear una fila del ResultSet a un objeto Producto
private Producto mapearResultado(ResultSet rs) throws SQLException {
return new Producto(
rs.getInt("id"),
rs.getString("nombre"),
rs.getDouble("precio"),
rs.getInt("stock"),
rs.getString("categoria")
);
}
}
// Uso del DAO desde el resto de la aplicación
public class Main {
public static void main(String[] args) {
ProductoDAO dao = new ProductoDAO();
// Listar todos
System.out.println("=== TODOS LOS PRODUCTOS ===");
dao.listarTodos().forEach(System.out::println);
// Buscar por ID
System.out.println("\n=== BUSCAR ID 2 ===");
dao.buscarPorId(2).ifPresentOrElse(
System.out::println,
() -> System.out.println("Producto no encontrado")
);
// Insertar
System.out.println("\n=== INSERTAR ===");
Producto nuevo = new Producto(0, "Hub USB 7 puertos", 34.99, 120, "Periféricos");
int nuevoId = dao.insertar(nuevo);
System.out.println("ID generado: " + nuevoId);
// Actualizar
System.out.println("\n=== ACTUALIZAR ===");
Producto actualizado = new Producto(1, "Laptop Pro 15 (2025)", 1149.99, 20, "Electrónica");
System.out.println("Actualizado: " + dao.actualizar(actualizado));
// Eliminar
System.out.println("\n=== ELIMINAR ===");
System.out.println("Eliminado: " + dao.eliminar(nuevoId));
}
}
Errores comunes y cómo resolverlos
Error
Causa probable
Solución
Communications link failure
MySQL no está corriendo o el host/puerto es incorrecto
Verificar que el servicio MySQL esté activo y revisar la URL de conexión
Access denied for user
Usuario o contraseña incorrectos
Verificar las credenciales en MySQL
Unknown database
La base de datos no existe
Crear la base de datos con CREATE DATABASE
No suitable driver found
El driver MySQL Connector/J no está en el classpath
Agregar la dependencia en Maven/Gradle o el .jar manualmente
Table doesn't exist
La tabla no fue creada en la base de datos
Ejecutar el CREATE TABLE correspondiente
SSL connection error
Versión de MySQL 8 requiere configuración SSL
Agregar useSSL=false&allowPublicKeyRetrieval=true a la URL
Buenas prácticas
- Usa siempre PreparedStatement cuando el SQL incluya valores del usuario. Nunca concatenes strings para construir consultas.
- Cierra siempre los recursos: Connection, Statement y ResultSet. Usa try-with-resources para hacerlo automáticamente.
- No guardes las credenciales en el código fuente. Usa variables de entorno, archivos .properties o un sistema de configuración.
- Usa un pool de conexiones en aplicaciones de producción. Abrir y cerrar una conexión por cada operación es costoso. Bibliotecas como HikariCP gestionan un conjunto de conexiones reutilizables de forma eficiente.
- Separa la lógica de datos con el patrón DAO. El código SQL no debe estar mezclado con la lógica de negocio ni con la interfaz de usuario.
- Maneja los errores con excepciones personalizadas. En lugar de dejar que SQLException llegue hasta las capas superiores, envuélvela en excepciones con significado de negocio.
- Semana 18. Métodos en Java
Semana 18. Métodos en Java
Métodos en Java, funciones y procedimientos. Cómo hacerlos y usarlos
Los métodos en Java, las funciones y los procedimientos, especialmente en Java, son una herramienta indispensable para programar. Java nos permite crear o hacer nuestros propios métodos y usarlos sencillamente como también nos facilita hacer uso de los métodos de otras librerías (funciones matemáticas, aritméticas, de archivos, de fechas, etc. Cualquiera que sea el caso, las funciones permiten automatizar tareas que requerimos con frecuencia y que además se pueden generalizar por medio de parámetros o argumentos. Aprender a crear métodos en Java y usarlos correctamente es de gran importancia, separar nuestro código en módulos y según las tareas que requerimos. En java una función debe contener la implementación de una utilidad de nuestra aplicación, esto nos pide que por cada utilidad básica (abrir, cerrar, cargar, mover, etc.) sería adecuado tener al menos una función asociada a ésta, pues sería muy complejo usar o crear un método que haga todo de una sola vez, por esto es muy buena idea separar cada tarea en una función o método (según corresponda).Para estar claros en todo, en Java es mucho más común hablar de métodos que de funciones y procedimientos y esto se debe a que en realidad un método, una función y un procedimiento NO son lo mismo, veamos la diferencia:
¿Funciones, métodos o procedimientos?
Es muy común entre programadores que se hable indistintamente de estos tres términos sin embargo poseen deferencias fundamentales.
Funciones:Las funciones son un conjunto de líneas de código (instrucciones), encapsulados en un bloque, usualmente reciben parámetros, cuyos valores utilizan para efectuar operaciones y adicionalmente retornan un valor. En otras palabras una función puede recibir parámetros o argumentos (algunas no reciben nada), hace uso de dichos valores recibidos como sea necesario y retorna un valor usando la instrucción return, si no retorna algo, entonces no es una función. En java las funciones usan el modificador static.
Métodos:
Los métodos y las funciones en Java están en capacidad de realizar las mismas tareas, es decir, son funcionalmente idénticos, pero su diferencia radica en la manera en que hacemos uso de uno u otro (el contexto). Un método también puede recibir valores, efectuar operaciones con estos y retornar valores, sin embargo en método está asociado a un objeto, SIEMPRE, básicamente un método es una función que pertenece a un objeto o clase, mientras que una función existe por sí sola, sin necesidad de un objeto para ser usada. Nota: Es aquí donde digo que en Java se debe hablar de métodos y no de funciones, pues en Java estamos siempre obligados a crear un objeto para usar el método. Para que sea una función esta debe ser static, para que no requiera de un objeto para ser llamada.
Procedimientos:Los procedimientos son básicamente un conjunto de instrucciones que se ejecutan sin retornar ningún valor, hay quienes dicen que un procedimiento no recibe valores o argumentos, sin embargo en la definición no hay nada que se lo impida. En el contexto de Java un procedimiento es básicamente un método cuyo tipo de retorno es void que no nos obliga a utilizar una sentencia return.
Crear un método en JavaLa sintaxis para declarar una función es muy simple, veamos:
[acceso] [modificador] tipo nombreFuncion ([tipo nombreArgumento,[tipo nombreArgumento]...]){/* * Bloque de instrucciones */return valor;}EL primer componente corresponde al modificador de acceso, que puede ser public o private, éste es opcional, si no ponemos nada, se asume el modificador de acceso por defecto, el segundo componente es el modificador que puede ser final o static (o ambas), también es opcional. Recordemos que un método o función siempre retorna algo, por lo tanto es obligatorio declararle un tipo (el tercer componente de la sintaxis anterior), puede ser entero (int), booleano (boolean), o cualquiera que consideremos, inclusive tipos complejos, luego debemos darle un nombre a dicha función, para poder identificarla y llamarla (invocarla) durante la ejecución, después al interior de paréntesis, podemos poner los argumentos o parámetros. Luego de la definición de la "firma" del método, se define su funcionamiento entre llaves; todo lo que esté dentro de las llaves es parte del cuerpo del método y éste se ejecuta hasta llegar a una instrucción return.
Acerca de los argumentos o parámetrosHay algunos detalles respecto a los argumentos de un método, veamos:
- Una función, un método o un procedimiento pueden tener una cantidad cualquier de parámetros, es decir pueden tener cero, uno, tres, diez, cien o más parámetros. Aunque habitualmente no suelen tener más de 4 o 5.
- Si una función tiene más de un parámetro cada uno de ellos debe ir separado por una coma.
- Los argumentos de una función también tienen un tipo y un nombre que los identifica. El tipo del argumento puede ser cualquiera y no tiene relación con el tipo del método.
- Al recibir un argumento nada nos obliga a hacer uso de éste al interior del método, sin embargo para qué recibirlo si no lo vamos a usar.
- En Java los parámetros que podemos recibir pueden ser por valor por referencia, esto implica que si modificamos los valores recibidos al interior del método, estos pueden mantener sus cambios o no después de ejecutada el método (esto lo explico con más detalla enseguida).
Consejos acerca de
Debes tener en cuenta dos cosas importantes con la sentencia return:- Cualquier instrucción que se encuentre después de la ejecución de return NO será ejecutada. Es común encontrar funciones con múltiples sentencias return al interior de condicionales, pero una vez que el código ejecuta una sentencia return lo que haya de allí hacia abajo no se ejecutará.
- El tipo del valor que se retorna en una función debe coincidir con el del tipo declarado a la función, es decir si se declara int, el valor retornado debe ser un número entero.
- En el caso de los procedimientos (void) podemos usar la sentencia return pero sin ningún tupo de valor, sólo la usaríamos como una manera de terminar la ejecución del procedimiento.
Ejemplos de métodos
Veamos algunos ejemplos prácticos de métodos en Java.
Ejemplo 1:int metodoEntero()//Función sin parámetros { int suma = 5+5; return suma; //Acá termina la ejecución del método //return 5+5;//Este return nunca se ejecutará //Intenta intercambiar la línea 3 con la 5 //int x = 10; //Esta línea nunca se ejecutará }Como puedes ver es un ejemplo sencillo, es un método llamado metodo Entero, si ejecutas esto, la función te retornará el valor de suma que es 10 (5+5). Las líneas posteriores no se ejecutarán nunca, aunque no generan error alguno, no tienen utilidad. Puedes notar que para este caso es lo mismo haber escrito return suma que escribir return 5+5. Ambas líneas funcionan equivalentemente.
Ejemplo 2:
Ejemplo :
String metodoString(int n)//método con un parámetro { if(n == 0)//Usamos el parámetro en la función { return "a"; //Si n es cero retorna a //Notar que de aquí para abajo no se ejecuta nada más } return "x";//Este return sólo se ejecuta cuando n NO es cero }Ejemplo 3:static boolean metodoBoolean(boolean n, String mensaje)//Método con dos parámetros
{ if(n)//Usamos el parámetro en el método { System.out.println(mensaje);//Mostramos el mensaje } return n; //Usamos el parámetro como valor a retornar }
Aquí creamos un método público, hicimos uso de múltiples sentencia return y aprovechamos la característica de que al ser ejecutadas finalizan inmediatamente la ejecución de la parte restante del método. De este modo podemos asegurar que la función retornará "a" únicamente cuando el valor del parámetro n sea cero y retornará un "x" cuando dicho valor no sea cero.
Cursos de JavaEjemplo 3:
- Semana 19. Desde 05/10/2026 hasta 10/10/2026
Semana 19. Desde 05/10/2026 hasta 10/10/2026
Realizar proyecto Final
Realizar el proyecto Final de Semestre
El mismo debe constituirse de lo siguiente:
1. programa en java
2. formulario principal o de inicio
3.al menos 4 formularios
4. conexión con una base de datos en sql
5. El tema es libre y la fecha de entrega es para el día 17/10/2026
- Tema 24
