2024-10-21-Programacion | Mediateca de EducaMadrid

Y nada, ya estamos grabando. Y nada, preguntaros si tenéis alguna duda antes de empezar a hablar de otras cosas. Este tema 1 es como muy introductorio sobre el que hemos estado trabajando. 00:00:00

el tema 2, lo abro luego esta noche 00:00:12

en principio la fecha de apertura es mañana 00:00:15

pero bueno, lo abro luego esta noche o mañana por la mañana 00:00:18

y bueno, todavía ya empezamos 00:00:21

a hacer alguna cosilla más con el lenguaje Java 00:00:24

pero todavía es como muy sencillo 00:00:28

sencillo al menos para los que ya habéis programado con anterioridad 00:00:30

igual los que llegáis desde cero sí que necesitáis 00:00:33

toda esta introducción para empezar a ir aterrizando un poco 00:00:37

¿Tenéis alguna cosilla, alguna pregunta que queráis que comentemos antes de arrancar? ¿A contaros yo cosas? No, vale, pues nada, genial. 00:00:39

Sí, sí, ese es, no sé si con alguna pequeña variación que nos surja según vayamos haciendo las tutorías de este año, pero ese chuletario es el que hemos utilizado por lo menos los dos últimos años y bueno, pues hay un resumen razonable de lo que es la sintaxis. 00:01:03

Como ya os comentaba que el examen en sí lo haremos en papel, pues bueno, que tengáis ese chuletario de referencia. Entonces, contad con él, sí. De hecho, normalmente junto con el examen os lo damos nosotros el chuletario el propio día que tengáis la prueba. 00:01:22

No, no, no, ese chuletario lo tendréis a vuestra disposición para cuidar el hombre. Es aconsejable quizás que lo echéis un ojo para estar familiarizado con la información que tiene, porque igual el día del examen no es el mejor momento para familiarizarse, porque tendréis que estar más centrados en el examen. 00:01:39

Pero esa hoja la tendréis a mano para que podáis vosotros tirar de ella como referencia. 00:02:00

Y si en ese chuletario a la que vayamos hablando de los diferentes contenidos, 00:02:07

bueno, pues os parece que vendría bien añadir alguna cosilla, pues no lo decís. 00:02:13

Y en principio, el chuletario es común para los dos grupos, lo tendría que coordinar con el otro profesor. 00:02:18

Pero bueno, si son cosas para sintaxis y todo esto, que os puedan ayudar en el día del examen, 00:02:24

pues lo podemos añadir en principio sin problema bueno pues no sé exactamente a qué diferencias te 00:02:30

refieres a problemas en tanto en cuanto a la instalación o en tanto en cuanto a que aparecen 00:03:00

diferentes opciones ya pues probablemente entre todas las opciones java te da una cantidad de 00:03:05

alternativas brutales y no solamente para lo que es la gestión de un proyecto java sino para la 00:03:46

gestión de proyectos muy en general, o sea 00:03:52

es un mundo, estos IDEs 00:03:54

están estupendos porque 00:03:56

todas esas opciones al final son 00:03:58

nos facilitan la vida una vez que nosotros 00:04:00

estamos haciendo trabajos 00:04:02

pues que tengan que ver con esas alternativas 00:04:04

pero aquí 00:04:06

vamos a trabajar con 00:04:08

programas Java 00:04:10

razonablemente sencillos y no vamos 00:04:11

a profundizar en todo eso, no sé si 00:04:14

en la asignatura de entornos de desarrollo 00:04:16

que claro va un poco más al hilo de 00:04:18

este tipo de IDEs, que no toda la 00:04:20

asignatura versa, digamos, sobre estar viendo en torno al desarrollo. 00:04:22

Luego hacéis bastantes más cosas en ese módulo. Pero no sé si 00:04:26

ahí sí que hará un poco más recorrido sobre todas las opciones de menú que van apareciendo. 00:04:30

En principio, de nuestra asignatura se queda un poco fuera del 00:04:35

ámbito de lo que vamos a trabajar. Esto no quiere decir que si 00:04:38

alguna a ti tú crees, pues yo creo que esta por lo que 00:04:42

sugiere me va a resultar interesante. No quiere decir que ponla 00:04:46

en los foros y bueno pues entre todos y yo mismo si quieres la investigó un poquillo y llegamos a 00:04:50

conclusiones pero lo que es en sí necesario para la asignatura el millón de opciones que nos 00:04:56

proporciona eclipse o net bienes no va a ser necesario que las conozcáis ya sí sí sí mira 00:05:01

bueno te cuento te cuento un poco para poner en contexto quizás la pregunta y a ver si termino 00:05:40

respondiendo te en los programas que nosotros vamos a hacer en principio durante la asignatura 00:05:44

aunque bueno en la base para luego hacer grandes proyectos no pues son sencillos van a tener poca 00:05:51

cosa el de esta forma veremos lo que son paquetes en algún momento habla en alguno de los temas no 00:05:56

recuerdo exactamente en cuál de lo que son los paquetes digamos en java cuando estamos creando 00:06:03

un proyecto aquí con eclipse estas nuevas versiones ofrecen directamente al crear un 00:06:09

proyecto, lo voy a ir haciendo por aquí, después borramos este proyecto, vamos a llamarlo a A, una cosa 00:06:14

sencillota, la propia creación del proyecto genera aquí en la carpeta source este ficherito, este 00:06:22

ficherito tiene como objetivo digamos estructurar diferentes clases que puedan estar distribuidas 00:06:29

en diferentes paquetes, ahora te explico un poco la idea de los paquetes, digamos que es como un 00:06:36

enlace ahí para que todo el código Java sea capaz de localizar 00:06:41

unas clases a otras. Entonces aquí con cierta sintaxis se puede 00:06:46

meter ese tipo de información. ¿Qué vengo yo haciendo en esta 00:06:51

asignatura todo este tiempo? Pues en cuanto creo un proyecto 00:06:55

elimino este. El hecho de tener esto, cuando tú quieres crear 00:06:58

una nueva clase, te obliga a que organizes las cosas sí o sí 00:07:02

por paquetes. Entonces por eso te estaba exigiendo que tuvieras 00:07:06

que introdujese es un paquete y el hecho de crear un paquete 00:07:08

luego ya te dejaba seguir con el proyecto adelante. 00:07:12

Para evitar esto, nuestros pequeños proyectos de ahora, 00:07:15

yo lo que hago directamente es eliminar este ficherito. 00:07:18

Y eliminando este ficherito nos libramos de esta situación. 00:07:20

Que para grandes proyectos puede ser interesante, cuidado, 00:07:24

pero que ahora quizás nos van a complicar más la vida 00:07:26

que nos la van a favorecer. 00:07:30

¿Qué son los paquetes en Java? 00:07:32

No sé si de hecho tenía apuntado a hablaros un poco de ello aquí 00:07:34

Y si no, bueno, os lo cuento ya que va al hilo. 00:07:37

Pues vamos a ponernos en la situación de un gran proyecto. 00:07:40

Imagínate que la banca te coge y te dice, pues mira, quiero que me hagas un proyecto, pero integral de todo. 00:07:43

No un proyecto que haga una función main y me saque por pantalla tres cosillas, sino algo que me resulte ya funcional. 00:07:51

Y la banca, por ejemplo, igual si alguno soy de banca me tomo la pata, 00:07:59

Pero bueno, vamos a suponer que tiene varias líneas de negocio, una de créditos, otra de cuentas corrientes y otra para trabajar en bolsa, ¿no? 00:08:05

Y entonces, si tú coges y te pones a hacer código para la aplicación en su conjunto, pues resultará que para dar servicio a cada uno de estos campos, 00:08:14

de estas líneas de trabajo, necesitas hacer 10 ficheritos con extensión .java. 00:08:23

Y claro, como si necesitas 10 ficheros con extensión .java para las tres funcionalidades, pues terminar juntando 30 y esas 30 estarían agrupadas en un único directorio, en lo que sería un único paquete que por defecto un proyecto, si quitamos el módulo este, es el paquete por defecto. 00:08:28

Entonces, ¿qué es lo que podemos hacer? Pues podemos decir, mira, vamos a organizar el código de Java por bloques. Entonces, para lo que decíamos de bolsa, pues hacemos un paquete que vendría a ser en la estructura del sistema de archivos, un directorio y ahí organizo todo el código que tiene que ver con bolsa. 00:08:47

Entonces ahí creo los 10 ficheritos .java con el código correspondiente que tiene que ver con bolsa. Creo otro directorio, es decir, un mecanismo de organización del código. Creo otro paquete que finalmente en la estructura del sistema de archivos va a ser un directorio diferente, donde creo la parte de préstamos y otro paquete para la otra parte que habíamos comentado. 00:09:05

con lo cual, bueno, pues visualmente lo tengo mejor organizado 00:09:31

que luego tengo un problema 00:09:34

en el código que tiene que ver con las acciones a bolsa 00:09:35

porque me detectan un error, pues ya por lo menos sé 00:09:40

que me tengo que ir al paquete de bolsa y no en toda la vorágine 00:09:43

de 30 ficheros con todo mezclado 00:09:46

que si en lugar de 3 funcionalidades hablamos de 50, pues al igual 00:09:48

tenemos 150 ficheros, pues localizar 00:09:52

en esos 150 es más difícil que localizar justo en el 00:09:55

paquetito, precisamente vamos al término 00:09:58

de paquete donde tenemos organizado todo el código que tiene 00:10:01

que ver con bolsa. Es decir, una forma 00:10:04

de ser ordenado, digamos, en el código. Entonces, esa es la idea 00:10:07

de los paquetes. Y luego, además, una de las características 00:10:10

que tiene la programación orientada a objetos es 00:10:13

que es tener 00:10:16

la intención de reutilizar el código. Si yo 00:10:18

un primer banco me sugiere que 00:10:22

le haga un desarrollo, pues igual tengo que hacer 00:10:25

todo el código es de cero pero a lo mejor luego entrando en esa línea de negocio pues otros 10 00:10:28

bancos me lo piden también y resulta que la forma de trabajar para en bolsa de todos ellos a lo 00:10:33

mejor termina siendo muy parecida pues pero otras otras a lo mejor otras líneas de negocio no tanto 00:10:38

no pues entonces a lo mejor puedo ir al primero de los proyectos y directamente coger el paquete 00:10:43

de donde he desarrollado el código relacionado con bolsa y coger y utilizarlo directamente 00:10:49

trasladando ese paquete de forma completa al otro proyecto 00:10:56

y haciendo quizás algún pequeño retoque. 00:11:00

¿Estas ventajas tiene? 00:11:02

Al final, en los proyectos de ingeniería, 00:11:03

de ingeniería y ingeniería software también, 00:11:06

lo que sueles facturar son horas que facturas 00:11:09

y horas que tienes que pagar a quien está haciendo el desarrollo. 00:11:13

Si ya lo tienes hecho el código de otra ocasión, 00:11:15

a lo mejor con un poco de suerte hasta puedes facturar como nuevo 00:11:20

y tener los beneficios como reutilizado. 00:11:22

Y no solamente es el desarrollo, sino porque nosotros ahora justo aquí con Eclipse y en las clases vamos a hacer programas y parece que aquello ya se terminó, pero el hecho de hacer el desarrollo del código quizás no sea la que más tiempo te dedica en ocasiones y seguro que no es la que más dolor de cabeza te da. 00:11:26

Porque luego, bueno, pues hay que probar todo aquello, hay que tener certeza si vas a dar un producto ya incluyente que va a ser final que prácticamente nunca falla, ¿no? Por no quemar la imagen de tu empresa dando algo desarrollado y poco probado. 00:11:46

Entonces, paquetes que ya tienes muy trabajados, pues están ya muy probados y si los reutilizas, aparte de no tener que hacer el código, ya muy bien probados, pues eso ganas. Entonces, es un poco el espíritu de distribuir los proyectos en paquetes. ¿Sí? Más o menos. 00:12:00

Para nuestros proyectos, ahora en el momento, mira, cuando, si quitas el módulo, el ficherito ese, como lo he borrado yo aquí de este proyecto, te libras de ello. 00:12:21

Y luego, si quieres de todas formas organizar el código en paquetes, pues por aquí puedes crear nuevos paquetes y luego el código ir distribuyéndolo por ahí. 00:12:30

más o menos para hacer un enlace del estilo de lo que decía 00:12:38

el módulo info este de todo el proyecto, luego en la cabecera 00:12:43

se puede poner aquí código donde identifiques cada clase 00:12:47

en qué paquete está, que es con la etiqueta package 00:12:51

pero bueno, ya esto lo vamos viendo 00:12:54

pero un poco el espíritu de los paquetes es este, y bueno pues 00:12:59

ya ves, esto tiene un montón de opciones, yo seguro 00:13:06

Seguro que, al menos en un tema que habla de refactorización en entornos de desarrollo, hablaría de esta, de refactor y source, que viene a ser que el propio IDE te reconstruya o te dé ciertas características al código sin que cambie la funcionalidad, cambiando nombres de variables, cosas de este estilo. 00:13:10

trabajéis más en entornos 00:13:30

con ello. Y luego, bueno, pues por aquí 00:13:32

ya veis, tiene un millón de opciones 00:13:34

que seguro que todas son 00:13:36

súper útiles y te aportan cosas 00:13:38

y que yo no he utilizado nunca porque son tantas. 00:13:40

¿Alguna otra cosita por ahí? 00:13:50

Sí. 00:14:21

Sí. El bytecode. 00:14:28

No, no, 00:14:41

en realidad va contra el punto class. 00:14:42

Yo creo que sí. 00:14:46

El intérprete, a veces 00:14:48

nos intentan ayudar tanto los 00:14:49

cuando hacen los programas, que probablemente 00:14:51

el intérprete hasta sea capaz 00:14:54

de generar, el intérprete 00:14:56

te hablo del programa Java, no del Java 00:14:58

que es el compilador, probablemente 00:15:00

hasta si lo enfrentas al 00:15:02

punto Java, a lo mejor hasta te lo ejecuta 00:15:04

porque se va al código, hace el proceso 00:15:06

ese que haría el compilador 00:15:08

y 00:15:09

si 00:15:10

en realidad 00:15:18

si tú 00:15:26

Mira, te cuento, si tú utilizas el intérprete, que el intérprete es Java, el compilador es Javad, el intérprete Java. Si tú utilizas el intérprete, a ver, si saco aquí un editor texto, si tú, para compilar, el compilador es Javad, y el intérprete es Java. 00:15:26

si tú utilizas el intérprete imagínate que ya teníamos aquí una clase que era hola mundo punto 00:15:50

java entonces sobre esta clase es ahora que tú pasas el compilador y ésta te da esta es la que 00:15:56

te da el punto clase sobre el intérprete lo que le pasas es hola mundo en principio sin extensión 00:16:06

es como como en principio funciona pero si lo pasas sin extensión en el que ejecutas el punto 00:16:15

class y puede ser que si le pones me parece que alguna vez que he hecho yo alguna prueba si le 00:16:21

pones el donde está el código fuente pues el intérprete intenta intentar trabajar tanto por 00:16:27

nosotros que es como que hace las dos fases de una entonces es como que lo intenté compilar 00:16:34

e interpretar vale igual no hasta nos funciona pero lo suyo suyo lo purista es compiló con jabba 00:16:40

obtengo el punto clas y ejecutó con el intérprete el hola mundo sin el punto clas y en principio si 00:16:47

al ponerlo así sobre el que tira es sobre este no sobre este y se lo traga puede ser si yo creo 00:16:54

yo creo que no creo que pasa como tú dices pero cuando tú ejecutas así lo que te ejecuta realmente 00:17:09

es este a ver miramos vamos a hacer una pequeña prueba mira tenemos aquí este ejecutable el hola 00:17:17

2 este es el que cree cuando se dice la copia está el otro día entonces os dije que os comentaba la 00:17:28

semana pasada que tiene un directorio de trabajo eclipse que es este entonces vamos a ir ahí no 00:17:38

vamos a ir a ese proyecto a la hora 2 y mira no vamos a ir aquí al bien que tiene el punto 00:17:47

classo lo veis que si yo pongo aquí java bueno vamos a poner la ruta completa wish java aquí 00:17:54

me chiva la ruta observa que aquí no está el punto java si ponemos esto y ponemos hola hola 2 es cómo 00:18:00

funciona es decir me ha funcionado porque porque ha tirado del fichero punto clas miramos a para 00:18:14

ya salir de dudas total voy a cambiar el nombre a este fichero para que no exista el punto clas 00:18:22

y lo voy a llamar por un momento lo cambió el nombre vale ahora ahora lo recuperó por si 00:18:30

queremos hacer algo con él y entonces si ahora hago una ejecución es hago la ejecución del 00:18:40

intérprete que está en esa ruta de o la 2 pero ya no existe o la 2 punto clas sino que si teclas 00:18:46

punto 2 por dice que no puede encontrar el fichero ves como para que como ya no existe el punto clas 00:18:51

el intérprete en realidad está intentando tirar del punto clas y de hecho el mensaje que nos da 00:18:59

errores no puede encontrar el fichero punto clas del ejecutable o lados si volvemos a recuperarlo 00:19:04

pues en principio volvería a ir es decir que la idea funciona el teclado hay un poco la idea es 00:19:11

que contra quien tira el intérprete es contra el punto class y si lo ejecutamos contra el punto 00:19:22

java y funciona pues bueno es porque pues porque nos quiere ayudar el intérprete más de lo normal 00:19:27

pero no es en realidad para lo que está para lo que está diseñado mira ves ahora volvemos a 00:19:33

ejecutar y ya nos vuelve a funcionar porque porque tenemos volvemos a tener el punto class no sé si 00:19:40

has visto el bueno la tutoría del otro día y el vídeo hacíamos el proyecto este justo desde aquí 00:19:49

desde el terminal con un editor nano, compilábamos y terminábamos 00:19:55

lanzando el intérprete. Si quieres un poco aclarar 00:19:59

cómo lo hicimos, en el vídeo este que os tengo colgado en el aula virtual, justo estuvimos hablando 00:20:03

un poco de todo esto. Que es para centrar conceptos, porque ya no vamos 00:20:07

a volver a hacer proyectos a través de esos medios, sino que 00:20:11

utilizaremos el IDE. ¿Alguna cosilla más por ahí? 00:20:15

Te salen pequeñas, ¿no? No sé si será porque... 00:20:46

Te sale de partida pequeño, ¿no? 00:21:04

Es que... 00:21:08

A ver, a ver, ¿dónde es? 00:21:09

Yo... 00:21:46

Sí. 00:21:47

Sí, bueno, y te iba a comentar yo justo eso también. 00:21:48

Están Virtual Boss, 00:21:51

que es una cosa independiente en sí de la máquina. 00:21:53

Tiene una cosa que se llama las Guest Additions, 00:21:57

que es, bueno, pues cosas adicionales a los invitados, 00:21:59

se podría traducir, pero bueno, 00:22:02

que lo que te hace es que... 00:22:04

¿Sí? 00:22:09

sí que lo pusiste 00:22:09

entonces 00:22:16

ya 00:22:17

es que 00:22:20

es que justo 00:22:21

justo con 00:22:21

las 00:22:25

las GES Addition 00:22:25

suelen tener que ver 00:22:26

con eso 00:22:26

entre otras cosas 00:22:27

pero 00:22:28

pero 00:22:29

cuando no tienes instaladas 00:22:29

las GES Addition 00:22:31

implica que 00:22:31

te salen pequeño 00:22:33

y luego cuando metes 00:22:34

las GES Addition 00:22:35

entre otras cosas 00:22:36

lo que hace es 00:22:37

digamos adaptar 00:22:37

al tamaño 00:22:38

de tu pantalla 00:22:39

y te lo vuelve en grande 00:22:40

teóricamente 00:22:41

eh 00:22:43

sí 00:22:44

las 00:22:44

las 00:22:45

Ya, claro 00:22:47

Pues no sé decirte 00:22:51

¿No habrás cambiado de versión 00:22:56

De VirtualBox respecto al año pasado 00:22:58

Y se te ha quedado desactualizada 00:23:00

La gestión? 00:23:02

Y ha sido a posteriori 00:23:14

Sí 00:23:16

Sí, nada 00:23:38

No se me ocurre nada así de antemano 00:23:40

No sé si quieres abrir 00:23:42

Si te da muchos problemas 00:23:44

Pon algún pantallazo ahí en el foro 00:23:46

A ver si entre todos se nos ocurre echarte una mano. 00:23:48

Así de primeras, se me ocurría lo de la Guest Addition, pero poco más. 00:23:51

A bote pronto. 00:23:55

Bueno, nos vas contando, Silvia. 00:24:07

Pero ¿por qué has puesto Java.class? 00:24:31

¿O cómo? 00:24:33

Sí, si le pones la extensión .class, mira, no sé si me estás viendo a mí ahora. 00:24:34

Si le pones la extensión .class, es verdad que no funciona. 00:24:43

O sea, el intérprete utiliza el .class, pero sin ponerle el .class. 00:24:45

Ya, igual te está pasando esto porque, como has organizado el proyecto con paquetes, entonces igual intenta buscar esas estructuras que te aportaría el ficherito módulo java.modulo, ese que aparecía ahí al principio, que bien configurado te da la estructura de cómo encontrar unos paquetes u otros. 00:24:50

mira hace una cosa si te parece crea un nuevo proyecto elimina el fichero ese genera el hola 00:25:43

mundo y si quieres intenta ejecutarlo desde el terminal yo creo que va a funcionar sí sí pues 00:25:51

mira en él justo ese proceso es uno de los que hicimos te lo digo por bueno pues por darme otras 00:26:11

cosas lo hicimos justo aquí en este vídeo en este que no sé si has podido ver el vídeo que os colgué 00:26:18

de la semana pasada justo estuvimos haciendo eso desde el terminal creando un proyecto no 00:26:25

lo creamos no lo metíamos en ningún paquete y ejecutamos el bueno con el intérprete del punto 00:26:31

class entonces si te parece echar un ojillo y si tienes algún problema si quieres en la próxima 00:26:38

tutoría si ves que aún así no te sale o a través del foro me lo comentas y lo intento echar un 00:26:44

vistazo por hacer algo lo digo por hacer algo un poco diferente a lo que hicimos ya la semana 00:26:51

pasada sabes si te parece vale de tal forma no te quedes con la duda ya te digo si vuelves a 00:26:55

intentarlo viendo el vídeo y no te funciona o bien por foros o la semana que viene lo echamos un ojo 00:27:05

que para eso son estas tutorías en principio para aclarar dudas que podéis tener bueno alguna 00:27:11

cosilla más pues hoy yo creo que hoy mismo os abro os abro el tema 2 y como en el tema 1 ya 00:27:22

lo habíamos repasado y no tiene grandes cosas que hacer pues lo vamos a hablar sobre contenidos que 00:27:34

tenéis que se os abren aquí en este tema entre lo que comentemos hoy y bueno durante la semana 00:27:39

cosas que podéis ir viendo incluso la tutoría de la semana que viene si es necesario pues 00:27:46

terminamos de finiquitarlo porque este tema tiene solo una semana de vida y luego ya la siguiente 00:27:50

pues nos vamos a ir al tema 3. Vamos a ir directamente ya aquí a Eclipse y vamos a empezar 00:27:55

a hablar de diferentes conceptos de los que van a aparecer por ahí. El lenguaje, cuando trabajamos 00:28:05

con un lenguaje de programación, pues hay un montón de... ese lenguaje tiene una semántica, 00:28:11

que es como se entienden las cosas, una sintaxis, típico como en lengua castellana tenemos palabras que tienen su sujeto, su predicado, 00:28:18

pues aquí es necesario para hablar en castellano, pues seguir una determinada estructura, pues los lenguajes de programación tienen su sintaxis. 00:28:28

¿Quién se encarga de comprobar esa sintaxis? Pues el compilador. 00:28:37

cuando nosotros le pasamos a un código java con código fuente 00:28:45

el compilador lo que verifica es todas estas cosas 00:28:50

el compilador en sí no sabe si tu propósito es 00:28:53

en tu algoritmo es una suma y tú le pones 00:28:58

el signo de resta, pues el compilador no sabe interpretar que tú lo que querías 00:29:02

era sumar, pero sí sabe que si en lugar de 00:29:06

si tú tienes dos variables y pones a más b, pues le gusta porque 00:29:10

el más lo entiende como un símbolo que hace sumas, el a menos b lo entiende también y si pones a, z, b, pues esto no lo sé, porque con una variable que pueda haber por aquí y otra aquí, no hay nada que me realice una operación entre dos variables poniendo la etiqueta de una z. 00:29:14

Entonces, este no le gustaría y estas, pues en principio sí le gustaría. 00:29:32

En Java, dentro de la sintaxis que tenemos, todas las instrucciones, que no necesariamente tienen por qué estar en una línea, 00:29:39

pero lo que sí que sucede es que todas las instrucciones acaban con un punto y coma. 00:29:46

Pues bueno, eso forma parte de la sintaxis de Java. 00:29:49

¿No vamos a otro lenguaje? Pues podrá tener una sintaxis un poquito diferente y obligarnos a seguir unas determinadas pautas que hay igual Java, ¿no? 00:29:52

En cada uno de los lenguajes tendremos que aprender esa síntesis, igual que si queremos hablar en castellano, en vasco, en catalán o en gallego. Cada uno tiene sus reglas y hay que trabajar sobre ellas. 00:29:58

Entonces tendremos una serie de palabras que son reservadas en cada uno de los lenguajes y que terminarán utilizándolas o tokens que terminarán utilizándolas para validar que sean correctas las estructuras. 00:30:12

Entonces fijaros por aquí, public, static, void, todas estas que nos aparecen por aquí en rosita, son palabras de esas reservadas que tenemos en Java. 00:30:29

String, esta no nos aparece en rosita, pero también es una palabra reservada que necesariamente tenemos que utilizar para darle ciertas funcionalidades 00:30:41

y que no podemos definir, por ejemplo, nosotros variables que tengan estos nombres porque confundirían estas palabras claves con aquellas variables que queremos ir utilizando en nuestro programa. 00:30:50

Hola2, en cambio, no es una palabra que esté reservada por Java, con lo cual lo podemos utilizar nosotros para dar nombre a una clase. 00:31:00

Pues ahí tenemos la clase Hola2, que no utiliza una de las etiquetas propias de Java y que tiene reservadas. 00:31:07

Bueno, entonces, ¿con qué tipo de cosas trabajamos nosotros en Java? 00:31:14

Pues una de las cosas con las que trabajamos, bueno, en cualquier lenguaje de programación, una de las cosas que necesitamos son variables. 00:31:24

¿Las variables para qué nos sirven? Pues nos sirven para ir teniendo información del desarrollo de nuestro programa mientras está en ejecución, cosas que no queremos perder. 00:31:29

Mira, si queremos hacer un programa que sume números, pues cogemos y podemos definir con una etiqueta de las definidas en Java, int. 00:31:43

esta está asociada a un tipo de datos entero, es decir, un valor numérico entero 00:31:54

que se almacenará en la memoria RAM con 32 bits 00:31:59

y lo siguiente que vamos a identificar va a ser una variable de tipo entero 00:32:03

entonces ponemos int a, entonces ponemos aquí un punto y coma 00:32:10

pues a sería una variable de tipo entero 00:32:15

y en esta a podríamos guardar números para ir utilizando luego en el programa 00:32:18

entre un determinado rango que es el que acepta guardar información de tipo sin decimales, números sin decimales en 32 bits. 00:32:24

Aquí podríamos coger y decir, pues mira, que directamente va teniendo ya un valor, un 7 de inicio. 00:32:37

Lo que hacemos es aquí, en una variable que es de tipo entero, guardar un número. 00:32:42

Igual que tenemos los tipos enteros, pues podemos tener cadenas de caracteres. 00:32:49

Las cadenas de caracteres en Java, estas son cosas que tenemos que aprender de cada uno de los lenguajes, 00:32:53

No tanto el algoritmo de pensar cómo vamos a resolver un problema, 00:32:58

porque ese algoritmo sí que puede ser común a muchos lenguajes. 00:33:02

Y lo podríamos escribir incluso antes de programar en un lenguaje o en otro con pseudocódigo. 00:33:06

Pero sí que cada uno de los lenguajes, luego cuando vamos a llegar a la concreción de escribirlo en él, 00:33:11

pues tendrá unas, a lo mejor otro lenguaje utilizará entero para guardar un valor numérico que no tenga decimales. 00:33:17

Pues Java utiliza int. ¿Qué utiliza Java para guardar cadenas de caracteres? Pues string. Entonces lo que definamos como string es nombre. Los string los metemos en Java entre comillados. El texto que queremos que vaya en esta cadena de caracteres que en el contexto de este método lo hemos llamado nombre y es de tipo cadena de caracteres porque lo hemos definido como un string, pues lo ponemos entre comillas aquí. 00:33:26

Entonces, por ejemplo, ponemos aquí José, con lo cual la variable José en este momento tiene un valor, la variable ese nombre en este momento tiene un valor que es José y el tipo de información que ha sido capaz de guardar al definirla como un string es una cadena caracteres, que la sintaxis para ponerlo en Java es entrecomillado. 00:33:57

Pues igual que tenemos estos dos tipos, pues tenemos otro tipo para guardar números enteros que es el tipo long, pues también guarda valores enteros, pero este cuando hace una reserva en la memoria RAM, y ahora os hablo de la memoria RAM, para albergar el valor que tiene B, reserva más bits, entonces como reserva más espacio en memoria, el rango de valores puede ser mayor. 00:34:18

Si quisiéramos guardar, por ejemplo, no sé si en el tema habla de la población mundial o cuando habla un poco del ejemplo de esto, el número de habitantes que tenemos en el mundo, pues a lo mejor en 32 bits no dan como para guardar un número de la población mundial. 00:34:46

O sí, bueno, siempre habrá un número más grande que ya no entrará dentro del rango de los que aceptan los enteros. 00:35:03

Entonces, en ese caso, lo que haríamos sería definir otra variable que también es de tipo entero, sin decimales, long, 00:35:09

y entonces este, como ocupa más espacio, reserva más espacio de memoria para guardar el valor, 00:35:16

pues su rango de valores que puede guardar es mayor. 00:35:21

En cuanto a los enteros, tenemos estos, luego tenemos otro tipo, que es el tipo byte, que también guarda enteros. 00:35:26

Y en cuanto a los valores que almacenan con decimales numéricos, pues tenemos el float, tenemos el double, estos dos nos permiten guardar valores con decimales, punto, como carácter, a ver qué es lo que está pasando aquí, bueno, con float me decía que hiciera un casting ahí, float, no sé muy bien por qué, bueno, luego os hablo de los casting también. 00:35:32

Pues estos admiten números decimales. Los tipos de datos que tenemos predefinidos en Java, pues para enteros estos tres, para números incluyendo el float, que me está dando ahora un mensajillo de error, luego lo investigamos. 00:36:24

cadena de caracteres, tenemos los string, hay algunos más, pero estos son los más típicos. 00:36:39

Para un solo carácter, es decir, un valor alfanumérico, pero uno solo, 00:36:46

pues podemos definir un char, los char, si las cadenas de caracteres se guardan entre dos comillas, 00:36:52

pues los char se guardan con una comilla simple. 00:36:59

Y luego tenemos también los Boolean, que son tipos de datos que almacenan dos posibles valores, que son o bien verdadero, true, o bien falso, la otra alternativa. Iremos trabajando mucho sobre ellos. 00:37:03

¿Qué pasa cuando nosotros queremos dar de alta una variable que vamos a ir utilizando en nuestro programa? 00:37:21

Pues esto se traduce en que el intérprete en este caso necesitará para guardar esta información que A, hasta que termine de estar en uso A, si la queremos volver a utilizar por aquí, 00:37:31

que este dato sea capaz de guardarse relacionado 00:37:46

con una variable A en nuestro programa, implicará 00:37:50

que se tendrá que guardar ese valor en algún sitio. 00:37:52

¿Qué tenemos en el ordenador para guardar este tipo de información 00:37:55

de los programas en ejecución? 00:37:58

Pues tenemos la memoria RAM. 00:38:02

Si abrimos el ordenador en la asignatura 00:38:04

de sistemas informáticos, veremos que es un dispositivo 00:38:07

que está penchado junto al procesador y junto al resto 00:38:10

de componentes hardware. El sistema operativo hace una gestión 00:38:14

intermedia entre los programas que necesitan hacer uso de la RAM 00:38:18

y el hardware que está pinchado en nuestro ordenador. El hardware 00:38:22

nos queda muy lejos, entonces nosotros desde el lenguaje, cuando estemos hablando 00:38:26

de nuestros programas, diremos, nuestro intérprete en este momento 00:38:29

está dando de alta una variable de tipo entero 00:38:34

que sabemos que en memoria RAM ocupa 7 bytes y queremos que guarde 00:38:37

un valor de un 7. Por lo que hará el intérprete será decir al sistema operativo 00:38:41

vete a buscar en el sistema operativo, busca en la memoria RAM 00:38:46

espacio de 32 bits al menos, y relacionalo con que tiene que ver 00:38:52

con esta variable A del programa que estoy ejecutando. 00:38:58

Y guarda el valor 7. Esto es lo que hará el sistema operativo 00:39:01

y hará esa reserva. ¿Hasta cuándo tendrá reservado 00:39:07

nuestro programa esa memoria RAM para guardar 00:39:11

información en nuestra variable? Hasta que esta variable se salga de ámbito. 00:39:15

El ámbito es un término que tiene que ver con el momento 00:39:20

en el que está viviendo, tiene vida 00:39:23

nuestra variable en el programa. Y los ámbitos los marcan las llaves. 00:39:27

Entonces, esta variable A está en el ámbito 00:39:32

de este método main 00:39:35

entonces cuando acabe el método main 00:39:37

finalizará la variable a que está definida dentro de este ámbito 00:39:41

si, bueno 00:40:03

el recolector de basura es una herramienta 00:40:05

me preguntaba, lo digo porque en la grabación 00:40:09

vuestro audio no se escucha, me preguntaba 00:40:12

un compañero si hay alguna forma 00:40:15

de saber cuando el recolector de basura va a liberar 00:40:18

la memoria RAM que ha reservado para una determinada variable 00:40:21

en nuestros programas de Java. 00:40:24

El recolector de basura es un programa que corre por ahí detrás, 00:40:27

que nosotros no tenemos que preocupar en principio por él, 00:40:30

y que es el encargado de irse dando cuenta de aquellas variables 00:40:33

que han dejado de utilizarse dentro de nuestro programa 00:40:38

y cuando se da cuenta de esto, avisa al sistema operativo 00:40:41

de que esa variable ya no tiene sentido en nuestro programa 00:40:46

y el sistema operativo libera esa memoria RAM para que pueda ser utilizada por otras variables en nuestro programa 00:40:49

o por otras variables de otros programas diferentes. Ese es el recolector de basura. 00:40:55

El recolector de basura es un proceso que corre de forma independiente a nuestro programa. 00:40:59

Entonces se activa cuando él quiere. No sé exactamente, bueno, cuando él quiere, entiendo que habrá que en sí Java en su estructura 00:41:04

tendrá unos criterios para activar el recolector de basura, pero no es algo que nosotros, 00:41:12

normalmente nuestros programas 00:41:16

hagamos, si que hay 00:41:18

la posibilidad para objetos de clase 00:41:20

que ya os comentaré lo que son los objetos 00:41:22

de clase y como trabajan con la memoria RAM 00:41:25

si que creo recordar 00:41:27

que tiene un método que es el método destroy 00:41:29

en el cual podemos 00:41:31

obligar sin que sea 00:41:32

el recolector de basura de forma 00:41:34

independiente cuando el 00:41:36

le toque 00:41:38

liberar la memoria RAM, obligar a nosotros 00:41:39

a que se libere, pero normalmente a no ser 00:41:42

que tengamos un lenguaje de altísimo 00:41:44

rendimiento, pues nos despreocupamos de liberar 00:41:47

la memoria RAM y ya será el recolector de basura quien se encargue 00:41:50

de hacerlo. Esto es una 00:41:53

ventaja que tiene Java, la existencia del recolector de basura 00:41:56

porque luego hay otros lenguajes como C, que creo 00:41:59

que os hablaba de él el primer día, una pregunta que me planteabais 00:42:02

algunos de vosotros, que no tiene recolector de basura. 00:42:05

Entonces, si tú reservas memoria para 00:42:09

variables y tú por código no la liberas, 00:42:11

lo que vas haciendo es dejar bloqueada esa memoria continuamente en el ordenador. 00:42:14

Y si haces muchísimas reservas de memoria sin liberar nunca, 00:42:19

podrías llegar a comerte todos los recursos de memoria RAM que tiene el ordenador 00:42:23

y dejarte de funcionar no solo tu programa, sino todos los demás que estén ejecutándose en tu ordenador. 00:42:26

¿Por qué? Por falta de memoria RAM. 00:42:31

En este caso con Java, somos afortunados que el recolector de basura lo va a ir haciendo a su aire. 00:42:33

Él va a chequear que hay variables que ya no están usándose. ¿Por qué? 00:42:39

Porque el ámbito donde se estaban ejecutando ha dejado de estar en funcionamiento, entonces ya no son necesarias esas variables y como no lo son, el recolector de basura coordinado con el sistema operativo liberará esa memoria RAM. 00:42:42

y os decía antes 00:42:55

creo que el método 00:42:58

destroy durante el curso 00:43:00

lo veremos en algún momento 00:43:02

puede con independencia 00:43:04

de que el recolector de basura 00:43:06

libere memoria RAM creo que puede dar 00:43:08

la orden de liberar memoria RAM 00:43:10

pero 00:43:11

generalmente no lo hacemos y os decía 00:43:14

a no ser que sea un programa de alto rendimiento 00:43:16

que necesitemos que todos los recursos 00:43:18

estén muy muy disponibles en todo 00:43:20

momento, que pasa que 00:43:22

normalmente si vamos a hacer un programa de este estilo 00:43:24

no solemos trabajar con Java 00:43:26

es un programa que su máximo objetivo 00:43:27

sea sacar el mejor de los 00:43:30

rendimientos y el tiempo real 00:43:32

como podrían ser otros programas 00:43:34

imaginaros yo que sé un programa que está 00:43:36

un día os hablaba de ello también 00:43:38

una central nuclear y 00:43:40

de un sensor tiene que detectar una fuga 00:43:42

y no le vale cada milisegundo 00:43:44

a lo mejor es oro para bloquear 00:43:46

o sellar unas puertas 00:43:48

entonces esos programas a lo mejor 00:43:49

tienen que ser en tiempo real 00:43:52

de cuando pasa ya tiene que estar el aviso dado, pues esos programas 00:43:53

no los haríamos en Java en ningún caso. Utilizarían otros lenguajes más 00:43:58

enfocados a ese tipo de funciones. Continúo con esto. 00:44:01

Me vais interrumpiendo si tenéis consultas que hacerme. 00:44:12

O si me preguntáis alguna cosa y no queda muy clara, pues también 00:44:15

me decís. Cuando trabajamos 00:44:19

con variables en nuestros programas, ya os digo 00:44:22

las variables tienen que guardarse 00:44:27

en memoria RAM. El primero 00:44:29

de los días, os decía, un programa normalmente 00:44:33

y Java en particular es un lenguaje orientado a 00:44:35

utiliza programación orientada a objetos 00:44:38

con lo cual tenemos clases y de esas clases creamos 00:44:42

objetos. Y os hablaba del desarrollo de una clase 00:44:45

donde había profesores y creábamos diferentes clases 00:44:48

y luego interactuaban unas con otras. 00:44:50

estos objetos, vamos a crear en este programa una clase 00:44:53

esto que estoy haciendo ahora es comentar el código 00:44:58

en Java hay dos opciones, puedes comentar el código línea a línea 00:45:08

que es con 00:45:13

las dos barritas estas o bloquer de código multilínea 00:45:16

con la barra y el asterisco y al finalizar asterisco 00:45:20

barra, esto que implica aquel código que pongamos entre 00:45:24

comentarios, bien sea código o bien sea texto. Todo lo que se encuentre el compilador 00:45:28

Javad cuando vaya a compilar nuestro programa, lo que encuentre como comentario, es decir, 00:45:33

a la línea que hayamos antepuesto el barra barra o le hayamos puesto la barra asterisco 00:45:38

con cierre asterisco barra, lo considera como comentarios al código, no código propiamente 00:45:44

dicho y no lo tiene en cuenta en la compilación. Este código no lo voy a borrar ahora de momento 00:45:49

por si lo queremos reutilizar, pero como no me interesa por el momento, lo voy a poner como comentado. 00:45:56

Y mirad, vamos a crear en este proyecto otra clase, en el proyecto hola2, que es justo sobre el que estamos, 00:46:04

este a, vamos a crear la clase, por ejemplo, la clase profesor o la clase alumno. 00:46:09

Fijaros que ahora ya nuestro programa tiene dos clases, una hola2.java, que es donde está ese punto de entrada 00:46:25

del programa, el módulo main y otra clase alumno que tendrá una serie de características 00:46:32

propias de los alumnos y definiremos unos métodos que serán aquellas acciones que 00:46:38

hacen los alumnos. Y luego podremos ir dando de alta alumnos para que vayan participando 00:46:43

en nuestro programa. Vamos a suponer que los alumnos tienen un nombre y los nombres en 00:46:48

qué tipo de variables los almacenamos. Los almacenamos en variables de tipo string. 00:46:57

Pues mira, vamos a definir aquí que cuando yo luego dé de alto a un alumno, tendrá unos parámetros, madre mía, teclado, bueno, tendrá unos parámetros, no lo corrijo porque la letra del teclado de retroceso no me va muy bien. 00:47:02

de hecho tendrá unos parámetros que caracterizarán a los alumnos 00:47:29

por ejemplo tendrán un nombre 00:47:34

y luego vamos a suponer que tienen una edad 00:47:35

los parámetros numéricos hemos dicho 00:47:56

la edad será un número entero 00:48:00

no será muy grande, vamos a definirlo como un entero 00:48:02

y luego los alumnos podrán hacer una serie de cosas 00:48:05

os acordáis que os comentaba que las cosas que pueden hacer 00:48:10

las identificamos como métodos 00:48:14

Entonces, dentro de las etiquetas, pues tenemos public, que ya hablaremos de qué es, o private, o protected, public void, saludar, vamos a poner. Ponemos aquí otras llaves. System.out, ahora repasamos todo este código. 00:48:16

mirad aquí, respecto a los ámbitos que os decía 00:48:44

hemos definido un ámbito que corresponde a toda la clase 00:49:03

he abierto aquí una llave, Eclipse me está archivando que se cierra aquí 00:49:08

con lo cual las variables que definamos en este ámbito 00:49:12

como puede ser el senombre o el iedad 00:49:15

están activas en todo momento 00:49:19

en el que tengamos un alumno, cuando creemos una variable de tipo alumno 00:49:24

ahora la vamos a crear después, su ámbito de vida es el que hemos definido con código entre estas dos llaves. 00:49:28

Como estas variables están definidas en todo el ámbito, esas variables se habrá reservado en memoria RAM 00:49:35

para ellas mientras el alumno exista. En cambio, si cogemos y ponemos aquí saludar y definimos una variable 00:49:42

de tipo string, que la definamos como misal hola desde saludar, esta variable misal, que viene a significar 00:49:52

de mi saludo, está definida en este otro ámbito, con lo cual esta variable está disponible dentro del método saludar 00:50:10

y estas para toda acción que realice un alumno, por ser su ámbito. Si cogemos y ponemos aquí otro método 00:50:17

que sea despedirse. La variable misal está disponible en el método saludar pero como está 00:50:25

definido en este método una vez que se encuentra la llave de cierre de saludar misal desaparece y 00:50:45

será el recolector de basura el que termine eliminando ese espacio de memoria y no estará 00:50:51

disponible en despedir. ¿Por qué? Porque solamente está en este ámbito. En cambio ese nombre eiedad 00:50:57

como está disponible en todo el ámbito de la clase alumno 00:51:03

podríamos utilizarla dentro de saludar o podríamos utilizarla 00:51:07

dentro de despedir. Fijaros como 00:51:10

si yo le doy un valor aquí a iedad 00:51:14

no se queja el compilador, no se pone en rojo 00:51:16

si le doy un nuevo valor a mi sal 00:51:25

tampoco se queja, ¿por qué? 00:51:28

porque estas dos variables en esta zona 00:51:34

están dentro del ámbito donde están definidas, una porque 00:51:37

está definida en toda la clase y otra porque está definida dentro del método 00:51:40

saludar. Pero si yo trabajo con 00:51:43

esas dos variables dentro del método despedir 00:51:46

y edad sí que le sigue gustando, pero mi sal 00:51:49

ya no. ¿Por qué? Porque no existe en el ámbito de despedir, 00:51:53

solamente existe en el ámbito de saludar. Se entiende 00:51:55

más o menos supongo esto de los ámbitos donde están definidas 00:52:04

las variables. Mirad, aquí 00:52:07

en este proyecto tenemos 00:52:11

el main y la clase alumno. 00:52:15

En este proyecto cogemos y podemos definir en el método main, que decimos que es el punto de entrada a nuestro programa, 00:52:18

podemos definir una variable. 00:52:25

Entonces decimos string sbar y la inicializamos como variable 1. 00:52:26

Nuevamente esta variable estará definida dentro del ámbito del main. 00:52:38

Todo lo que pase dentro del main podrá utilizar la variable sbar. 00:52:41

String es una clase que está definida en las librerías de Java. 00:52:47

Como vamos a... 00:52:52

Bueno, string luego tiene... 00:52:54

Sí, string está definida dentro de las clases de Java. 00:52:55

En particular, el tipo string, sí. 00:52:58

Java tiene definidas una serie de variables 00:53:01

que son estas que os había puesto por aquí. 00:53:04

Las voy a rescatar, todas estas. 00:53:08

Que las llama variables primitivas. 00:53:11

Primitivas de Java. 00:53:14

Es decir, que las tiene definidas 00:53:16

para que las utilice cualquiera en cualquier momento. 00:53:18

son características muy habituales en todo programa, 00:53:20

que existan cadenas de caracteres, con lo cual nos han despreocupado 00:53:25

de que tengamos que nosotros definir los componentamientos 00:53:29

de estos tipos de variables y las han definido ellos en las librerías. 00:53:31

En cambio, no todo proyecto tiene una clase que sea alumno. 00:53:37

Esta es muy particular del problema que queremos resolver nosotros. 00:53:42

Entonces, aquí es donde empezamos a nosotros a actuar 00:53:45

definiendo nuestras clases propias de nuestro ejercicio. 00:53:47

Nuestro ejercicio utilizará cosas que definamos nosotros particulares para él y utilizará cosas que están disponibles desde las clases de Java. 00:53:50

Fijaros, hemos querido definir una variable que al llegar aquí habrá pedido nuestro programa sistema operativo que haga una reserva de memoria para guardar con ese nombre el valor jose. 00:54:01

y podremos definir una nueva variable que en este caso 00:54:12

en lugar de ser de tipo string sea de un tipo que hemos creado nosotros 00:54:17

en nuestro programa, que tenemos un esquema de qué características tiene 00:54:21

y cómo se comporta. Entonces cogemos y definimos un alumno aquí 00:54:25

alumno al 1, vamos a llamarlo alumno 1 00:54:28

Entonces ahora acabamos de definir una variable 00:54:34

de tipo alumno. ¿Al 1 qué tendrá? Pues tendrá las características 00:54:48

string, ese nombre que tendrá, pues 00:54:52

aquellas características que se hayan definido en las librerías 00:54:55

de Java para toda variable que sea de tipo string. 00:54:58

Ya veremos cosas que se pueden hacer con los strings. Sobre todo 00:55:01

es trabajar con cadenas de caracteres. Al 1, ¿qué 00:55:04

será? Pues será una variable en nuestro programa, igual que 00:55:07

ese nombre lo es, que es de tipo objeto 00:55:10

de una clase que tendrá como características 00:55:13

y cosas que puede hacer aquello que hayamos definido 00:55:16

para este tipo de datos. Este tipo de datos es un tipo que hemos 00:55:19

incorporado a nosotros en nuestro programa como una clase, que es la clase 00:55:22

alumno. ¿Y qué es en particular lo que puede hacer? Pues lo que hayamos puesto nosotros aquí en el 00:55:25

programa Java, tendrá estas características y estos métodos, estas 00:55:29

propiedades. Los tipos que ya están disponibles en Java, 00:55:33

string es un poco particular, pero bueno, aquí en este contexto lo vamos a meter 00:55:44

también entre los tipos propiamente definidos en Java para lo que os voy a contar, 00:55:47

como puede ser, por ejemplo, el tipo string, el tipo int, son los tipos primitivos 00:55:51

de Java. Y los tipos como alumno, que son clases que definimos 00:55:56

nosotros, de los cuales podemos crear también variables, son 00:56:01

variables referenciadas. Ahora os desarrollo lo de referenciadas. 00:56:05

Tipos primitivos, variables referenciadas. ¿Qué sucede cuando 00:56:09

en nuestro programa, si os pierdo en algún momento me cortáis 00:56:14

o me vais diciendo? ¿Qué sucede cuando en mi programa yo defino 00:56:19

una variable de un tipo primitivo. 00:56:23

Pues directamente, como os decía antes, 00:56:26

el intérprete va a preguntar al sistema operativo 00:56:29

por espacio donde guardar una información 00:56:32

tipo cadena de caracteres, porque la hemos dicho string, 00:56:34

o entero, si siguiéramos con este otro ejemplo, 00:56:37

le va a asociar a esa zona de memoria 00:56:41

el nombre de la variable, ese nombre, 00:56:44

y va a guardar su información. 00:56:46

Es decir, en esta línea de texto, 00:56:49

cuando llegamos a esta línea de código 00:56:51

cogerá mi intérprete y dirá 00:57:05

sistema operativo, necesito 00:57:08

espacio para almacenar 00:57:11

un string 00:57:16

el sistema operativo buscará en la memoria RAM y dirá 00:57:17

una vez en un sitio, otra vez en otro 00:57:22

es una gestión que hace el sistema operativo con independencia 00:57:24

de que nosotros la podamos controlar, pues dirá 00:57:27

en la posición de la memoria RAM, en la 20.000 00:57:29

resulta que tengo espacio para guardar 00:57:32

tu stream 00:57:35

y te lo reservo 00:57:36

con lo cual 00:57:37

desde la 20.000 hasta un determinado 00:57:40

espacio que ocupará para la cadena stream 00:57:43

vamos a suponer que es hasta la 20.020 00:57:44

este espacio 00:57:47

está reservado y ahí voy a guardar 00:57:51

tu información que es José 00:57:52

y cuando quieras 00:57:54

preguntarme por ella, lo voy a dejar asociado 00:57:56

a una variable que me has dicho que es ese nombre 00:57:58

cuando tú me preguntes por ese nombre, me iré 00:58:00

a la posición 20.000 y sabiendo que en el espacio 00:58:02

entre la 20.000 y 20.030 está la información relacionada con ese nombre, te diré 00:58:06

que lo que había ahí es José. Si yo cojo 00:58:10

en el programa para esa misma variable y le pongo ese 00:58:14

nombre igual a José2, pues dirá, como ese nombre está 00:58:17

asociado a esta zona de memoria, para la cual he reservado ya 00:58:21

un espacio, pues en ese espacio de memoria guardo ese 2. Cuando me preguntes 00:58:25

por ese nombre, ahora lo que pondrás será jose2 00:58:30

y te devolveré que esa variable en esa posición de memoria 00:58:32

tiene jose2, en la forma en la que va a ir trabajando Java. 00:58:36

Para cuando hacemos la definición de una variable primitiva de Java, 00:58:41

el sistema operativo ya hace esta reserva. 00:58:53

Pero cuando hacemos la definición de una variable 00:58:57

que es referenciada, es decir, un objeto, la variable que apunta a un objeto 00:59:00

de una clase nuestra o incluso de una clase de Java, pero un objeto de una clase 00:59:06

en una de las variables primitivas, lo que estamos reservando es una referencia 00:59:12

en memoria. ¿Esto cómo funciona? Esta instrucción está escrita aquí en dos fases 00:59:17

que la vamos a romper ahora. Vamos a quitar este trozo aquí y ahora vamos a poner esto. 00:59:24

En estos dos trozos. Cuando nosotros cogemos y hacemos esto, estamos definiendo una variable que va a ser de tipo alumno. Pero no, el sistema operativo en este caso no reserva el espacio de memoria necesario para albergar toda la información de un alumno. 00:59:36

Fijaros, como poco, un alumno necesita espacio de memoria para guardar un nombre y una edad. Lo que hace es guardar una referencia. Dice, vale, esta variable, cuando vayas a querer referirte a ella, tienes para esta variable, busco en memoria RAM y te doy la posición 30.000 en este caso. 00:59:54

esa referencia es donde 01:00:15

vas a ir a buscar información cuando 01:00:19

hagas referencia en tu programa al 1 01:00:22

que es un objeto de la clase alumno 01:00:25

pero no te he reservado de la 30.000 01:00:28

a un determinado número de memoria RAM 01:00:31

donde puedas guardar el nombre y la edad 01:00:35

solamente te voy a reservar un trocito de memoria 01:00:38

pequeño para que se almacene 01:00:41

una referencia. Es decir, aquí voy a decirte 01:00:44

que si tú ahora coges y me haces este otro bloque de código 01:00:48

new, con este new es el momento 01:00:52

en el que te voy a reservar espacio para guardar todos estos datos. 01:00:57

Entonces, con este new se fija 01:01:02

en cómo está construido el alumno, que tiene 01:01:05

un nombre y una edad, y dice, para un string necesito 01:01:08

20 bytes y para 01:01:12

un entero necesito 01:01:14

32. Entonces aquí es cuando 01:01:16

yo cojo y busco en memoria RAM 01:01:18

un espacio mucho más grande 01:01:20

donde poder guardar esa información 01:01:22

que imaginemos que es del 50.000 01:01:24

al 50.050. 01:01:26

En este espacio de 50.000 al 50.050 01:01:30

en el 50.000 01:01:33

estará para 01:01:34

alumno 1 01:01:36

el nombre 01:01:37

desde el 50.000 al 50.030, vamos a suponer, y del 50.030 al 50.050 es donde estará la edad. 01:01:40

Y aquí, en este espacio entre el 30.000 y el 30.002, lo que guardará es que la información DAL1 se encuentra a partir del 50.000. 01:02:02

Recapitulamos. 01:02:18

Las variables primitivas hacen, cuando tú defines una variable directamente de las primitivas de Java, 01:02:20

hacen ya la reserva del espacio donde se va a guardar su información 01:02:25

sin que tengamos nosotros que hacer nada más. 01:02:30

Dice ya, reservo memoria para que tú pongas ahí el dato, José 2. 01:02:33

Cuando definimos un objeto de una clase, lo que se guarda es, 01:02:38

estamos aquí definiendo un objeto de una clase, 01:02:44

lo que se guarda es en memoria run la posición donde luego 01:02:47

vamos a ser capaces de guardar los datos de ese objeto 01:02:54

si ese objeto tiene un nombre y una edad 01:02:58

necesitará un espacio de memoria RAM que hemos hecho un supuesto aquí que es del 01:03:02

50.000 a 50.050, pero si aquí tienes 50 parámetros 01:03:06

pues necesitará más espacio para guardar todos esos datos, pues entonces el 01:03:10

espacio para guardar el objeto iría del 50.000 al 60.000 01:03:14

y en esta definición donde no hemos hecho este new 01:03:17

lo único que se requiere de memoria RAM es el espacio necesario e imprescindible 01:03:21

a donde luego va a guardarse la información de todo el objeto de la clase. 01:03:29

Una posibilidad podría ser definir esto a nul, mirad. 01:03:39

Esto lo que implica es, si lo definimos a nul, lo que implica es que este objeto no apunta a ninguna posición de memoria. 01:03:43

en este espacio 01:03:50

pondríamos null, no estamos apuntando a ningún sitio 01:03:52

y luego cuando hacemos el new 01:03:55

lo que hacemos es cargar 01:03:57

en esta referencia que está entre la 30.000 y la 30.002 01:03:59

ese 50.000 que es donde el sistema operativo 01:04:04

ha encontrado espacio en memoria RAM 01:04:07

para guardar sus datos 01:04:09

eso pasa con el new 01:04:11

si nosotros cogemos y ponemos la instrucción esta 01:04:14

como la habíamos puesto al principio 01:04:18

con las dos cosas de una atacada al 2 y hacemos aquí un niño alumno es una atacada digamos que 01:04:20

hace estos dos procesos y haciendo estos dos procesos ya lo que tenemos es algo que se empieza 01:04:34

a parecer mucho a lo que en una sola instrucción hacemos para las variables de primitivas dejaba 01:04:42

Que es que para ALDOS ya tenemos un espacio de memoria donde poder guardar información para sus variables. ¿Se entiende más o menos? La parte de la gestión de memoria no es fácil del todo, eso ya lo digo, pero bueno, como lo repasaremos mucho. 01:04:47

estáis ahí verdad me oís sí sí vale se entiende esto es lioso un poco lioso sí bueno vamos a 01:05:12

vamos a repetirlo intentando simplificarlo definimos una variable de tipo entero que 01:05:32

son las que existen en java y igual a 10 a 20 el sistema operativo busca espacio para esta 01:05:40

variable y los enteros tienen un tamaño de 32 y en ese espacio no es necesario hacer un 01:05:49

nosotros específico específico por código y directamente cuando nosotros pongamos una 01:05:54

referencia de y ya directamente nos dirá el valor de 20 entonces el sistema operativo habrá ido y 01:06:02

y habrá buscado en un espacio de memoria el 40.000 y dirá, pues a partir de ahí guardo con los siguientes 32 bits, 20. 01:06:11

Si yo digo, escríbeme, escribe el valor de i por pantalla, con System of Println, por pantalla me saldrá un 20, 01:06:18

y la variable i vale 20. Si yo cojo y digo, alumno, mi alum, esto lo que está haciendo es, fijaros, si yo digo, alumno, mi alum, 01:06:29

¿qué es? Información que puede tener en su nombre, 01:06:48

información que puede tener en su edad, o algo 01:06:53

que puede llegar a ser, del cual podemos expresar su nombre 01:06:56

y su edad. Pues todavía no es ninguna de las cosas. Si yo digo 01:07:01

alumno1 ese nombre, defino un alumno y digo ahora aquí 01:07:04

mi alumno, mi alumno ese nombre, pues aquí me estoy 01:07:15

refiriendo al nombre del alumno. 01:07:19

Si yo cojo y digo mi ALU1 y edad, me estoy refiriendo a la edad del alumno. 01:07:23

Pero si digo mi ALU, ¿a qué me refiero? 01:07:29

Al nombre, a la edad, a otra de sus características, a ninguna de ellas en particular. 01:07:33

Entonces, como un alumno, digamos que tendríamos la posibilidad de tener diferentes parámetros, 01:07:39

uno que es el nombre, otro que es la edad, y todos ellos son comunes a mi ALU, 01:07:46

con Mialu no nos referimos a ninguno de ellos 01:07:51

sino a algo desde lo que podemos llegar a cualquiera de ellos 01:07:54

entonces lo que tenemos es una referencia 01:07:58

al objeto en memoria RAM 01:08:00

que no es ninguno de todos esos valores 01:08:04

en este caso, esa referencia a todos los posibles valores 01:08:06

a los que vamos a ir accediendo este alumno Mialu 01:08:14

pues sería una posición de memoria en memoria RAM 01:08:16

es decir, un espacio que nos reserva el sistema operativo en memoria RAM 01:08:19

en una determinada posición. A partir de la posición 90.000 01:08:22

vas a poder empezar a localizar información del alumno. 01:08:25

Y luego cuando tú coges y haces 01:08:31

mialu igual a new y pones esta expresión de new 01:08:33

y pones aquí el mismo nombre de la clase que es un método constructor del cual hablaremos 01:08:41

con este new es cuando de verdad hacemos 01:08:45

reserva para todos estos valores. Con lo cual 01:08:49

ya sí que podemos empezar a acceder a cada uno 01:08:53

de ellos. Si yo pongo 01:08:55

System.out, con las 01:09:13

instrucciones, la instrucción System.out 01:09:15

println, println es un 01:09:17

método que tenemos 01:09:19

en Java, en las librerías de la 01:09:21

clase System.out, y que 01:09:23

nos permite escribir por pantalla, 01:09:25

pues yo podría poner, entrecomillado, 01:09:28

información como si fuese un 01:09:30

string aquí, que os decía, 01:09:31

el valor de 01:09:35

i es, 01:09:37

si hago esta ejecución, 01:09:41

¿Veis? Me muestra el valor de i es, que es lo que le acabo de decir yo, que nos muestre por pantalla este método. 01:09:42

Y en println podemos enlazar diferentes variables para ir mostrando por pantalla datos. 01:09:51

Entonces, si yo digo, le pongo aquí un más i, pues este i no lo pongo entrecomillado, con lo cual ya no es una cadena de caracteres, sino que es una variable que tenemos disponible en el código, que es i. 01:09:56

Entonces, si yo pongo aquí mi valor de i es más i, lo que hará será juntar esta cadena de caracteres con esta variable. Entonces, si yo cojo y hago esto, me dice mi valor de i es 20. 01:10:08

