Saltar navegación

Métodos y excepciones (Parte 1) - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 6 de febrero de 2026 por Gerardo R.

2 visualizaciones

En este vídeo se ve una primera aproximación a los métodos y excepciones.

Más información Transcripción

Descargar la transcripción

Hola y bienvenidos al vídeo número 3, en donde vamos a contar hoy varios conceptos. 00:00:06
Para empezar, vamos a partir desde el entorno de desarrollo, desde NetBeans. 00:00:15
Vamos a partir de nuestro programa principal, del cual partimos siempre. 00:00:23
Y vamos a fijarnos ya en algunos detalles un poquito más precisos. 00:00:28
por ejemplo vamos a fijarnos en que aquí tenemos una clase que nos dice que es pública 00:00:32
y dentro de esta clase que es pública tenemos un método que también es público 00:00:39
de tipo estático y que es el proceso principal 00:00:45
hasta ahora esto no lo habíamos dado mucha importancia 00:00:50
pero bueno vamos a empezar a darle la importancia que se merece 00:00:52
esta modificación de public significa que esta clase puede ser accedida por otras clases 00:00:57
el hecho de que sea estático o estática significa que se creará una copia en memoria 00:01:05
y otras clases podrán acceder a esta copia ya que su modificador es público 00:01:13
La pregunta sería si podríamos tener más de un método dentro de una clase 00:01:21
Sería algo parecido a lo que teníamos cuando hablábamos de los subprocesos en PSAIN 00:01:29
Si recordáis, el concepto de subproceso en PSAIN 00:01:38
Era un programa que estaba junto al programa principal 00:01:41
pero que solamente era llamado cuando era necesario. 00:01:48
En el caso de los métodos también pueden formar parte de la clase principal 00:01:53
y ser llamados cuando los necesitemos. 00:01:58
En este caso tenemos un código que seguramente ya habremos visto 00:02:01
pero básicamente lo que hace es que en el programa principal 00:02:07
se declaran el nombre de una persona y su edad, 00:02:10
se hace una salida por pantalla para pedir los datos al usuario 00:02:15
y una entrada de datos para que podamos capturar estos datos 00:02:20
vamos a ejecutar este programa 00:02:24
aunque ya lo hayamos visto para que veamos la diferencia con lo que queremos mostrar 00:02:27
al ejecutar este programa 00:02:31
aquí en la parte inferior ya nos pide el nombre 00:02:34
vamos a meter por ejemplo mi nombre 00:02:39
y vamos a meter una edad 00:02:42
y como veis, pues bueno, esto que estoy ahora mismo seleccionando 00:02:44
pues es la ejecución o el resultado de la ejecución de nuestro programa 00:02:52
vamos a imaginar ahora que nosotros en vez de querer que el programa se ejecute así 00:02:56
queremos que se vaya borrando la pantalla 00:03:02
vamos a limpiar este área y vamos a agregar un nuevo método a esta clase 00:03:04
al cual le vamos a llamar limpiar pantalla y que va a ser tan sencillo como crearnos aquí debajo del método principal. 00:03:12
Vamos a crear un método público que yo ya tengo por aquí en otro sitio para no perder mucho tiempo. 00:03:27
Lo voy a copiar aquí y aquí tenemos un método público que como vemos está dentro de la clase. Esta llave es la llave de cierre de la clase. El método le he llamado limpiar pantalla. También es estático porque puede ser compartido por aquellas llamadas a la clase que sean instanciadas. 00:03:33
y es público porque significa que está a disposición de aquellas partes del código que lo quieran llamar. 00:04:05
Como veis, esto tiene aquí una parte nueva en la que se habla de excepciones. 00:04:14
No vamos a entrar mucho en detalle, pero vamos a contar un poco qué es esto de las excepciones. 00:04:20
Las excepciones son sucesos que ocurren durante la ejecución de un programa 00:04:25
que normalmente están relacionadas con errores en el sistema. 00:04:30
y una forma de que los programas no aborten es decir no se rompan es gestionando o controlando dichas excepciones 00:04:34
en este caso la función de limpiar pantalla lo que hace es una llamada creando un proceso 00:04:44
y que este proceso va a hacer llamadas a la función CLS del sistema operativo 00:04:49
y por lo ello tengo que hacer llamadas 00:04:55
o mejor dicho capturas de excepciones 00:05:00
por si acaso se produce un error 00:05:04
la única salvedad que tengo que hacer 00:05:05
en el uso de excepciones 00:05:11
es que para capturarlas 00:05:13
pues tengo que tener en cuenta 00:05:15
que hay que importar determinadas clases 00:05:17
así que yo voy a poner aquí 00:05:19
la importación de las clases que necesito 00:05:21
y repito otra vez que ahora mismo no le voy a dar mucha importancia a las excepciones 00:05:24
porque lo que estamos intentando ver es el comportamiento de los métodos dentro de las clases 00:05:30
entonces una vez que tengamos este programa, bueno las excepciones 00:05:39
normalmente se propagan a las clases, a los métodos que las llaman 00:05:46
y como las llamadas las vamos a hacer aquí, pues entonces seguramente nos va a dar error si no lo ponemos aquí, ¿vale? 00:05:52
Pero no lo voy a poner para que veáis lo que pasa. 00:05:59
Vamos a llamar aquí al método limpiar pantalla, limpiar pantalla, 00:06:05
cuyo objetivo simplemente es hacer un clear screen de la pantalla, 00:06:13
Es decir, que me pida el nombre, se limpie la pantalla, me pida la edad, se limpie la pantalla y por último, al mostrar los datos, también se limpie la pantalla. 00:06:21
Bueno, como veis aquí ya nos está marcando un error porque evidentemente como desde el programa principal, que es esto, desde el método principal, mejor dicho, voy a reducir un poco la pantalla para que se entienda un poquito mejor. 00:06:32
Desde este método principal vamos a llamar a este método, digamos que está en segundo lugar, no digo lo de segundo lugar porque sea menos importante, sino porque es un método adicional, pero como veis la llamada es a un método diferente. 00:06:44
entonces el arrojo de excepciones que se produzcan en este método secundario o auxiliar 00:07:03
no son propagables aquí a menos que yo también capture aquí las excepciones 00:07:13
así que lo que voy a hacer aquí es copiar esta parte que básicamente lo que hace es declarar 00:07:20
que en esta parte también se pueden producir excepciones provocadas obviamente por la llamada a esta función 00:07:25
o a este método, una vez que ponemos esto 00:07:31
pues ya la gestión de excepciones que se produzca aquí 00:07:36
si la llamada procede aquí va a subir a este método y la gestión 00:07:40
de excepciones también va a ser visible desde el proceso 00:07:45
main, pero al ejecutarlo 00:07:48
vamos a guardarlo, al ejecutarlo os vais a dar cuenta de una 00:07:53
parte, de una cosa curiosa, vamos a ejecutar el código 00:07:56
aquí abajo, perdón, aquí abajo aparece de nuevo 00:08:00
que le demos los datos, le damos el nombre 00:08:07
nos pide la edad y aparece la información 00:08:10
y alguien dirá, entonces, ¿para qué hemos puesto 00:08:17
esto de limpiar pantalla? Todo el mundo habrá observado que 00:08:21
he generado aquí un nuevo método que te limpia la pantalla 00:08:24
pero sin embargo no hemos conseguido el objetivo que queríamos 00:08:28
Pues bien, esto ocurre porque el IDE no es capaz de interpretar esto de aquí 00:08:32
Porque esto son llamadas a las funciones del sistema operativo 00:08:38
Y alguien dirá, entonces, ¿para qué me sirve esto en realidad? 00:08:44
Bueno, para poder ver el uso de esto y la utilidad 00:08:48
Voy a hacer un clear aquí 00:08:51
lo que vamos a hacer es sacar el símbolo del sistema 00:08:54
aunque antes os quería enseñar aquí en principal 00:09:02
si os vais a propiedades 00:09:07
os dice en el apartado source 00:09:08
os dice la ruta de vuestro proyecto 00:09:13
esta es la ruta de vuestro proyecto 00:09:16
Si ahora sí sacamos el símbolo de sistema, voy a moverlo para no perder las dos pantallas, y nos metemos en esta ruta, ahora mismo estamos en CD Users, trabajo, bueno, esto es en mi máquina, vosotros tendréis que ver cuál es la ruta en la vuestra, y entramos o navegamos hasta esa ruta, vamos a la carpeta NetBeans, 00:09:18
vamos a la carpeta principal 00:09:47
y voy a borrar la pantalla con el CLS 00:09:53
hacemos un DIR para mostrar los directorios 00:09:58
y vemos aquí el directorio SRC 00:10:01
que es donde está el source 00:10:05
hacemos un CD SRC 00:10:07
hacemos un DIR 00:10:10
y vemos aquí que aquí hay un mail 00:10:13
una carpeta mail 00:10:15
voy a hacer un CLS para que no os perdáis todo 00:10:17
cd main, lo único que estoy haciendo es navegar a través de los directorios 00:10:20
que me encuentro, hago un dir para volver a listar directorios y me encuentro 00:10:26
otro directorio que es java, vale, vamos a meternos dentro 00:10:30
hacemos un cls, un dir y ya aquí vemos que aparece el com 00:10:33
alguien dirá, ¿esto de com qué es? vale, pues esto de com, fijaos que aquí arriba 00:10:41
aparece el paquete com my company 00:10:44
punto principal y debajo ya estaría el fichero 00:10:49
principal punto java qué significa eso pues que si sigo esta ruta a partir de aquí voy a encontrar 00:10:52
este fichero vale así que vamos a hacer cd con vamos a hacer hundir para que veáis que esto es 00:11:00
así fijaos que aquí aparece en my company que es justo lo que aparece aquí en el dominio este que 00:11:09
hemos puesto cd mycompany y cd principal que aparece también aquí. Vamos a hacer un cls y 00:11:14
vamos a hacer un dir para que veáis el contenido del directorio. Como veis aquí aparece ya un 00:11:29
fichero que es principal.java y que justo coincide con el que tenemos aquí. Cuando nosotros tenemos 00:11:36
un fichero java y tenemos ya la utilidad instalada, podemos también hacer uso del compilador 00:11:43
de modo que nos puede compilar el programa en este mismo lugar. ¿Cómo se haría? Pues 00:11:49
se haría de la siguiente forma. Si escribimos java c, que significa que vamos a compilar 00:11:56
un programa en java y le ponemos el nombre del programa, punto java, en este caso como 00:12:04
no hay errores o no debería haber errores nos va a compilar bien le damos a enter y si no da 00:12:10
errores se supone que se ha compilado si ahora queremos ejecutar el programa en vez de con java 00:12:16
hace lo vamos a hacer con java y vamos a poner principal punto cuando hagamos esto no se va a 00:12:22
compilar el programa fijaos la diferencia entre los dos comandos voy a centrar un poco más la 00:12:32
ventana y fijaos que ahora lo que quiero es ejecutar vale al ejecutar aquí el programa 00:12:38
veis que lo primero que ha pasado es que se ha borrado la pantalla vale esto es una cosa que 00:12:48
no pasaba en la ejecución del otro programa vale si recordáis lo que hacía nuestro programa voy 00:12:53
a volver a ver si lo puedo enseñar aquí este limpiar pantalla es el primero que se ha ejecutado 00:12:59
ejecutado y voy a quitar esto. El primero que se ha ejecutado nos va a pedir el nombre 00:13:04
y una vez que tengamos este nombre nos va a permitir introducir la edad. Así que siguiendo 00:13:10
con la práctica esta que estamos haciendo, vamos a meterle el nombre y cuando lo introduzcamos 00:13:17
debería borrar la pantalla de nuevo. Veis que se ha borrado la pantalla y ahora sí 00:13:23
nos permite meter la edad 00:13:29
cuando introduzcamos la edad 00:13:32
veis que, voy a poner esto un poquito al lado 00:13:35
cuando introduzcamos la edad y pulsemos enter 00:13:37
pues se va a ejecutar esta parte de aquí 00:13:40
es decir, nos mostrará solamente los datos 00:13:42
borrando previamente la pantalla 00:13:45
y bueno, pues aquí tenéis 00:13:47
que se ha borrado la pantalla 00:13:50
nos muestra aquí 00:13:52
los datos del usuario que hemos introducido 00:13:53
y bueno, aquí nos sale la línea del PROM 00:13:56
porque ya el programa ha terminado, entonces como resumen de esta primera parte del vídeo, porque quiero hacer una continuación de este vídeo, como veis hemos tocado varias cosas, en primer lugar que una clase no tiene por qué tener un solo método, 00:13:59
En este caso tenía el método main, pero le hemos añadido un método adicional que es limpiar pantalla. 00:14:25
En segundo lugar, el modificador public hace que este método sea accesible a cualquier clase que lo instante. 00:14:33
El modificador static lo hace para que todos los que instancen este método lo hagan compartiendo el mismo código. 00:14:43
y por último que el uso de algunas llamadas a funciones dentro de la aplicación 00:14:51
podrían producir errores que podemos gestionar mediante el uso de excepciones 00:15:00
y aunque no hemos insistido mucho en cómo gestionar estas excepciones 00:15:04
que veáis que si no ponéis este uso de excepciones pues la aplicación no va a funcionar 00:15:08
obviamente habrá que hacer importación de estas librerías 00:15:14
para que podamos hacer la gestión apropiada 00:15:20
de este tipo de funciones 00:15:22
bueno, vamos a dejar el vídeo aquí 00:15:26
y en el siguiente vídeo vamos a intentar 00:15:29
hacer una pequeña modificación en este programa 00:15:32
para volver a añadir algún método más 00:15:35
Idioma/s:
es
Materias:
Sistemas Microinformáticos y Redes
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado básico
      • Primer Curso
      • Segundo Curso
    • Ciclo formativo de grado medio
      • Primer Curso
      • Segundo Curso
    • Ciclo formativo de grado superior
      • Primer Curso
      • Segundo Curso
Autor/es:
Gerardo Ruiz Criado
Subido por:
Gerardo R.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
2
Fecha:
6 de febrero de 2026 - 12:58
Visibilidad:
Clave
Centro:
IES LA ARBOLEDA
Duración:
15′ 40″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
299.65 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid