Saltar navegación

20240917 ProgrEstruct-Variables_3 - 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 17 de septiembre de 2024 por Raquel G.

23 visualizaciones

Más información Transcripción

Descargar la transcripción

Entonces, descargar... 00:00:00
Vale, descargar la JDK hemos dicho que si... 00:00:03
¿Y yo por qué me he puesto? 00:00:08
La batería del ordenador y de muchas cosas más está agotando ya. 00:00:10
Nos estamos agotando todos. 00:00:20
Vale. 00:00:25
pues a ver 00:00:25
lo que significa 00:00:32
cuando lo hagáis en casa 00:00:33
lo de instalar esto hemos dicho 00:00:35
que significa que aparece esta ruta 00:00:38
y esta ruta 00:00:40
tiene el javacé 00:00:42
¿significa eso que ahora ya cuando vayáis ahí 00:00:43
y hagáis javacé 00:00:46
os va a compilar y lo va a encontrar? 00:00:47
pues tampoco significa eso 00:00:50
¿por qué? falta solo una cosa 00:00:51
no, no hay que reiniciar, falta solo una cosa 00:00:54
¿eh? 00:00:56
agregarlo al pad 00:00:56
vale, a ver 00:00:59
¿qué pasa? aquí la consola 00:01:01
está hecha para que uno la abra 00:01:03
y llame a programas, llame a comandos 00:01:05
lo llamamos comandos 00:01:07
pero claro, tú pones un comando 00:01:09
¿y qué hace Windows? 00:01:11
te busca 00:01:14
ese comando en la carpeta 00:01:15
en la que estás colocado 00:01:17
y esto 00:01:18
no está en esta 00:01:22
ruta, esto está en 00:01:23
C, archivos de programa, bla, bla, bla. 00:01:25
Entonces, ¿qué significa eso? 00:01:27
Un segundín. ¿Qué significa eso? 00:01:29
¿Significa que me tengo yo 00:01:32
que ir a esa ruta 00:01:33
cada vez que quiera hacer Java C? 00:01:34
Podría trabajar así. 00:01:38
Pero es un rollo, tenerme que ir 00:01:39
a esa ruta cada vez que quiera hacer Java C. 00:01:41
Con el problema añadido de que 00:01:44
si me voy a esa ruta, mi programa no está en esa ruta. 00:01:45
Con lo cual, tengo que poner Java C 00:01:48
y toda la ruta de donde está 00:01:49
mi programa. Un rollo. No, yo quiero 00:01:51
compilar desde aquí, para 00:01:53
poner mi nombre de programa directamente 00:01:55
porque está aquí dentro, porque está aquí. 00:01:57
Quiero copiar desde aquí. ¿Qué solución 00:01:59
tengo? Bueno, pues Windows 00:02:01
tiene, el sistema operativo tiene una variable 00:02:03
de entorno que se llama, tiene una 00:02:04
cosa, por no llamarlo 00:02:07
variable, tiene una cosa que se llama 00:02:09
path, el path del sistema, el camino, 00:02:10
que incorpora muchas rutas 00:02:13
de mi sistema de archivos, las que yo quiera darles. 00:02:15
Muchas. Todas las que yo quiera. 00:02:17
¿Y para qué sirve esa variable 00:02:19
path? Sirve para 00:02:21
que cuando se encuentra un comando, yo 00:02:23
tengo un comando aquí, y el sistema 00:02:24
operativo, este comando 00:02:26
no lo encuentra dentro de esta ruta, 00:02:28
se va al pad y dice, vale, voy a empezar a buscar 00:02:30
la ruta gemela, voy a empezar a buscar. ¿Está en esta primera? 00:02:32
No está. ¿Está en esta segunda? 00:02:35
Ah, aquí sí está. Vale, pues 00:02:37
entonces ya he encontrado jabalí, se acabó. 00:02:39
Luego, ¿qué segundo paso os falta 00:02:41
cuando instaléis esto 00:02:42
en casa? Añadir 00:02:45
la ruta donde está 00:02:46
JDK, toda 00:02:50
esta ruta, 00:02:52
Y el bin, con el bin incluido, porque Java C está aquí, añadir toda esta, ¿vale? 00:02:54
Toda esta ruta, la podéis copiar, añadir toda esta ruta a la variable path, toda esa ruta. 00:03:02
¿Cómo se añaden cosas a la variable path? 00:03:11
Pues, bueno, buscamos aquí variables de, editar variables de entorno. 00:03:16
En cuanto pongáis variables, ya os ofrece editar las variables de entorno. 00:03:20
Claro, en los del aula os va a pedir 00:03:24
contabilidad de administración, en vuestro ordenador de casa 00:03:29
y en vuestro portátil, si os la pide, la sabéis 00:03:31
¿Vale? 00:03:33
Y si es robado, pues lo devuelves 00:03:38
pidiendo disculpas 00:03:40
Vale, y entonces 00:03:43
Una vez que habéis metido la contraseña 00:03:48
de administrador 00:03:54
Ya se os abre esta ventanita 00:03:55
¿Vale? 00:03:58
Pues en esta ventanita que se os abre 00:04:03
Hay una abajo que pone 00:04:04
Variables de entorno 00:04:07
Pues pincháis en variables de entorno 00:04:08
Y os aparecen aquí 00:04:11
Variables del sistema 00:04:13
Pues hay unas cuantas 00:04:14
Esta es la que nos gusta 00:04:17
La que nos interesa ahora 00:04:18
Pincháis en variable pad 00:04:20
Y le dais abajo a editar 00:04:22
Este botoncito que está aquí oculto 00:04:25
Por la lupa 00:04:27
vale, le dais a editar 00:04:28
ala 00:04:30
y aquí añadís ya 00:04:31
la ruta esa 00:04:33
con c archivos de programa bla bla bla 00:04:36
jdk bin, vale 00:04:38
el msi 00:04:39
a veces 00:04:45
depende de como lo hayáis instalado 00:04:46
puede ocurrir 00:04:50
que os incluya esto 00:04:51
que claro 00:04:53
que esto, como veis no es la ruta 00:04:55
donde ha metido la jdk 00:04:57
pero es un sitio donde está 00:04:58
esa ruta y con eso también lo encuentro 00:05:01
pero si os aparece 00:05:02
no encuentro Java C 00:05:04
no os compliquéis la vida y simplemente añadir 00:05:06
ahí esa, la que os digo 00:05:09
C, archivos de programa, Java 00:05:10
JDK, BIM y solucionar el problema 00:05:12
¿vale? 00:05:14
claro, ponéis nuevo 00:05:17
y aquí ponéis esa ruta 00:05:18
la ruta tal cual, con el BIM 00:05:19
porque es donde está Java C 00:05:22
¿vale? 00:05:23
y ya está 00:05:27
Vale, pues entonces 00:05:28
Esto es lo que en principio 00:05:33
Tendréis que hacer 00:05:36
En casa 00:05:39
Para 00:05:40
Para 00:05:42
Este por qué no se me baja 00:05:48
Ah bueno, porque tengo el comando para arriba 00:05:51
Vale, vale 00:05:54
Vale, para compilar y que lo encuentre 00:05:55
Si aún así os pasan cosas raras 00:05:58
Pues hay mil vídeos de Youtube 00:06:00
Para, o volvéis a ver el vídeo 00:06:03
Este hasta que os enteréis 00:06:04
hombre, añadir una variable 00:06:06
una ruta al pad 00:06:08
eso está en mis dios de internet 00:06:09
o yo que sé 00:06:12
o lo preguntáis 00:06:15
vale, bueno pues entonces 00:06:18
estamos ya 00:06:20
deberíamos estar en la fase 00:06:22
en la que ya todo el mundo 00:06:23
después de haber llamado al compilador javac 00:06:25
no le ha dado ningún error 00:06:28
no le ha dado ningún error 00:06:31
con lo cual el programa estaba escrito perfectamente 00:06:33
vale, pues que ha ocurrido, que este programa 00:06:35
se ha pre compilado 00:06:38
luego ya tenemos un código 00:06:40
intermedio, que no es ni código fuente 00:06:42
ni código máquina, vamos a ver 00:06:44
que ha hecho, le damos a dir 00:06:46
para ver lo que hay en la carpeta 00:06:48
y de repente nos ha aparecido 00:06:50
un fichero más 00:06:52
nos ha aparecido este 00:06:53
este es el 00:06:55
pre compilado, el que 00:06:58
ha generado el comando javac 00:07:00
el comando javac ha generado 00:07:02
este, el de extensión .class. 00:07:04
¿Recordáis la extensión que os puse ayer? 00:07:07
Cada vez que se edite 00:07:09
y se programa y se extienda, 00:07:10
hay que volverlo a compilar. 00:07:12
Cada vez que hagas un cambio, tienes que volverlo a compilar. 00:07:14
Cada vez que hagas un cambio en el .java, 00:07:16
no crea otra carpeta, se compila en el mismo .class. 00:07:18
Sí, sí, sí. 00:07:21
En la misma ruta en la que tú estés, te crea el .class. 00:07:22
Y no vas cambiando, se va a sustituir 00:07:24
un reporte. 00:07:27
¿Vale? 00:07:29
Entonces, este es el precompilado, 00:07:30
el .class que ha creado en esa misma carpeta 00:07:33
donde estaba el otro y ya está. 00:07:35
Y este ya la máquina virtual lo puede ejecutar. 00:07:37
Antes que nada, observadores, 00:07:40
¿no observáis nada extraño? 00:07:42
¿Qué? 00:07:45
Bueno, sí, ocupa más. 00:07:47
Pero ¿alguna cosa más, un matiz pequeñito? 00:07:49
Claro, la extensión es distinta. 00:07:52
El precompilado es .class. 00:07:54
El nombre. 00:07:56
Claro, el nombre lo ha cambiado. 00:07:58
¿Por qué? 00:08:00
Porque el .class 00:08:01
no tiene nada que ver con el nombre del fichero 00:08:02
yo el nombre del fichero pongo el que me da la gana 00:08:05
como si lo quiero llamar Pepito Pérez 00:08:06
el nombre que importa es este 00:08:09
este es el nombre 00:08:11
que importa 00:08:13
y este es el nombre de mi programa 00:08:13
si yo a este le he llamado ejemplo 00:08:16
lo guardo porque lo he cambiado 00:08:18
y lo vuelvo a compilar 00:08:21
con java c 00:08:23
pues ahora el 00:08:24
se llamará 00:08:26
el punto class se llamará 00:08:29
ejemplo 00:08:31
vale 00:08:31
entonces el que importa es ese 00:08:33
vale 00:08:35
entonces 00:08:38
me voy al explorador 00:08:39
otra vez 00:08:42
vale, voy a borrar este 00:08:44
porque ya tenía un 00:08:49
ejemplo class 00:08:51
vale, entonces obviamente 00:08:53
este ejemplo class 00:08:54
uno no puede abrirlo de ninguna manera 00:08:59
imaginaos que intentamos 00:09:01
le digo, no, voy a abrirlo 00:09:03
pues con 00:09:05
Con el blog de notas, a ver qué tiene dentro 00:09:06
Voy a abrirlo 00:09:08
Claro, siempre puedo abrir 00:09:09
Vale, estupendo 00:09:12
Ya no sé ni dónde estoy 00:09:14
No me la había llegado a abrir 00:09:16
Vale, a ver 00:09:31
A ver, si uno abre esto 00:09:32
Venga, voy a abrirlo con el blog de notas 00:09:39
Pues él dice, estupendo 00:09:40
yo te lo abro 00:09:42
esto no tiene ningún sentido 00:09:43
¿por qué? porque el .class no es 00:09:48
un fichero de texto 00:09:50
¿qué hace el sistema operativo cuando 00:09:51
le decís que abra con un editor de texto 00:09:54
un archivo que vete a saber lo que tiene? 00:09:56
pues lo que os he dicho que hacen 00:09:59
los editores de texto 00:10:00
se va cogiendo bytes 00:10:01
de uno en uno, coge el primer byte 00:10:04
mira el numerito que codifica, el 7 00:10:06
me voy a la tabla haste 00:10:08
a ver que carácter se corresponde con el 7 en la tabla 00:10:10
y te planta ese carácter 00:10:12
cojo el siguiente 00:10:14
miro el número entero que codifica 00:10:15
el 18 en binario 00:10:18
me voy a la tabla ASTI y me cojo el carácter 18 00:10:19
y te lo planto 00:10:22
claro, los ficheros de texto van a encajar 00:10:22
perfectamente porque lo que tienen 00:10:26
son secuencias de carácter, es así 00:10:27
según la tabla 00:10:29
pero el punto class no tiene nada de la tabla ASTI 00:10:30
no tiene ningún carácter, no tiene nada 00:10:33
tiene cosas que el único que sabe interpretarlas 00:10:35
es la máquina 00:10:38
virtual de Java 00:10:40
tú lo hablas con el blog de notas 00:10:40
pues te sale lo que ha coincidido 00:10:43
pero no tiene ningún sentido porque este no es un fichero de texto 00:10:45
bueno, pues este punto class 00:10:48
¿para quién sí tiene sentido? 00:10:50
para la máquina virtual 00:10:52
pues ahora entonces vamos a llamar a la máquina virtual 00:10:53
para que la ejecute 00:10:56
¿cómo llamamos a la máquina virtual? 00:10:57
de nuevo llamando al comando 00:11:01
que lanza la máquina virtual 00:11:02
¿cómo se llama el comando 00:11:05
que llama a la máquina virtual? 00:11:06
se llama java a secas 00:11:07
java a secas 00:11:09
vale, pues java a secas 00:11:11
y le tenemos que decir 00:11:13
el programa que queremos que ejecute 00:11:15
nuestro programa ¿cómo se llama? 00:11:18
se llama ejemplo 00:11:20
es el compilado, el .class 00:11:21
no tiene que 00:11:24
ejecutar el ejemplo 1.java 00:11:25
ese no se ejecuta, ese se compila, ya está compilado 00:11:28
el que tiene que 00:11:30
ejecutar es este 00:11:32
vale, pues le damos el nombre 00:11:33
sin la extensión .class, eso no se lo damos 00:11:35
vale 00:11:38
mi programa se llama ejemplo 00:11:41
y lo he ejecutado 00:11:43
claro, no hemos visto nada 00:11:46
porque es que no había nada que ver 00:11:49
ha creado un espacio en memoria 00:11:51
le ha dado un nombre 00:11:53
ha creado otro, le ha dado otro nombre 00:11:54
y se cerró el programa 00:11:56
todo eso lo ha hecho, pero no lo hemos visto 00:11:58
todo eso lo ha hecho, pero no lo hemos visto 00:12:01
vamos a meterle algo al programa 00:12:02
para por lo menos ver algo 00:12:05
pues bueno, vamos a 00:12:07
vamos a meterle 00:12:09
que 00:12:10
esa sentencia de mostrar por consola 00:12:11
podemos usarla desde ya 00:12:16
porque tampoco hay mucho que memorizar ni aprender 00:12:18
vamos a meterle 00:12:20
a nuestro programa, vamos a volver a abrirlo 00:12:23
y le vamos a meter 00:12:26
una sentencia 00:12:29
que vamos a usar mucho desde ya 00:12:31
que es una sentencia que sirve 00:12:33
para mostrar un texto por consola 00:12:36
esa ya nos la aprendemos 00:12:38
de memoria 00:12:40
¿Cómo se llama esa sentencia? 00:12:40
¿Cómo se escribe? 00:12:43
System con la S mayúscula 00:12:45
Punto out 00:12:47
Punto println 00:12:48
Y entre paréntesis 00:12:51
Entrecomillado el texto 00:12:53
Que yo quiera mostrar 00:12:55
¿Vale? Entonces 00:12:57
Esto ya lo podemos usar desde ya 00:13:12
Ahora mismo se nos hace un poco raro 00:13:13
Porque hay un punto 00:13:16
Porque hay no sé qué 00:13:18
Eso ya lo entenderemos más adelante 00:13:19
también cuando veamos la opción de entrada de objetos 00:13:21
porque hay un punto. Ahora mismo 00:13:23
quedémonos con que si yo quiero mostrar 00:13:25
un mensaje por consola 00:13:27
que vamos a querer a menudo 00:13:29
porque mostrar mensajitos informando de lo que hacemos 00:13:31
siempre viene bien. 00:13:33
Pues entonces, siempre que queramos 00:13:36
mostrar un mensaje para informar 00:13:37
de algo, hagámoslo así. 00:13:39
Con esto, S mayúscula 00:13:41
y entre paréntesis 00:13:44
entre comillado el texto que queramos. 00:13:45
Vale. Entonces, ahora como le hemos 00:13:48
cambiado el código, guardamos 00:13:49
y tenemos que volverlo a compilar. 00:13:51
Pues no pasa nada, 00:13:54
lo volvemos a compilar, java c. 00:13:55
No hemos metido ningún error. 00:13:58
Si alguien se ha equivocado, 00:13:59
ha escrito mal el system out print ln, 00:14:01
pues le dará un error de compilación. 00:14:04
¿Vale? Si alguien lo ha escrito, 00:14:07
si alguien le sale un error de compilación, 00:14:09
que revise si algo lo ha escrito mal. 00:14:11
Vale, pues entonces, 00:14:16
el que lo haya escrito bien, 00:14:17
ya está. Ahora, 00:14:19
Volvemos a ejecutar ese mismo programa 00:14:20
Lo vuelvo a ejecutar 00:14:22
Lo guarda 00:14:25
Ah, es que es ejemplo 00:14:38
Que no le vaya a cambiar el nombre 00:14:43
Vale, vale, entonces el que tengo que ejecutar en mi caso es ejemplo 00:14:44
Vale, pues voy a ejecutar 00:14:47
Es que no sé cuántas sois 00:14:49
Bueno, me merece más la pena cambiarle aquí el nombre 00:14:50
Esto va a ser más rápido 00:14:52
Vale 00:14:55
Porque estarás ejecutando 00:14:55
Otro, no lo habrás guardado 00:14:59
Vale, lo guardo con el nombre ejemplo 00:15:00
lo vuelvo a compilar 00:15:02
javac ejemplo 1 00:15:03
punto java 00:15:06
recordad que ahí se pone 00:15:09
el nombre del fichero, ahí sí, para compilar 00:15:10
javac ejemplo 1 00:15:12
y ahora ya voy a 00:15:14
ejecutarlo, java ejemplo 00:15:16
vale, pues ahora ya ha hecho 00:15:19
lo de crear las dos variables, que no es eso 00:15:22
no lo vemos, pero lo ha hecho 00:15:24
y luego ha hecho la siguiente sentencia, que es la de mostrar 00:15:25
por consola, vale, pues 00:15:28
¿Este proceso de compilar y ejecutar 00:15:35
algún problema o duda? 00:15:38
Recordad que recopilando 00:15:43
un fichero con extensión .java 00:15:44
el nombre que yo quiera de texto 00:15:47
esto lo pongo tal cual, calcao 00:15:49
aquí el nombre que yo quiera 00:15:52
este ya es el nombre de mi programa, el que yo quiera 00:15:54
y aquí dentro de esas llaves, el código 00:15:57
para compilar javac nombre del fichero 00:16:01
y para ejecutar Java 00:16:05
nombre y el programa, que es este. 00:16:08
¿Vale? Vale. 00:16:11
Bueno, pues, esto es lo único 00:16:16
que sabemos hacer ahora mismo, pues muy poquita cosa, 00:16:18
¿no? Muy poquita cosa. 00:16:20
Vale, pues entonces, sabemos 00:16:22
declarar variables. 00:16:24
Vamos al siguiente paso, 00:16:26
que es, ya que tengo yo 00:16:28
variables ya en mi programa 00:16:29
pensadas para recibir valores, 00:16:31
vamos a darle valores. 00:16:35
Vamos a darle valores. 00:16:36
Pues eso es lo que se llama asignación de variables, ¿vale? 00:16:38
Entonces, declarar dos variables es crear el espacio en memoria y darle un nombre, ¿vale? 00:16:42
Entonces, con esto, ¿qué estamos haciendo nosotros en realidad? 00:16:49
Declaramos, estamos declarando estas variables. 00:16:53
Y ahora, vamos a asignarles valor. 00:17:00
¿En los comentarios se suelen poner mayúsculas? 00:17:03
No, lo estoy poniendo en mayúscula para que se vea bien. 00:17:05
No, eso sí que no, como sea más cómodo. 00:17:08
Vale. 00:17:10
vale, pues ahora 00:17:10
vamos a ver 00:17:13
cómo asignar valores a variables 00:17:15
vale, pues la variable ya está declarada 00:17:17
vamos a suponer que le queremos dar a número 00:17:30
un valor 00:17:32
tiene que ser un número entero 00:17:33
sí o sí, un número entero, no puede ser otro 00:17:35
tengo dos opciones 00:17:37
dárselo desde fuera por la consola 00:17:39
pero eso todavía no sabemos hacerlo 00:17:43
hay que usar unas sentencias de entrada 00:17:46
que vamos a 00:17:48
dar después 00:17:49
o puedo yo dárselo directamente por programa 00:17:50
aquí en código, es decir 00:17:53
esto es una sentencia de asignación 00:17:54
nombre de variable 00:17:57
igual a 00:17:59
valor de la variable 00:18:00
menos 7, por ejemplo 00:18:02
¿vale? 00:18:04
es una sentencia de asignación, entonces 00:18:07
voy a ponerlo aquí en el Word 00:18:09
para no escribir en la pizarra 00:18:10
¿vale? 00:18:12
sentencia de asignación 00:18:17
¿Cómo es la sentencia de asignación 00:18:18
de un valor a una variable? 00:18:22
Tiene que ser un 00:18:26
Sí, pero 00:18:27
claro, pero eso es para 00:18:30
la condición de igualdad 00:18:32
aquí, vale, para un valor 00:18:35
de un valor a una variable 00:18:36
tan grande, peor 00:18:41
Bueno, pues ¿cómo es la sentencia 00:18:43
de asignación de un valor a una variable? 00:18:50
siempre es de esta manera 00:18:52
siempre es 00:18:55
a la izquierda 00:18:57
nombre de la variable 00:19:01
el nombre que le hayamos dado 00:19:03
nombre de la variable 00:19:05
el símbolo igual 00:19:07
y a la derecha el valor 00:19:09
y todo esto terminado en punto y coma 00:19:11
este es el formato 00:19:14
de la sentencia de asignación 00:19:16
así 00:19:18
tal cual, sí o sí 00:19:20
No, no hace falta 00:19:22
Pero 00:19:26
Entramos en otra regla de estilo también 00:19:27
Es más claro el código 00:19:29
Si se deja un espacio antes y después 00:19:32
A la máquina virtual le da igual 00:19:34
Al compilador le da igual 00:19:37
Los espacios, el compilador se los salta a todos 00:19:38
Pero el código queda más legible y más bonito 00:19:40
Que si lo quedamos todo apiñado 00:19:44
Entonces, otra regla de estilo 00:19:45
Aparte de esto de los tabuladores que hemos dicho 00:19:48
Pues poner aquí un tabulador 00:19:50
y aquí un tabulador ya para el programa 00:19:52
otra regla de estilo es este igual 00:19:54
antes y después 00:19:56
luego 00:19:57
la sentencia de asignación es siempre así 00:19:59
cuidado 00:20:02
estas son las cosas que uno se revisa 00:20:03
y se repasa en casa 00:20:06
porque luego ahora parece que es evidente 00:20:07
y es clarísimo, pero luego el 50% 00:20:10
de la gente 00:20:12
hace una asignación y la hace al revés 00:20:13
me pone el valor aquí 00:20:15
y el número de la variable aquí 00:20:18
es decir, como si me pusieran 00:20:19
menos 7 igual a número 00:20:21
no me he fudido a la asignación 00:20:23
claro, el nombre de la variable 00:20:25
quien recibe el valor va aquí 00:20:28
y el valor que le das va aquí 00:20:29
¿vale? 00:20:32
entonces, ¿qué significa esta sentencia 00:20:34
de asignación? que la cajita 00:20:36
llamada número, que está en RAM 00:20:38
esa cajita, acaba 00:20:39
de recibir el valor menos 7 00:20:41
y con ese se queda 00:20:43
¿que yo lo quiero cambiar más adelante? 00:20:44
lo quiero, lo cambio 00:20:48
las veces que me dé la gana según me interese 00:20:50
con lo que esté haciendo el programa, claro 00:20:52
ahora he hecho 00:20:54
otra sentencia de asignación 00:20:56
el valor menos 7 00:20:58
desapareció, pisado 00:21:00
borrado, ahora la cajita 00:21:02
número tiene el 8 00:21:04
¿vale? 00:21:05
se sobrescribe 00:21:08
se sobrescribe 00:21:09
y esta es la sentencia 00:21:10
de asignación, ¿vale? 00:21:13
entonces, claro, obviamente 00:21:15
que no se nos olvide 00:21:17
El valor tiene que ser del tipo del que está declarada la variable, ¿vale? 00:21:21
Es decir, si la variable está como entera, le tengo que dar un valor entero. 00:21:40
Si la variable está como char, le tengo que dar una variable char, ¿vale? 00:21:43
Con los matices de promoción que veremos ahora un poco después. 00:21:51
Vale, pues entonces, ahora, como ahora ya sí que tenemos que empezar a meter, 00:21:57
Pues eso, muchas pequeñas cosas. 00:22:04
¿Y qué pasa si la variable es char? 00:22:06
¿Y qué pasa si cambia no sé qué? 00:22:08
¿Y qué pasa si cambia no sé cuánto? 00:22:09
Ya son muchas pequeñas cosas y vamos a recogerlas ya en ficheros ya más grandes 00:22:10
con todo lo que vayamos añadiendo. 00:22:15
Vamos a dejar de trabajar con el bloc de notas, una pena, 00:22:17
porque va a quedar muy feo y muy poco organizado. 00:22:21
Entonces, asumido que está entendido y entendidísimo y es, por supuesto, material evaluable, 00:22:27
cómo se compila y cómo se ejecuta desde consola 00:22:33
porque eso es cómo se hacen las cosas 00:22:36
así se hacen 00:22:38
asumido que está entendido 00:22:39
vamos ahora ya a ir a lo vago 00:22:41
que es vamos a poner un entorno de desarrollo 00:22:43
vamos a usarlo 00:22:46
que me ofrece un editor de texto 00:22:47
más bonito y con colorines que el blog de notas 00:22:50
me permite compilar 00:22:53
dándole a un botón 00:22:54
y ejecutar en lugar de tener que teclear 00:22:55
java desde la consola 00:22:58
vamos a ser vagos 00:23:00
y usar un entorno de desarrollo que me facilita 00:23:02
escribir el contenido, darle a Java C y Java 00:23:05
de forma sencilla, ¿vale? Y así ya 00:23:08
cuando vayamos metiendo cosas en ficheros 00:23:11
para subir al aula y que otros miréis todo lo que hemos visto 00:23:14
pues está más organizado que en ficheros del blog de notas 00:23:17
¿vale? Pues venga, ¿cuál es el entorno 00:23:19
de desarrollo que vamos a usar? Ya os dije ayer 00:23:26
que el Eclipse 00:23:28
¿Para qué? 00:23:30
Si para Java no se usa 00:23:34
Nunca jamás, nadie usa para Java 00:23:35
El Visual Studio 00:23:37
Claro, no, no, no 00:23:38
Para Java o Eclipse o IntelliJ o NetBeans 00:23:41
Bueno, hay más entornos 00:23:43
Pero sobre todo Eclipse es el que más se usa 00:23:45
Vale, vamos a usar aquí 00:23:47
Vale 00:23:48
Bueno, pues el Eclipse lo tenéis instalado 00:23:49
En los ordenadores del aula 00:23:52
Y si no 00:23:55
Desde casa en los portátiles 00:23:56
Download Eclipse y os descargáis el Eclipse para desarrolladores. 00:23:59
Hay varios Eclipses. 00:24:03
El Eclipse para web developer, desarrolladores web, no. 00:24:05
El Eclipse estándar para desarrolladores, 00:24:08
si alguien tiene alguna duda. 00:24:10
Bueno, pues una vez que está, eso sí que se instala, 00:24:14
pues con siguiente, siguiente, como siempre, el Eclipse. 00:24:16
No tiene nada. 00:24:18
Bueno, pues una vez que arranquéis el Eclipse, 00:24:19
le deis a doble clic al Eclipse una vez ya instalado, 00:24:23
os abre 00:24:25
esta ventanita 00:24:27
donde 00:24:28
en esta ventanita 00:24:30
os dice 00:24:36
¿qué espacio de trabajo 00:24:37
quieres? ¿por qué? 00:24:40
porque el Eclipse 00:24:43
organiza los códigos 00:24:44
lo que trata es de facilitaros el trabajo 00:24:47
entonces organiza 00:24:48
nuestros programas en espacios 00:24:50
de trabajo, que yo puedo tener varios 00:24:52
por ejemplo, imaginaos que trabajáis en varios 00:24:54
proyectos en la empresa 00:24:57
en uno de clientes, en uno de facturas 00:24:57
pues os podríais hacer dos espacios de trabajo 00:25:00
mi espacio de trabajo para mis programas 00:25:02
de clientes, mi espacio de trabajo 00:25:04
para mis programas de facturas 00:25:06
bueno, tiene sentido hacerse varios espacios de trabajo 00:25:07
pues el Eclipse 00:25:10
lo llama Workspace, ¿vale? 00:25:11
¿en qué se concreta? 00:25:15
¿a qué se corresponde el espacio de trabajo? 00:25:16
a una ruta del sistema de archivos 00:25:18
ya está, un espacio de trabajo 00:25:20
es una ruta del sistema 00:25:22
de archivos donde están unos cuantos programas 00:25:24
y podéis tener varios espacios de trabajo 00:25:26
¿vale? en realidad no podría 00:25:29
trabajar así haciéndose sus carpetas 00:25:31
y separando por carpetas, pero bueno 00:25:33
un entorno de desarrollo se trata 00:25:35
se usa para que te facilite las cosas 00:25:36
pues cada workspace para él 00:25:38
es una carpeta que te crea y metes ahí 00:25:41
¿vale? pues 00:25:43
vosotros en el ordenador 00:25:44
poned aquí 00:25:46
la ruta en la que queráis 00:25:48
guardar los programas con los que vais 00:25:51
a empezar a trabajar ahora 00:25:53
Si no existe esa ruta 00:25:54
La crea él 00:25:59
Yo pues mi workspace 00:26:00
Pues va a ser este 00:26:02
Pues venga 00:26:05
Si quiero cambiar a otro le doy a browse 00:26:06
Y busco otro 00:26:09
Pero como quiero 00:26:10
Trabajar con este que me ofrece 00:26:15
Repito, si no queréis trabajar con el que os ofrece 00:26:16
Escribís aquí 00:26:19
Uno a mano 00:26:21
Y si sois vagos y no queréis escribirlo a mano 00:26:21
Le dais a explorador 00:26:24
Y aquí ya seleccionáis la ruta que queráis 00:26:27
¿Vale? 00:26:29
Bueno, pues yo quiero este 00:26:31
Lanzo ese Workspace 00:26:32
Ay, no, que la lupa 00:26:34
Ahí, vale 00:26:44
Vale, a ver 00:26:53
Pues un momentito 00:26:57
Olvidaos de esto 00:26:59
Ay, delete 00:27:01
Este fuera por ahora 00:27:07
vale, pues se os habrá abierto 00:27:10
primero una ventanita que dé la bienvenida 00:27:15
o algo así 00:27:17
y ya esa ventanita tendrá un botón 00:27:18
que pone ir al workspace 00:27:21
y ya no se vuelve a abrir más 00:27:22
bueno, pues se os habrá abierto algo así 00:27:24
algo limpio como esto 00:27:26
vale 00:27:28
ahora ya vamos a hacer nuestro 00:27:30
primer programa 00:27:34
bueno, pues Eclipse 00:27:35
organiza los programas 00:27:38
en cosas que se llaman proyectos 00:27:40
proyecto es una cosa que no tiene que ver con java 00:27:42
para java lo que hay son 00:27:44
estos ficheros .java que yo digo 00:27:47
que tienen esos códigos agrupados en paquetes 00:27:50
bueno, cosas que ya veremos, pero el concepto de proyecto no existe 00:27:53
para java, es un concepto de eclipse 00:27:57
que es una forma de organizar mis programas 00:27:59
pero luego cuando ya se compilan y se distribuyen 00:28:02
para que la gente lo ejecute, el proyecto ha desaparecido 00:28:06
Ya solamente están los .class 00:28:09
¿Qué os digo? ¿Vale? Para Java están los .class 00:28:11
Y ya está 00:28:13
Bueno, pero como Eclipse lo organiza en proyectos 00:28:14
Vamos a hacer un nuevo proyecto 00:28:17
¿Vale? Nuevo proyecto 00:28:18
Nuevo proyecto de Java 00:28:20
Nuevo proyecto de Java 00:28:22
Pues venga, le dais un nombre al proyecto 00:28:25
Es el que os dé la gana 00:28:27
Pues venga, como este va a ser, vamos a usar este proyecto 00:28:28
Para ver el tema de variables y asignaciones 00:28:31
Proyecto 00:28:35
Variables 00:28:39
asignaciones 00:28:43
operadores 00:28:47
como queráis, llamarlo como queráis 00:28:50
al proyecto, yo como este proyecto es el que luego 00:28:53
según vayamos incorporando 00:28:56
es el que voy a ir subiendo a la virtual para que esto recogido 00:28:57
pues le he puesto este nombre largo 00:29:00
para que quede así explicativo 00:29:02
proyecto sobre variables, asignaciones 00:29:03
operadores, ponedle el nombre que 00:29:06
vosotros os queráis organizar 00:29:07
pues venga, por ahora no cambiamos 00:29:09
nada porque no entendemos nada de lo que significa y le podéis 00:29:13
dará 00:29:15
si le dais a next 00:29:16
se deja todo tal cual 00:29:19
y finish, vale 00:29:20
y ya está creado el proyecto 00:29:23
vale 00:29:27
bueno, pues habrá 00:29:29
creado esto de aquí 00:29:34
esto, esto de aquí 00:29:35
ahora mismo no entendemos 00:29:44
muy bien lo que significa, lo iremos entendiendo 00:29:46
esto lo único que significa es 00:29:48
que este proyecto 00:29:50
lo va a ejecutar esta 00:29:52
máquina virtual con esta versión 00:29:54
esta, esto se podría cambiar, lo dejamos tal cual 00:29:55
lo va a ejecutar esta máquina 00:29:58
virtual con esta versión 00:30:00
y ya está, ahora mismo que os 00:30:01
quede simplemente que esta es información 00:30:04
sobre qué máquina virtual 00:30:06
va a ejecutar este proyecto 00:30:08
se supone que él ha cogido 00:30:09
la que tenéis en vuestra 00:30:11
cuando habéis instalado el Eclipse 00:30:13
pues la que él ha visto que tenéis 00:30:16
instalado el ordenador 00:30:18
se supone que ha cogido esa 00:30:19
a ver 00:30:20
¿os ponen todos la 16? 00:30:26
yo la 22 00:30:29
da igual, da lo mismo 00:30:30
porque de la 8 en adelante es todo lo mismo 00:30:33
siempre se puede cambiar, aquí botón derecho 00:30:34
propiedades 00:30:37
y aquí 00:30:39
hay un montón de opciones 00:30:41
siempre podéis cambiaros 00:30:43
pues a la última que os ofrezca 00:30:45
si queréis 00:30:47
me da lo mismo 00:30:47
con Sindo me da igual 00:30:53
da igual porque 00:30:56
de 8 en adelante 00:31:00
las variaciones son mínimas 00:31:05
es puro marketing en realidad para que Oracle parezca 00:31:08
que sigue sacándolos del mercado 00:31:11
bueno, añaden la opción de a lo mejor 00:31:12
cuando usa una sentencia usarla con otra palabra 00:31:17
en vez de solo con esa 00:31:20
pequeñas cosas, pero pequeñas cosas que a efectos prácticos 00:31:22
no se incorporan, de hecho 00:31:24
en las empresas, los servidores 00:31:26
suelen conservar casi todos la versión 00:31:28
1.8 00:31:31
que es de hace un montón 00:31:31
entonces, vale, pues entonces 00:31:34
ahora 00:31:37
nuestros programas a donde van a estar 00:31:38
aquí, ahí van a estar 00:31:43
esta carpetita 00:31:45
es la que va a tener nuestros códigos 00:31:46
fuente 00:31:49
Pues vamos a hacer el primero de ellos 00:31:49
¿Vale? 00:31:52
Entonces, aunque ahora no entendemos 00:31:53
Lo que es 00:31:56
Java nos permite 00:31:58
Organizar 00:32:01
Mis ficheros.java 00:32:02
A su vez en subcarpetas 00:32:04
Dentro de esta SRC 00:32:07
Lo que llama paquetes 00:32:09
Simplemente 00:32:11
A efectos de organización 00:32:12
Voy yo a crear un paquete 00:32:14
Que sea paquete que voy a llamar 00:32:16
ejemplos variables 00:32:18
para meter en él 00:32:20
mis ficheros relacionados 00:32:21
con variables, es una organización 00:32:24
sin más 00:32:27
ya entenderemos más adelante en un paquete 00:32:27
que implicaciones tiene 00:32:30
pues entonces aquí en src hacéis new 00:32:31
package 00:32:34
y decís, ¿a qué nombre? 00:32:35
pues en este paquete que es una subcarpeta 00:32:40
y en realidad interpretar 00:32:42
que paquete es sinónimo 00:32:44
de subcarpeta, nada más 00:32:46
pues venga, voy a llamarlo 00:32:47
variables, por ejemplo. 00:32:49
¡Hala! Y finish. 00:32:54
Ya está creado el paquete. Vale. 00:32:55
Ya tendréis 00:32:59
esta estructura. 00:33:00
Y ahora, aquí ya, ya vamos a 00:33:01
hacer mi fichero .java 00:33:03
con mi código, para ir viendo cosas 00:33:05
de variables y demás. Pues, 00:33:07
venga, ¿cómo lo hacemos? 00:33:09
New 00:33:12
y hacer un programa 00:33:12
en Java 00:33:15
es hacer una clase. 00:33:17
¿vale? programa y clase 00:33:18
son entre comillas 00:33:21
sinónimos, como todavía no hemos visto 00:33:23
cuando se han inventado objetos no entendemos eso 00:33:25
de clase, pero ahora mismo tenemos 00:33:27
que usar el eclipse para hacer cosas 00:33:29
bueno, pues entonces yo os digo 00:33:31
y os creéis que para hacer 00:33:33
un fichero con un programa que yo 00:33:35
pueda ejecutar, lo que tenéis que hacer es una 00:33:37
nueva clase, esto 00:33:39
new class 00:33:41
ala, new class 00:33:41
¿qué nombrecito quieres darle? 00:33:44
Pues venga 00:33:47
Ejemplo variables 00:33:49
Es que ponemos siempre lo mismo 00:33:52
Pero es que no se me ocurre 00:33:53
Algo más explicativo 00:33:55
Ejemplo variables le quiero dar 00:33:57
Y además si uno es muy vago 00:33:59
Y al colmo de vago 00:34:02
Y quiere ahorrarse escribir esta línea 00:34:03
Que recordad que os he dicho que hay que ponerla acá 00:34:05
Pues si marcáis esto 00:34:07
Te la escribe el solito 00:34:10
Porque dice 00:34:12
Como se te va a olvidar porque eres de la generación 00:34:13
Me lo callo 00:34:15
Como se te va a olvidar. 00:34:18
Ponme lo marco. 00:34:22
Y finish. 00:34:24
Y toma ya. 00:34:27
¡Hala! 00:34:29
Todo lo que te ha escrito. 00:34:31
Ya te ha escrito 00:34:34
todo esto ya. 00:34:35
Te ha escrito 00:34:37
esta línea. 00:34:38
No nos importa nada. 00:34:42
Nos olvidamos de ella. 00:34:43
No nos importa. 00:34:44
Hay que ponerla porque yo he creado 00:34:46
una subcarpeta variables. 00:34:48
todo esto de cómo funcionan los paquetes 00:34:49
lo tendremos que ver más adelante 00:34:51
cuando hayamos visto ya clases, ahora mismo 00:34:53
no podemos entenderlo, vale 00:34:55
¿qué me ha parecido? la línea 00:34:56
que os dije que tiene que aparecer sí o sí 00:34:59
ha puesto un public delante 00:35:00
me da igual, podéis ponerlo o quitarlo 00:35:02
lo que significa 00:35:05
tampoco podemos saberlo ahora todavía 00:35:07
si lo quitáis, no pasa nada 00:35:09
si lo dejáis, tampoco pasa nada 00:35:11
y ha puesto esta línea 00:35:13
que es la que os he dicho que hay que poner tal cual 00:35:15
y ha puesto las llaves 00:35:17
y además ha hecho la regla de estilo 00:35:18
que os dije, poner tabuladores para que quede bonito 00:35:20
y un comentario para decirte 00:35:22
oye, mete aquí el código 00:35:24
que quieras ya, lo quitamos que es muy feo 00:35:26
ese comentario, vale, pues 00:35:28
me ha escrito él solito ya todo esto 00:35:30
por si a mí se me ha 00:35:32
olvidado, y esto 00:35:34
de aquí que repito, ya entendemos 00:35:36
lo que significa, pero esto sí que lo tenéis que dejar 00:35:38
puesto, vale, pues ahora aquí 00:35:40
ya podemos escribir código, pues 00:35:44
venga, vamos a ver 00:35:46
Primera parte. Vamos a ver ya más en detalle cómo funcionan las variables enteras. Las variables de tipo entero. Vamos a verlo un poquito más en detalle con ejemplos. Variables de tipo entero. ¿Sabéis qué variables de tipo entero? I, by, short, int y long. 00:35:48
Vale, pues primero, primera cosa que vamos a incorporar, primera, se puede asignar un valor a una variable a la vez que se la está declarando, vale, primera cosa que vamos a incorporar. 00:36:11
Por ejemplo, declaro mi variable entera número, declarada, estupendo, sentencia perfectamente hecha, pero a la vez que la declaro, si uno quiere ya, la puedo dar un valor, es decir, yo quiero declararla y ya de partida darle el número 8. 00:36:43
podría hacer esto 00:37:02
y esto está perfectamente hecho 00:37:03
la he hecho aparecer en memoria 00:37:05
y le he metido un 8 en la cajita 00:37:07
pero me puedo ahorrar 00:37:09
dos líneas, me puedo ahorrar y a la vez 00:37:11
que la declaro 00:37:14
le doy el valor, con lo cual esta ya me sobra 00:37:15
a ver, la podría dejar 00:37:18
pero es que estoy sobre escribiendo el 8, luego es estúpido 00:37:20
esta ya me sobra 00:37:22
¿vale? luego primera cosa que añadimos 00:37:23
se puede a la vez que uno 00:37:26
declara un valor, perdón una variable 00:37:28
a señalar un valor. Esto es lo que se suele 00:37:30
llamar inicializar. 00:37:32
Se le suele llamar, el nombre técnico 00:37:36
es inicializar. 00:37:38
¿Es obligado a inicializar 00:37:41
una variable? No, tú la declaras 00:37:42
y le das valor cuando te interese. 00:37:43
Pero puedes en ese momento. 00:37:46
Más cosas. 00:37:49
Se pueden declarar 00:37:52
varias a la vez del mismo tipo 00:37:53
de esta manera. 00:37:56
Por ejemplo, yo quiero 00:38:05
declarar dos variables enteras, 00:38:06
número 1 y número 2. 00:38:08
Pues no hace falta que haga esto. 00:38:10
Int número 1. 00:38:12
Int número 2. 00:38:16
Claro que puedo. 00:38:19
Perfectamente declaradas y muy bien. 00:38:20
Pero queda muy feo. 00:38:23
Esto no es para programadores. 00:38:24
Cuando tengo varias variables a la vez del mismo tipo, 00:38:27
las puedo declarar así. 00:38:30
Separándolas por comas. 00:38:32
Así, ¿vale? 00:38:34
Y puedo inicializarlas si quiero. 00:38:38
Una, las dos o ninguna. 00:38:40
Por ejemplo, puedo hacer esto y esta la he inicializado y esta no. 00:38:41
O puedo inicializar las dos o ninguna. 00:38:47
Entonces, en la misma línea podemos... 00:38:50
Vale, entonces, ¿qué quiero del mismo tipo? 00:38:53
Eso ya sí que tiene que ser separado. 00:38:57
¿En líneas? 00:38:59
En realidad no, porque el concepto de línea es un concepto del editor de texto para el que lo ve. 00:39:00
Pero uno podría hacer un programa donde está todo seguido en una línea. 00:39:04
Claro, horroroso. 00:39:09
¿Quién visualiza ese programa todo en una línea? 00:39:10
Horrible 00:39:13
Entonces, hombre, si yo quiero declarar 00:39:13
Una variable 00:39:16
De otro tipo distinto 00:39:18
Ya iré a una línea distinta, ¿vale? 00:39:20
Pero ahora estaba con variables enteras 00:39:22
Todavía estaba con variables enteras 00:39:24
Luego no estamos declarando char 00:39:26
Aún, ¿vale? 00:39:28
Uy, son i22 ya 00:39:30
Ay, qué lástima 00:39:32
Pero a mí ya la voz está muy mal 00:39:34
Así que lo siento muchísimo por vosotros 00:39:36
Pero vamos a parar aquí, ¿vale? 00:39:38
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
23
Fecha:
17 de septiembre de 2024 - 18:52
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
39′ 40″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
163.20 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid