Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Introducción a Netbeans IDE - Maven - Swing - 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 18 de noviembre de 2024 por Pedro Luis L.

138 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, vamos a ver un IDE muy interesante que es este, NetBeans. 00:00:00
Está escrito en Java y es muy bueno para hacer proyectos en Java. 00:00:07
Tiene una herramienta bastante interesante para hacer herramientas gráficas 00:00:14
y vais a ver que es muy similar a todos los editores, o mejor dicho, a todos los IDEs. 00:00:18
Para empezar, ¿cómo se crea un proyecto? 00:00:24
Bueno, aquí en esta parte voy a tener los proyectos 00:00:26
Para crear un nuevo proyecto de aquella file 00:00:29
New project 00:00:30
Y aquí me dice que elija el tipo de proyecto 00:00:32
Bueno, pues puede ser 00:00:35
Un proyecto Maven, un proyecto Gradle 00:00:37
Voy a elegir Maven 00:00:40
Por eso de que no lo hemos visto antes 00:00:42
Y le damos a continuar 00:00:45
Bueno, otra cosa que venía ahí 00:00:47
Que era un proyecto Hado 00:00:51
Voy a hacerlo otra vez 00:00:52
Lo cierro antes de tiempo 00:00:55
bueno, aquí tengo el proyecto creado, que no me interesa el proyecto, por la razón que sea 00:00:58
bueno, pues aquí se puede borrar, veis que aquí pone borrar 00:01:05
borro el proyecto, sí, sí, quiero borrar todo, incluso 00:01:10
las fuentes, si le dices borrar, solamente te quita el proyecto 00:01:14
del IDE, no borra los ficheros, pero si activo esta opción, borra todo 00:01:18
el proyecto del IDE y los ficheros, bueno, pues me cargo el proyecto 00:01:22
ahí está, está borrando, venga 00:01:27
Mira, tú puedes, curiosamente no me está aquí, esto de aquí es un control de la RAM que está consumiendo. 00:01:32
Como lo tengo a un nivel muy básico, pues no está consumiendo mucha RAM. 00:01:43
Bueno, vamos a crear un nuevo proyecto de nuevo. 00:01:48
Voy a elegir Maven, aunque podría decir Gradle, y aquí elijo el tipo de proyecto. 00:01:52
Pues voy a elegir un proyecto Java. 00:01:57
Siguiente. 00:01:59
Nombre del proyecto, voy a llamarlo Ejemplo 2. 00:02:01
Y luego, el paquete. Aquí hay que decirle el nombre del paquete. Si fuésemos una organización, por ejemplo, trabajo en Microsoft, pondría com.microsoft. Normalmente suele ser la URL de la empresa. 00:02:07
¿Qué no tienes empresa? Pues local.ejemplo2. ¿De acuerdo? Esto si no tenemos nombre de la empresa. Creo el proyecto. Le doy tiempo. ¿Vale? 00:02:24
Y aquí muy importante, antes de empezar vais a ver que sale un proyecto en negrita, este es el proyecto principal, si doy a hacer cualquier operación la va a hacer sobre el proyecto principal, como voy a trabajar en el ejemplo 2 lo tengo que poner como proyecto principal, pues me voy aquí a run, donde pone run, pone aquí set my project y elijo el ejemplo 2, vale, vamos a ver que me ha creado, me voy aquí a los paquetes fuentes y aquí tengo el ejemplo 2, aquí está el ejemplo 2 00:02:42
que es un simple hola mundo, si lo doy a ejecutar en este botón de aquí 00:03:12
y me voy aquí a esta pestaña que pone output 00:03:15
lo compila, va a tardar un poquito, porque ahora el Maven 00:03:19
hace exactamente lo mismo que Gradle 00:03:24
busca dependencias, compila y demás, pues está haciendo exactamente lo mismo 00:03:27
como no le he puesto dependencias, pues no ha tardado casi nada, mirad 00:03:32
veis que dice aquí hello world, el típico hello world 00:03:36
de aquí, del típico 00:03:38
Heleware 00:03:40
voy a meterle 00:03:40
aquí más líneas de código, esto 00:03:44
voy a copiarme esta, un poquito más para ver 00:03:46
unas cosas interesantes que tiene 00:03:48
voy a pegarle 00:03:50
varias 00:03:52
antes de eso me voy a crear una variable 00:03:53
i igual a 0 00:03:57
y aquí voy a 00:04:00
poner 00:04:02
más 00:04:02
y más más 00:04:05
me voy a copiar esta línea, mira 00:04:08
me la voy a copiar varias veces 00:04:10
por una cuestión 00:04:12
que me interesa ver ahora 00:04:14
me la copié muchas veces 00:04:17
y ahora la tengo copiada 00:04:20
bueno, aquí puedo guardar 00:04:24
si no, control S para guardar 00:04:27
y ahora lo ejecuto 00:04:29
si lo ejecuto, pues vamos a ver 00:04:31
que pondrá hello world y un número 00:04:32
pero muchas veces, es todas las veces que he puesto aquí 00:04:34
le damos paciencia 00:04:39
le he puesto que y vale 0 y más más significa incrementar en 1. 00:04:40
Entonces aquí, aquí valdrá 0, aquí pondrá Hello World, 00:04:45
aquí pondrá 1, 2, 3, 4, porque más más significa aumentar en 1. 00:04:49
¿Lo veis ahí? He puesto 0, luego no he puesto de nada, 00:04:54
luego 1, 2, 3, vale. 00:04:58
Vamos a ver una cosa interesante. 00:05:00
El debug, vamos a empezar por aquí por el debug. 00:05:02
Debug sirve para encontrar errores en nuestros programas. 00:05:04
programas entonces yo puedo elegir una línea buena que me activa el punto de ruptura pulso 00:05:07
botón derecho y donde pone aquí break point dice todo el berth point vale he activado un 00:05:12
punto de ruptura y le voy a poner otro más o menos por aquí a la mitad he puesto dos puntos 00:05:18
de ruptura entonces el código se va a ejecutar hasta que encuentra algún punto de ruptura ahora 00:05:24
ha aparecido esto de acuerdo este menú que no estaba antes esto es para ver pues el modo 00:05:29
de book el modo de errores si le doy a ejecutar va a ejecutar hasta llegar al primer punto de 00:05:36
ruptura vaya me ejecuta el que no es este mes este a ver este ejecuta hasta que llegue el 00:05:41
primer punto de ruptura vale pero que me está ejecutando el proyecto que no es ahora b 00:05:49
Bien, otra vez más, debug main project, ahora aparece este menú que antes no salía, está preparando todo el entorno de ejecución, aquí lo veis, para hacer el debug, 00:05:59
ya ha llegado, ha ejecutado la primera línea y ha llegado aquí al primer punto de ruptura, o sea, la ejecución va pasito a pasito, en el modo debug va pasito a pasito, 00:06:16
hasta que llega al primer punto de ruptura, y me dice, mira, aquí en variables, dice, has definido la variable i, y veo que tengo estos botones, 00:06:26
este botoncito de aquí significa pasar a la siguiente línea, si pasamos a la siguiente línea, veis que i ha aumentado en 1, ¿no?, ¿de acuerdo?, 00:06:35
porque aquí sumábamos 1 ahí, y se ha quedado al principio de esta línea, si vemos el output, veis que ha ejecutado esta línea roja, 00:06:43
y ahora está en la verde, antes de la verde, antes de ejecutarla, si le doy a siguiente, ¿veis? Ha puesto ahí el hello world, hello world, ahora está en esta línea de aquí, está haciendo el debug, ¿vale? 00:06:52
Voy ejecutándolo línea a línea. En esta línea, ¿qué va a hacer? Pues va a poner hello world y a ver, ¿y cuánto valía? Uno, ¿no? Pues pues va a poner uno y le va a incrementar en uno, ¿vale? 00:07:03
O sea, el más más significa sumar después de la operación, o sea, es como este más más que he puesto aquí, significa que le suma uno después de que ejecute la instrucción. Pues le ha sumado uno y le ha puesto dos. Y si veo el output, pondrá hello world, hello world uno. ¿De acuerdo? Porque el más más, si lo pongo detrás, significa que sume después. 00:07:16
si le voy dando, salta la siguiente instrucción 00:07:37
y así sucesivamente, con este salta la siguiente 00:07:40
instrucción, imaginaos 00:07:42
que quiero, pues estas instrucciones me las quiero 00:07:44
saltar, hemos visto que 00:07:46
voy viendo lo que vale 00:07:48
la variable, imaginaos que estas instrucciones 00:07:50
me las quiero saltar y quiero llegar 00:07:52
a esta instrucción de aquí 00:07:54
¿de acuerdo? directamente, pues tengo aquí 00:07:55
el state 00:07:58
el run to cursor 00:07:59
¿de acuerdo? lo que hace es que vais a ver 00:08:02
que salta estas instrucciones 00:08:04
hasta llegar al siguiente punto de ruptura, ahí está, se ha saltado todas estas instrucciones hasta llegar al siguiente punto de ruptura 00:08:05
y ahora podría seguir continuando aquí o en una o en una, la vemos ahí que la va ejecutando de una en una, va poniendo los outputs 00:08:14
o bien si le vuelvo a dar, si le vuelvo a dar y ya está, vais a ver que no hay más puntos de ruptura, va a ejecutar hasta el final 00:08:22
¿Veis? Ha ejecutado ya hasta el final 00:08:32
Se acabó la ejecución 00:08:36
Y me quita el entorno de debug 00:08:37
Vamos a ver 00:08:39
Bueno, los puntos de ruptura se pueden quitar 00:08:42
Aquí simplemente botón derecho 00:08:44
Y lo quito 00:08:46
Bueno, lo he desactivado 00:08:47
Activo 00:08:50
O directamente quitarlo con el tab 00:08:52
Lo quito 00:08:55
O también haciendo clic, lo quito 00:08:57
¿Qué más cosas interesantes tiene? 00:08:59
Vamos a ir viendo los menús 00:09:02
que tiene uno a uno. 00:09:04
Bueno, File, Menu File. 00:09:06
Menu File, pues el típico menú File 00:09:08
de todos los editores de texto o todos los procesadores. 00:09:09
Sí que tiene dos opciones muy interesantes, 00:09:13
que son Export, que exporta un fichero zip, 00:09:14
y luego lo puedes importar como fichero zip. 00:09:16
¿De acuerdo? 00:09:18
Puedo importar ficheros de Clix, 00:09:19
porque Clix es un entorno rey en Java. 00:09:21
Bueno, y aparte, pues imprimir páginas y cosas así. 00:09:24
El típico menú de edición, 00:09:27
sí que tiene una acción curiosa. 00:09:29
Bueno, el típico menú de edición 00:09:32
de deshacer, copiar y pegar y tiene una opción curiosa que es control mayúsculas D 00:09:34
que te permite pegar el historial, o sea, ves aquí todo lo que has ido copiando 00:09:40
y puedes pegar desde el historial, ¿de acuerdo? 00:09:45
Control Z, así puedes luego encontrar, buscar cosas, grabar macros, 00:09:50
o sea, puedes grabar un conjunto de texto y luego cuando dispares la macro se ejecuta ese texto. 00:09:59
Bueno, este es el menú View 00:10:04
Para ver las distintas barras de tareas 00:10:07
Si lo pones en pantalla completa 00:10:12
Si quieres ver solo el editor 00:10:14
Porque fijaros que me ha chupado todo el espacio 00:10:15
Entonces si le doy aquí, control mayúsculas, intro 00:10:17
Se pone menú completo 00:10:22
Y si pongo control mayúsculas, intro 00:10:24
Me quita el editor completo 00:10:26
Esto es muy útil 00:10:30
Esto es muy útil para saber 00:10:32
Lo que estás haciendo 00:10:34
Porque en esta ventanita tan pequeña 00:10:35
Es difícil programar 00:10:37
Puedo navegar por el código 00:10:38
O sea, puedo ir a ficheros, buscar símbolos, etc 00:10:40
Ir a una línea, eso debe ser muy útil 00:10:43
Oye, un error en tal línea 00:10:45
Pues control G y salto a esa línea 00:10:46
O puedo poner bookmarks 00:10:48
El bookmark es un marca páginas 00:10:50
Por ejemplo, voy a poner un bookmark aquí al final 00:10:53
Pues me voy aquí, navegar 00:10:55
Añado un bookmark 00:10:56
Acaba de añadir un bookmark 00:10:58
entonces ahora me voy a otra parte del código 00:11:00
y por alguna razón quiero saltar a ese punto 00:11:02
por la razón que sea, pues me voy 00:11:05
a los bookmarks, salto al siguiente 00:11:06
pulso intro 00:11:08
y veis que salta, bueno me ha saltado 00:11:10
es que tenía un bookmark 00:11:13
en otro, mira, me ha servido de ejemplo 00:11:14
he metido dos bookmarks, este es un bookmark 00:11:16
que tenía en otro fichero, pues me ha saltado 00:11:19
al bookmark, al marca páginas que tenía en otro 00:11:20
fichero, me ha servido 00:11:22
me ha servido de ejemplo, no era el bookmark 00:11:24
al que quería saltar, pero bueno, vamos a ver si salto 00:11:26
ahora 00:11:28
a ver, claro, este 00:11:29
ahora, este es el bookmark 00:11:33
al que quería saltar, ¿vale? pero que veis 00:11:38
que puede saltar incluso a otro fichero que tengo cerrado 00:11:40
fuente 00:11:42
aquí el menú fuente 00:11:44
este es interesante 00:11:46
bueno, imaginaros, por ejemplo 00:11:47
la primera opción, el de formato, esta se usa mucho, imaginaos 00:11:50
que copiáis y pegáis un texto 00:11:52
¿no? copiáis y pegáis 00:11:54
y cuando copias y pegas 00:11:56
lo habitual es que se copia así de mal 00:11:58
¿vale? el texto te queda 00:12:00
suele quedar pues así, mal intentado, esto está mal y esto en un examen te lo puntúan como mal 00:12:02
y de hecho si estás en un proyecto de software y esto no lo respetas seguramente te regañan 00:12:07
y bien hecho por regañarte porque vais a ver que es muy incómodo, entonces marco la parte que quiero reformatear 00:12:12
me voy aquí a source, elijo formato y vais a ver que automáticamente me pone el formato automático 00:12:21
aquí hay más opciones, si os habéis fijado 00:12:29
con estas dos opciones 00:12:33
sirven para, yo selecciono 00:12:34
un cacho de texto 00:12:37
esto es común a todos los editores 00:12:38
selecciono una parte de texto y luego 00:12:41
con el tabulador lo intento 00:12:43
y con mayúsculas tabulador lo desintento 00:12:45
esto se usa mucho y es algo común 00:12:47
en todos los editores 00:12:49
¿qué más tenemos aquí en source? 00:12:50
bueno, subir, bajar, duplicar 00:12:53
poner o quitar comentarios 00:12:55
aquí le he puesto el comentario 00:12:57
Se lo quito, ¿de acuerdo? 00:12:59
Si marcó, pues lo habéis visto que pone 00:13:03
Y quita el comentario, esto es útil 00:13:05
¿Qué más? 00:13:06
Completar código 00:13:09
Esto básicamente lo suelo hacer 00:13:10
Según estás escribiendo 00:13:13
¿De acuerdo? Insertar 00:13:14
Arreglar el código, esto es una opción interesante 00:13:16
Si meto la pata 00:13:19
Si meto la pata, él puede intentar arreglarlo 00:13:20
Bueno, este no lo va a arreglar 00:13:23
Pero bueno, me va a dar la sugerencia 00:13:25
Si pongo aquí ratón, habéis visto que lo he subrayado en rojo 00:13:26
Si pongo aquí retorno, me dice, oye, que espera un punto y coma. 00:13:30
Pulsa al intro para ver las pistas. 00:13:33
Aquí me dice que te falta el punto y coma. 00:13:37
Vale, pues le pongo el punto y coma. 00:13:40
Bueno, este ejemplo ya he dicho que no lo iba a corregir, 00:13:42
pero hay otro tipo de códigos que sí que los corrige, o sea, sí que detecta fallos. 00:13:44
Si aquí a la variable, la voy a nombrar mal, la he llamado con la mayúscula. 00:13:48
De acuerdo, fijaos que de repente aquí me han salido un montón de errores 00:13:55
Y aquí me sale como una especie de albentencia. Esto no es un error. Me dice la variable nunca, nunca se lee. ¿De acuerdo? Y me dice, ¿la quieres quitar? Pues no, no la quiero quitar. ¿Vale? Porque está pensando que eso es un error. 00:13:58
Aquí, por ejemplo, me dice, oye, la variable y minúscula no existe. Pues mira, puedes crearla. La vamos a crear. Si le decimos crear, la crea. Claro, la ha creado como un string, ¿vale? Hace lo que puede. Si os fijáis, él lo intenta. Él al menos lo intenta. A veces acierta. Sobre todo lo vais a ver ahora con los import. Ahora vamos a hacer un ejemplo de importar una cosa y vais a ver que los import está bien para los import. 00:14:12
Luego tengo, bueno, aparte de todo esto, vale, refactorizar. Esto sirve, lo veremos más adelante en el curso, de hecho tenemos un tema solamente dedicado a refactorización, pero refactorizar, un adelanto a lo que es la refactorización, es modificar el código para que sea más legible. 00:14:37
El objetivo de refactorizar es que el código sea más legible. ¡Ojo! Eso no significa que sea más óptimo. ¿O no? Después de refactorizar el código puede ser más óptimo o no serlo. ¿De acuerdo? Pero refactorizar es simplemente que sea más legible. 00:14:57
Entonces, por ejemplo, una cosa que se suele hacer mucho en refactorización es cambiarle el nombre a las variables. 00:15:12
Por ejemplo, y no representa nada, ¿de acuerdo? 00:15:17
A lo mejor me interesa ponerle un nombre más largo, más representativo. 00:15:22
Pues entonces, con mayúsculas, cursor, selecciono lo que quiero, cambiar, me voy a refactorizar, rename, 00:15:25
y aquí le pongo el nuevo nombre que quiero que tenga. 00:15:36
Pues le voy a poner contador. 00:15:38
Y si os fijáis, ahora cuando dé aquí refactorizar, fijaros lo que va a pasar con estas IEs. 00:15:40
¡Hala! Las ha cambiado. 00:15:46
Y lo hace bien. 00:15:48
O sea, no es un simple buscar y reemplazar, porque yo con un editor de toda la vida podía buscar y reemplazar. 00:15:49
No, no. Es que lo hace bien. 00:15:55
Bueno, aquí hay muchas opciones que por ahora nos vamos a saltar. 00:15:57
Ejecutar. Vale, el menú ejecutar. 00:16:02
Este tiene varias opciones interesantes. 00:16:05
Bueno, Build simplemente compila el proyecto. 00:16:07
Si le doy a build, simplemente lo compila, no lo ejecuta. Esto viene bien para cuando meto dependencias, pues para que las descargue o simplemente para ver si voy bien. 00:16:09
Oye, ¿compila el código? Sí, pues hala, compila el código. Voy a probar cada uno de los errores para que veáis. 00:16:21
Bueno, cuando cometas un error vais a ver que ya te lo dice aquí, ¿de acuerdo? Pero a veces puedes tocar un archivo y ese archivo tener consecuencias en otro. 00:16:27
¿de acuerdo? puedes trabajar en una clase 00:16:36
en un sitio, cambiar el nombre a una variable 00:16:39
y esa variable a lo mejor la estás usando en otro archivo 00:16:41
entonces te da un error 00:16:43
puede venir bien 00:16:44
y eso no lo vas a ver 00:16:47
porque no estás editando el otro archivo 00:16:48
pues entonces acabo de cometer un error 00:16:51
adrede, si le doy aquí a compilar 00:16:53
me va a decir aquí el error 00:16:55
ya sé que está aquí 00:16:59
lo estoy viendo, pero si yo no lo viera 00:17:00
por la razón que fuera 00:17:03
me lo va a decir 00:17:04
aquí mirad, me dice 00:17:06
error está en el archivo 00:17:09
el error está en el archivo 00:17:11
ejemplo 2 00:17:13
y me dice que me falta un punto y coma 00:17:14
en la línea 17, lo veis ahí 00:17:17
aquí dice la ruta, el archivo 00:17:19
la línea, la columna 00:17:21
donde espera estar el error 00:17:23
y luego el error que he encontrado, porque hace falta 00:17:24
un punto y coma, si hago clic aquí 00:17:27
me salta donde está el error 00:17:29
me voy a poner en otra línea, me voy a poner en otro sitio 00:17:31
si hago clic en el error 00:17:33
me salta donde está el error 00:17:34
y aquí le pongo el punto incómodo 00:17:37
y acabamos 00:17:39
¿puedo limpiar? 00:17:39
esto es limpiar y compilar 00:17:43
esto es muy interesante 00:17:45
cuando tienes muchas dependencias 00:17:47
y has hecho una limpieza 00:17:48
entonces te has descargado 00:17:49
todas las dependencias 00:17:51
y están ahí molestando 00:17:52
imaginaos que hay un archivo 00:17:54
del que antes dependías 00:17:56
una dependencia 00:17:57
una biblioteca de la que antes dependías 00:17:58
que de repente la quitas 00:18:00
entonces si antes la usabas 00:18:02
Pues la has descargado y está ocupando espacio 00:18:05
Entonces la podemos limpiar 00:18:07
Le damos aquí a limpiar y construir 00:18:09
Entonces borra todo 00:18:11
Vais a ver que tarda mucho 00:18:12
Borra todo y lo hace todo desde el principio 00:18:14
El IDE suele ser muy ahorrativo 00:18:16
O sea, si hay una cosa que ya ha compilado 00:18:20
No la compila otra vez 00:18:22
Que eso puede ser 00:18:23
Para determinadas cosas fuentes de problemas 00:18:26
Bueno, también me está diciendo aquí 00:18:28
Mira, en esta línea me ha generado el fichero hard 00:18:31
de la aplicación, ¿vale? 00:18:35
Mira, me está diciendo aquí que en este sitio, en esta 00:18:37
ruta, no lo había dicho, pero 00:18:39
me está diciendo aquí que ha 00:18:43
generado el fichero hard de la aplicación. 00:18:44
Bueno, pues ahí me ha generado el fichero hard 00:18:47
de la aplicación. Más 00:18:48
cosas. Debug, que ya 00:18:51
lo hemos visto. 00:18:53
Debug. Bueno, aquí en 00:18:55
run también tengo lo de seleccionar el 00:18:56
proyecto principal, que ya lo hemos visto. 00:18:59
Puedo elegir incluso la configuración, 00:19:00
elegir la versión de Java que quiero usar, 00:19:03
porque no me ha preguntado qué versión de Java quiero usar. 00:19:05
Vale, pues aquí puedo, si me voy aquí a cambiar las opciones, esto de Customize, pues puedo cambiar la versión de Java. 00:19:07
Bueno, aquí en Debug puedo hacer el debut del proyecto. 00:19:16
Profile ya lo veremos, ¿de acuerdo? 00:19:20
Team, tienes para, pues cuando trabajamos en equipo tendré un repositorio, pues puedo elegir el repositorio, por ejemplo, Wit. 00:19:22
Bueno, este no lo tengo asignado a ningún repositorio, pero si tengo un proyecto que esté asignado a algún repositorio, 00:19:30
por ejemplo este, este sí que lo tengo en un repositorio 00:19:35
me voy aquí al menú team 00:19:37
pues lo tengo en wit 00:19:38
¿de acuerdo? lo tengo en wit 00:19:41
y aquí puedo pues añadir un archivo 00:19:42
hacer un commit, hacer un 00:19:45
checkout, muy importante 00:19:47
cuando hagáis un push 00:19:48
cuando hagáis un push 00:19:51
está por aquí, no lo veo ahora 00:19:53
¿dónde está el push? 00:19:55
no lo veo ahora, bueno, pues cuando hagáis un push 00:19:59
hacedlo siempre desde aquí 00:20:00
o sea, aquí hay botón derecho 00:20:02
wit 00:20:05
y le haces un... ¿Dónde está push? 00:20:06
No lo encuentro ahora. 00:20:10
Tengo el commit. 00:20:12
Bueno, espera, claro. 00:20:15
Como no he hecho ningún commit, no tengo push. 00:20:16
Bueno, pues cuando hago el commit 00:20:18
me sale el push y le puedo hacer un push. 00:20:19
Si le hacéis un push, hacerlo siempre 00:20:22
dando botón derecho aquí. 00:20:23
Y te vas aquí y haces el push. 00:20:26
El commit y el push. ¿Por qué? 00:20:27
Siempre desde aquí. 00:20:29
Porque si lo haces desde aquí, solamente 00:20:31
te hace el commit del archivo 00:20:33
actual, solamente de este 00:20:36
si has modificado 5 archivos 00:20:37
solamente te va a subir 00:20:40
este, entonces si lo haces 00:20:41
desde aquí, dando botón aquí 00:20:44
derecho a wit 00:20:46
pues te lo va a hacer de todo 00:20:47
el proyecto, no solamente de este archivito 00:20:50
tools, bueno herramientas 00:20:52
varias, o sea puede hacer un div 00:20:54
entre archivos, aplicar un div 00:20:56
con distintas herramientas 00:20:58
el típico menú windows para ver 00:20:59
los distintos elementos 00:21:01
y la ayuda 00:21:03
Vamos a ver otra cosa interesante. 00:21:05
Vamos a añadir algo al proyecto. 00:21:07
Bueno, me voy a mi proyecto, porque tengo una clase por ahora. 00:21:09
Y si quiero añadir otra. 00:21:13
Vamos a añadir otra clase. 00:21:14
Bueno, pues me voy aquí al código, botón derecho, de CNew. 00:21:16
Y puedo añadir una nueva carpeta, una nueva clase de Java. 00:21:19
Pues puedo añadir una nueva clase de Java. 00:21:25
¿De acuerdo? 00:21:28
O puedo añadir otro tipo de cosas. 00:21:29
Vale, voy a añadir una clase de Java. 00:21:32
Azar. New class. Bueno, aquí le pongo el nombre. Le voy a poner nueva y la añado. Y me crea la nueva clase. ¿De acuerdo? ¿Que la quiero eliminar? Botón derecho. ¿Dónde está aquí? Eliminar. A ver. Perdón. Botón derecho. Ahora. Eliminar. Eliminar. ¿Quieres borrarla? Sí, por supuesto. Borrarla. 00:21:33
Voy a añadir otra clase, un pequeño ejemplo. Vamos a ver ahora una opción muy interesante que tiene este entorno, que es el de diseñar interfaces gráficas. Botón derecho, aquí en la carpeta donde quiero añadir el proyecto y me doy a New. Other. ¿De acuerdo? Other. 00:22:04
Y aquí me dice que puedo añadir un swing 00:22:26
Swing.fc es una interfaz gráfica 00:22:28
Ya es un poquito antigua 00:22:32
De hecho está intentando reemplazar la Oracle por otra cosa 00:22:33
Por JavaFX 00:22:37
Si lo vais a ver, JavaFX 00:22:40
Pero bueno, de momento está aquí y se sigue usando 00:22:42
Entonces le voy a decir que me cree una nueva ventana 00:22:45
Una ventana es un frame 00:22:48
Tengo los dialogues 00:22:49
Esto es un dialogue 00:22:52
La ventana que te bloquea, la ventana principal, o sea, estos menús que se ven aquí que te bloquean el uso de ventana principal, se llaman dialogues. 00:22:55
Esta ventana de aquí, que acabo de abrir, es un dialogue. 00:23:02
Y luego tengo los frames, que los frames son las ventanas convencionales. 00:23:05
¿Qué más puedo hacer? Bueno, y luego tengo un ejemplo de aplicación, que me pone a esta menús. 00:23:10
Voy a hacer primero el ejemplo de aplicación, ¿vale? 00:23:15
Lo habitual es esta, hacer un frame, ¿de acuerdo? 00:23:17
que es una ventana sin nada, en la que pongo cosas 00:23:22
pero 00:23:24
esta me pone ya los menús 00:23:25
le voy a hacer que el siguiente 00:23:27
me dice el nombre, la voy a llamar 00:23:29
de la clase la voy a llamar ventana 00:23:32
y lo doy aquí a finalizar 00:23:33
y me va a crear la nueva clase 00:23:38
ahí la tenemos, ventana 00:23:39
bueno, y aquí me sale 00:23:42
algo más, aquí me sale algo más 00:23:44
veis que pone aquí source 00:23:46
que es el código fuente 00:23:48
que me ha metido un montón de código 00:23:49
las partes en gris es 00:23:52
es que no las toque, que las ha generado él 00:23:54
y no me deja tocarlas, ¿vale? 00:23:56
Esas las ha generado él y va a seguir generando 00:23:58
cosas y no me deja tocarlas. Y luego 00:24:00
en la parte de diseño, aquí está 00:24:02
la ventana que me ha generado, que me ha generado 00:24:04
una simple ventana con un menú. Si le doy 00:24:06
aquí a ver, 00:24:08
pues ves, está la ventana que he generado. 00:24:10
¿De acuerdo? Que la ha generado 00:24:13
hasta elementos. Si yo doy 00:24:14
a ejecutar, vais a ver 00:24:18
que no sale la ventana. Me van 00:24:19
a salir aquí los alamundos 00:24:22
a ver que se está compilando 00:24:23
paciencia, me salen aquí los solamundos 00:24:27
vamos, ahí está 00:24:30
los solamundos, me han salido los solamundos 00:24:34
pero no me ha salido la ventana, ¿por qué? porque en ningún momento 00:24:36
le ha dicho que la ponga, en el proyecto principal 00:24:38
o sea, aquí en el main 00:24:40
tengo que decirle que en algún momento muestre la ventana 00:24:42
vale, pues, para mostrar la ventana 00:24:44
me voy aquí a source 00:24:46
pincho la ventana, me voy a source, y en la parte final 00:24:47
vemos que hay un main 00:24:50
vemos que hay un main 00:24:51
y aquí pone crear y mostrar 00:24:53
el formulario, vale 00:24:56
pues cojo este cachito de código, lo copio 00:24:58
este que pone dentro del main que hay en la clase ventana 00:25:02
pues dentro de este main que hay en la clase ventana, me cojo este cachito de código 00:25:06
que pone crear y mostrar el formulario, lo copio 00:25:09
y lo pego aquí, lo voy a pegar aquí 00:25:14
esto luego ya lo pondría donde corresponde, ahí está 00:25:17
aquí me crea la ventana, bueno me dice algunos errores aquí 00:25:21
mínimos, que de notación 00:25:25
y demás, me da igual, lo dejo ahí 00:25:28
y ahora lo ejecuto, y ahora si lo ejecuto 00:25:30
vais a ver 00:25:32
que ya va a salir la ventanita, va a poner aquí los holamundos 00:25:33
y después de los holamundos 00:25:36
saca la ventana, paciencia 00:25:37
ha puesto los holamundos y aquí está 00:25:45
aquí está la ventana, fijaros que sale con un aspecto 00:25:47
feo, de acuerdo 00:25:49
esto no es el aspecto que sale 00:25:51
en el editor 00:25:53
vale, bueno y aquí me ha puesto 00:25:54
algunos menos y algunos son operativos 00:25:57
Pues este de aquí, Exit, ya funciona. 00:25:59
¿De acuerdo? 00:26:02
Bueno, fijaos lo primero al aspecto. 00:26:03
El aspecto no era el que me sale aquí. 00:26:05
De entrada, el aspecto, cuando me voy aquí a Diseño 00:26:09
y le doy aquí al ojito para verlo, 00:26:12
no es el mismo. 00:26:15
Este aspecto es más bonito. 00:26:16
¿Por qué? 00:26:17
Porque hay que ponerle un tema. 00:26:18
¿Vale? 00:26:20
Vamos a ver cómo se ponen dependencias a un proyecto. 00:26:20
A un proyecto en Maven. 00:26:24
es muy parecido 00:26:25
es muy parecido 00:26:27
a como se hace 00:26:29
en Gradle 00:26:30
es una serie de líneas que tenemos que copiar 00:26:33
en el proyecto principal 00:26:35
¿dónde está el fichero que define el proyecto? 00:26:37
pues este, donde pone 00:26:40
project files, este que pone pon 00:26:41
xml, le doy, y me sale esto 00:26:42
bueno, vais a ver 00:26:45
que es un xml 00:26:47
aquí tengo que añadir, para meter dependencias 00:26:47
dos líneas 00:26:51
dependencias 00:26:52
así como lo he escrito 00:26:55
vale 00:26:57
ahí está, fijaos que hasta me ha autocompletado 00:27:00
el código, cuando pongo dependencias 00:27:03
dependencias 00:27:06
cuando pongo esto 00:27:08
quiere decir que aquí dentro voy a meter las dependencias 00:27:09
voy a buscarle un tema a las 00:27:12
ventanas, un tema que se suele usar 00:27:13
mucho es este 00:27:15
flatlab, que es el típico de los 00:27:17
bueno, si os fijáis el flatlab 00:27:19
este es el mismo que tiene el editor que estoy usando 00:27:21
¿no? este tema 00:27:23
es este tema, y tiene incluso 00:27:26
versión oscura 00:27:28
este tema también lo usa 00:27:29
un entorno de desarrollo mucho 00:27:32
que es el Intel IJ 00:27:34
pues voy a añadirle esta dependencia 00:27:35
el FlagLav, para añadirle la dependencia 00:27:38
bueno, bajo para aquí, para abajo 00:27:41
y dice, mira 00:27:44
la dependencia la tengo aquí en Maven Central 00:27:45
si hago clic en Maven Central 00:27:49
le hago clic 00:27:50
me sale esto, ya estoy en Maven Central 00:27:51
Y me dice, venga, para añadir tu proyecto, mira, si estás en Maven, tienes que añadir estas líneas. 00:27:55
Si estuviéramos en Gradle con Kotlin, tendríamos que añadir esta línea. 00:28:00
Bueno, como hemos elegido crear el proyecto con Maven, me cojo estos códigos de aquí, los copios, 00:28:05
me voy aquí a mi proyecto en la parte de dependencias y lo pego. 00:28:13
Esto lo voy a formatear para que quede bonito. 00:28:17
Ahí está, ya queda bonito. 00:28:23
Y ahí ya tengo la dependencia puesta. 00:28:25
¿Va a funcionar directamente? No. Tengo que añadir una cosa más. Siempre que importo un proyecto, no solo es importarlo, sino añadir más código que me van a decir para que funcione. Tendré que traerlo al proyecto, importarlo y trabajar con él. 00:28:27
fijaos esto que va a ser muy interesante, le voy a dar 00:28:41
de momento 00:28:43
le voy a dar a compilar 00:28:45
para que me baje la dependencia 00:28:46
le doy a compilar para que me baje la dependencia 00:28:48
simplemente me interesa que me baje la dependencia 00:28:53
y ahora vamos a ver cuando me baje la dependencia 00:28:54
bueno, dejo ahí que se baje la dependencia 00:28:57
se está bajando la dependencia 00:28:58
y mientras se la baja, voy a ver cómo se usa 00:28:59
me tengo que ir siempre 00:29:03
a la página del manual 00:29:04
de la biblioteca para ver cómo se usa 00:29:06
y me dicen que simplemente que añade 00:29:08
esta línea, hay que añadir esta línea 00:29:10
¿De acuerdo? 00:29:13
La tengo aquí en esta página y tengo que añadir esta línea. 00:29:14
La voy a añadir. 00:29:17
Me va a dar un error. 00:29:19
Me interesa que me dé el error. 00:29:21
La añado. 00:29:22
Y me da un error. 00:29:23
Error. 00:29:24
¿Por qué? 00:29:25
Porque no he importado la biblioteca. 00:29:25
He añadido el módulo al proyecto Maven, pero la biblioteca no la he importado. 00:29:28
La tengo que importar. 00:29:33
Bueno, pues me pincho aquí. 00:29:34
Me dice, no puedo encontrar el símbolo. 00:29:38
Doy aquí. 00:29:40
A ver, espera. 00:29:41
Hazme caso. 00:29:43
Aquí. 00:29:44
Pues me dice, mira, ¿puedes añadir el import? Ah, pues lo añado. Lo añado. Vais a ver que me ha añadido aquí el import. ¿De acuerdo? Y además me ha añadido el import correcto. Si ahora le doy a ejecutar, vais a ver que ya sale la aplicación. Le he dado a ejecutar. Un poco de paciencia. Y ya me va a salir la aplicación. Espero que me salga la aplicación. 00:29:44
He puesto los Hello World, ¿veis? 00:30:10
Y ya me sale con la apariencia correcta. 00:30:14
¿De acuerdo? 00:30:17
¿Tengo más apariencias? 00:30:18
Sí, mirad. 00:30:19
Tengo más apariencias. 00:30:20
Fijaos que ahí pone un tema oscuro. 00:30:22
Voy a poner el tema oscuro. 00:30:23
Por, con, punto. 00:30:24
Voy copiando. 00:30:27
Lo que voy a hacer es copiar esto. 00:30:28
Tal cual viene arriba. 00:30:30
Hasta que el momento complete. 00:30:34
Y aquí tengo los temas. 00:30:36
Mira, tengo aquí el tema de Árcula. 00:30:37
¿De acuerdo? 00:30:40
Ahora mismo estoy usando el tema Like. 00:30:41
Este de aquí. 00:30:42
¿Vale? Pero tengo el tema 00:30:43
Darkula, pues lo importo 00:30:45
Que es el tema oscuro 00:30:47
Control-C y ahora aquí me copio 00:30:49
Esta línea, este cachito de aquí 00:30:51
Y para usar 00:30:53
El tema Darkula 00:30:55
Lo pongo aquí 00:30:56
Pongo el setup 00:30:58
Y esta línea la comento 00:31:00
Porque si no se puede liar 00:31:04
¿De acuerdo? 00:31:05
¿Vale? Según he comentado 00:31:08
Esta línea vais a ver que aquí arriba me dice 00:31:11
Oye, que este imporna lo estás usando 00:31:12
pues lo voy a comentar 00:31:14
estas cosas que no uso al final 00:31:16
se suelen limpiar, o sea cuando ya 00:31:18
haces la refactorización limpias este código 00:31:20
que no usas, porque esto pueden ser pruebas 00:31:22
vamos a ver como queda el tema oscuro 00:31:24
vamos a ver como 00:31:26
queda el tema oscuro, que este suele ser 00:31:28
el típico que usan todos los 00:31:30
editores de desarrollo 00:31:32
de hecho al NetBeans se le puede poner 00:31:33
perfectamente el tema oscuro, hay una opción por ahí 00:31:36
de aquí en 00:31:38
configurar, que le puedes poner 00:31:40
el tema oscuro, veis le hemos puesto el tema oscuro, le voy a dejar 00:31:42
el tema oscuro. Bueno, de momento hemos creado una ventana, vale, muy bien, muy bonito, pero esto cómo se usa. Vamos a verlo. Bueno, aquí tengo mi ventana. 00:31:44
Una cosa curiosa, si vamos a un elemento y le hacemos doble clic, me salta a la función que se ejecuta cuando le hago clic. O sea, si yo hago clic sobre un elemento, 00:31:55
por ejemplo ese menú 00:32:10
va a ejecutar una función 00:32:11
y en este caso para ese menú es esta 00:32:14
que simplemente lo que está haciendo es un 00:32:16
system.exit 00:32:18
lo que hace es que corta, para la ejecución 00:32:19
y devuelve al sistema operativo 00:32:23
este código, en este caso 00:32:24
un 0, lo habitual es 00:32:26
devolver el código 0, el código 0 00:32:28
es que no se han producido errores en la ejecución 00:32:30
si devuelvo un código 1, 2, 3 00:32:32
le estoy diciendo al sistema operativo que 00:32:34
la aplicación ha parado 00:32:36
con errores, y el error va a ser el 1, el 2 00:32:38
o el 3, o el número que yo ponga ahí 00:32:41
ese número va a tener significado 00:32:43
para el programador, yo tengo que asignarle valores 00:32:44
a esos números, ¿de acuerdo? 00:32:46
por supuesto, a cualquier elemento del menú 00:32:51
a cualquier elemento del menú 00:32:53
si hago doble clic 00:32:56
doble clic, aquí está 00:32:59
¿vale? pues me añade la función 00:33:01
esa función no estaba creada, y aquí me añade 00:33:03
la función para la acción 00:33:05
como he hecho clic sobre el menú 00:33:07
about, pues aquí pondría 00:33:09
lo que quiero que se haga en el menú 00:33:11
de about, pues un system 00:33:12
out 00:33:14
print 00:33:16
en un momento voy a hacer 00:33:18
un system out print que se haga por consola 00:33:20
no voy a hacer nada más 00:33:23
que diga 00:33:23
about, vale 00:33:25
o sea, cuando hago clic en el menú about 00:33:28
en consola va a poner about 00:33:30
le doy run, lo ejecuto 00:33:32
paciencia 00:33:36
fijaos que no puedo tocar las partes en gris 00:33:40
no me deja de editor, ¿vale? 00:33:43
tal, y ahora si voy a 00:33:48
hell y pincho en about 00:33:49
lo veis que ha puesto aquí about, ¿no? 00:33:51
lo veis aquí que ha puesto about 00:33:53
aquí en mi ventanita, hell 00:33:54
about, me pone about, ¿vale? 00:33:57
ahí podría hacer una operación o lo que sea 00:33:59
¿de acuerdo? 00:34:01
esta ventana sigue sin hacer cosas interesantes 00:34:03
bueno 00:34:05
le doy aquí escape, me cierro esto 00:34:06
eso es, ¿vale? bueno, ¿qué cosas 00:34:09
qué elementos puedo añadir aquí a la ventana? 00:34:11
Pues puedo añadir bastantes. Esto me tengo que ir al menú de Swing. 00:34:13
O sea, hay un tutorial de Swing. Si nos buscamos aquí a Google 00:34:17
y buscamos Swing Java 00:34:22
Tutorial. De cómo hacer aplicaciones 00:34:27
en Swing. A ver... Bueno, el habitual, bueno, ahí tengo un curso 00:34:31
pero el habitual es el de Oracle. Este. El de Oracle 00:34:39
este es el clásico. Este es el tutorial 00:34:42
de toda la vida, el que se ha usado, y aquí me dice pues todos los elementos 00:34:47
de swing, como hacer un drag and drop, un drag and drop es arrastrar y soltar un fichero 00:34:51
por ejemplo, los distintos componentes de swing 00:34:55
¿de acuerdo? ¿cómo usarlo con NetBeans? 00:34:59
que eso ya lo estamos usando, ¿vale? pues aquí, modificar la vista 00:35:03
el aspecto, que es lo que estamos haciendo, y me dice aquí distintos 00:35:07
elementos, ¿vale? pues aquí en Agatiz Startup 00:35:11
Te da una primera lección de cómo usar Swing. 00:35:14
Bueno, pues el típico menú, el típico tutorial es este. 00:35:20
Aquí me tengo que aprender cómo se usa. 00:35:23
Vamos a aprender dos elementos que son muy fáciles, bueno, tres elementos que son muy fáciles de usar. 00:35:25
Tenemos el label, la etiqueta. 00:35:30
Bueno, cuando quiero añadir un elemento simplemente lo arrastro y lo suelto. 00:35:34
Y lo voy a poner ahí. 00:35:37
Bueno, imaginaos que lo pongo por aquí. 00:35:39
De acuerdo, si le doy a previsualizar, vas a ver que lo trata de mantener ahí. 00:35:41
¿Veis que si cambio el tamaño, él trata de mantenerlo ahí? 00:35:47
¿Veis? Incluso lo tapa. 00:35:49
Si me lo llevo a un borde, vais a ver que aparecen unas líneas de guía. 00:35:53
Y si lo pego a la línea de... ¿Veis que ya han aparecido las líneas de guía? 00:35:56
Si la pego a la línea de guía de arriba, se ve mejor que la de abajo. 00:35:59
Si la pego a la línea de línea de abajo, 00:36:03
significa que cuando yo cambio el tamaño de la ventana, en lugar de desaparecer, 00:36:08
¿lo veis que la sigue? Sigue el tamaño de la ventana. 00:36:11
Si la pego aquí, ahí, 00:36:15
pues la ha pegado en esa posición. 00:36:19
Pues va a tratar de mantener esa posición cuando cambie la ventana, que esa posición es fácil de mantener. 00:36:20
Más cosas. Si le hago doble, bueno, si le hago botón derecho, puedo cambiar el texto, porque he añadido un label. 00:36:25
Un label es una etiqueta, simplemente muestra texto. Pues voy a poner aquí, precio. 00:36:32
Voy a hacer una pequeña aplicación que yo le meta un precio y me devuelva el IVA, el precio con el IVA. 00:36:40
Intro, ¿vale? Y aquí tengo la variable. Si os fijáis, aquí ha aparecido, bueno, aquí tengo los distintos elementos de mi ventana, y aquí ha aparecido este, el JLabel. Le puedo cambiar el nombre y es interesante cambiarle el nombre a la variable. 00:36:45
change variable name 00:37:03
hay algunos que no interesa 00:37:05
este por ejemplo lo podría haber dejado sin cambiar 00:37:08
¿de acuerdo? 00:37:10
pero 00:37:13
por ejemplo 00:37:13
le puedo cambiar su nombre a 00:37:16
preciolabel y ahora cuando vaya a java 00:37:18
si me quiero referir a este elemento tengo que 00:37:20
poner preciolabel, o sea 00:37:22
aquí en el código fuente cuando por alguna 00:37:23
razón me quiera referir ahí tengo que poner 00:37:26
preciolabel ¿vale? de momento 00:37:28
no voy a usar ese 00:37:31
el campo de texto. 00:37:32
El campo de texto es para meter, pues, texto. 00:37:36
Entonces, me voy a ponerlo aquí 00:37:38
siguiendo las líneas de guía 00:37:40
que lo ponga ahí pegado arriba 00:37:42
y pegado al siguiente elemento. 00:37:44
Este ya se me ha ido. 00:37:46
Al soltar el clic se me ha ido. 00:37:48
Ahí está. 00:37:49
Si os habéis fijado las dos líneas de guía 00:37:50
le he puesto que lo ponga arriba 00:37:52
y pegado a este elemento. 00:37:53
Incluso puedo coger y estirar esta. 00:37:54
Es que le puedo cambiar el tamaño. 00:37:57
Y le voy a tratar de pegar a la otra línea de guía. 00:37:58
De aquí. 00:38:01
eso es, ¿vale? 00:38:01
así, como lo he pegado a esta línea de guía 00:38:05
de aquí, cuando amplio el tamaño de la 00:38:07
ventana, veis que el elemento se amplía 00:38:09
si no lo hubiese pegado a esa línea de guía 00:38:11
pues mantendría su tamaño 00:38:13
bueno, le voy a cambiar aquí, a esta sí que 00:38:15
necesito cambiarle el nombre, la vamos 00:38:18
a llamar 00:38:22
precio test fill 00:38:23
conviene mantener 00:38:30
el tipo de dato, ¿eh? esto es un 00:38:31
test fill, pues conviene mantener 00:38:33
el tipo de dato, pues sabes lo que estás manejando 00:38:35
y le voy a cambiar aquí también 00:38:37
el texto, voy a poner 0 00:38:39
¿de acuerdo? 00:38:41
y ahora voy a añadir otro 00:38:44
bueno, un botón 00:38:46
¿dónde está el botón? aquí, botón 00:38:47
el botón que lo voy a poner 00:38:49
aquí 00:38:52
lo he pegado hasta dos líneas de guía 00:38:55
le voy a cambiar el nombre 00:38:57
a la variable, le voy a llamar 00:38:59
calcular 00:39:04
calcular 00:39:05
y le voy a cambiar el texto por supuesto 00:39:11
calcular 00:39:13
iba 00:39:17
¿de acuerdo? y ahora me falta un último 00:39:19
label que es donde voy a mostrar el resultado 00:39:22
lo vamos a poner 00:39:24
ahí 00:39:28
¿de acuerdo? los labels solamente sirven 00:39:31
para mostrar texto, pues ahí 00:39:35
voy a mostrar el resultado 00:39:36
resultado 00:39:37
resultado 00:39:43
y aquí voy a poner, le voy a volver a cambiar 00:39:46
el nombre a la variable 00:39:48
label, resultado 00:39:49
bueno 00:39:55
hay una cosa en la que no me he estado fijando 00:39:57
que son las propiedades de los objetos 00:40:00
que así que me va a interesar 00:40:02
tocarlas 00:40:04
bueno, aquí tengo más elementos 00:40:04
eso luego voy a usar ayuda, pero por ejemplo 00:40:07
tengo un campo para introducir contraseñas 00:40:09
una barra de progreso 00:40:12
el textarea, bueno tengo el textfield 00:40:13
y el textarea, el textarea es para meter 00:40:18
textfield es meter una línea 00:40:19
de texto, y el textarea es meter 00:40:22
muchas líneas de texto, esto es lo que usaría 00:40:24
para hacer un editor de texto 00:40:25
Los típicos combo box, estos son los desplegables 00:40:27
Los botones de encender 00:40:30
Bueno, los checkbox, que son los botones 00:40:32
De encender y apagar, ¿de acuerdo? 00:40:34
¿Vale? Los típicos 00:40:37
Botones de check 00:40:38
Y aquí tengo 00:40:38
Bueno, más elementos, y luego tengo incluso 00:40:41
Otros elementos de aquí arriba, los containers 00:40:43
Que son elementos para contener a otros elementos 00:40:45
O sea, por ejemplo 00:40:47
El split panel es muy típico 00:40:48
Tengo aquí un ejemplo de split panel 00:40:51
Tengo aquí un ejemplo de split panel que voy a enseñar 00:40:53
A ver 00:40:57
Ah, por eso yo tenía el marcador 00:41:00
Aquí tengo otro ejemplo 00:41:02
Esto es un split panel 00:41:06
Es el típico elemento, ¿veis? 00:41:10
Esto es un split panel 00:41:13
Le he puesto dos botones 00:41:14
Y es para cambiar el tamaño de uno y otro 00:41:16
O sea, aquí metería elementos, aquí metería más elementos 00:41:20
Y con esto le cambio el tamaño 00:41:23
Este es el split panel 00:41:25
Bueno 00:41:27
Bueno, volvemos a nuestro proyecto 00:41:28
Tengo el resultado, venga, ya 00:41:31
Ya tengo todos mis elementos. Ahora, quiero que me calcule el IVA. Pues en calcular IVA, este botón, hago doble clic y al hacer doble clic me queda, me crea una función que me dice, bueno, to do significa por hacer. Esto realmente debería ir separado. Por hacer, oye, añade aquí tu código. 00:41:33
Siempre que veis aquí un todo, los todos, siempre que veis todos, es que son mensajes que te suelta el editor o tú mismo como programador de, oye, que te falta por hacer esto. Bueno, pues aquí te falta calcular la función. Vamos a ver cómo se usan los elementos. 00:41:53
fijaros, el texto 00:42:07
el texto 00:42:10
que mete el usuario, lo estamos metiendo aquí 00:42:12
en esta cosita, ¿no? en el precio 00:42:14
text field, pues venga, pongo aquí 00:42:15
precio 00:42:18
test, hay que malescribir 00:42:22
field 00:42:31
punto, vale 00:42:32
y ahora, me sale 00:42:37
como es un objeto 00:42:39
me está mostrando todas las 00:42:41
funciones o todos los métodos que tiene ese objeto 00:42:43
me interesa uno que se llama get test 00:42:45
O sea, conseguir el texto que se está 00:42:47
Está escrito, me interesa 00:42:49
De los campos de texto me interesan 00:42:50
Dos campos, el gettest y el settest 00:42:53
Ay, se me ha olvidado una cosa 00:42:55
Me salta una cosa, bueno 00:43:00
Lo cuento al final 00:43:01
Que va a quedar más bonito 00:43:03
Pues busco gettest, casi lo escribo y tardo menos 00:43:04
Los programadores somos así de bajos 00:43:12
Ahí está, gettest 00:43:15
Gettest devuelve lo que ha escrito el usuario 00:43:20
El texto se devuelve siempre 00:43:23
en stream, ¿vale? Los usuarios siempre meten texto, el ordenador 00:43:25
entiende texto, esto va a ser el texto 00:43:29
que me ha introducido el usuario, ¿de acuerdo? Es buena idea 00:43:31
hacerle un trim, trim significa quitar los espacios en blanco del principio 00:43:39
y del final, ¿de acuerdo? El usuario cuando escribe 00:43:45
mete mucha porquería, entonces lo primero que vamos a hacer es a lo que meta 00:43:48
el usuario le hago un trim para que me quite esos espacios en blanco que va a meter muchas veces 00:43:53
el usuario. O sea, si yo ahora, por ejemplo, me voy aquí a diseño e intento 00:43:57
ver la aplicación, pues llega el usuario y puede hacer esto. 00:44:02
Meter aquí un montón de espacios y ya el número. ¿De acuerdo? Pues estos 00:44:06
espacios del principio o del final no me 00:44:09
interesan. Esto de aquí no me interesa. Entonces le hago un trim. 00:44:13
Le hago un trim. ¿De acuerdo? Tengo el texto. Vale. 00:44:20
Me está diciendo ahora mismo que esta variable la he puesto en 00:44:25
en su radio en amarillo, me dice que nunca ha sido usada. 00:44:28
Vale. La voy a convertir a float. 00:44:32
Tipo float. A texto. 00:44:36
Que esto va a ser el precio. 00:44:39
Y voy a hacer un parse. 00:44:41
Tengo que convertir el texto a un número. 00:44:44
Vale. Pues se hace con float.parseFloat. 00:44:49
Ahí lo veis. Lo veis ahí, ¿no? 00:44:57
ParseFloat. 00:45:00
Y el texto. 00:45:02
Bueno, fíjate que él mismo se ha dado cuenta de que tengo que meterle el texto. 00:45:03
Fijaos que ya me está saliendo aquí una cosa en amarillo. 00:45:07
¿De acuerdo? 00:45:11
Vale, ya me está diciendo aquí cosas en amarillo. 00:45:13
Vale, pues mira, me dice que la variable texto nunca ha sido usada. 00:45:17
Ahora me va a decir más cosas cuando la use. 00:45:20
Bueno, no quería borrar. 00:45:22
Ahora voy a calcular el IVA. 00:45:26
Flat precio con IVA. 00:45:29
Pues el precio con IVA es coger el precio y multiplicar por 1.21. 00:45:36
Ya tengo el precio con IVA. 00:45:43
¿De acuerdo? 00:45:45
Y ahora, quiero mostrar el resultado. 00:45:46
¿El resultado dónde lo voy a mostrar? 00:45:48
Bueno, si os fijáis en mi diseño que he hecho, tengo aquí este label. 00:45:51
Este label de aquí, que es el resultado label. 00:45:56
Pues lo quiero mostrar en resultado label. 00:45:59
Pues me tengo que ir aquí y poner aquí. 00:46:00
resultado 00:46:04
resultado 00:46:06
label, punto, y hay una opción 00:46:08
que se llama setTest. 00:46:11
Esto lo voy a escribir 00:46:14
para no... 00:46:15
setTest, ahí lo tenemos. 00:46:16
setTest 00:46:19
Si espero un poquito me suelta la ayuda. 00:46:19
Bueno, está tardando mucho. 00:46:23
Vale, bueno, pues 00:46:26
ahí en esa ventana me debería salir la ayuda. 00:46:27
Bueno, setTest 00:46:30
y aquí voy a poner 00:46:30
el precio 00:46:31
con 00:46:37
se me ha ido el, como tengo un 00:46:42
top patch, se me ha ido 00:46:45
vale, precio con IVA 00:46:46
¿de acuerdo? voy a borrar toda esta porquería 00:46:49
lo pongo bonito 00:46:51
no sé 00:46:55
por qué 00:46:57
me lo sigue marcando 00:46:57
¿por qué me lo marca? ah, vale 00:47:00
que esto es un double 00:47:11
vale, se me estaba diciendo 00:47:11
Oye, mira, que el 1.21 es un W. Pues mira, le estoy indicando que el 1.21 lo quiero que lo coja como float. Vale. Bueno, me pone aquí que si quiero mejorar el código y demás. De momento lo dejo aquí. Vale, vamos a ver mi aplicación. 00:47:15
¿Por qué he puesto las comillas estas? ¿Por qué le he sumado las comillas? Porque me quiero, estos, fijaos que ese test admite un string, ¿de acuerdo? Y claro, precio con IVA es un float, si le meto directamente el float, si me cargo esto, vais a ver que genera un error, me dice, oye, que esto es un string, que no puedo convertir un float a un string, pues lo que hago es que le sumo unas comillas para que convierta el float a string. 00:47:32
Vamos a ver esto funcionando, mi maravillosa aplicación 00:47:59
Me quedan dos cositas 00:48:02
A ver si no explota 00:48:04
Bueno, vais a ver que programar con un IDE 00:48:07
Es muy fácil, a los novatos 00:48:12
Se les suele recomendar lo contrario, programar sin IDE 00:48:13
Porque como te hice todos los errores 00:48:16
Pues... 00:48:18
Ah, mira, de hecho me va a interesar 00:48:22
Mostraros esto 00:48:23
Bueno, aquí tengo la consola 00:48:25
Y nos fijamos en la consola 00:48:28
Vamos a calcular los precios con IVA 00:48:29
El IVA de 100, vamos a ver si lo he hecho bien 00:48:31
pincho aquí en calcular IVA 00:48:34
y cuando pincho en calcular IVA 00:48:36
me pone, ¿lo habéis visto? 00:48:37
que ha puesto aquí el precio 00:48:40
¿de acuerdo? ¿qué es lo que ha hecho? 00:48:41
al hacer click sobre el botón 00:48:43
me ha ejecutado esta función 00:48:45
me ha ejecutado este cachito de código 00:48:47
que he puesto aquí, ¿qué está haciendo este cachito de código? 00:48:49
pues ha cogido 00:48:52
del precio test fill 00:48:53
del precio test fill 00:48:55
que es este de aquí 00:48:57
la cantidad 00:48:58
le ha quitado la porquería con esto de aquí 00:48:59
con el trim, o sea, con el getTest 00:49:03
consigo el texto, con el trim la limpio 00:49:05
la he pasado de texto 00:49:06
a número, hago la operación 00:49:09
que tengo que hacer, es sumarle el IVA 00:49:11
y luego por último, el resultado 00:49:13
que es este de aquí, pues le pongo 00:49:15
el resultado, ya está 00:49:17
bueno, esto se puede mejorar, cierro la aplicación 00:49:18
vale 00:49:21
bueno, aquí por ejemplo, me está pidiendo a gritos 00:49:24
que le ponga el símbolo 00:49:27
de euro, ¿no? a mí me lo está pidiendo 00:49:31
a gritos, y luego está como 00:49:33
muy pequeño, o sea, el precio 00:49:35
El resultado final está como muy pequeño 00:49:37
¿Se puede cambiar el tipo de letra y cosas así? 00:49:40
Sí, que es lo que me faltaba por contar 00:49:42
Si pincho en un elemento 00:49:43
Pincho en un elemento 00:49:46
Puedo pinchar aquí o aquí 00:49:48
Que me esté seleccionado, ¿vale? 00:49:49
Si lo selecciono, vais a ver que aquí aparecen sus propiedades 00:49:52
Las propiedades del elemento 00:49:54
Voy a pinchar en otro para que se vea que cambian 00:49:55
¿Veis? Que han cambiado las propiedades 00:49:57
¿De acuerdo? Pues aquí salen sus propiedades 00:50:00
Por ejemplo, en el campo de texto 00:50:04
Puedo decir que sea editable o no editable 00:50:06
¿De acuerdo? Puede haber campos de texto que no sean editables 00:50:08
porque estén desactivados 00:50:11
¿De acuerdo? Puedo cambiarle el color 00:50:13
de fondo. Ah, mira, es muy interesante. El tipo de letra 00:50:15
Voy a cambiarle el tipo de letra. ¿Veis que le está 00:50:17
poniendo este tipo de letra? Pues mira, le voy a poner 00:50:19
un tipo de letra así más grande, ¿no? 00:50:21
Le voy a poner negrita y le voy a 00:50:23
poner un tamaño bestial 00:50:25
Ok. Ahí está 00:50:26
¿Vale? Lo habéis visto, ¿no? 00:50:29
Con estas cositas de aquí puedo 00:50:31
cambiar las propiedades de los elementos 00:50:33
Claro, tendré que saber lo que significan 00:50:35
Primero, hay muchas cosas que no me interesa tocar, porque las hace él ya por defecto, pero otras me voy a ver obligados a tocarlas, ¿vale? Pues en este caso quería cambiarle de ahí el tamaño del tipo de letra, ¿vale? Pues le doy a ejecutar, le doy a ejecutar, con paciencia, y ahí lo tengo. 00:50:37
¿Veis que lo ha puesto ahí en grande? Y ahora meto aquí un IVA, con una cantidad para calcularle el IVA, y me dice aquí el IVA. Bueno, esto se podría mejorar, ¿no? Bueno, fijaros que aquí me ha puesto un 0,002, que no debía ponerlo. Si lo hacéis a mano, vais a ver que ese 0,02 no debería salir. 00:51:07
¿Eso por qué es? Porque los ordenadores se equivocan. 00:51:30
Sí, sí, se equivocan. 00:51:33
El ordenador piensa en binario. 00:51:35
Y al pasar determinados números a binario, tienen infinitos decimales. 00:51:36
O muchos decimales. 00:51:42
Claro, el ordenador tiene una memoria limitada. 00:51:43
Entonces tiene que cortar por algún lado. 00:51:46
Pues corto por aquí. 00:51:48
Y eso hace que se pierda precisión. 00:51:49
Y es lo que provoca que el ordenador se equivoque. 00:51:52
¿Veis? ¿Esto cómo lo maquillamos? 00:51:56
Pues esto lo que voy a hacer es, debería formatear el código, formatear el número, para limitar el número de decimales, decirle que estos decimales no los muestre, ¿vale? Pero sí, el ordenador se equivoca. 00:51:57
Y hasta aquí el vídeo. Bueno, una última cosa por decir, que es que, bueno, ya lo hemos dicho antes, que cuando compilo el proyecto, me dice aquí el fichero hard en el que sale el proyecto. 00:52:10
A ver, pero bueno, esto si lo hacemos, yo lo estoy haciendo con Maven para mostrarlo, pero si lo hacéis con Gradle, pues vais a ver que también es bastante fácil. Es lo mismo, Gradle ya lo habéis visto y es fácil de manejar. 00:52:24
Vale, pues ahí tengo el fichero hard. Fichero hard sin dependencias. Ojito. Este fichero, si intentase ejecutar este fichero, saldría un error exigiéndome la dependencia plan lab que le he puesto. 00:52:36
Pero habría que coger y poner las dependencias, habría que buscarse en internet cómo se añaden las dependencias a un fichero Maven. 00:52:50
vais a ver que te dan un porrón de código 00:52:57
que tienes que copiar 00:52:59
aquí, acordaos que en Maven 00:53:00
es el pon.xml 00:53:03
que le copias aquí 00:53:05
y ya está, y te lo hace. 00:53:07
Materias:
Informática, Programación
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
Subido por:
Pedro Luis L.
Licencia:
Reconocimiento - No comercial - Sin obra derivada
Visualizaciones:
138
Fecha:
18 de noviembre de 2024 - 10:42
Visibilidad:
Público
Centro:
IES VILLABLANCA
Duración:
53′ 14″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
106.22 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid