Programación
Java Básico desde Cero
Acerca del curso
El curso empieza antes del código: qué hace un programa, cómo se instala Java y cómo se lee un error. Desde ahí avanza por variables, decisiones y ciclos hasta métodos, objetos, colecciones, archivos y pruebas, y cada idea nueva se trabaja sobre los mismos tres escenarios —facturación, almacén y nómina— para no montar un decorado distinto en cada lección.
Al completar el curso, el estudiante podrá analizar un problema sencillo y construir en Java una aplicación de consola que reciba datos, valide entradas, tome decisiones, repita tareas, organice el trabajo en métodos y clases, guarde información en archivos, responda a los fallos sin detenerse y se compruebe con casos de prueba repetibles.
Lo que aprenderás
Al completar el curso, el estudiante podrá:
- Explicar qué es un programa y distinguir un error de compilación, uno de ejecución y uno de lógica.
- Preparar un entorno Java, compilar y ejecutar código desde la terminal.
- Guardar y transformar datos con variables, tipos y operadores.
- Pedir información a quien usa el programa y validarla antes de utilizarla.
- Resolver problemas con decisiones y ciclos, incluidos sus casos límite.
- Organizar una solución en métodos con una responsabilidad clara, y depurarla siguiendo su ejecución.
- Procesar arreglos y cadenas de texto sin salirse de sus límites.
- Modelar entidades del problema con clases, objetos y relaciones entre ellos.
- Elegir entre lista, conjunto y mapa según lo que el problema pida.
- Responder a los fallos con excepciones y conservar información en archivos de texto.
- Diseñar casos de prueba, comprobarlos de forma repetible y mejorar el código sin cambiar lo que hace.
- Construir, probar y explicar un proyecto integrador de consola.
¿Para quién es este curso?
Personas que quieren aprender a programar de verdad y empezar por un lenguaje que se usa en la industria: quienes vienen de un curso de algoritmos y quieren dar el salto al código, quienes trabajan con información y procedimientos —facturación, almacén, nómina, operaciones— y necesitan automatizar parte de su trabajo, y quienes estudian informática y buscan una base que no dé nada por sabido. Los ejemplos no excluyen a otros perfiles.
- No requiere experiencia previa en programación.
- No presupone conocer Java, la terminal ni un entorno de desarrollo.
- Requiere manejo elemental de archivos, carpetas y aplicaciones.
- Las matemáticas se limitan a operaciones aritméticas, porcentajes y comparaciones básicas.
Contenido del curso
- Introducción al Módulo 0
- Unidad 1. Pensar como programador 4 lecciones
- ¿Qué es programar? 35 min
- Cómo piensa una computadora 35 min
- Algoritmos, entrada, proceso y salida 35 min
- Comprobación de la Unidad 1 15 min
- Unidad 2. Conocer Java y preparar el entorno 4 lecciones
- Qué es Java y dónde se utiliza 35 min
- Conocer el editor, los archivos y la carpeta del proyecto 35 min
- Instalar y verificar el JDK 35 min
- Comprobación de la Unidad 2 15 min
- Unidad 3. Completar el primer ciclo de trabajo 3 lecciones
- Crear y ejecutar tu primer programa 35 min
- Reconocer errores de compilación y ejecución 40 min
- Comprobación de la Unidad 3 15 min
- Práctica Local - Mi presentación en Java 45 min
- Examen del Módulo 0 35 min
- Cierre del Módulo 0
- Introducción al Módulo 1
- Unidad 1. Variables y estado 3 lecciones
- Datos, memoria y variables 35 min
- Declaración, inicialización y reasignación 40 min
- Comprobación de la Unidad 1 15 min
- Unidad 2. Representar diferentes tipos de información 4 lecciones
- Tipos enteros y decimales 40 min
- Texto, caracteres y booleanos 40 min
- Constantes y convenciones de nombres 35 min
- Comprobación de la Unidad 2 15 min
- Unidad 3. Transformar y evaluar datos 6 lecciones
- Operadores aritméticos 45 min
- Comparaciones 35 min
- Operadores lógicos 40 min
- Prioridad de operaciones 40 min
- Conversión de tipos y parsing 40 min
- Comprobación de la Unidad 3 20 min
- Práctica Local - Calculadora de presupuesto personal 60 min
- Examen del Módulo 1 35 min
- Cierre del Módulo 1
- Introducción al Módulo 2
- Unidad 1. Comunicar información 4 lecciones
- print, println y saltos de línea 40 min
- Concatenación y formato de salida con printf 40 min
- Diseñar mensajes claros 35 min
- Comprobación de la Unidad 1 15 min
- Unidad 2. Recibir y procesar datos 5 lecciones
- Introducción a Scanner 45 min
- Leer texto y números 45 min
- Diferencias entre next y nextLine 40 min
- Flujo completo de entrada, proceso y salida 45 min
- Comprobación de la Unidad 2 20 min
- Práctica Local - Calculadora interactiva de compras 60 min
- Examen del Módulo 2 35 min
- Cierre del Módulo 2
- Introducción al Módulo 3
- Unidad 1. Construir caminos alternativos 4 lecciones
- Condiciones booleanas e if 45 min
- Alternativas con if/else 40 min
- Condiciones múltiples con else if 40 min
- Comprobación de la Unidad 1 15 min
- Unidad 2. Elegir mediante textos y opciones 3 lecciones
- Comparar cadenas correctamente 45 min
- Menús y opciones con switch 40 min
- Comprobación de la Unidad 2 15 min
- Unidad 3. Convertir requisitos en validaciones 4 lecciones
- Rangos, campos obligatorios y reglas 45 min
- Combinar condiciones 40 min
- Traducir requisitos a decisiones 40 min
- Comprobación de la Unidad 3 15 min
- Práctica Local - Sistema de evaluación de calificaciones 60 min
- Examen del Módulo 3 35 min
- Cierre del Módulo 3
- Introducción al Módulo 4
- Unidad 1. Comprender y elegir un ciclo 5 lecciones
- Modelo mental de un ciclo 40 min
- Ciclo while 40 min
- Ciclo do-while 40 min
- Ciclo for 40 min
- Comprobación de la Unidad 1 20 min
- Unidad 2. Resolver problemas mediante repetición 4 lecciones
- Contadores y acumuladores 45 min
- Promedios, mínimos y máximos 45 min
- Ciclos anidados 40 min
- Comprobación de la Unidad 2 15 min
- Unidad 3. Controlar y diagnosticar ciclos 3 lecciones
- Ciclos infinitos y condiciones de salida 45 min
- break y continue 40 min
- Comprobación de la Unidad 3 15 min
- Práctica Local - Adivina el número con intentos limitados 60 min
- Examen del Módulo 4 35 min
- Cierre del Módulo 4
- Introducción al Módulo 5
- Unidad 1. Dividir una solución en métodos 5 lecciones
- Responsabilidad y reutilización 45 min
- Métodos sin retorno 40 min
- Parámetros y argumentos 45 min
- Métodos con retorno 45 min
- Comprobación de la Unidad 1
- Unidad 2. Reutilizar sin confundir datos 3 lecciones
- Sobrecarga básica 40 min
- Variables locales y alcance 45 min
- Comprobación de la Unidad 2
- Unidad 3. Investigar errores 4 lecciones
- Errores de compilación, ejecución y lógica 40 min
- Leer mensajes y stack traces 45 min
- Depuración paso a paso 45 min
- Comprobación de la Unidad 3
- Práctica Local - Calculadora de compra 75 min
- Examen del Módulo 5
- Cierre del Módulo 5
- Introducción al Módulo 6
- Unidad 1. Trabajar con grupos de valores 6 lecciones
- Crear e inicializar arreglos 40 min
- Índices, tamaño y límites 40 min
- Recorrer con for y for-each 40 min
- Buscar, sumar y calcular promedios 45 min
- Diagnosticar errores de índices 40 min
- Comprobación de la Unidad 1
- Unidad 2. Procesar texto 5 lecciones
- Métodos esenciales de String 45 min
- Comparar, buscar y reemplazar texto 40 min
- Separar texto con split 40 min
- Construir texto con StringBuilder 40 min
- Comprobación de la Unidad 2
- Práctica Local - Analizador de respuestas y palabras 75 min
- Examen del Módulo 6
- Cierre del Módulo 6
- Introducción al Módulo 7
- Unidad 1. Pasar de una entidad a un objeto 4 lecciones
- Estado, comportamiento, clase y objeto 45 min
- Crear atributos y métodos de instancia 45 min
- Instanciar objetos con new 45 min
- Comprobación de la Unidad 1
- Unidad 2. Construir y proteger el estado 4 lecciones
- Constructores y this 45 min
- public, private y visibilidad 40 min
- Getters, setters y validaciones 45 min
- Comprobación de la Unidad 2
- Unidad 3. Representar comportamientos compartidos 3 lecciones
- Miembros de instancia y static 40 min
- Representación con toString 35 min
- Comprobación de la Unidad 3
- Práctica Local - Gestión de estudiantes con datos validados 90 min
- Examen del Módulo 7
- Cierre del Módulo 7
- Introducción al Módulo 8
- Unidad 1. Colaborar mediante composición 4 lecciones
- Relaciones «tiene un» 45 min
- Objetos como atributos 45 min
- Distribuir responsabilidades entre objetos relacionados 40 min
- Comprobación de la Unidad 1
- Unidad 2. Especializar mediante herencia 4 lecciones
- Relación «es un» y extends 45 min
- Constructores y super 40 min
- Sobrescritura y @Override 45 min
- Comprobación de la Unidad 2
- Unidad 3. Programar mediante contratos 4 lecciones
- Polimorfismo básico 45 min
- Clases abstractas 40 min
- Interfaces e implements 40 min
- Comprobación de la Unidad 3
- Práctica Local - Catálogo con diferentes tipos de productos 90 min
- Evaluación del módulo 8
- Cierre del Módulo 8
- Introducción al Módulo 9
- Unidad 1. Crear listas dinámicas y seguras 6 lecciones
- Arreglos y ArrayList 40 min
- Añadir, consultar, reemplazar y eliminar 40 min
- Recorrer, buscar y filtrar 40 min
- Listas de objetos 40 min
- Genéricos y seguridad de tipos 40 min
- Comprobación de la Unidad 1
- Unidad 2. Elegir una colección 4 lecciones
- Valores únicos con Set 40 min
- Claves y valores con Map 40 min
- Elegir la colección adecuada 40 min
- Comprobación de la Unidad 2
- Práctica Local - Inventario de productos en memoria 90 min
- Evaluación del módulo 9
- Cierre del Módulo 9
- Introducción al Módulo 10
- Unidad 1. Reconocer y manejar fallos 4 lecciones
- Qué es una excepción 40 min
- try, catch y finally 45 min
- Capturas específicas y mensajes útiles 40 min
- Comprobación de la Unidad 1
- Unidad 2. Comunicar situaciones inválidas 3 lecciones
- Validar y lanzar con throw 45 min
- Excepciones personalizadas básicas 40 min
- Comprobación de la Unidad 2
- Unidad 3. Leer y escribir archivos de texto 4 lecciones
- Archivos, directorios y rutas 40 min
- Escribir archivos de texto 40 min
- Leer archivos de texto 40 min
- Comprobación de la Unidad 3
- Unidad 4. Convertir archivos en persistencia 3 lecciones
- Convertir líneas en objetos 45 min
- Manejo seguro de recursos 40 min
- Comprobación de la Unidad 4
- Práctica Local - Inventario almacenado en un archivo 120 min
- Evaluación del módulo 10
- Cierre del Módulo 10
- Introducción al Módulo 11
- Unidad 1. Mejorar código existente 5 lecciones
- Nombres, formato y métodos pequeños 40 min
- Evitar duplicación 45 min
- Separar responsabilidades 45 min
- Refactorizar sin cambiar el comportamiento 45 min
- Comprobación de la Unidad 1
- Unidad 2. Diseñar y ejecutar pruebas 5 lecciones
- Casos esperados, límites e inválidos 45 min
- Pruebas manuales estructuradas 40 min
- Comprobaciones automatizadas básicas 50 min
- Código fácil de probar 45 min
- Comprobación de la Unidad 2
- Unidad 3. Planificar y construir la versión mínima 4 lecciones
- Requisitos, historias y criterios de aceptación 45 min
- Diseñar clases, relaciones y operaciones 45 min
- Construir la versión mínima 50 min
- Comprobación de la Unidad 3
- Unidad 4. Completar y demostrar la solución 3 lecciones
- Agregar validación y persistencia 50 min
- Probar, documentar y presentar 45 min
- Comprobación de la Unidad 4
- Práctica Local - Inventario listo para demostrar 120 min
- Evaluación del módulo 11
- Cierre del Módulo 11
Gratis
Inscripciones cerradas
Este curso no recibe inscripciones en este momento.
Este curso incluye:
- 97 horas de contenido
- 144 lecturas
- 47 exámenes con corrección automática
- Acceso por tablet, móvil y PC
- Acceso durante 90 días
Cursos relacionados
Cursos con temática similar
Programación Web con JavaScript
Luis Fortuna Gratis
Desarrollo Web Front-End con Angular
Luis Fortuna Gratis