¿Qué es lo que ha pasado en este programa? En relación a memoria rank, os decía, cuando hemos llegado aquí, se ha reservado en la posición 80.000, digamos, una que elige el sistema operativo, un espacio donde guardar información para un entero y ha puesto el valor 20. 01:10:24

Y cuando ha llegado aquí, ha dicho, quiero saber la información de esta variable, pues el programa tiene que la variable i está en la posición 80.000 y coge su valor y lo muestra por pantalla, que es este 20. 01:10:40

Sí, te cuento. Una de las características que tiene la programación orientada a objetos es la sobrecarga. Se utiliza mucho en métodos y nosotros podemos sobrecargar métodos que es que métodos como este que pone aquí saludar, poniendo aquí unos determinados parámetros extras, pues podemos hacer que salude de diferentes formas. 01:10:55

Entonces, con el mismo método saludar está sobrecargado y puede tener comportamientos diferentes según llames al método saludar que no tiene aquí dentro de los paréntesis nada o uno que sí que tenga ciertas cosas. Esa es la sobrecarga de métodos. 01:12:01

Luego hay otra cosa en los lenguajes de programación orientado a objeto que es la sobrecarga de operadores, que tiene que ver justo con lo que tú dices. Que Java no permite definir sobrecarga de operadores. Existe la que hay ya predefinida en Java, pero no te permite darle nuevos comportamientos al operador más. 01:12:15

Entonces, ¿qué pasa? 01:12:32

Que si tú en el código pones un más, 01:12:33

depende si te encuentras una cosa por aquí, 01:12:35

a la izquierda y a la derecha se comporta de una forma 01:12:38

y si te encuentras otra, se comporta de otra. 01:12:40

Entonces, si tú a la izquierda y a la derecha del más 01:12:43

pones números, lo que hace es sumártelo como números. 01:12:46

Pero si a la izquierda tienes una cadena de caracteres, 01:12:49

lo que hace es concatenar cadenas de caracteres, 01:12:52

es decir, unir una con otra. 01:12:55

O sea, es diferente comportamiento de un mismo operador 01:12:59

porque el operador está sobrecargado. 01:13:01

¿Y por qué se comporta de una forma o de otra? 01:13:03

En función de lo que va encontrando a izquierda o derecha. 01:13:06

Mira, si ponemos aquí, para que lo veas. 01:13:12

Mira, aquí nos ha sacado el valor de i es, 01:13:29

y como esto es una cadena de caracteres, 01:13:34

ha concatenado cadena de caracteres. 01:13:37

Entonces pone i, que es 20, y luego i2, que es 10. 01:13:38

Si tú coges y haces así, mira, 01:13:44

Le pones aquí unos paréntesis como en matemáticas. 01:13:46

Antes de esto, de este más, antes de operar con este más, va a dar prioridad a los paréntesis. 01:13:49

Entonces, fíjate con los paréntesis. 01:13:55

Le das aquí y te pone el valor de i es 30. 01:13:57

¿Por qué? 01:14:00

Porque aquí hace esta operación antes y como lo que se encuentra este más, 01:14:01

a la izquierda y a la derecha son números, hace la operación, en este caso, el más de sumar dos números. 01:14:05

Y ya no le dice el valor de i es 30. 01:14:11

En cambio, este más se sigue comportando como una concatenación de cadenas, de caracteres, porque a la izquierda se ha encontrado una cadena de caracteres. 01:14:13

Vale, pues continuamos por aquí para intentar llegar a lo de la... 01:14:26

No es fácil entender la memoria RAM, por lo menos los primeros días, pero insistiremos mucho con ella. 01:14:32

Y unos días u otros terminarán con la tecla de explicarlo para que lo entendáis seguro. 01:14:38

bueno, aquí estábamos mostrando 01:14:43

y, mirad, si cogemos y ponemos 01:14:45

alumno 01:14:48

mial 01:14:52

sin poner lo del new que os decía 01:14:54

si yo ahora pongo aquí un system.out.println 01:14:56

y lo que muestro es esto 01:14:58

bueno, fijaros que ni siquiera 01:15:01

me deja por no haberlo inicializado 01:15:13

por ser una variable local 01:15:15

vamos a ponerle aquí 01:15:17

vamos a inicializarlo a nulo 01:15:18

que no tenga ningún valor 01:15:25

¿vale? Dice el valor de mi al es null. Mira, si yo cojo y, en este caso, si yo cojo y pongo aquí y le hago el new, que es como empieza a reservar memoria este new en las primitivas, no es necesario hacer un new para que ya el sistema operativo haga reserva de memoria RAM. 01:15:29

Para los objetos de las clases es necesario este new. Entonces, si yo ahora hago esto, le he quitado el null este y lo he inicializado después de hacer un new, fijaros que lo que me muestra aquí es esto que me acaba de decir mi alumno, me di cuenta que pertenece a la clase alumno y me he puesto aquí un identificador que yo creo que tiene que ver con la posición de memoria en la que va a estar referenciado el alumno. 01:15:53

Ese 80.000 que os decía antes, o 90.000, 01:16:21

tiene que ver con, este número tiene que ver con ese dato de 01:16:23

verdad. 01:16:27

Y ahora si cojo y digo, mi al punto, ese nombre, 01:16:28

igual a Rubén, y el system.out.println lo pongo de mi al, 01:16:33

pero no de mi al ya, que es una referencia en memoria a lo que 01:16:44

va a ser un alumno, sino de ese Rubén, de ese nombre, perdón. 01:16:47

Aquí ya sí que me dice que es Rubén. 01:17:01

Bien, ¿qué es lo que está pasando aquí? Aquí necesitábamos hacer un new, nos reservaba memoria RAM directamente y con i accedíamos ya a su valor. Como es un valor único, porque es un valor primitivo, que es un entero, no hay lugar a dudas, pues ya me muestra el 20. 01:17:03

aquí para el alumno en realidad es un objeto 01:17:18

y lo que tenemos es una referencia a lo que va a ser un alumno 01:17:23

digamos que un puntero a donde va a estar el alumno Mial 01:17:27

pero todavía no le hemos dado información ni a nombres ni a nada 01:17:30

y con este new lo que hacemos es ya reservar espacio de memoria RAM 01:17:33

para que pueda albergar toda la información que hemos definido aquí como parámetros 01:17:38

y para acceder en sí a un nombre que ya es, fijaros, de tipo string 01:17:42

es una variable primitiva, pero que está embebida, digamos, dentro de la clase, pues aquí ya sí que podemos coger y mostrar su nombre, 01:17:48

mial y con el punto accedemos a la variable ese nombre. Bueno, lo iremos retomando. Las variables primitivas no necesitan un new, 01:17:58

que son todas aquellas que son tipos básicos, digamos, de Java y que tenemos predefinidos. 01:18:10

Los objetos, que van a ser aquellas variables que vamos a ir definiendo nosotros relacionadas con nuestras clases, necesitan utilizar la etiqueta new para hacer la reserva de memoria RAM, porque si no, no tenemos ese espacio. 01:18:16

Aquí relacionado con los ámbitos, antes hemos definido unas variables por aquí que tienen que ver con todo que está en el ámbito del objeto alumno y otras con un método. 01:18:42

Estas variables que definimos para un método en particular se llaman variables locales y las que definimos en toda una clase se llaman variables miembro de la clase. 01:18:56

Fijaros, puede haber variables que durante el proceso de saludar vayamos a necesitar pero que no tienen que ver con un alumno. 01:19:11

imaginaos que el alumno está haciendo unos determinados cálculos 01:19:18

calcular una operación trigonométrica 01:19:25

vamos a llamarla trigo 01:19:28

los alumnos tienen capacidad 01:19:33

de hacer cálculos trigonométricos 01:19:37

como una de sus funciones 01:19:41

pueden saludar, pueden despedirse 01:19:44

y pueden hacer cálculos de operaciones trigonométricas 01:19:47

para hacer el cálculo de operación trigonométrica 01:19:49

a lo mejor hay un momento en el que tenemos que guardar, necesitamos conocer pi. 01:19:53

Entonces podemos definir una variable de tipo double, al cual podemos llamar pi, que sea igual a 3.14. 01:20:00

En este caso, cuando por aquí este alumno que hemos creado, queramos, según la lógica de nuestro programa, 01:20:18

que haga un cálculo trigonométrico, pues pondríamos mi al punto trigo. 01:20:24

Y estaríamos diciendo, alumno, este en particular, 01:20:32

podríamos tener más alumnos en nuestro programa, 01:20:36

pero hemos dado de alta uno, realiza una función trigonométrica. 01:20:38

¿Y qué va a hacer cuando realice esta acción el alumno? 01:20:42

Pues lo que va a hacer va a ser lo que hayamos descrito dentro de este método. 01:20:47

y por aquí tendríamos diferentes cálculos que tuvieran que ver con la resolución 01:20:50

de esta operación trigonométrica, todo el código Java que corresponda. 01:20:57

A lo mejor para apoyarnos en estos cálculos va a haber un momento en el que necesitemos pi 01:21:02

porque vamos a hacer unos cálculos de senos y cosenos y vamos a necesitar pi. 01:21:05

Entonces cogemos y definimos esta variable en el ámbito del método trigo 01:21:11

y desaparecerá cuando termine este método. 01:21:16

Esta variable dejará de existir y el recolector de basura la eliminará. 01:21:20

¿Esta variable tiene sentido dentro de las operaciones trigonométricas? 01:21:24

¿O cuando nosotros damos de alta a un alumno tiene sentido que esta variable esté definida aquí? 01:21:30

Pi sería una característica de todo alumno, que normalmente tenemos asociado con un alumno su nombre, su edad, su DNI, características propias del alumno, 01:21:36

pero pi típicamente va a ser una característica propia de los alumnos 01:21:48

en principio no, ¿verdad? 01:21:52

pi, ¿cuándo lo vamos a necesitar? 01:21:54

lo vamos a necesitar cuando realicemos la operación trigonométrica 01:21:56

porque aquí sí que nos va a ser necesaria con toda seguridad 01:22:00

en cambio pi lo vamos a necesitar cuando saludemos 01:22:02

pues no, para saludarnos es raro que el alumno salude 01:22:06

despidiéndose adiós soy pi o adiós pi 01:22:09

o para despedirse igual 01:22:12

pero en cambio en el contexto de la operación trigonométrica 01:22:13

Oye, ahí sí parece tener sentido la cosa. 01:22:16

Con lo cual, esta, a todas luces, es una variable que por diseño 01:22:19

pega en este método, con lo cual la vamos a definir aquí 01:22:23

como variable local a este método trigo, 01:22:28

y de hecho, se va a dar de alta en el momento en el que llamemos a este método, 01:22:31

es decir, va a existir desde esta llamada, 01:22:35

cuando hagamos esta llamada se va a ejecutar esta parte del código hasta aquí, 01:22:38

y luego va a desaparecer, porque ya no la queremos. 01:22:41

Si no estamos haciendo operaciones trigonométricas, 01:22:43

no queremos esta variable, que el recolector de basura nos libere la RAM 01:22:45

para que vaya más fluido nuestro ordenador, en cambio 01:22:49

y por eso la definimos como una variable local, en cambio están las variables 01:22:52

de clase, que sí que tienen sentido con el 01:22:59

alumno, entonces si nosotros cogemos y damos de aquí, aquí de alta un alumno 01:23:03

todo el tiempo que existe este alumno, fijaros que esta es una 01:23:06

variable que existe en el ámbito del método main, por aquí lo seguimos utilizando 01:23:11

queremos tener disponible por si nos hace falta su nombre 01:23:14

porque es una característica propia del nombre 01:23:18

y queremos tener disponible su edad 01:23:20

porque es una característica propia de su edad 01:23:21

si nosotros el nombre lo definiésemos aquí 01:23:23

como una variable local del método trigo 01:23:26

¿qué pasaría? 01:23:30

pues que aquí, fijaros 01:23:32

como no está disponible para el alumno 01:23:33

¿veis que ahora se me queja y no me compila el programa? 01:23:36

aquí en ese nombre 01:23:38

nombre es una característica propia de los alumnos 01:23:39

¿cuándo tiene vida el alumno? Desde que lo creo hasta que desaparece. 01:23:42

Es una variable de este tipo, con lo cual tiene sentido que el nombre 01:23:47

esté en todo el ámbito de la clase. Con lo cual, ese nombre, 01:23:50

lejos de ser una variable del método trigo, 01:23:55

es una variable del alumno en sí y la tenemos que definir en el ámbito del alumno. 01:23:58

Y estas variables son las que llamamos variables de clase. 01:24:04

La variable de clase 01:24:08

pertenecen a los objetos de la clase e identifican a la clase. 01:24:09

¿Podría compilarnos el programa si la definimos esta aquí? 01:24:15

Nos compila seguro. 01:24:18

¿Pero por diseño sería correcto que pille este aquí? 01:24:20

Pues no. 01:24:22

Es algo local al método trigo. 01:24:23

Retomando un momentito lo de la memoria RAM que decíamos antes. 01:24:29

Cuando nosotros aquí hacemos un new de un objeto mial, 01:24:33

para qué variables 01:24:38

se reserva 01:24:41

el sistema operativo 01:24:43

espacio en memoria RAM, para aquellas que son 01:24:45

propias del alumno, ¿cuáles son propias del alumno? 01:24:47

estas, las variables de clase 01:24:49

para pi 01:24:51

en este momento en el que estoy 01:24:53

dando de alta un alumno 01:24:55

se reserva memoria RAM, no 01:24:56

porque es una variable local 01:24:58

a trigo, de hecho, fijaros 01:25:01

como no existe, que si yo pongo aquí 01:25:05

ni al punto 01:25:07

pi 01:25:12

igual a 3 01:25:13

pues no me compila, ¿por qué? 01:25:15

porque pi no es una variable propia de los 01:25:17

alumnos, no es una característica de los alumnos 01:25:20

pi es una variable que 01:25:21

tiene su 01:25:23

vida durante su ámbito 01:25:24

su vida vive dentro del método trigo 01:25:27

y cuando lo ejecuten se creará 01:25:29

esa variable y cuando no 01:25:32

desaparecerá, porque el 01:25:33

recolector de basura la liberará 01:25:35

su espacio de memoria RAM 01:25:37

entonces, si damos de alta esta variable 01:25:38

se hace una solicitud al sistema operativo 01:25:43

para guardar esta información. 01:25:45

Pi, no. 01:25:48

Si luego vengo por aquí 01:25:49

y llamo al método trigo, 01:25:50

que es un método propio 01:25:53

de las acciones que son 01:25:55

capaces de hacer los alumnos, 01:25:57

en el momento que entro aquí 01:25:58

se encuentra esta variable y hará una reserva 01:25:59

de memoria al sistema operativo para pi 01:26:02

y guardará 3.14 01:26:04

que estará activa en el ámbito 01:26:05

del método trigo. 01:26:08

Cuando termine el método trigo, ¿qué pasa? 01:26:10

que desaparece pi y ya no está disponible 01:26:11

para seguir utilizándolo por aquí. ¿Por qué? Porque su ámbito era 01:26:14

el tiempo de ejecución de ese método. 01:26:17

¿Se entiende más o menos? 01:26:26

Mirad, aquí hemos cogido y ¿qué hemos hecho? Hemos definido 01:26:28

dos variables primitivas de Java, de tipo entero 01:26:31

las dos. Pues en la posición 01:26:34

80.000 guardo un 20 y la reserva 01:26:37

para la variable i y para la variable i2 01:26:41

el sistema operativo buscará otra posición, que aquí pone 80.000 del copy y pega de antes, 01:26:44

que será la 80.300, por ejemplo, y guardará el 10. 01:26:48

Cada variable, lógicamente, tiene un espacio de memoria diferente. 01:26:53

Si yo muestro la información de i, me mostrará lo que hay en la posición de memoria 80.000 01:26:57

y escribirá un 20. Si muestro la información de la variable i2, 01:27:01

pues buscará 80.300 y mostrará un 10. 01:27:06

pues igual que para dos variables de tipos primitivos de Java 01:27:09

tenemos espacios de memoria distintos, aunque los dos sean de tipo entero 01:27:14

pues si yo he creado aquí un alumno 01:27:19

que le he llamado Mial y ahora creo aquí un segundo alumno 01:27:22

que llamo, vamos a llamarlo con un nombre propio, vamos a poner Sandra 01:27:26

creo el alumno Sandra, pues cuando hice esta operación 01:27:32

del new se me reservó en una posición de memoria, vamos a poner 01:27:43

las 90.000, por decir una, 01:27:46

será la que sea, el sistema operativo localizará una, la 99.000, 01:27:51

reservará un espacio de memoria para los datos 01:27:55

de un alumno que en el programa lo hemos nombrado como Mial 01:27:57

y que en un momento dado, ya que tiene estas características, tendrá una edad 01:28:02

y un nombre. De hecho, le hemos puesto un nombre que ha sido Rubén. 01:28:06

Y ahora, cuando hago este new, 01:28:12

el intérprete pedirá al sistema 01:28:13

operativo, el intérprete de Java 01:28:16

un espacio de memoria y el sistema 01:28:18

operativo localizará por ahí un espacio de memoria 01:28:20

igual teníamos corriendo Excel 01:28:22

y se ha apagado y ha liberado 01:28:24

memoria Excel y ahora tengo 01:28:26

la posición 60.000 01:28:28

y en la posición 60.000 01:28:30

es la que reserva 01:28:34

para que Sandra pueda guardar sus datos 01:28:36

¿Sí? ¿No me escucháis? 01:28:38

Vaya 01:28:45

Bueno, hoy no se ha aguantado más 01:28:45

por lo menos. El otro día, bueno, avisé por aquí a ver si pueden hacer algo con la red. ¿Se recupera o no? 01:28:48

Bueno, voy a pausar un poco la grabación hasta que lo recuperemos. Nada, ¿no me oís? Y nada, continuamos aquí 01:28:59

después de este pequeño lapsus que hemos tenido con la red. Mirad, os estaba contando que, igual que para las clases 01:29:07

primitivas, cada vez que definimos una variable se hace una reserva de memoria RAM diferente, pues para nuestras 01:29:16

variables que creamos como objetos y 01:29:21

tras hacer el new, donde finalmente se termina haciendo la reserva 01:29:25

de memoria RAM para nuestro objeto alumno en este caso 01:29:29

será donde se va a ir guardando esta información, si creamos 01:29:33

diferentes objetos de la misma clase, tendremos diferentes espacios de memoria 01:29:37

si ponemos aquí Sandra ese nombre 01:29:41

ay no, es verdad, no, no, no estoy 01:29:45

compartiendo, bien avisado, como he tenido que reiniciar 01:29:51

no la he puesto a compartir, ahora la pongo ya, ahí estamos 01:29:58

ya, compartiendo, ya me veis, ¿verdad? Pues 01:30:14

esto que os decía, vale, pues ahora para la variable Sandra, pues 01:30:18

también tiene disponible, como ya que es un alumno, tiene entre sus características que puede 01:30:22

tener un nombre y una edad, pues para Sandra podemos decir que su nombre 01:30:26

sea, precisamente ya que hemos llamado al objeto Sandra, vamos a decir que 01:30:30

sí que se llama Sandra. Fijaros, que se guarde 01:30:34

Sandra en memoria RAM en una zona reservada por el sistema operativo 01:30:39

para la variable ese nombre de el objeto Sandra implicará 01:30:42

que a partir de la posición 60.000 habrá un sitio 01:30:46

donde pondrá Sandra. Cuando queramos acceder a esta variable 01:30:50

el sistema operativo dirá Sandra empieza en el 60.000 y justo es 01:30:54

el nombre que queremos recuperar, pues llegaremos al 60.000 01:30:58

y dirá, pues el nombre se encuentra a partir de esta posición 01:31:02

y el dato que tiene es Sandra. 01:31:06

Si cogemos y decimos Sandra.iedad igual a 30, 01:31:08

pues probablemente saltando desde el 60.000 01:31:16

todo el espacio que necesite para guardar un string 01:31:19

que es el que corresponde al nombre, 01:31:21

pues a lo mejor en la posición 60.000, 01:31:25

bueno, este dato de cantidad es inventada, 01:31:31

pero ahí pues cogerá y guardará 30. 01:31:34

entonces si ahora nosotros cogemos y decimos 01:31:36

system.out.println, sácame por pantalla 01:31:39

el nombre de Sandra 01:31:41

pues muéstrame 01:31:43

por pantalla, system.out.println 01:31:45

si decimos muéstrame Sandra 01:31:48

pues nos mostraría 60.000 01:31:53

que es la posición de memoria 01:31:59

que tiene, no como cuando pulsábamos 01:32:01

decíamos muéstrame y que ya directamente 01:32:03

mostraba el dato, no, Sandra mostrará 01:32:05

60.000 01:32:07

si cogemos y decimos 01:32:09

system.sandra.sedaz 01:32:10

ese nombre 01:32:15

pues que es lo que 01:32:17

hará, pues dirá, tengo que sacar por pantalla 01:32:19

Sandra 01:32:21

sé que empieza en la posición 60.000 01:32:22

y como es 01:32:25

el primer parámetro 01:32:27

este sería el caso 01:32:28

de que estuviera así, como primer parámetro 01:32:31

como es el primer parámetro 01:32:33

guardo un string, pues ese string es el que 01:32:35

corresponde al nombre, según me han identificado 01:32:37

entonces 60.000 más 01:32:39

un desplazamiento de 0 al ser el primer parámetro 01:32:40

muestro el contenido que tiene, pues muestro Sandra 01:32:43

y si cojo y digo 01:32:45

System.off.println Sandra 01:32:47

y edad 01:32:49

pues lo que hará será decir 01:32:51

me voy al 60.000 01:32:53

que es el punto de inicio en memoria RAM 01:32:54

para la que el sistema operativo me ha reservado 01:32:57

espacio, y el que quiero mostrar 01:32:59

en particular es si edad 01:33:01

se dará cuenta que antes había un nombre 01:33:02

y sabiendo la cantidad de espacio 01:33:05

que reserva para un string 01:33:07

mira, el siguiente es la edad, pues mostrará el contenido que hay a partir de 01:33:09

en este ejemplo que hemos puesto, el 6400, que sería un 30 01:33:13

lo pulsamos aquí y veis, aquí tenemos zona de memoria, que este 01:33:16

corresponde a este, no es ni un dato ni otro, ni el nombre 01:33:23

ni la edad, aquí cuando hemos mostrado el nombre y aquí cuando hemos mostrado 01:33:27

la edad, y esa misma jugada si la hacemos 01:33:31

en lugar de para una variable de tipo clase 01:33:35

alumno, es decir, un objeto de la clase alumno 01:33:44

que era Sandra, lo hacemos para otro que hemos definido con anterioridad 01:33:48

aquí, que lo llamábamos Mial, pues al ejecutar 01:33:51

fijaros como la posición de memoria 01:33:56

que tenemos para Sandra es una, que nos da 01:34:02

el sistema operativo, y la que tenemos para Mial es otra 01:34:05

y luego sus datos, bueno, pues son diferentes, es decir 01:34:08

un comportamiento, como es lógico 01:34:11

al ser variables distintas, diferente a la hora de mostrarlo 01:34:14

por pantalla y los espacios de memoria que ha utilizado el programa para guardar uno y otro 01:34:17

diferentes de la misma forma que había sucedido aquí con los enteros, que cuando enseñábamos sí 01:34:22

mostraba 20, cuando enseñábamos sí 2 mostraba 10. ¿Se entiende más o menos? Variables, referencias, 01:34:27

objetos, estoy haciendo un repaso de las cosas que tengo por aquí, variables locales y variables 01:34:46

en miembro, también hemos hablado un poco, el alcance de las variables. 01:34:50

Las variables de tipo 01:34:55

primitivo, dependiendo si son variables 01:34:59

locales o son variables de clase, es necesario inicializarlas 01:35:02

o no, antes de utilizarlas. Las variables locales 01:35:06

es necesario inicializarlas, las variables de clase no. Y si no las 01:35:10

inicializamos, ¿qué valor tienen al principio? Pues hay una serie de valores por 01:35:14

defecto las variables numéricas me da igual que tengan decimales o no tienen como valor cero su 01:35:18

valor inicial si no le damos un valor por defecto inicial escoger el de por defecto que es cero si 01:35:29

tú quieres que una variable inicialmente tenga un valor distinto de cero obligatoriamente se 01:35:35

lo tienes que dar igual que estamos haciendo aquí las las variables tipo cadena de caracteres 01:35:40

es decir las string 01:35:49

tienen comillas comillas 01:35:52

es decir tienen una cadena de caracteres vacía 01:35:55

sin ningún dato 01:35:57

las variables booleanas 01:35:58

estas variables son las que 01:36:01

sus dos alternativas 01:36:05

son verdadero o falso 01:36:07

el verdadero o falso se utiliza mucho 01:36:09

luego en las condiciones 01:36:11

y en los bucles que iremos viendo 01:36:13

en las próximas tutorías y en los próximos 01:36:15

temas, por defecto 01:36:17

tiene false, es decir, si tú defines una variable booleana 01:36:19

y de inicio no le das un valor, pues esa variable va a 01:36:22

valer falso, y bueno, y ya está 01:36:25

estos son los valores que hay por defecto 01:36:30

otra cosa de la que hemos hablado también han sido los comentarios 01:36:32

en Java, los ponemos para una línea 01:36:35

bueno, para lo que hay a partir de las dos 01:36:39

barras en una línea, son comentarios, entonces si la ponemos 01:36:42

al principio de la línea, toda la línea es un comentario, es típico 01:36:45

poner ciertos comentarios en los programas, sobre todo en zonas de código que son un poco 01:36:48

difíciles de interpretar, pues nos ponemos unas pistas por si luego 01:36:52

repasamos el código o tenemos que hacerle un mantenimiento, saber un poco de qué va 01:36:56

lo que hicimos ahí, cuando hicimos ese código. Y si lo ponemos en una 01:37:00

línea, puede ser que haya código anteriormente y a partir 01:37:04

de un determinado momento poner un comentario. Entonces lo que hay a partir de aquí es 01:37:08

un comentario y en este caso sería la línea entera. 01:37:12

y si lo que queremos es comentarios multiliña 01:37:15

ya hemos dicho que el compilador de Java 01:37:18

considera comentarios multiliña lo que se encuentre 01:37:21

entre la barra y el asterisco 01:37:24

y asterisco y barra, todo lo que pongamos aquí, ya veis que el id 01:37:27

me lo muestra en verde, quiere decir que son comentarios 01:37:30

no lo va a tener en cuenta el compilador, cuando 01:37:34

el compilador coja el punto Java y genera el bytecode 01:37:36

todo esto será como que lo borra y como si no existiera 01:37:39

no le interesa para generar bytecode que luego 01:37:42

sea ejecutable. Otra cosa que también es 01:37:45

que podemos comentar aquí que es rápida ya que no nos queda 01:37:55

mucho tiempo es las constantes. Hay variables 01:38:00

que irán, normalmente una variable reserva una zona de memoria 01:38:03

y podremos ir cambiando su valor. Aquí i vale 20 01:38:08

pues aquí decimos que a partir de aquí i vale la 30. 01:38:11

En la zona de memoria RAM, en la 80.000 pasará su valor de 20 a 30 01:38:15

y a partir de ahora, cuando queramos acceder ahí, 01:38:20

pues nos mostrará el valor que justo tenga la RAM, 01:38:23

que si se ha ido sobreescribiendo será el nuevo. 01:38:25

En Java podemos definir constantes. 01:38:29

Una constante no es más que una variable, 01:38:32

la definimos de partida como una variable, 01:38:35

con lo cual hará la reserva en memoria RAM para guardar su valor, 01:38:38

pero al ponerle la etiqueta final, 01:38:42

pues ya no podremos modificarla. 01:38:45

No sé si como variable local me deja. 01:38:49

Sí, pues fijaros, si le ponemos la etiqueta final, si ahora yo intento cambiar el valor de pi aquí, digo que no, que ya pi me gusta más como 3.15, ¿veis? No me deja. 01:38:51

Y si le quito la etiqueta final, pues como es una variable normal, podría cambiar su valor como cualquier variable de un valor que tiene ahora mismo a otro diferente. 01:39:05

Entonces, si a una variable le ponemos la etiqueta final, se convierte en una constante. 01:39:14

¿Para qué nos sirve? 01:39:18

Bueno, pues nos sirve para ir utilizándola 01:39:19

como parte de las operaciones, 01:39:23

pero no ir modificando su valor. 01:39:25

Es una constante. 01:39:27

Y es con la etiqueta final. 01:39:30

Normalmente las... 01:39:33

Fijaros, aquí hemos puesto pi minúscula 01:39:35

cuando hay un convenio 01:39:38

que se suele seguir a la hora de programar en Java, 01:39:40

que no es obligado para el compilador, 01:39:45

pero que si lo seguimos todos 01:39:48

es de buenas prácticas y así cuando vayamos 01:39:49

encontrando diferentes personas códigos 01:39:52

si todos hemos seguido los mismos 01:39:54

criterios, pues nos resultará 01:39:56

un poco más fácil mantenerlo 01:39:58

entonces las constantes 01:40:00

se suelen definir con letras 01:40:02

mayúsculas todas, entonces si vamos 01:40:04

a definir una constante ponemos pi 01:40:06

y si tiene varios valores 01:40:07

imaginaros que 01:40:10

queremos definir una constante 01:40:12

que tiene el número 01:40:14

máximo de espectadores que pueden entrar en un estadio 01:40:16

sería num y si lo queremos poner con dos palabras 01:40:18

num más, aquí lo definimos como 01:40:22

final de tipo entero y 01:40:26

el número máximo de espectadores serían 50.000 01:40:30

y la forma de nombrar la constante con mayúsculas 01:40:32

y si está formada por varias palabras con un guión bajo 01:40:38

las variables normalmente el convenio 01:40:42

que hay es que empiecen por una letra minúscula y si tienen varias varias palabras que cada una 01:40:49

de las palabras empiece con letra mayúscula entonces imaginaos que te definimos un int y 01:40:59

queremos es número de entradas pues una forma sería ponerlo así en un número o num entradas 01:41:06

o entrada entradas entonces esto sería siguiendo un convenio muy utilizado una forma de definir 01:41:12

una variable la primera letra minúscula y luego cada una de las nuevas palabras que formasen 01:41:19

parte de esa variable entradas yo tengo costumbre ya lo ir viendo cuando voy haciendo los programas 01:41:25

que no es obligado ni mucho menos de poner una primera letra aquí en minúscula para seguir este 01:41:33

criterio con el que más o menos me dé una idea si luego veo y edad por ahí en mitad del código 01:41:39

de qué tipo es entonces si empieza por una y pues sé que es una variable de tipo entero si empieza 01:41:45

por una s de tipo string en cierto momento estuve trabajando una empresa que seguía en esta 01:41:49

nomenclatura y ahí se me quedó y siempre me salen las variables de esta forma pero esto es un 01:41:56

criterio más particular mío o del contexto es en el que trabajé yo que el que es de verdad está como 01:42:01

muy aceptado que es este otro no necesariamente identificar el tipo pero sin minúsculas y 01:42:07

siguientes letras con mayúsculas las clases 01:42:11

la empiezan con una letra mayúscula aquí alumno lo tengo correcto y los métodos 01:42:17

empiezan con letra minúscula que yo lo he hecho mal aquí vale no seguido el 01:42:23

convenio sería trigo con té minúscula saluda saludo con saludar con ese 01:42:27

minúscula y despedir con de minúscula 01:42:33

No lo he hecho de acuerdo al criterio de buenas prácticas, el nombre de los métodos. 01:42:38

Pero bueno, ya veis que antes puse pi aquí como constante con minúsculas y el compilador le vale. 01:42:43

Esto también está de esta forma y le vale. 01:42:52

Con lo cual, bueno, pues está bien seguirlo, pero no va a bloquear los programas el no utilizarlos así. 01:42:54

Y bueno, pues de mi guión de aquí, de cosas que os quería contar relacionadas con el tema 2, 01:43:04

he tachado unos cuantos y la 01:43:08

semana siguiente yo creo que continuamos 01:43:10

con otros pocos. Nos quedan 01:43:12

cinco minutos para cerrar 01:43:14

y bueno, aprovecho por si queréis 01:43:15

hacerme alguna pregunta o alguna 01:43:18

o alguna 01:43:20

sugerencia un poco desesperada de la clase 01:43:22

ahí con la memoria y eso, si 01:43:24

os ha costado mucho seguirlo. 01:43:25

Esto de la memoria hablaremos mucho de ello, entonces 01:43:28

no os preocupéis, pero sí que es importante entenderlo. 01:43:30

Ya, claro. 01:43:45

Claro, si 01:43:48

tienen letras, pues 01:43:49

El significado que tiene el símbolo de más es concatenar, unir unos con otros. 01:43:51

Si tienes números, lo que te hace es sumar. 01:43:57

Sobrecarga de operador, es decir, el operador se comporta de diferentes formas según lo que tenga por ahí alrededor. 01:44:02

¿Alguna otra cosilla por ahí? 01:44:14

De las clases, bueno, pues un poco lo que vengo haciendo, este es el tercer año que doy distancia 01:44:21

y un poco las organizamos 01:44:26

siempre así, estamos 01:44:29

pues os pregunto si tenéis dudas, intentamos 01:44:30

aclararlas o ponernos sobre la 01:44:33

pista de alguna duda que tengáis 01:44:35

y luego os voy contando cosas 01:44:36

si en un momento dado veis 01:44:38

no sé, que alguna 01:44:40

otra técnica creéis que va a resultar 01:44:42

más provechosa, me decís, yo no tengo 01:44:44

inconveniente y si hay alguna cosa en particular 01:44:46

que queráis que tratemos en 01:44:48

alguna reunión, si la adelantáis 01:44:50

en los foros, pues siempre está bien, no va a ser 01:44:52

que me preguntéis algo durante la tutoría 01:44:54

que en ese momento no sea capaz de resolveros. 01:44:58

Si me la comentáis con anterioridad, pues la preparo yo un poquillo. 01:45:01

Y si no, pues bueno, yo siempre vendré con un guión 01:45:05

para contaros alguna peli por ahí. 01:45:07

¿Alguna otra cosa? Sí. 01:45:16

Sí, sí, sí. 01:45:28

Tenéis bastantes ejercicios para hacer. 01:45:30

Ahora ya veréis ya en el tema 2, ya hay colecciones de ejercicios 01:45:34

por ahí un poco relacionados con el nivel 01:45:37

del tema que vamos viendo 01:45:39

para que podáis practicar. Están resueltos 01:45:41

en líneas generales todos 01:45:43

pero bueno, pues está bien 01:45:44

que los intentéis hacer vosotros antes de 01:45:47

mirar las soluciones 01:45:49

para entrenaros programando 01:45:50

que ya os comentaba días atrás 01:45:52

que si no le echas 01:45:55

ratos ahí programando 01:45:57

viendo el código solo, luego no te sale 01:45:58

pero sí, sí, hay 01:46:01

muchos ejercicios propuestos 01:46:02

y bueno, si queréis 01:46:05

vosotros investigar más, supongo que habréis 01:46:07

hecho alguna búsqueda por internet, te salen miles, pero vamos 01:46:10

también dentro de nuestro curso también ofrecemos enunciados 01:46:13

de ejercicios y estos ejercicios resueltos 01:46:16

bueno, pues nada, si no tenéis nada más voy a ir deteniendo 01:46:18

dime, si en 01:46:28

mira, un momentito 01:46:36

te pide contraseña, voy a poner la misma en todas 01:46:37

las clases, mira 01:46:41

aquí justo que está el enlace, aquí 01:46:45

os he puesto enlace a la contraseña 01:46:47

y le pongo PROC 2024 a todas 01:46:49

ellas. Entonces, os iré 01:46:51

poniendo enlaces a cada una de las tutorías 01:46:53

y en todas le pongo la misma 01:46:55

contraseña para que no 01:46:57

os volváis locos. Y además lo tenéis aquí 01:46:59

chivado justo al lado de los enlaces. 01:47:01

Sí. 01:47:06

Bueno, pues nada. 01:47:10

2024-10-21-Programacion - Contenido educativo

Del mismo autor…

Vídeo resumen "Proteínas, enzimas y vitaminas" Biología 2º Bachillerato

Vídeo resumen "Lípidos" Biología 2º de Bachillerato

Vídeo resumen "Glúcidos", Biología 2º Bachillerato

Vídeo resumen "Anabolismo", Biología 2º de Bachillerato

Vídeo resumen "Catabolismo", Biología 2º Bachillerato

Vídeo resumen "El ciclo celular, Biología 2º Bachillerato

Vídeo resumen "Bioelementos, El agua y las sales minerales", Biología 2º de Bachillerato