2024-10-28-Programacion | Mediateca de EducaMadrid

Bien, mirad, seguimos con el tema 2 hoy, mañana ya abrimos el siguiente tema, el tema 3, a lo largo del día os lo pongo ya disponible, en principio para la tarea del tema 2 lo tenéis abierto hasta esta noche, a las 12 de la noche, animaros a intentarla, ya he visto que alguno habéis hecho la entrega, y bueno, pues le echo un ojillo y ya os voy haciendo por ahí comentarios. 00:00:03

Retomando un poco de lo que estuvimos hablando el otro día 00:00:29

Bueno, pues estábamos con algo 00:00:35

Bueno, con este proyecto 00:00:38

Estuvimos comentando un poco como la información 00:00:39

Bueno, antes de ponerme a contaros 00:00:44

Que doy por hecho que no tenéis ninguna pregunta 00:00:47

No sé si queréis hacerme alguna consulta o algo 00:00:49

Antes de arrancar a contaros cosas 00:00:52

¿Alguna duda por ahí? 00:00:54

sí, sí, sí, el código 00:00:56

de hecho yo para verlo 00:01:08

lo subiré a, lo pasaré a Eclipse 00:01:09

y pues aparte de echar un vistazo al código 00:01:12

pues le haré un par de ejecuciones 00:01:14

por ahí, pues con alguna variante 00:01:16

alguna cosilla que quiera comprobar 00:01:18

entonces sí, el código, no es necesario que me envíéis los .class 00:01:19

ni nada de eso 00:01:22

el código ya está, sí 00:01:23

de hecho, o sea, el código seguro 00:01:25

enviármelo, porque es lo que utilizaré yo 00:01:28

aparte de verlo para ejecutarlo, no me envíéis 00:01:29

solo el .class, si me envíéis todo 00:01:32

terminaré cogiendo solo el código 00:01:33

pero solo lo otro no 00:01:35

solo los ejecutables no 00:01:36

hombre, por existir 00:01:40

pues un poco los que 00:02:01

hablábamos en el tema 1 00:02:03

son un poco los que puedes 00:02:06

hacer, de todas formas los diagramas 00:02:08

de flujo en un proyecto como os comentaba 00:02:10

estas semanas 00:02:12

atrás, en un proyecto en general 00:02:14

se suelen definir 00:02:16

antes de hacer el programa, que es un poco 00:02:18

entiendo por donde vas 00:02:20

en la parte de diseño, entonces 00:02:21

yo creo que para nuestros programitas estos que son cortitos 00:02:24

no hace falta, pero bueno, si te animas 00:02:27

en la asignatura de entorno de desarrollo 00:02:30

pues, bueno, aquí habíamos hablado un poquillo 00:02:33

habláis, creo que habláis un poquito también de alguna herramienta 00:02:36

de estas para hacer diagramas de flujo y luego 00:02:39

tiene también una parte de pruebas donde 00:02:42

bueno, se hacen diagramas, digamos, para 00:02:45

ver cómo vas a probar el programa. En esta asignatura 00:02:48

en particular no vamos a trabajar con eso. 00:02:51

No es imprescindible, desde luego. 00:02:54

Vale, pues nada, si no tenéis ninguna cosita más, 00:03:01

continúo contándoos. 00:03:05

Mirad, cuando creamos un programa en Java, 00:03:07

bueno, un programa en cualquier lenguaje, 00:03:10

al final la información tiene que estar, 00:03:12

cuando está en ejecución, 00:03:15

utiliza una serie de variables 00:03:16

y estas variables tienen que utilizar memoria RAM 00:03:18

para ir guardándose durante el tiempo 00:03:21

en el que están en ejecución. 00:03:23

Cosas de las que hablábamos el otro día. 00:03:25

Pues hablábamos de... 00:03:26

el ámbito en el que están definidas las variables. 00:03:29

Las variables, ahora en el programa lo vemos, en Java, 00:03:31

las variables, el código en sí en Java, se encierra entre unas llaves. 00:03:36

Entonces cada bloque de estas llaves es un ámbito 00:03:44

y las variables que defines dentro de un determinado ámbito, 00:03:46

en unas llaves, están disponibles para ese conjunto de instrucciones. 00:03:50

Entonces si yo defino aquí una variable, 00:03:56

imaginamos que tenemos una clase, public class 00:03:58

hola, vamos a llamar a la clase, y luego tenemos un método aquí 00:04:02

y la clase, las clases también están encerradas con unas llaves 00:04:06

la clase, todo lo que definamos como variables 00:04:10

de clase, que cuando hablábamos de la programación orientada a objetos decíamos 00:04:16

que eran métodos que estaban relacionados en sí con 00:04:20

la clase en sí, vamos a poner persona, la clase persona, pues por ejemplo podría ser 00:04:23

el nombre, esta variable estaría disponible en todo 00:04:28

el ámbito de la clase, que sería desde la llave de apertura hasta la llave de cierre. 00:04:34

Si aquí definimos nosotros un método que sea el public void 00:04:39

saludar, el método saludar, y definimos una variable 00:04:42

decimos string también ese saludo 00:04:48

que sea igual a hola 00:04:53

por ejemplo. Y si tenemos aquí otro método que sea despedirse 00:04:57

despedir, pues resulta que la variable saludo 00:05:02

es una variable que está en este ámbito y no está disponible 00:05:11

en este otro, porque en el momento que termina el ámbito donde está definida, que sería en esta otra 00:05:15

llave, ya ha desaparecido. Es decir, cuando nos pongamos a 00:05:19

ejecutar este método, el programa pedirá al sistema operativo un trocito 00:05:23

de memoria RAM donde guardar información que está relacionada con 00:05:27

una cadena de caracteres a la cual va a llamar ese saludo y va 00:05:31

asignarle el valor hola. Y cuando termine el método saludar 00:05:35

queda fuera del ámbito, con lo cual ya se supone que no es una 00:05:39

variable necesaria dentro del programa y el recolector de basura 00:05:43

que hablábamos de él también la semana pasada, liberará esa zona 00:05:47

de memoria RAM. Con lo cual, si yo pongo aquí ese saludo 00:05:51

igual intento actuar sobre esa variable, diciendo que en lugar de decir 00:05:54

hola al despedirse, digas adiós, me dará un error de compilación 00:05:59

porque esta variable no existe en un ámbito en el cual, no está definida en un ámbito en el cual la estoy intentando utilizar, 00:06:03

sino que está definida en este otro. En cambio, si utilizo ese nombre, ese nombre, pongo aquí el nombre de Ana, 00:06:10

esto sí me compilaría, porque me compilaría y me permitiría utilizar esta variable, porque estoy utilizando esa variable 00:06:22

en el ámbito donde el nombre está definido, que es en toda la clase. En relación a esto, si tenemos la clase persona, 00:06:28

podemos definir una serie de variables que tienen que ver de forma muy directa con las personas 00:06:37

y que son relevantes en nuestro programa cuando demos de alta una nueva persona. 00:06:42

Definimos un objeto de la clase persona, que sea la persona José, 00:06:49

y tendrá una variable donde podremos poner un nombre, que será José Manuel, por ejemplo, en mi caso. 00:06:53

Estas variables son las que llamamos variables miembro de clase o variables de clase, 00:07:00

variables de clase o variables miembro. 00:07:04

Y estas otras son variables que están definidas en un ámbito de un método. Realmente la variable saludo nos viene fenomenal dentro del método saludar, pero saludo no es algo que identifique a las personas, sino que tiene su uso realmente en el marco del método saludar. 00:07:06

Por lo tanto, no tenemos que definirla como una variable de clase miembro, sino una variable particular de este método, entonces sería una variable local. 00:07:28

Otra cosa de las que hablábamos a la hora de clasificar el otro día las variables en relación a la memoria RAM era si eran variables primitivas o referenciadas. 00:07:42

Y después voy a incluir otro tipo de variables. 00:08:06

Mirad, otra en relación al uso, digamos, a la reserva de memoria. 00:08:09

Lógicamente, toda variable va a necesitar reservar una zona de memoria, 00:08:16

porque este hola, en algún sitio se tiene que estar guardando por si luego lo quiero utilizar yo posteriormente aquí en el método saludar. 00:08:22

Igual que para esta variable tendrá que haber una zona de memoria que me reservará el sistema operativo 00:08:30

a petición del intérprete de java para poder luego acceder a la información que tenga esa variable 00:08:34

todas ellas necesitarán de un espacio de memoria donde guardar la información ahora bien hay una 00:08:40

serie de variables de tipos de datos que nos permiten generar variables que son las variables 00:08:47

primitivas en java que son aquellas propias del lenguaje java como puede ser string o como puede 00:08:53

ser int, las variables estas como puede ser la variable boolean que hablábamos de ellas el otro 00:08:59

día, la long también de tipo entero, la float ya para meter decimales, todas estas variables se 00:09:05

consideran o se definen como primitivas. El hecho de definir esta variable int a por ejemplo de tipo 00:09:14

a ya directamente permite que hace que el sistema operativo nos reserve el espacio donde guardar la 00:09:21

información del entero, es decir, cuando 00:09:29

el programa se encuentre esto, llegará el intérprete 00:09:32

de Java y le dirá al sistema operativo, búscame espacio 00:09:35

para guardar un valor que necesita 00:09:37

creo que son 32 bits, entonces el sistema operativo 00:09:41

dentro de la RAM, según se esté usando por este programa y por 00:09:44

otros, localizará ese espacio 00:09:47

y a lo mejor en la posición de memoria 00:09:49

30.000, digo 30.000 como podría ser cualquier otra 00:09:53

reservará esos 32 bits donde 00:09:56

a partir de este momento cuando guardemos un número 33 este 33 estará asociada a la etiqueta 00:09:59

a variable local del método saludar lo mismo sucede si defino para un long pues reservará 00:10:06

más espacio de memoria pero si defino el long b pues en otro espacio de memoria reservará esos 00:10:13

bytes donde guardar el dato entonces si metemos aquí 660 cualquier número pues este número 00:10:20

directamente ya se guardará en memoria RAM. Estas son las variables 00:10:28

primitivas. Directamente identificar una variable primitiva 00:10:32

implica reservar en la memoria RAM el espacio donde se 00:10:36

guarda su valor. Luego tenemos, imaginaos que tenemos 00:10:40

aquí otra clase, public class 00:10:44

clase, vamos a llamarla aula. 00:10:46

Imaginaos que en esta clase definimos como variable 00:10:53

miembro, o como cualquier variable 00:10:58

en el main, vamos a poner aquí el método main, y ya no es una variable 00:11:02

miembro, public static void main, recordad el método 00:11:05

main, es el punto de entrada en el programa 00:11:09

paradme si tenéis dudas de cualquiera de las cosas que comento, entonces 00:11:13

aquí en el main, como otro método más, igual que estábamos haciendo aquí en la clase persona 00:11:20

tenemos este método, podríamos definir una variable, en este 00:11:24

caso no una variable miembro, sino una variable local al método main, que fuese 00:11:28

un int, int y valor, entonces esta variable 00:11:32

fijaros, es de tipo int, es una variable de tipo primitiva 00:11:37

pues como igual que antes decíamos, pedirá al sistema operativo 00:11:40

un espacio de memoria para guardar un valor posible 00:11:45

de tipo entero y valor del método main, y ya 00:11:49

directamente se reserva la memoria 00:11:52

para donde va a ir guardándose valores enteros para este valor. 00:11:56

En cambio, si cogemos y decimos que queremos definir una variable, 00:12:02

pero en una variable primitiva, sin una variable, en este caso, referenciada, 00:12:07

lo que estamos diciendo es que vamos a crear una variable de una clase que tenemos nosotros. 00:12:13

En este caso, la variable, si antes definíamos un entero que permitía guardar números, 00:12:18

ahora lo que vamos a definir va a ser una variable del tipo persona y el tipo persona es una clase 00:12:24

que hemos definido nosotros en nuestro programa entonces podemos llamarlo persona 1 y fijaros esta 00:12:32

persona tiene aquí pues tiene diferentes variables miembro estas variables locales al método saludar 00:12:41

variables miembro las variables miembro suelen identificar características muy directas de los 00:12:52

objetos de la clase en la que están asociadas por eso el nombre y la edad si parecen variables que 00:12:59

por diseño tienen que ver con una persona una variable saludar parece que es una variable que 00:13:06

vamos a utilizar en medio de este método para hacer ciertas ciertas actividades con ella pero 00:13:11

saludo no es algo que identifiquen si a las personas por eso está el local y estas son 00:13:16

variables miembro. Cuando estamos definiendo un objeto de la clase que se llama per una de la 00:13:21

clase persona, este per una por pertenecer a esta clase seguirá este esquema y tendrá como 00:13:29

características la de los parámetros que hayamos definido y acciones o métodos que puede realizar 00:13:37

las que tengamos también definidas en la clase. Con lo cual para per una vamos a necesitar espacio 00:13:43

de memoria que tenga que ver con una variable de tipo string que sea su nombre y una variable de tipo entero que sea su edad, según tenemos definido 00:13:50

aquí en nuestro código. Estas variables referenciadas, por defecto, no cogen un espacio de memoria todavía, igual que hacían las primitivas que decíamos 00:13:59

y ya directamente el definir persona per una no implica que ya tengamos un trocito de memoria run que nos haya asignado el sistema operativo 00:14:10

para guardar su nombre o para guardar su edad, 00:14:20

sino que lo que tenemos es una zona de memoria 00:14:24

a partir, digamos, en la que vamos a poder empezar a identificar a PER1. 00:14:29

Imaginaros que el sistema operativo en este caso nos dice 00:14:33

que cuando tú en el programa pongas PER1, 00:14:35

está asociado a la zona de memoria RAM 50.000. 00:14:40

Pero este 50.000 no es ni el nombre que le vayamos a asignar a per una ni su edad. Es una referencia a este objeto. Para de verdad, mira, si ahora cogemos y ponemos aquí per una para esa persona quiero darle una edad, fijaros, la edad del objeto per una igual a 10, por ejemplo, 10 años, esto nos va a dar un error en ejecución. 00:14:46

¿Por qué? Porque el sistema operativo no ha hecho una reserva para donde guardar información para este entero. Por eso las variables que definimos a partir de una clase se llaman referenciadas. 00:15:16

No tenemos esa zona de memoria RAM reservada con la simple definición del objeto al contrario de lo que nos pasaba con este tipo de variable que es primitiva de las iniciales de Java. 00:15:32

Pero oye, nosotros en verdad lo que queremos es poder asignar a esta persona su edad y su nombre y trabajar con ella y permitir que pueda despedirse y permitir que pueda saludar y para eso necesito ese espacio de memoria. 00:15:45

Para obtener ese espacio de memoria, lo que hacemos es decir que per una y aquí utilizamos el operador new y este new es el que coge y nos pide espacio de memoria RAM para donde poder albergar esta información. 00:15:58

Por ser referenciada, necesitamos hacer este segundo paso. 00:16:17

Y luego, disculpad, luego lo que se hace es llamar a un método, 00:16:21

aquí tenemos el método saludar, pues a un método que se llama igual que la clase, persona. 00:16:29

Fijaros que esto, al tener aquí los paréntesis, es que estamos llamando a la ejecución de un método. 00:16:37

Este método es el método constructor, del cual hablaremos más adelante. 00:16:42

Ahora, quería poner el foco aquí en este new. 00:16:47

Este new lo que hace, como os digo, es hacer la reserva de la memoria RAM. 00:16:50

Esto le pide al sistema operativo espacio en la memoria RAM, 00:16:55

donde poder guardar información de aquellos atributos que tiene definida la clase persona. 00:16:58

En particular, para una persona que estoy dando de alta, un objeto que es per1. 00:17:05

Después de hacer esto, si ahora yo cojo y digo per1.iedad igual a 10, 00:17:11

ya sí que me lo permite. ¿Por qué? 00:17:15

Porque gracias a este new 00:17:18

ahora ya tengo un espacio de memoria donde 00:17:19

poder guardar la edad 00:17:21

para la per1, persona1 00:17:23

que es un objeto de la 00:17:26

clase persona. 00:17:27

¿Cómo es como ha funcionado esto? 00:17:30

Pues mirad, este new lo que hace 00:17:31

es, el sistema operativo 00:17:33

dice, voy a buscar 00:17:35

un espacio de memoria donde 00:17:38

guardar esta información 00:17:39

y a lo mejor un nombre y una edad. 00:17:41

es lo que está 00:17:44

realizando esteño 00:17:47

y a lo mejor el sistema operativo dice 00:17:48

pues mira, tengo un espacio, he encontrado 00:17:50

un huequecito en la memoria RAM 00:17:52

en la posición 85.000 00:17:54

estos números 00:17:56

son los que sean, pongo cualquiera 00:17:58

donde 00:18:00

entra 00:18:01

información para 00:18:02

una variable de tipo string, que es el nombre 00:18:06

y una variable 00:18:08

de tipo entero, int, que es la edad. 00:18:12

Reserva desde el 85.000, vamos a suponer hasta, por decir un número, 00:18:20

que no sé exactamente hasta qué cantidad lo hará, hasta el 85.100, 00:18:24

vamos a suponer, hasta el 85.100, que en estos 100 es donde entran 00:18:30

estos dos datos. Y este 85.000, que es donde está el nombre y la edad, 00:18:34

esto, este es el dato que asigna a este 50.000, a PER1. Entonces, en la posición de memoria 50.000, lo que aguarda es el 85.000, 00:18:39

que es a partir de donde tengo los parámetros del objeto PER1 de la clase persona. En definitiva, esta instrucción, 00:18:52

qué es lo que hará si pensamos en memoria. 00:19:01

Por decir, a Peruna, esta la tengo claro, que está en el 50.000. 00:19:04

El 50.000 apunta al 85.000 y edad estará por el 85.000 00:19:08

en algún sitio donde tiene guardada la edad. 00:19:13

¿Se entiende? ¿Más o menos? 00:19:20

¿Sí? Vale. 00:19:28

Pues ahí radica un poco la diferencia de las variables primitivas 00:19:30

y las referenciadas. 00:19:33

Nosotros en un programa donde utilicemos este tipo de variables 00:19:35

no tenemos nunca que preocuparnos de hacer la reserva de memoria, simplemente con la definición de la variable 00:19:38

ya me está asignando ese espacio de RAM para ir trabajando con ese dato. 00:19:44

En cambio, cuando lo que estamos trabajando es con una variable, que en realidad es una instancia, 00:19:51

un objeto de una clase que tenemos definida en nuestro programa, esto lo único que nos hace es 00:19:56

reservar directamente espacio memoria para guardar ese dedito 00:20:04

que apunta al sitio donde luego se va a reservar la memoria 00:20:09

de verdad cuando hagamos el new. 00:20:13

Vale, pues aquí tenemos las primitivas y las referenciadas. 00:20:19

En Java se dice que todo o prácticamente todo, 00:20:26

estas primitivas, luego tienen unas otras clases que son 00:20:29

las wrappers, que en algún momento 00:20:33

haremos alguna cosita con ellas 00:20:36

bueno, durante el curso 00:20:38

pero en algún momento os contaré más explícitamente 00:20:40

que tiene métodos para trabajar con estos tipos 00:20:41

de datos, pero en Java 00:20:43

todo, todo, todo 00:20:46

es un, son 00:20:47

clases, entonces, si venimos 00:20:49

por ejemplo aquí a este ejercicio 00:20:52

que teníamos, fijaros 00:20:53

como un programa 00:20:56

que simplemente tenga un main 00:20:57

donde, aunque solamente 00:21:00

cojamos y hagamos un system.out.println 00:21:03

pongamos un hola, un holamundo 00:21:07

de los que hacíamos ahí al principio, si lo ejecutamos 00:21:11

a ver, que quito por aquí, que tenía más cosas en el proyecto 00:21:14

y no me compila, si no, ya compila 00:21:29

bueno, pues si lo doy aquí a ejecutar 00:21:32

pues nada, me muestra el hola, fijaros como simplemente 00:21:35

este código ya está metido dentro de una clase, es decir 00:21:38

todo va dentro de clases y siempre hay una clase 00:21:41

que al menos tiene que tener un main que es el punto de entrada al programa 00:21:44

Mirad, esto, si veis esto, esto no cuadra del todo al 100% con lo que os estoy contando yo aquí de clases o variables de este tipo o referenciadas. 00:21:49

Porque las primitivas, las variables primitivas son estas, los enteros, los boolean, los longs, estos que guardan datos de los más básicos, los string. 00:22:01

y las referenciadas son variables de objetos 00:22:09

de los cuales definimos nosotros un objeto, 00:22:14

como por ejemplo la clase Persona hacíamos aquí. 00:22:19

Y aquí, en cambio, estamos utilizando un método, 00:22:22

fijaros que los métodos son los que hacen cosas, 00:22:25

recordad, println y tenemos aquí entre paréntesis, 00:22:28

que recibe aquí un valor, pero está metido entre paréntesis. 00:22:34

Entonces, println, ¿qué será? Pues será un método. Hemos dicho que las clases se organizan en parámetros y métodos. 00:22:37

Los métodos son los que hacen cosas, pues este método saca por pantalla. 00:22:44

Entonces me diréis, si tú estás utilizando aquí un método, ¿dónde has definido el objeto que tendrá que ver con esta clase? 00:22:49

System.out, ¿verdad? System será un paquete, out será una clase. 00:22:56

¿Dónde has definido un objeto? 00:22:59

¿Dónde has dicho, voy a definir un objeto 00:23:02

System.out 00:23:04

a, a, a, igual 00:23:08

a new, un poco en el esquema que os decía 00:23:11

del objeto de la clase 00:23:13

persona del que hablábamos antes. Pues resulta 00:23:17

que para trabajar 00:23:20

con objetos 00:23:23

ahora retomo el System.out, para trabajar con objetos 00:23:25

lo que hacemos es definir un objeto de la clase Persona 00:23:29

y podemos definir un segundo objeto de la clase Persona, 2 00:23:34

y ahora hacemos un new de nuevo 00:23:44

y decimos que la persona 2 tiene una edad diferente 00:23:47

ahora vuelvo al System.out, a lo que os iba a contar 00:23:51

pero voy a introducir primero un segundo objeto de la clase Persona 00:23:55

cuando hemos hecho todo esto 00:24:00

se han producido estos pasos 00:24:02

en este primero 00:24:04

per 1 a per 00:24:06

nos había dado este 50.000 00:24:08

que habíamos dicho 00:24:10

por aquí 00:24:11

y cuando hicimos el new 00:24:13

hizo la reserva en el 85.000 00:24:16

y este dato del 85.000 00:24:18

que es donde se guarda el nombre 00:24:20

y la edad 00:24:22

se lo asignó a per 1 00:24:23

con lo cual a través de per 1 00:24:26

50.000 y de este dato somos capaces de llegar 00:24:27

a su nombre y a su edad. Cuando definimos una segunda persona 00:24:32

esta segunda persona queremos que tenga un nombre 00:24:36

y una edad diferente. O podría tenerlo, ¿no? 00:24:39

Entonces, cuando hacemos esta asignación, ¿qué hará el sistema 00:24:43

operativo? Pues igual que hizo aquí y nos dio el 00:24:48

50.000 para la persona 2, cogerá en el sistema operativo 00:24:52

y buscará una zona de memoria, que por ejemplo sea la 100.000. 00:24:56

Y todavía no tendrá asignado un espacio en esta instrucción 00:25:02

donde guardar el nombre y la edad de la persona 2. 00:25:06

¿Por qué? Porque es una variable de tipo referenciado. 00:25:09

En cambio, si hacemos un new a la persona 2, 00:25:13

se producirá el mismo proceso de antes, 00:25:18

buscará un espacio de memoria para la edad y el nombre de esta persona 2 00:25:20

y el sistema operativo vamos a suponer que lo encuentre en la 110.000. 00:25:24

Aquí ha encontrado un huequecito donde guardar información para un nombre, un string y una edad, un entero. 00:25:29

Y este 100.000, 110.000 se lo va a asignar como consecuencia de este new a PER2 porque es al que se lo estamos aplicando aquí. 00:25:38

Entonces este apuntará a 110.000 y en este 110.000 se reservará un trocito para guardar el string para el nombre y el entero para la edad de esta segunda persona. 00:25:47

Con lo cual, cuando nosotros pongamos per1 y edad igual a 10, en algún espacio de este trocito se guardará ese 10 para el entero y cuando digamos per2 igual a 20, en algún trocito de este otro espacio, del 110.000, se guardará el 20. 00:26:00

Fijaros que tenemos para una variable una zona de memoria y para otra, otra zona de memoria. 00:26:20

La verdad, ambas dos son la edad, pero cada una corresponde a una persona distinta que es per1 y per2 dentro de nuestro programa. 00:26:27

Cada uno de los objetos tiene su espacio de memoria. 00:26:34

Mira, retomamos esto. 00:26:43

Aquí no hemos definido un objeto, no hemos definido un objeto de la clase System.out y hemos cogido y hemos dicho luego a.ejecuto el método. 00:26:45

No, directamente lo hemos utilizado. ¿Esto qué supone? Pues resulta que hay una serie de clases que tienen información que es común para todos los objetos de la clase. 00:26:56

Mirad, aquí el nombre en la persona no puede ser común a todos los objetos de la clase. 00:27:12

Si tuviera una única zona de memoria, es decir, el nombre fuese común para todos los objetos de la clase, 00:27:17

si nosotros pusiésemos per1.nombre, ese nombre, igual a Rubén, pues guardaría en una zona de memoria Rubén. 00:27:23

En verdad lo está haciendo por aquí. 00:27:39

Y si ponemos per2 ese nombre noa, en realidad lo estará guardando por aquí, ¿verdad? En la zona donde habíamos reservado. 00:27:40

Si el nombre fuese común para todas las personas, lo que tendríamos no sería un trocito para el nombre reservado para per1 y otro trocito para el nombre reservado para per2, 00:28:06

sino que tendríamos, si todos tuvieran el mismo nombre, resulta que esto es un club de aquellas personas que se llaman NOA. 00:28:19

Pues entonces, la clase, no cada uno de los objetos per1 y per2, sino la clase persona, para la clase persona, 00:28:27

se reservaría un trocito de memoria donde guardar el nombre. 00:28:36

entonces si cogiésemos y dijésemos per1 igual a Rubén 00:28:47

en ese trocito de memoria ya que es común a todos ellos 00:28:51

se pondría Rubén y si luego pongo 00:28:54

per2 igual a noa como la zona de memoria 00:28:59

bajo ese supuesto sería común 00:29:02

y sería común a todos los objetos de esa clase 00:29:04

persona en el mismo espacio de memoria se pondría noa 00:29:08

y sobre escribiría Rubén 00:29:11

entonces en este código fijaros si pusiéramos 00:29:13

suponiendo que el nombre es común para todos los objetos 00:29:17

de la persona, si nosotros ponemos aquí un system.out.println 00:29:21

per1.eseNombre, viendo el código pensaríamos que nos va a poner 00:29:27

Rubén porque hemos asignado el valor Rubén aquí, luego hemos 00:29:39

asignado el valor Rubén no aquí, pero a per2 y muestro 00:29:42

per1.eseNombre. El código nos invita a pensar que lo que va a 00:29:45

escribir esto por pantalla va a ser Rubén. Pero en cambio lo que escribiría 00:29:50

en este caso sería Noah. ¿Por qué? Porque como la zona de común, 00:29:54

la zona de memoria sería común, el Rubén que se había escrito aquí 00:29:58

lo habría sobrescrito este otro. 00:30:02

Y es común hasta tal punto de que para escribir cuando 00:30:06

una de estas variables o métodos, esto sirve para los métodos, 00:30:10

recordad los métodos que son las acciones que hacen los objetos de la clase 00:30:14

o los atributos, cuando se trata de métodos 00:30:18

que son comunes, ahora os hablo de cómo lo definimos, podemos escribirlo 00:30:23

incluso de esta forma, poner persona.eseNombre, imaginaos que 00:30:27

hacemos un system.out de persona.eseNombre, esto nos 00:30:35

valdría siempre y cuando ese nombre, esta 00:30:42

variable, una variable miembro o de clase, se haya 00:30:46

definido, ahora os digo cómo se hace, de forma común a todos los objetos 00:30:50

de la clase, porque no hay lugar 00:30:54

a incertidumbre de a qué nombre se está refiriendo. Si es común 00:30:58

está claro que se está refiriendo a este. En cambio, si no lo hemos 00:31:02

definido como común, vamos a poner aquí y edad 00:31:06

que no hemos hablado en ningún momento que todas 00:31:10

las personas tengan la misma edad, sino que cada una tiene su edad, tal y como habíamos 00:31:14

distribuido por aquí antes para la PER 1 estará guardada la edad por aquí 00:31:18

y para la per 2 estará guardada la edad por aquí esto no me no sé no me entendéis pero no me 00:31:22

entendéis o no me oís pero pero por el micrófono o por la explicación voy a cuelgo y me conecto de 00:31:33

nuevo vale no paro no paro la grabación al menos en la grabación si os va quedando pero voy a 00:31:50

colgar y me vuelvo a conectar aunque veáis que me salgo esperarme un segundo ahí bueno estoy de 00:31:56

vuelta no sé si hemos resuelto algo o no ahora sí vale pues voy a compartir pantalla de nuevo 00:32:26

vale pues nada continuó lo que estaba comentando era en relación a las variables que son comunes 00:32:35

a todos los objetos de una clase o no lo son estábamos haciendo el supuesto de que todo en 00:32:51

esta clase persona ahora os digo cómo se asigna eso por código todos los nombres tuviesen el mismo 00:32:58

todos los objetos tuviesen el mismo nombre, con lo cual esta variable sería común 00:33:05

y como consecuencia de ello, en la memoria RAM solamente reservaríamos 00:33:08

un trocito de memoria RAM para un solo stream y estaría relacionado 00:33:13

con toda la clase. Todos los objetos de la clase, cuando quieran acceder al nombre, 00:33:17

accederían a esta zona de memoria. En cambio, estábamos haciendo 00:33:22

el supuesto de que la edad, no, la edad queremos que sea diferente 00:33:25

¿Me veis la pantalla, verdad? 00:33:30

que la edad sea diferente para cada una de las personas. 00:33:33

Como consecuencia de esto, no me valdría tener una sola zona de memoria 00:33:38

porque per 1 tendría una edad de 10 y per 2 tendría una edad de 20. 00:33:43

Si tenemos un único espacio común de memoria, 00:33:48

cada vez que escribiésemos la edad de una persona, 00:33:51

machacaríamos la edad de la otra. 00:33:54

Cuando estas variables son variables de cada uno de los objetos, 00:33:57

esta instrucción no la puedo utilizar, no puedo decir 00:34:01

dime la edad de persona 00:34:04

¿por qué? porque me van a decir, oye, muy bien, ¿de qué persona? 00:34:07

¿de PER1 o de PER2? es de quien quieren mostrar 00:34:10

la edad, entonces en este caso 00:34:13

me vería obligado a decir, oye, la que quiero mostrar es la edad de PER1 00:34:16

y dicen, vale, esto me gusta porque aquí no hay 00:34:19

discrepancias, si me dices de PER1, sé que tengo que buscarlo 00:34:22

en esta zona de código, y si digo de PER2 00:34:25

pues lo tengo que buscar en esta otra zona de código. 00:34:31

Cada uno tiene un espacio, no hay discrepancias, no hay problema. 00:34:34

Si pongo aquí persona para la edad, me dice, muy bien, tengo dos personas, 00:34:37

no has definido la variable miembro y edad como común a todos los objetos de la clase, 00:34:45

¿cuál quieres que muestre? ¿Esta o esta? 00:34:51

Y el programa no le gusta esta discrepancia y no nos compilaría. 00:34:54

Es decir, existen a la hora de definir variables miembro, variables miembro de la clase o métodos, podemos definirlos para que cada uno de los objetos que definamos tenga su propia zona de memoria donde guardar esa información o sea común a todas ellas. 00:34:57

el nombre en línea general es el nombre y la edad se entiende 00:35:17

siempre un programa nos va a invitar a que sean variables 00:35:24

en el que cada objeto tenga su propia zona de memoria 00:35:28

ya os digo, a no ser que sea el ejemplo que os estaba poniendo en el cual todos los objetos 00:35:32

tuviesen, fuera un club de personas que se llaman NOA 00:35:37

pero bueno, por ejemplo, imaginaros que 00:35:40

yo que sé, imaginaros que es de personas de una determinada 00:35:43

quinta, que justo nacieron 00:35:48

en un año. Entonces puede ser 00:35:50

int y 00:35:52

año 00:35:54

y ponemos que sea 00:35:56

el año 2000. 00:35:57

Pues este año 00:36:01

si justo este programa va a tratar 00:36:02

de todas aquellas personas que 00:36:05

tendrán nombres y edades diferentes pero 00:36:06

todos son de este año, si lo definimos 00:36:08

así tal cual, ahora os digo 00:36:10

la diferencia para convertirlo en una variable 00:36:12

de clase que no sea de cada uno de los objetos 00:36:15

¿qué sucedería? 00:36:17

que cada uno de los objetos que definiéramos, per1 y per2, tendría una reserva de espacio de memoria para un entero, porque lo hemos definido así como entero, ¿veis? 00:36:18

¿Dónde pondría 2000? Este tendría otro espacio de memoria reservado donde pondría también 2000. 00:36:29

Y si definimos, vamos a ser un poco brutos, 10.000 personas, 10.000 veces tendríamos un espacio de memoria reservada para cada uno de ellos 00:36:36

y en todos ellos pondría 2000, con lo cual haríamos un derroche de memoria RAM innecesario, 00:36:47

porque todos tienen el mismo dato. 00:36:53

Para convertir esta variable en una variable común a todos los objetos de la clase, 00:36:55

la definimos como estática, que es meterle aquí la etiqueta static. 00:37:01

Y esto lo que hace es que cuando vayamos definiendo diferentes personas, 00:37:07

a la hora de hacer una reserva de memoria RAM donde guardar la información de sus atributos, 00:37:11

para cada uno de los objetos solamente hablará para aquellos 00:37:15

en los que sí que puedan tener información diferente 00:37:20

y para la variable static que es común a todos ellos 00:37:23

solamente se reserva un espacio de memoria RAM entero 00:37:28

para toda la clase persona y cualquiera de sus objetos 00:37:31

con lo cual aquí ahora tendríamos el 2000 00:37:34

y no lo tendríamos en cada uno de ellos. 00:37:38

Repitiendo lo que os decía antes, en este caso 00:37:43

que ahora ya hemos definido el año como estático y no el nombre y la edad 00:37:45

para poder acceder al nombre y la edad 00:37:49

primero tendríamos que identificar de qué persona estamos hablando 00:37:51

per una y edad 00:37:55

y esto le gustaría, o per dos 00:37:58

y edad y también le gustaría, en un caso se vendría esta edad 00:38:00

y en otro caso se vendría esta 00:38:03

bueno, no sé, el matiz de constante y variable 00:38:05

no, esto, tú imagínate que 00:38:19

estamos haciendo la ejecución del programa 00:38:22

y durante la ejecución del programa dices, pues ahora voy a trabajar con todas las personas 00:38:25

que sean del año 2000. Y le pones aquí 2000. Y luego dices, pues ahora quiero trabajar 00:38:30

con todas las personas que sean del año 2001. Entonces tú podrías actualizar esta variable 00:38:35

en el código y cambiar este valor a 2001, con lo cual es una variable porque puede cambiar 00:38:40

su valor, no es constante en todo el programa. ¿Cómo podríamos hacer este cambio? 00:38:46

Pues aquí podrías poner en el código, por ejemplo, en saludar, esto te lo permitiría el compilador, poner 2001. ¿Es variable? Sí. Lo que pasa es que esta asignación te cambia el año para absolutamente todas las personas que están de alta, no para una persona en particular. 00:38:49

Es estática porque es para todas, pero sigue siendo variable porque puede cambiar su valor. 00:39:10

La etiqueta que convertiría en una constante esto sería la etiqueta final. 00:39:15

Si tú pones una etiqueta final a un atributo, la etiqueta final, dependiendo a quién se la pongas, tiene diferentes significados. 00:39:21

Hablaremos de ello también en algún momento. 00:39:28

Si está relacionada para un parámetro o un atributo de clase en particular, lo que hace es convertirla en una constante. 00:39:31

Entonces, si tú pones esta etiqueta aquí final, esto daría un error de compilación, porque no podrías cambiarlo. 00:39:38

Esta sí que sería una constante, no me va a cambiar en ningún momento en ninguna zona de código. 00:39:47

Cambio esto, esto sí lo permitiría, cambiaría el valor, pero ese cambio de valor afectaría a todos los objetos de esa clase. 00:39:52

Mira, imagínate que lo que queremos es que el nombre sea estático. 00:40:05

Si pones tu static, resulta que la memoria RAM, cuando se reserva para esto, 00:40:12

no se hace una reserva particular para cada uno de los objetos, 00:40:17

sino que se hace una única para la clase de este estilo, para la clase persona. 00:40:21

Entonces, si tú tienes aquí este código, puedes asignar al nombre que es estático el valor de Rubén. 00:40:26

¿Eso qué implicaría? Pues que en esta única zona de memoria, lea Rubén, si luego pones para el nombre que es común su zona de memoria para todos los objetos de esa clase, noa, pues te pondré aquí noa. 00:40:34

¿Estamos cambiando el valor del nombre? Sí, entonces es una variable, no es una constante. 00:40:49

Si yo ahora intento escribir aquí per1, como os decía antes, por pantalla per1, ese nombre, a pesar de que aquí le asigné Rubén, cuando vaya a hacer el acceso al nombre de per1 al tratarse de una variable de tipo estático, tendrá una zona única de memoria para la clase persona y cogerá la información que hay aquí, que es noa, que es la que se asignó aquí. 00:40:54

Con lo cual, este per 1, por mucho que aquí pusimos robin, nos mostrará no a. 00:41:22

Pero, siendo estático, ¿es una variable? Sí, nos permite cambiar su valor. 00:41:27

Si es final, ¿va a ser sí o sí una constante? Sí. 00:41:31

Entonces, si yo intento modificar el valor de iedad, directamente no me va a compilar el programa. 00:41:38

Bien, pues, estábamos diciendo entonces, para aquellas variables estáticas que son comunes, 00:41:52

Pasa igual, los métodos también se pueden definir estáticos, static. 00:42:02

Entonces este método, su ejecución sería común a todos los, 00:42:10

el código sería común a todos los objetos que lo pudieran utilizar. 00:42:13

Mirad, la información estática, podemos acceder a ella, como os decía, 00:42:19

a través de un objeto, per 1, ese nombre, que ahora lo tenemos definido como static, 00:42:24

Per 2, ese nombre no hay lugar a dudas, se refiere a esta zona de memoria y como la zona de memoria es única para toda la persona, podemos acceder a ella a través de persona. Persona, ese nombre no tiene problemas, no hay conflictos, solamente hay una zona de memoria ya que el nombre es estático que será esta, con lo cual cojo noa y cojo y lo pongo por pantalla en este momento. 00:42:28

Si en nuestro programa nosotros no hemos definido ningún objeto y somos capaces de acceder a cosas de la persona, en este caso un atributo, aunque no hayamos definido ningún objeto, tenemos total certeza de que esta variable en la clase persona está definida como estática. 00:42:54

Porque si no está definida como estática, nos daría un error de compilación. Necesitaríamos saber a cuál de los nombres nos estamos refiriendo si no es estática. Pero si es estática, para la clase hace esa reserva y directamente con el nombre de la clase y el atributo accedemos al nombre. 00:43:19

esto que hablamos para un atributo pues sucede para los métodos aquí en el sistema println este 00:43:37

esto es un método y resulta que si miramos hacia la izquierda deberíamos tener un objeto que ejecuta 00:43:46

este método pero no hemos definido ningún objeto por aquí veis en definitiva println es estará 00:43:53

definido en la clase out del paquete existen como un método estático por eso podemos utilizar cierto 00:43:59

código sin haber definido antes objetos pero hay un buen toncio para llegar a este punto pero 00:44:07

entendéis la jugada más o menos bueno sí pero pero bueno ahí hay dos conceptos no quería llegar justo 00:44:16

a ese concepto pero bueno también lo que incorporó tu concepto y vuelve a pegar un repasillo nuestro 00:44:40

programa estará formado por clases que definamos en el propio programa. En este tenemos una clase 00:44:48

alumno y una clase hola2 y por clases que estarán en la biblioteca de Java. Es decir, el juntar 00:44:55

diferentes clases de la librería de Java y las que tengamos definidas nosotros con nuestro código 00:45:03

será lo que le dé la entidad completa a nuestro proyecto. De la librería de Java utilizaremos 00:45:09

clases que tendrán comportamientos 00:45:14

generales. Lógicamente, cuando alguien definió las 00:45:18

librerías de Java, no estaba pensando en, hoy que os estoy 00:45:20

contando yo aquí, una serie de cosas del tema 2 00:45:24

de distancia. Estaba pensando en funcionalidades generales 00:45:26

de Java. Entonces, una funcionalidad general de Java 00:45:29

será casi seguro, tanto en nuestro programa 00:45:32

como en tantos otros, será escribir por pantalla. Entonces, 00:45:35

dijeron, vamos a crear unas clases. La clase out 00:45:38

que está en el paquete system, que tenga 00:45:41

un método que nos permita escribir por pantalla. 00:45:44

Estamos pudiendo utilizar esto sin haber definido 00:45:48

nosotros el código de la clase out 00:45:50

en uno de nuestros ficheros porque está en las 00:45:53

librerías de Java. Perfecto, eso por un lado. Tenemos 00:45:56

información que está en las librerías 00:45:59

de Java, información de nuestros proyectos, que va un poco 00:46:03

al hilo de lo que me comentabas. 00:46:06

Y luego, por otro lado, tanto en las librerías 00:46:09

de Java como en las nuestras, podremos tener definidos parámetros 00:46:11

y métodos que sean estáticos. Cuando en la librería de Java, 00:46:17

pues por ejemplo, ahora dentro de un momento os voy a comentar 00:46:23

algo de la clase Scanner. La clase Scanner es una clase que está 00:46:25

definida en las librerías de Java. Para utilizar Scanner tenemos 00:46:29

que definir, igual que os decía aquí, que definíamos un objeto 00:46:33

per uno de la clase Persona y Persona es una clase que he 00:46:38

desarrollado yo el código, para poder utilizar Scanner es necesario 00:46:41

definir un objeto. Igual que Per 1 antes, pues aquí definimos 00:46:45

un objeto. ¿De quién? De la clase Scanner. Esto quiere decir 00:46:49

que si yo defino diferentes objetos 00:46:53

de la clase Scanner, para cada uno de estos objetos, cuando le hago 00:46:57

un new, tendré una zona de memoria diferente para aquellos métodos 00:47:01

que tenga la clase Scanner y que estarán definidos donde 00:47:05

su código Java? Pues lo habrán hecho para nosotros y estará ubicado 00:47:09

en la librería de Java. Han hecho ese código para nosotros 00:47:13

que nos viene estupendo, porque ya veréis ahora que fácil es poder 00:47:17

hacer una lectura con la clase Scanner de información desde teclado 00:47:21

que si lo tuviéramos que codificar nosotros, el ser capaces de llegar a través del sistema 00:47:25

operativo al teclado sería una locura. 00:47:29

Pero, igual que tenemos ahí la clase, cuando la han definido 00:47:33

tendrán sus métodos y sus parámetros y para poder tener zona de memoria 00:47:36

para esos métodos y esos parámetros, definimos un objeto y le hacemos un new 00:47:41

scanner y aquí le ponemos 00:47:45

bueno, pues ahora lo completamos. Es decir, estamos 00:47:49

definiendo un objeto scanner de la clase scanner. 00:47:53

La clase scanner está en la librería de Java. Aquí estábamos 00:47:57

definiendo un objeto per1 y per2 de la clase 00:48:01

persona. ¿La clase persona está en las librerías 00:48:05

de Java? No, pertenece a nuestro 00:48:07

proyecto que estamos desarrollando. 00:48:09

Es decir, la clase 00:48:14

persona aquí en nuestro desarrollo 00:48:19

tiene algunos métodos 00:48:22

que no los hemos definido estáticos 00:48:23

y tiene algunos, perdón, algunos atributos 00:48:25

que no los hemos definido estáticos y algún 00:48:27

método que no lo hemos definido estático 00:48:29

y tiene algún método que lo hemos 00:48:31

definido estático y algún atributo que lo hemos 00:48:33

definido estático. Esto lo hemos hecho en una 00:48:36

clase que hemos hecho nosotros. 00:48:37

Igual que aquí hemos tenido 00:48:39

nosotros ese criterio para diferentes métodos y diferentes parámetros, los han podido tener ellos 00:48:41

cuando hayan hecho clases que están en las librerías de Java. Sabiendo que esto puede pasar tanto en un 00:48:47

sitio como en otro, pues cuando utilizamos nuestro programa, si queremos acceder a una variable 00:48:54

que sea estática, que sea común a todos los objetos de la clase, podemos acceder a ella poniendo el 00:49:02

nombre de la clase y el atributo o podríamos ejecutar el método saludar poniendo el método 00:49:09

el nombre de la clase y el método y esto ejecutaría saludar en cambio si nosotros ponemos el nombre 00:49:16

de la clase y despedir esto nos daría un error de compilación porque porque despedir no es estática 00:49:26

y tenemos que ejecutarlo para cada uno de los objetos cuando es estática es común a todos los 00:49:31

objetos y podemos utilizar el nombre de la clase, cuando no es estática 00:49:36

es particular para cada uno de los objetos y si yo digo aquí 00:49:41

que me ejecute persona.despedir, me diría 00:49:44

como esto no lo has definido general para la clase, ¿tú quieres que se despida 00:49:47

per1 o per2? Pues entonces no te dejo que utilices 00:49:52

la clase persona para despedirte. ¿Veis la diferencia? ¿Cuándo es 00:49:56

estático y cuándo no? Si yo 00:50:02

quito todo este código 00:50:12

y no tengo definido ningún objeto de la clase 00:50:18

persona, esto 00:50:23

despedir no me funcionará 00:50:24

pero saludar 00:50:26

sí. ¿Por qué me funcionará saludar? 00:50:28

Pues porque no tiene lugar a dudas 00:50:33

el método saludar 00:50:35

igual que sucedía antes aquí 00:50:37

con los parámetros, es que con los parámetros se ve un poquito 00:50:39

mejor con la memoria RAM, es 00:50:41

único para toda la clase persona. Entonces la clase 00:50:43

persona por sí misma, aunque no haya ningún 00:50:45

objeto, es capaz de saludar. Pero si yo pongo 00:50:47

aquí despedir 00:50:49

esto no le gusta, ¿por qué? pues porque tenemos un método de despedir para cada uno de ellos 00:50:49

fijaros que saludar me lo ha permitido sin haber definido ningún objeto 00:50:56

entonces si nos venimos aquí, quito el escáner 00:51:00

fijaros como println tiene aquí unos paréntesis con lo cual esto es un método 00:51:07

es un método que estamos ejecutando de la clase out del paquete system 00:51:14

Y estamos ejecutando esto sin haber instanciado ningún objeto de la clase out. Es decir, trasladándolo a este ejemplo sin haber instanciado ningún objeto de la clase persona. Entonces, si sin instanciar ningún objeto de la clase persona nos deja utilizar el método println, será porque el método println es estático. En su definición, en la librería de Java, cuando lo han construido. 00:51:19

¿Se entiende? Regular, ¿no? 00:51:44

Respecto a la memoria RAM, entonces 00:52:00

tenemos las posibles variables que definimos 00:52:02

primitivas. Las variables primitivas, por ejemplo 00:52:07

int a, directamente ya me reserva para 00:52:12

una etiqueta de mi nombre a, un espacio de memoria donde podré guardar 00:52:15

información para un entero. Tenemos las referenciadas 00:52:19

persona miper. Esto no me 00:52:23

reserva espacio de memoria directamente para los atributos de una persona. Para conseguir 00:52:28

eso, ¿qué le tengo que hacer? Un new y luego, bueno, llamamos 00:52:32

a un método que es constructor, siempre después del new. Del constructor ya os hablaré, pero 00:52:36

con este new ya sí que reservo espacio para todos esos. 00:52:40

¿Para quién me reservará memoria este new? Para aquellos 00:52:45

parámetros que no sean estáticos. Si yo 00:52:48

tengo uno que es estático, static 00:53:00

y 00:53:01

año decíamos 00:53:03

este new no me 00:53:05

reserva espacio memoria 00:53:09

para esta persona, mi per 00:53:11

con esta 00:53:13

instrucción. ¿Por qué? 00:53:16

Porque al ser estático 00:53:18

ya tendré un espacio de memoria reservado 00:53:19

para toda la clase. 00:53:22

Es decir, tendré para la clase 00:53:24

persona, habrá mirado y habrá dicho 00:53:25

para los static 00:53:27

voy a ir reservando ya memoria y veo que 00:53:28

tengo un año, un entero, pues reservo espacio para un entero 00:53:31

y le asocio el nombre de año. Entonces, este miper 00:53:35

new nos reservará para este objeto miper 00:53:39

espacio de memoria particular para el nombre y para la edad. 00:53:43

¿Para el año lo necesita? No, porque ya hay uno que es común a toda 00:53:48

la clase y se ha reservado para toda la clase. 00:53:51

Si yo cojo y ahora pongo un system.out.println 00:53:55

y pongo persona.eseNombre 00:53:59

¿esto me funcionará? 00:54:07

Pues no me funcionará. 00:54:10

¿Por qué? 00:54:11

Porque si tengo instanciada 00:54:11

más de una persona 00:54:12

no sabrá a qué zona de memoria 00:54:13

tiene que acceder. 00:54:16

Para cada una de las personas 00:54:18

con el new habrá hecho 00:54:19

una reserva diferente. 00:54:20

Pero en cambio, 00:54:22

si yo pongo persona.ianio 00:54:22

en este caso no hay dudas 00:54:27

y podrá ejecutarlo. 00:54:30

¿Por qué? 00:54:32

porque para cualquier objeto de la clase persona y año se ha definido como estática 00:54:32

y hay una única posición de memoria por mucho que tenga uno, dos o cien objetos. 00:54:37

La posición de memoria es única en cuanto a los atributos. 00:54:42

Y la misma idea sucede con los métodos. 00:54:47

Si yo un método lo tengo definido como static, puedo acceder a él con el indicador de la clase. 00:54:49

y si no es static tendré que instanciar un objeto y acceder 00:54:54

al método pero ya con el objeto. Aquí 00:55:00

desde las librerías de Java han hecho la clase System.out 00:55:04

que tendrá unos métodos y unos parámetros y 00:55:09

esta clase sin haber instanciado por aquí ningún objeto 00:55:12

de esa clase nos está permitiendo acceder a un método que es Println 00:55:17

pues este acceso al método Println se produce a través de la clase 00:55:20

gracias a que es estático. Bueno, no lo enredo más veces. Si alguien tiene alguna duda, o bien preguntarme, o luego en los foros, por no volver a darle vueltas otra vez al mismo bucle. 00:55:25

bueno, en principio 00:55:44

no es un poco la idea de ir alargándolas 00:56:00

si tenéis una necesidad así general la puedo alargar 00:56:03

un día más o una cosa así 00:56:06

pero bueno, ya que es la primera, pero en principio 00:56:08

intentaremos ajustarnos a los plazos 00:56:11

de entrega con independencia y que luego 00:56:15

si quieres terminar de completarla 00:56:18

porque no te ha dado tiempo, me la envíes y te la echo un ojo 00:56:21

O sea, no es por la cuestión de echarla del ojo o no, sino por seguir un poco los formalismos de los plazos. Pero bueno, está en principio, si queréis, os la alargo un día más. Vale. Vale. Mira, un poco. Sí, claro, claro, claro. Mira, sirve, lo traslado un poco la pregunta porque creo que en la grabación no queda. 00:56:23

me preguntan si al final el objetivo de Static es optimizar memoria RAM. 00:57:08

Digamos que optimizar memoria RAM es una de las consecuencias que tiene el utilizar Static 00:57:14

y luego tiene una serie de ventajas adicionales a optimizar memoria RAM. 00:57:20

Imagínate que tienes, volviendo al ejemplo del que hablábamos antes, tienes el Static y Anio, 00:57:24

que es de tipo entero. 00:57:31

si tienes 200, imagínate que el año 00:57:33

lo hemos considerado estático porque es común a todos los objetos, que es 00:57:40

la filosofía que persigue el hecho de que sea estático el método 00:57:44

aquí no me compila porque tiene que ser una variable de clase 00:57:48

entonces, fijaros, un detalle, continúo contándote 00:57:52

lo había puesto aquí en el main, pero realmente si lo pongo 00:57:57

aquí es una variable local al main, no sería una variable 00:58:01

de la clase y estamos buscando con el static que sea una variable 00:58:04

para todos los objetos de la clase. Por eso no me compila aquí en este ámbito del método 00:58:09

main y si me compila, si lo convierto en una variable miembro 00:58:13

de la clase. Por comentaros ya que ha pasado 00:58:17

esto. Fijaros, tú imagínate que ahora durante el programa yo instancio 00:58:21

mil objetos de la clase hola. 00:58:25

El hecho de que sea estático implica que esos mil objetos 00:58:29

va a tener el mismo valor para año. 00:58:32

Y en el código, si no lo hubiera definido estático, 00:58:35

que sí que queremos que lo sea, 00:58:42

esos 1.000 objetos tendrían su trocito de memoria, 00:58:44

con lo cual tendríamos peor rendimiento 00:58:47

en cuanto al uso de memoria RAM. 00:58:49

Pero también en el tiempo de ejecución, 00:58:51

si resulta que yo tengo que es del año 2000 00:58:53

y quiero pasar al año 2001, 00:58:56

si tengo 1.000 objetos, 00:58:59

tengo que ir a cada uno de esos 1.000 objetos 00:59:00

si quiero que sea coherente y que todos tengan el mismo año 00:59:02

para pasarlo a 2001 tendría que cambiar mil variables 00:59:05

una de cada uno de los objetos 00:59:08

y en cambio, si la tengo como static 00:59:10

pues yo pongo static y ahora pongo aquí 00:59:13

en este caso la clase se llama hola2.ianio 00:59:16

y pongo 2001 00:59:21

y de una tacada tengo cambiado los mil 00:59:22

¿por qué? porque como es una única zona de memoria 00:59:25

cambio esa zona de memoria y como aplica al ser estática 00:59:28

los mil objetos, los mil objetos 00:59:31

cada vez que quieran acceder al año ya tendrán el 00:59:33

2001. 00:59:35

Con lo cual, me ahorraría tener que 00:59:37

hacer esta actualización para los mil 00:59:39

objetos. Y quien dice mil, 00:59:41

yo qué sé, ya podemos querer ser exagerados 00:59:43

y decir un millón de objetos, ¿no? 00:59:45

Pues fíjate, un millón de instrucciones 00:59:47

o una instrucción sola que al final 00:59:49

cumple con el objetivo que queremos. 00:59:51

Y es más, si la filosofía 00:59:53

de y año es que sea común 00:59:55

para todos ellos y tengo 00:59:57

esos mil objetos de los que hablábamos 00:59:59

antes resulta que yo por código he podido cambiar 500 y los otros 500 no lo he hecho con lo cual 01:00:01

estoy ya cometiendo un error de fondo según la filosofía de la variable y año que tendría que 01:00:08

ser común es para común para todos porque he dejado 500 de mis objetos de la clase o lados 01:00:13

con el valor 2000 y 500 con el valor 2001 con lo cual ya hay una incoherencia y entonces si es 01:00:19

estático es que nos viene de perlas si el valor en sí puede ser estático nos viene de perlas 01:00:25

definirlo como estático por todas estas ventajas 01:00:30

ahora 01:00:33

¿nos vale poner estático cualquier cosa? 01:00:34

pues no, pues en la clase persona de antes 01:00:36

si decimos, pues bueno, para tener 01:00:38

las ventajas que me pueda proporcionar 01:00:40

static, voy a definir 01:00:42

el nombre como estático, pues entonces 01:00:44

la puede chafar, porque cada persona puede tener 01:00:46

un nombre diferente y volvemos 01:00:48

a lo que os ponía antes, si 01:00:50

el nombre Rubén, primero 01:00:52

asignábamos el nombre Rubén y a la 01:00:54

per 1 y a la per 2 01:00:56

le asignábamos luego el nombre de Noah 01:00:58

cuando queríamos ir al nombre de Rubén se llamaba NOA porque la posición de memoria era única 01:01:00

es decir, hay variables que pueden ser static y variables que no 01:01:04

y cuando pueden ser static, el definirlas tal cual 01:01:07

aporta bastante ventajas y una de ellas es el ahorro de memoria RAM 01:01:10

también, no sé si más o menos está claro 01:01:15

bueno, pues 01:01:21

dejo un poco el tema este del static y todo esto, seguiréis trabajando 01:01:25

De todas formas, si luego volvéis a ver la práctica o tenéis dudas, en los foros os voy atendiendo e intentamos ir resolviéndolas. 01:01:30

Mirad, nuestros programas, me voy a otro ámbito de cosas para contaros. 01:01:40

Nuestros programas tienen que comunicarse con el mundo exterior. 01:01:46

Tiene que llegar la información tanto de entrada como de salida. 01:01:51

La información de entrada y de salida a los programas puede ser de diferentes fuentes 01:01:54

El año que viene veréis en una asignatura cómo comunicar aplicaciones a través de sockets 01:02:00

en la asignatura de programación de servicios y procesos 01:02:05

o según vuestro ritmo cuando matriculeis de ella 01:02:08

Esta técnica es a través de sockets, es por ejemplo cuando nosotros nos conectamos a un servidor web 01:02:12

Pues hay una aplicación que se pone a la escucha en un determinado puerto y tiene una determinada dirección IPS equipo. Y desde otra aplicación, que será nuestro navegador, nosotros hacemos que nuestro navegador en nuestra máquina se comunique con el servidor web, que a lo mejor es el servidor web de marca, para ver la página de tenis. 01:02:19

Entonces se establece un flujo de comunicación entre el navegador y el servidor que nos permitiría el traslado de la información de la página de tennis y ver, yo que sé, cómo va la Copa Davis o lo que sea. 01:02:42

Entonces es un flujo de comunicación. Otro flujo de comunicación que tenemos para sacar información y meter en nuestro programa puede ser a través, por ejemplo, de bases de datos. 01:02:56

El año que viene tenéis una asignatura de base de datos y el último tema de este curso, no sé si llegaremos con más o menos tiempo, pero también habla un poquito de cómo acceder a base de datos. Ahí podéis guardar vuestra información y recuperarla. 01:03:06

Más métodos de comunicar nuestro programa con el exterior para inyectarle datos o para sacar resultados puede ser a través de ficheros. 01:03:23

Tenemos un tema que hablaremos cómo trabajar con ficheros. 01:03:31

Todas estas vías de comunicación utilizan el término de flujos de datos. 01:03:35

Los flujos de datos son las tuberías que establecemos desde fuera de nuestro programa, 01:03:41

bien para inyectar o sacar resultados desde Java en este caso. 01:03:48

Y luego hay tres flujos de datos, aparte de todos estos que os comentaba y algún otro que pueda haber por ahí, hay tres flujos de datos que de forma estándar se activan en los programas. 01:03:53

Que es el flujo de datos de entrada, entrada de datos por defecto, que es a través del teclado, de salida por defecto, que es el monitor, y de error por defecto, que también está enlazado con el monitor. 01:04:05

cuando escribimos algo vamos a entenderlo como una tubería que en un lado de la tubería tiene 01:04:28

enganchado pues en nuestro programa está enganchado y en el otro lado pues está enganchado en cualquier 01:04:36

otro sitio en el ejemplo que decía antes del servidor web imaginaros que hemos hecho nuestro 01:04:42

programa del navegador en java pues tendríamos enchufado en el socket este que os decía antes 01:04:47

una parte de la tubería en nuestro propio programa y el otro extremo en el servidor web 01:04:54

que nos proporcionaría la página esta de tenis. 01:04:58

La entrada por defecto, pues tiene enchufado uno de los lados de la tubería en nuestro programa 01:05:02

y la otra en el teclado. 01:05:08

Entonces, cada tecla que escribimos se traslada hasta nuestro programa en Java. 01:05:10

La salida por defecto, pues tiene un lado de la tubería en nuestro programa y la salida al monitor. 01:05:15

Y la de error, cuando queremos escribir un mensaje de error, 01:05:21

pues un lado de la tubería en nuestro programa y la otra también al monitor. 01:05:25

esto es entendiendo como está organizado el tema 01:05:28

en realidad ya hemos utilizado alguna de ellas 01:05:35

porque si nosotros hacemos un system.out 01:05:37

.println y aquí ponemos 01:05:40

un texto, lo que sea, hola, lo que estamos haciendo es 01:05:48

que la clase system.out 01:05:50

en realidad lo que hace es conectarse 01:05:53

system.out está desarrollado en las librerías de Java 01:05:56

resulta que println es un método estático que lo podemos 01:05:59

utilizar sin instanciar ningún objeto de esa clase por ir enlazando con lo que hablábamos antes y es 01:06:02

una clase desarrollada en java que lo que hace es utilizar la salida por defecto entonces este hola 01:06:10

donde nos sale pues nos sale a consola al monitor si ejecutamos este hola mundo y le vamos a ejecutar 01:06:18

pues como consecuencia es sacarlo la mundo donde nos saca consola al monitor porque porque utiliza 01:06:29

la salida por defecto. ¿Quién? Una clase, que en Java 01:06:36

todos son clases, que está definida en las librerías, que se llama 01:06:40

out del paquete system y utiliza un método estático que es el println 01:06:44

que nos hace meter aquí el texto 01:06:48

que queramos que se enchufe al otro lado de la tubería en el monitor gracias a que 01:06:52

utiliza la salida por defecto. La entrada por defecto es 01:06:56

system in. Entonces hay una clase en Java, 01:07:01

también en las librerías que en la clase system, en la clase in del paquete 01:07:08

system, que igual que la system out utiliza la salida por defecto para 01:07:11

escribir en monitor, system in lo que hace es 01:07:15

enganchar el lado de la tubería del flujo de datos que tenemos 01:07:18

en nuestro programa, enganchar esa tubería que al otro lado 01:07:23

está en el teclado para ir metiendo información en nuestro programa. 01:07:28

Normalmente cuando utilizamos system in 01:07:32

podemos directamente, igual que con System.out, escribir, con System.in 01:07:35

podríamos leer directamente, pero en las librerías de Java 01:07:39

hay otra clase que le pone un envoltorio 01:07:43

a la clase System.in para facilitarnos la lectura 01:07:47

desde teclado en nuestros programas. Del flujo de datos System.in 01:07:50

que es la entrada por defecto, podemos utilizar otra clase 01:07:55

que también está definida en las librerías, que encasula 01:07:59

digamos que le da un abrazote ahí a System.in 01:08:02

y hacia nosotros nos resulta más fácil 01:08:05

con los métodos que tiene esta otra clase 01:08:09

el poder leer cosas desde el teclado, que es la clase 01:08:11

Scanner. Ir parándome, si tenéis dudas de cosas 01:08:14

me vais diciendo, mirad 01:08:23

Mirad, cuando he puesto aquí 01:08:24

el método println de System.out 01:08:36

no he tenido que hacer nada en especial, lo he podido utilizar directamente 01:08:39

Esta clase hemos dicho que está en las librerías 01:08:42

de java y la utilizó directamente en mi programa porque mi programa aparte de utilizar mis clases 01:08:45

es capaz de utilizar clases directamente sin tener que hacer nada más que están en un paquete de java 01:08:51

que se llama los paquetes java lang todo lo que son son clases están de uso tan común que 01:08:58

directamente no tengo ni que importarlas a mi proyecto directamente todo proyecto en java ya 01:09:07

es capaz de utilizarlas, todas las que están definidas en ese paquete, como es el caso 01:09:11

de la clase System.out o la clase System.in, que ya veis que no se me queja. 01:09:15

En cambio, luego en la librería de Java 01:09:20

hay muchísimos otros paquetes diferentes 01:09:23

y en unos programas querremos utilizar unos y en otros querremos utilizar otros. 01:09:27

Entonces Java ha decidido que sin necesidad de hacer nada más 01:09:31

podemos utilizar aquellas clases que están en este paquete, en Java.lang 01:09:35

Pero las demás, si queremos utilizarlas, tenemos que avisárselo para no tener en consideración todas las clases de la librería de Java que hubiera, aunque no vayamos a utilizar el 99% de todas las que estén definidas. 01:09:39

Ese es el caso de la clase Scanner. La clase Scanner está definida en los paquetes de Java, pero no está precisamente en esos paquetes que se importan de forma automática. 01:09:51

Entonces, para que lo tenga en consideración mi programa, 01:10:03

lo tengo que importar. 01:10:05

Si me pongo aquí con Eclipse sobre escáner, 01:10:07

que me está dando un error, me dice, 01:10:10

importa escáner del paquete Java útil. 01:10:11

Entonces, lo doy aquí y lo que me hace en el código 01:10:16

es ponerme aquí que importa Java útil. 01:10:18

Fijaros, este no lo he importado directamente 01:10:21

porque no está en Java lang. 01:10:23

Escáner y ya mi programa tiene en consideración 01:10:25

que cuando defina objetos como mi scan de la clase escáner, 01:10:27

En realidad tienen que responder a una clase que está desarrollada en el paquete Java útil y que la han llamado Scanner. 01:10:32

Igual que la clase persona la habíamos definido nosotros antes, pues aquí hay una clase definida en los paquetes de Java, 01:10:40

que es la clase Scanner y la han decidido meter dentro de un paquete de utilidades de Java. 01:10:47

Y para utilizarlo en nuestro programa tenemos que indicárselo aquí al inicio del programa del fichero .java 01:10:52

diciendo que la importamos para que esté disponible en este fichero a Java. 01:10:59

Entonces, fijaros lo que hemos hecho aquí. 01:11:06

¿Os acordáis de cuando antes ponía persona, miper, igual a new, persona, ponía algo así? 01:11:07

Cuando hablábamos antes, persona era el nombre de una clase y miper o per1, había puesto per1, 01:11:20

por ponerlo igual que lo habíamos dicho, per1 era un objeto de la clase persona, 01:11:29

al cual luego antes ya le podíamos asignar un nombre y una edad y todo esto. Pues aquí, fijaros que es el mismo esquema, mi scan es un objeto de la clase scanner, la clase scanner en este caso está desarrollada en los paquetes de Java, la clase personal la estaba desarrollando yo. 01:11:32

directamente esto decíamos, esto si es un tipo referenciado 01:11:50

que no es un tipo primitivo de Java, ya nos permite 01:11:55

acceder a sus parámetros y a sus métodos, decíamos no, si es referenciado 01:11:58

necesitamos hacerle un new, que era el que le pedía 01:12:03

al sistema operativo espacio de memoria para tener 01:12:07

toda la información relacionada con el objeto per1, pues fijaros lo que hacemos aquí 01:12:11

new, esto le está pidiendo al sistema operativo espacio de memoria 01:12:15

para reservar toda la información de un objeto que se llama en mi programa 01:12:19

miScan y que responde al esquema de una clase que tengo definida 01:12:23

en las librerías de Java, que es Scanner. 01:12:28

Y luego aquí os decía que aquí se llama, siempre después del new, 01:12:33

a un método, y es un método porque tiene aquí los paréntesis, 01:12:38

que se llama exactamente igual que la clase y es el método constructor, 01:12:42

del cual hablaremos otro día. 01:12:46

entonces fijaros como se sigue manteniendo el mismo esquema 01:12:48

la clase se llama Scanner y después del new llamamos a un método 01:12:52

y es un método porque hay aquí unos paréntesis como veis 01:12:56

que se llama exactamente igual que la clase con lo cual es un constructor 01:12:59

y en particular le estamos diciendo que este objeto Scanner 01:13:03

se enganche para leer información 01:13:08

a una tubería 01:13:12

que quiero enganchar a mi programa, que es System.im. 01:13:16

Y System.im hemos dicho que era la entrada por defecto. 01:13:20

¿Por qué indico aquí este System.im en este método constructor de la clase Scanner? 01:13:30

Pues porque con la clase Scanner puedo leer desde el teclado, 01:13:36

si pongo aquí System.im, puedo leer desde un fichero que tenga guardado en disco, 01:13:40

si pongo la ruta del fichero, iré haciendo diferentes lecturas 01:13:45

del flujo de datos que indique aquí en el constructor. 01:13:49

En particular ahora nos interesa leer desde el teclado, 01:13:53

por eso pongo System.im, que hemos dicho que es el flujo de datos 01:13:56

de la entrada por defecto en Java, que se establece. 01:14:00

Mira, si yo cojo y pongo aquí string, ese valor, 01:14:06

defino qué estoy haciendo en esta instrucción. 01:14:14

Cada instrucción voy despacito y voy repasando todo. 01:14:19

Defino una variable, que en este caso es de tipo string. 01:14:23

¿Necesito hacer un new? No, porque string es un tipo de los primitivos 01:14:25

de Java. String tiene alguna particularidad que la diferencia con el resto de datos 01:14:30

de tipos primitivos, pero en tanto en cuanto tener que hacer el new 01:14:34

no es necesario. ¿Por qué? Porque es tipo primitivo. Le indico 01:14:37

el nombre y bueno, de partida, he puesto aquí que se inicialice a un 01:14:43

valor. Podríamos poner que no estuviera inicializado. Vamos a decir que de partida 01:14:47

tenga un texto que sea nada. 01:14:52

entonces si ahora pongo yo aquí ese valor 01:14:54

que esa variable sea igual 01:14:57

utilizo el objeto 01:14:59

de la clase scanner, mi scan 01:15:04

y ahora si yo le pongo aquí un punto 01:15:05

tengo acceso 01:15:08

¿os acordáis antes cuando para la persona 01:15:09

per1 le quería asignar 01:15:12

una edad y ponía iedad? 01:15:14

aquí no me compila lógicamente 01:15:18

porque en el proyecto este de Eclipse no tengo 01:15:19

definido la clase 01:15:21

ni la clase persona 01:15:24

ni este objeto, porque está aquí comentado 01:15:26

pero la forma de acceder a la edad de una persona 01:15:28

era con un punto y su valor 01:15:32

y si queríamos que esa persona saludara 01:15:34

os acordáis que habíamos definido el método saludar 01:15:36

poníamos per1.saludar 01:15:38

y entonces hacía todas las acciones 01:15:42

que utilizan las personas para saludar 01:15:44

¿qué persona saludaba? per1 01:15:48

pues entonces, siguiendo esa misma idea 01:15:49

igual que teníamos per1 como un objeto de la clase persona 01:15:54

tenemos mi scan como un objeto de la clase scanner, entonces si ponemos aquí mi scan, ponemos aquí un punto, aquí me podré acceder a aquellos parámetros y aquellos métodos que tenga disponible en la librería de Java, porque así se definió en su momento, la clase scanner. 01:15:57

Entonces, pues mirad, fijaros todos los métodos que tiene disponible por aquí, muchos, uno de ellos es el método Nestline, lo que hace Scanner cuando llamas al método Nestline es leer una línea hasta que hay un Enter. 01:16:20

¿De dónde leerá Scanner? Pues como aquí, cuando lo hemos 01:16:54

definido en el constructor, le hemos dicho que sea de System.in, pues leerá 01:17:00

una línea completa desde teclado. Si aquí hubiéramos puesto un fichero, ¿de dónde leería 01:17:04

una línea completa el objeto 01:17:08

MiScanner, que es de la clase Scanner? Si hubiéramos puesto aquí un fichero, pues leería 01:17:11

una línea entera de ese fichero. Voy a hacer una ejecución ahora 01:17:16

un momento. Después de leer esta línea 01:17:22

voy a poner aquí un system.out.println 01:17:26

y a poner aquí terminando, este programa 01:17:30

arrancará en el main, bueno, sacará un, voy a comentar 01:17:42

el hola mundo este, el system.out, definirá esto, vale, pues 01:17:46

hará esa acción que no tendrá ninguna repercusión en la consola para 01:17:50

nosotros, una variable, lee una línea, pero esta lectura de la 01:17:54

línea la mete en esta variable, con lo cual seguimos sin ninguna repercusión 01:17:58

en nuestra consola para ver nada y luego después de leer esa línea, sacará un terminado aquí. 01:18:02

Si yo lo doy aquí y ejecuto, resulta que ahí se me queda. Fijaros, ¿veis que no me ha mostrado nada? 01:18:10

Pero el programa está arrancado. ¿Veis aquí el pilotito este rojo? ¿Qué es lo que ha sucedido? 01:18:17

Pues que se me ha quedado en esta línea esperando a que yo escriba algo. Ha definido estas variables 01:18:22

y está aquí en esta línea. Si yo pongo aquí hola por teclado y le doy enter, en el momento que le dé enter leerá hasta el next line y continuará. 01:18:27

Entonces le doy enter aquí y veis, como ya ha leído, habrá metido en ese valor este hola y me muestra el terminado. 01:18:40

En definitiva, antes de encontrarnos un next line, para que no nos parezca que el programa se nos ha quedado colgado, como sucedería en este caso, 01:18:48

he deshecho los cambios aquí, a ver, lo voy a parar, para que no suceda, como en este caso me parece que se nos ha quedado colgado, lo que haríamos sería meter un mensajito donde nos pida alguna información por teclado, entonces si nosotros ponemos aquí, como sé que aquí se me va a quedar parado, pues voy a poner por pantalla, system.out.ntln, mete alguna info, vamos a poner el mensaje que quisiéramos que nos saliese, 01:18:59

Entonces, en este caso ya nos dice esto y ya sabemos que es que estamos esperando algo de información. Ponemos hola aquí, damos enter, salta esto y nos muestra aquí terminado. 01:19:32

este valor que hemos cargado aquí, pues podríamos utilizarlo para trabajar con él 01:19:43

entonces podríamos poner aquí 01:19:48

me ha dicho y enlazo 01:19:50

esta cadena de texto fija con la información que tenga esta variable 01:19:59

que es la que acabamos de cargar por aquí por teclado, entonces dice 01:20:04

mete algo de información y decimos hola y ahora dice me ha dicho y fijaros como pone 01:20:11

este hola, gracias a que ese valor tiene el hola que acabamos de meter 01:20:15

a través de la lectura desde teclado. 01:20:19

¿Lo veis? 01:20:26

Bueno, me preguntan 01:20:40

por qué pongo ese valor. 01:20:42

Os comentaba otro día 01:20:44

en otra de las reuniones 01:20:46

las variables 01:20:48

tienen un determinado 01:20:50

hay una determinada 01:20:52

sintaxis para nombrar 01:20:54

las variables. 01:20:56

Típicamente las variables suelen empezar con 01:20:58

minúsculas y ¿por qué pongo yo aquí una S? 01:21:00

Pues es 01:21:02

una manía que tengo yo 01:21:03

de donde trabajé con anterioridad a ser profe. 01:21:05

Que allí, bueno, pues entre las normas que nos poníamos 01:21:09

era que para ser capaz de identificar un poco 01:21:12

el tipo de datos que nos encontrásemos 01:21:15

por ahí en cualquier zona de código, 01:21:17

pues le anteponíamos una letrita 01:21:20

que tenía que ver con el tipo de datos. 01:21:22

Pero esto es igual que, mira, para los métodos 01:21:25

hay un acuerdo más o menos 01:21:29

que los métodos tienen que empezar con minúsculas. 01:21:31

Que luego Java se traga con mayúsculas, pues se los traga, pero digamos que es un convenio generalizado. Las clases suelen empezar siempre con mayúsculas. Si tienes un nombre de una variable, pues por ejemplo, necesitas el valor en curso. 01:21:33

Pues lo normal es que la variable empiece con minúscula 01:21:52

Y si tiene varias palabras 01:21:55

Que cada una de las palabras 01:21:56

Su primera letra sea mayúscula 01:21:59

La S 01:22:01

Pues la costumbre que tengo yo 01:22:02

Heredada de aquellos tiempos en los que trabajaba 01:22:04

En este caso la S 01:22:07

Le he puesto una S porque es un string 01:22:08

Ese es el criterio que tengo yo 01:22:10

Pero no es un estándar 01:22:12

Tan oficial 01:22:13

Como el de los métodos minúsculas 01:22:16

Las clases mayúsculas 01:22:18

si tienes una constante todas ellas en mayúscula, esos son estándares 01:22:20

como muy generalizados de Java, este no tanto 01:22:24

pero en mis ejemplos verás que siempre lo suelo poner así 01:22:26

porque tengo esa rutina, ¿sabes? de hacerlo. ¿Se ve bien? 01:22:31

Vale, mirad, cuando tú 01:22:42

lees con Scanner, con Nest lee cualquier cosa 01:22:46

puedes poner un Nest Synth y te lee un entero 01:22:52

Puedes poner Ness Double y te lee una variable de tipo Double 01:22:56

Es decir, tiene un montón de métodos definidos en las librerías de Java 01:23:02

La clase Scanner que te permite la lectura de diferentes tipos 01:23:07

Hay algunas situaciones en las que el leer con Nessing bien gestionado no tiene por qué dar problemas 01:23:10

Luego algunos de vosotros me hacéis ejercicios y lo controláis y no os da problemas 01:23:19

Pero la lectura de datos con estos otros métodos, como Nessin, Nessdouble, a veces puede generar problemas del siguiente tipo. 01:23:25

Mirad, imaginaros que tú tienes en un programa que lees un entero y luego lees una línea. 01:23:36

Tienes estas dos líneas, en tu flujo de datos se puede dar esa situación, en la cual te vas a leer primero, 01:23:44

imaginaos que en el programa te pide 01:23:50

que metas un número, tienes la necesidad 01:23:53

de meter un número, metes un 8 01:23:55

y luego metes 01:23:56

un texto, que sea hola, ¿vale? 01:23:57

Si tú lees con nesint 01:24:02

un entero 01:24:04

cuando lee el 8 01:24:06

no se espera 01:24:08

a un enter porque 01:24:10

el enter lo coge cuando tú lees 01:24:12

con un nesline. 01:24:14

Entonces tú puedes coger y poner aquí 01:24:16

int y valor 01:24:18

igual y con nesynth te cogería y te leería un entero 01:24:19

pero te lee un entero cuando ya has metido un entero, no necesariamente espera 01:24:25

o a lo mejor metes aquí un espacio y ya como los separas con un espacio 01:24:29

no con un enter, has cogido y te ha considerado 01:24:33

ya un entero y te carga el 8 aquí, si tú en tu programa 01:24:37

después de leer un entero resulta que vas a leer una línea y haces esto 01:24:41

al meterlo pones 8 enter 01:24:45

se puede dar el caso, bajo ciertas casuísticas 01:24:49

y suele ser complicado encontrar el motivo 01:24:52

se puede dar 01:24:54

el caso que aquí te meta 01:24:56

el 8 y en esto que 01:24:57

tienes un Slime que esperabas 01:24:59

un texto con un Enter, te cargue 01:25:01

el Enter solo 01:25:04

y si te termina pasando esto, es complicado 01:25:04

si tienes un programa un poco largo 01:25:10

terminar de darte cuenta que esto sucede 01:25:11

esto, hay una 01:25:14

forma de evitarlo, si por 01:25:16

defecto, seguir siempre 01:25:18

este mecanismo, pero no es obligatorio porque también con cuidado 01:25:20

se puede evitar que se lleguen a dar estas situaciones. Pero una forma muy directa 01:25:24

que yo es la que utilizo siempre, es leer siempre con Nestline 01:25:28

aunque sean valores numéricos. Nestline lo que nos devuelve es un string. 01:25:31

Entonces si yo lo que quiero leer es un entero, 01:25:37

yo ahora defino aquí el valor entero y puedo pasar 01:25:40

un string, un valor string a un entero con un método 01:25:44

de la clase integer, no, de la clase 01:25:48

integer, si, bueno, hay varias formas 01:25:50

fijaros, el método integer parseInt 01:25:52

la clase integer 01:25:57

es una clase que tiene que ver 01:25:59

con funciones relacionadas con los enteros 01:26:03

entonces, si utilizas el método parseInt 01:26:05

de la clase integer y le pones aquí 01:26:08

un string, el valor 01:26:12

que tenga ese string, imaginaos que tiene como una cadena de caracteres un 8, lo traslada 01:26:15

para cargarlo en una variable de tipo entero a 8. Esto es un string cuyo único carácter 01:26:22

es el carácter 8 y esto es una variable entera con valor 8. Esto es un número, esto no es 01:26:29

un número, es un string, pero su carácter es un 8. Entonces con esta secuencia de hacer 01:26:35

leerlo como una línea y trasladarlo al valor entero, que en realidad en este momento lo que queríamos era leer un entero 01:26:41

mediante un integer parseInt, consigues el efecto equivalente al nestInt de escáner y en todo momento evitas situaciones 01:26:49

que se pudieran dar de esas raras como las que os intentaba comentar antes si lo que quiere ser 01:27:03

leer un valor con un flow at que tenga un double que tenga parte decimal pues puedes y hacer 01:27:09

lo lees como un string y luego pones double de valor y tienes la clase rapper double 01:27:20

punto y auxilias el par se da gol y aquí ha leído un double desde teclado 01:27:33

evitando el posible problema ese que os pudiera llegar a dar yo siempre hago esto en dos pasos 01:27:44

también mira podemos tenemos diferentes alternativas mira podríamos si tenemos tres 01:27:50

valores y valor 1 si es verdad es verdad si lanzó la pregunta me preguntan por por cómo podemos hacer 01:28:18

para tres valores seguidos a través de con escáner para de cara un poco a la idea de la práctica 01:28:32

bueno pues mira tenemos varias alternativas una podría ser si tenemos los tres valores que son 01:28:40

de tipo entero, int y valor 1, vamos a poner aquí tres valores, 2 y 3, ponemos aquí, dime el valor 1, por ejemplo. 01:28:45

Mirad, aprovecho y os cuento otra cosita, el System of Println, pues tiene no solamente el método print, 01:29:15

Println, o sea, Println, el método Println lo que hace es mostrar esto por pantalla y si es este 01:29:22

te muestra el cursor se queda aquí en la siguiente línea al principio y luego tienes por ejemplo el 01:29:30

método print que le quitas el ln y ya no te hace el salto de línea con lo cual si tú pones un print 01:29:36

en lugar de un print ln el cursor se te queda aquí que parece como mejor si has pedido algo aquí que 01:29:44

se te quede el cursor aquí para que puedas escribir lo que estás pidiendo entonces mira voy a poner un 01:29:50

print entonces que podríamos hacer pues podríamos hacer ese valor lo leo como valor igual a mi scan 01:29:54

veis y hago un es mi scan a ver qué es lo que he hecho por aquí que no le gusta a bueno next line 01:30:01

leo una línea y ahora puedo coger y digo el valor 1 es que sea igual a como es un entero integer 01:30:21

.parseInt 01:30:32

¿De quién? De ese valor. 01:30:43

Con lo cual, leo un primer valor, se me viene aquí, 01:30:46

lo tengo aquí en modo string y lo cargo aquí en modo entero. 01:30:50

Y luego, una posibilidad, si quieres leer tres, 01:30:55

que no me acuerdo si lo bloquea el enunciado ahora mismo, 01:30:58

pero bueno, os cuento esta posibilidad y ahora os cuento una segunda. 01:31:01

Dime el valor 2, vuelvo a leer, lo cargo aquí, no me importa perderlo del que cogí aquí porque ya me lo he guardado en valor 1. 01:31:03

Pongo aquí valor 2 y podría cargar un tercer valor aquí. 01:31:11

Dime el valor 3 y lo cargo en la variable 3. 01:31:18

Con lo cual ahí he leído tres números desde el teclado. 01:31:22

Mira, vamos a poner aquí valor 1, vamos a sacarlo por pantalla, valor 2, valor 3. 01:31:25

dice valor 1, vamos a poner un 5, un 7 y un 3 01:31:56

y aquí ves, ahora me muestra el resultado de los 3 valores y cada uno lo tengo en una de las variables 01:32:02

para poder hacer el cálculo que toque, no me acuerdo si 01:32:06

el enunciado lo exija así, pero también podría el enunciado 01:32:12

o como alternativa, podríais pensar, pues mira, quiero cargar los 3 valores pero solamente 01:32:16

quiero escribir una línea, entonces podría coger y en lugar de hacerlo 01:32:20

así, 3 veces, en una línea, vamos a ver como lo hacemos en una línea 01:32:24

pues mira hacer una línea podríamos cargarlo aquí vamos a hacer un sistema vendría a ser 01:32:33

pues mira la idea bueno en lugar de darme el valor 1 sería darme los tres valores separados 01:32:56

por un espacio hacemos así y me se me queja aquí en ese valor bueno se me queja 01:33:09

se me queja por este parseInt 01:33:18

lógicamente 01:33:22

¿qué ha sucedido? ¿por qué me ha dado 01:33:23

un error? el texto que he metido ha sido 01:33:25

esto, que no es un número 01:33:27

porque tiene espacios, he intentado 01:33:29

hacer un parseInt para convertir esto 01:33:31

en un entero y como 01:33:33

no ha sido capaz me ha dado este error 01:33:35

de hecho dice, me ha dado un error de 01:33:37

number format exception, ha dicho 01:33:39

no me gusta esto porque esto yo no sé 01:33:41

identificarlo como un número, voy a hacer 01:33:43

una ejecución después de comentar eso 01:33:47

fijaros como he cogido 01:33:49

el valor 3, 5, 6, lo tiene el string 01:33:52

no solo ha asignado ahora un valor 01:33:55

lo muestro, me muestra el 3, 5, 6, o sea que ese dato lo ha cogido 01:33:57

y luego he mostrado el valor 1, 2 y 3 que estaban 01:34:01

inicializados a ceros y es lo que me ha mostrado. Lo que quiero 01:34:04

es distribuir esto en 01:34:06

estas tres variables. Pues mirad, una posible 01:34:09

forma de hacerlo es con un método de la clase 01:34:12

string y 01:34:16

y con ese método la clase stream podemos utilizar un array de caracteres que no va a dar tiempo a 01:34:21

contarlo y yo creo los una los arrays mirad un array os cuento muy rápido si tú tienes si tú 01:34:28

coges y define es una variable imaginaos un entero y pues esto se va a la memoria ram es 01:34:37

una variable primitiva no necesitamos hacer el new y tú coges y en memoria ram coger y 01:34:47

dirá para la variable para la variable y reservo espacio en la posición 10.000 tú coges y dices 01:34:54

en jota y dice para la variable jota el sistema operativo respeto de reserva espacio en la 01:35:02

variable 10.100 y defines una tercera variable int p y lo mismo no para la variable p en el 10.200 01:35:10

para cada variable define su espacio de memoria cuando acceda a ellas pues guardará información 01:35:22

en esta zona de memoria y al leer leerá de ellas existe el existen los una de las estructuras de 01:35:27

datos que tenemos en java hablaremos en este tema me parece que había algo de teoría introductoria 01:35:35

los arrays ya o en el tema siguiente bueno son los arrays los arrays en qué consisten pues mira 01:35:41

tú puedes definir un tipo de datos con los corchetes tú identificas una variable el nombre 01:35:47

de una variable y ahora esta variable no es en sí un entero sino que es un array de enteros y 01:35:57

Y poniéndole un new para solicitar reserva de memoria para muchos en los arrays, podemos coger y poner int y entre corchetes otra vez, por ejemplo, un 3. 01:36:08

Esta sintaxis. Decimos L es un array de enteros y quiero que tenga un total de hasta tres enteros. 01:36:19

Y estos tres enteros, el tamaño en sí se lo identifico aquí y lo hago con este formato. 01:36:28

Le pongo igual a new, int, porque la array es de enteros, y entre corchetes el tamaño. Esto lo que implica es que en L, o sea, para la variable R, para L, el programa le pide al sistema operativo espacio de memoria, pero si un entero tiene 32 bits, que son los que reservaría para I, para J y para P, a partir de la posición 10.000, 10.100 y 10.200, 01:36:34

En este caso, por ser 3, lo que haría sería reservar 96 bits, es decir, son 36 por 12, 12, bueno, los que sean, no 3, 3 por el tamaño que tenga un entero. 01:37:05

Y a lo mejor coge y lo reserva a partir de la posición 90.000, con lo cual si accedo a la posición 90.000 estaré accediendo al primero de los enteros, 01:37:20

Si accedo a la posición 90.000 más el tamaño de un entero, estaré accediendo al segundo, más tamaño entero, estaré accediendo al segundo, pone lo que quiere y sin tilde ni nada, y si accedo al 90.000 más dos veces un entero, más dos veces el tamaño de un entero, estaré accediendo al tercero. 01:37:27

Esto en cuanto a la memoria RAM. ¿En el código cómo lo hacemos? Pues mirad, para acceder al primero, a este que se va a guardar en la posición 90.000, yo cojo y pongo L y entre corchetes un 0. Y este es el acceso al primero de los enteros. 01:38:01

fijaros, L0 es un entero 01:38:17

mirad, L y unos corchetes es un entero 01:38:21

con lo cual aquí lo puedo coger y guardar el valor, un valor entero 01:38:26

igual que se lo guardaba I, tanto I como L0 01:38:29

es un entero, para acceder al segundo 01:38:34

de los enteros que tengo definidos en este array 01:38:36

pondría L1, L1 es el segundo de los enteros 01:38:40

a los cuales accedo a partir de la etiqueta L, que será L posición 90.000 más el tamaño de un entero, 01:38:45

será la zona de memoria RAM donde estaría accediendo. 01:38:52

Entonces tendría una segunda variable que sería así, al cual le puedo acceder una 9. 01:38:56

Y la tercera de las variables sería con un 2. 01:39:00

¿Por qué llega hasta 2? Llega hasta 2 porque el tamaño es 3. 01:39:04

Son la posición 0, la posición 1 y la posición 2. Así son los arrays. 01:39:07

Hablaremos más de ellos. 01:39:12

Entonces, fijaros, si nosotros aquí cogemos y definimos un array de strings, ponemos string, ese info y utilizamos de la clase string, fijaros, string, el método split, pues tiene un montón de métodos, aquí le podemos indicar qué carácter es el que lo diferencia. 01:39:13

Os explico esta instrucción, enlazando con lo que os contaba antes. Ese valor, de acuerdo a esta ejecución, si la repetimos, tiene 3 espacio 5 espacio 6. Fijaros que este espacio es el carácter que he puesto aquí en el split. 01:39:44

split, seguro que sabéis mucho más inglés que yo, significa dividir 01:40:09

en inglés, ¿no? Entonces, estamos diciéndole 01:40:13

que lo que tiene este valor, esta variable, nos la 01:40:16

separe en trocitos, considerando que 01:40:21

la expresión separadora es un espacio, con lo cual si metemos 01:40:23

información separada por espacios, nos lo va a separar en tres 01:40:29

bloques, uno que tendrá un 3, otro que tendrá un 5 y otro que tendrá 01:40:33

un 6 y que lo guarde en un array de strings fijaros en ese info que es un array de strings 01:40:37

si metemos un 3 un 5 y un 6 resultará que vamos a tener tres posiciones que se parece mucho a lo 01:40:45

que habíamos definido antes aquí os acordáis de las tres posiciones entonces fijaros si yo ahora 01:40:53

cojo y aquí en una primera línea muestro ese valor en una segunda línea muestro ese valor 01:41:00

en la posición 0, ese valor no, ese info 01:41:11

que es el que es el array en la posición 0, ese info 01:41:21

ahí está, ese info en la posición 01:41:26

1 y ese info en la posición 2 01:41:34

mira, si hacemos esta ejecución, dime el valor, metemos el 3 01:41:40

el 6 y el 9, y mirad 01:41:47

dime el valor, este texto, como he puesto 01:41:51

print se me ha quedado el cursor aquí, ¿veis? He metido el 4, 6 y 9 01:41:55

en lo que he metido yo por teclado. Esa información la he cargado en ese 01:41:59

valor. La variable de ese valor aquí la he mostrado 01:42:03

y me ha sacado el 4, 6 y 9. Antes de hacer eso 01:42:06

utilizando la información que tiene ese valor que es 4, 6 y 9 01:42:11

como vemos aquí, he llamado al método split diciéndole que 01:42:15

la expresión por la cual quiero hacer la división de esa 01:42:19

cadena de caracteres es un espacio 01:42:23

y como voy a necesitar guardarlo en diferentes variables 01:42:26

cojo y defino un array de strings 01:42:29

esta separación me ha generado 01:42:33

tres strings diferentes, el 4, el 6 y el 9 01:42:38

que son los tres strings que están separados por este espacio 01:42:40

y me lo ha cargado en este array, ese info 01:42:43

como tiene tres valores, resulta que 01:42:45

si muestro ese info posición 0 01:42:50

me enseña uno de los valores, el primero de ellos, el 4. 01:42:53

Ese info 1 me muestra el segundo de los valores, 01:42:57

que en este caso es un 6. Y ese info 2 me muestra el tercero 01:43:01

de los valores, que en este caso es un 9. ¿Lo veis? 01:43:05

Ese info 0, ¿qué es? ¿Qué tipo de datos es? 01:43:08

Ese info 0, fijaros, es un string. ¿Lo tengo 01:43:13

en el dato que a mí me interesa? Todavía no, porque me interesa tenerlo 01:43:17

en valores numéricos, ¿verdad? 01:43:20

Como hemos pasado antes en el ejercicio, 01:43:22

antes de utilizar el split, 01:43:25

los valores que tenían cadenas de caracteres strings 01:43:27

a números, pues con el integer parseInt, 01:43:33

¿os acordáis? 01:43:36

Entonces podemos decir aquí, 01:43:37

y valor1 es igual a integer.parseInt. 01:43:38

Y aquí, ¿qué tengo que poner? 01:43:46

Tengo que poner un string. 01:43:47

¿Me interesa ese valor? 01:43:48

Si pongo ese valor, me va a dar este dato. 01:43:50

¿Quién tiene el primero de los valores, un 4? 01:43:52

¿Ese info cero? 01:43:57

Sí. 01:44:02

Es una buena pregunta. 01:44:13

Me preguntan, lo digo para la grabación, 01:44:14

que si no es necesario definir el tamaño previo aquí. 01:44:17

Pues normalmente, cuando tú definas un array, 01:44:20

tienes que definir el tamaño previo. 01:44:23

Es obligatorio, porque si no, no sabe. 01:44:25

Cuando hace una reserva de memoria, no sabe cómo hacerla. 01:44:27

No sabe cuánto hacer. 01:44:31

¿Qué formas tenemos para definir el tamaño previo de Arrays? Pues mirad aquí, hay diferentes alternativas, una es utilizando esto, el new, con el new estar definiendo aquí el tamaño, otra posibilidad es inicializándolo, 01:44:32

Tú puedes poner igual, pones aquí, creo recordar que es entre llaves, pones aquí valores, en este caso valores numéricos porque el array es de enteros y como se encuentra aquí una serie de valores de inicialización, da un tamaño ya de 3 y a la posición 0 le da un 2, a la posición 1 le da un 4, a la posición 2 le da un 2. 01:44:48

En este caso, el tamaño lo está entendiendo gracias a la inicialización. En este caso, porque se lo decimos aquí explícitamente. En este caso, pues porque el método split se encarga de fijarse a ver cuánto tamaño hay y dentro de este método en la librería de Java, que desconozco cómo lo han programado, con toda seguridad estará haciendo el new necesario para que esto tenga, en este caso, tres posiciones. 01:45:07

Es decir, ¿es necesario definir en un array el tamaño? Siempre. 01:45:34

¿Alternativas que tenemos? Indicándoselo de forma explícita a través de inicialización o que durante el código se haga de alguna forma. 01:45:38

En este caso, en nuestro programa, nosotros no se lo tenemos que poner, pero este array habrá tenido un tamaño inicial antes de asignar los valores, seguro. 01:45:45

¿Dónde se habrá asignado? En el método de split. ¿El método de split lo estamos programando nosotros? No. 01:45:56

lo habrán hecho cuando hicieron ese programa en las librerías de java se entiende claro por qué 01:46:00

porque en este en el momento el split estoy voy a hacer suposiciones porque no veo el código pero 01:46:12

que entiendo yo que hará split pues explica ojera y mirará a ver cuántos strings en este caso hay 01:46:20

separados por un espacio si pusiéramos aquí una en lugar de un espacio el carácter separador aquí 01:46:27

tenemos que poner 4 a 6 a 9 pues que ahora mirará a ver cuántos hay antes de empezar a asignar 01:46:33

cogerá y dirá voy a hacer una reserva para lo que tenga que guardar ese info que en este caso 01:46:41

será tres estrés mira si yo cojo vamos a hacer vamos a hacer uno mira vamos vamos a hacer una 01:46:47

cosa vamos a pasarle dos valores para que veáis lo que pasa en lugar de tres vamos a poner que 01:46:55

imaginaos que la cadena que ponemos es 3 y 6 y coge y me da un fallo mira lo que ha pasado ha 01:46:59

cogido y ha cargado 3 y 6 ha hecho el split y aquí ese info 0 que tiene 3 se lo ha cargado 01:47:06

bueno ha mostrado ese info 0 y ese info 1 ha mostrado ese info 0 con el 3 ha mostrado ese 01:47:18

info 1 con el 1 y este me ha dado un error, el 2. ¿Por qué? Porque no ha hecho una reserva 01:47:25

suficientemente grande como para que haya tres posiciones en el array. Cuando intenta acceder a 01:47:30

la tercera posición del array, este split no reservó para una tercera posición. ¿Por qué? 01:47:37

Porque split se dio cuenta que solamente había dos datos y al intentar acceder a una tercera 01:47:42

posición del array, ese info 2, me ha dado un error aquí, que es, fijaros, el tipo de error, 01:47:46

excepción, hablaremos de las excepciones también, es índice del array 01:47:52

fuera del alcance, digamos. Y aquí nos 01:47:57

lleva un poquito más el detalle. Dice, el index2 está fuera del alcance para 01:48:01

la longitud de este array. Es decir, sí que está preocupándose de ver 01:48:04

qué tamaño tiene el método split para reservar suficiente 01:48:11

zona de memoria aquí en ese info. No, no, mira, 01:48:15

sí, vale, sí, sí, vamos a hacer una ejecución. Me preguntan que 01:48:37

bueno, con tres valores, está esto preparado para tres valores, hemos visto que si metemos 01:48:41

dos valores nos da un error, ¿qué pasaría si metemos cuatro? Pues 01:48:46

vamos a hacer una suposición y ahora lo ejecutamos. Yo creo que si metemos 01:48:49

cuatro, este split va a reservar en ese info un tamaño de cuatro. 01:48:54

Entonces va a meter el primer valor en ese info cero, el segundo en ese 01:48:59

info uno, el tercero en ese info dos, el cuarto valor lo va a meter en 01:49:02

ese info tres y como aquí no lo tenemos en código, ese info 01:49:06

3 tendrá ese cuarto valor pero no lo estaremos mostrando por pantalla entonces si ponemos aquí 01:49:10

por ejemplo 3 5 7 y 8 este caso no nos da error es info 3 lo ha cargado pero no lo hemos utilizado 01:49:15

y vamos a asegurarnos de que esto es así vamos a poner un sistema print el n de ese info 3 y 01:49:22

ahora hacemos coincidir el número de parámetros con el número de datos que vamos a meter les 01:49:29

ponemos 3 y efectivamente para él es info 3 ahora en el segundo de los tres nos muestra el 7 que es 01:49:34

este dato que hemos puesto bueno pues nada tenemos y 21 aquí de las cosas que os iba a contar os he 01:49:42

contado muchas de las que quería y bueno alguna todavía no pero bueno por el próximo día os sigo 01:49:54

contando esto más o menos venía a hacer un poco falta para la práctica así que estupendo el 01:50:00

siguiente día cuento dos o tres detalles de por aquí y ya hablamos del tema 3 que a partir de 01:50:06

mañana lo pongo abierto ya tenéis alguna alguna cosilla que me queréis comentar antes de cerrar 01:50:12

se dime pues mira bueno tiene la posibilidad a través de file a ver cómo era esto bueno mira 01:50:20

te voy a decir la forma más directa de irte al código fuente y con como es un solo fichero me 01:50:47

lo puedes pasar por ahí y luego otro día lo intentamos terminar de colación bueno por aquí 01:50:52

con sport pases que si exportas el proyecto entero te va a exportar todo a todos los ficheritos me lo 01:50:56

podrías enviar también el fichero que te da esta exportación como un zip y yo luego lo descomprimo 01:51:03

y me cojo el código fuente para enviar el código fuente directamente mira aquí os comentaba que 01:51:09

clip se trabaja con un espacio de trabajo estos días atrás en el cual se van colocando todos los 01:51:17

proyectos entonces si estás utilizando la máquina virtual que os pase yo abriendo un terminal o 01:51:24

abriendo por aquí en la carpeta personal que la debían pues aparece este este directorio 01:51:31

el eclipse workspace ese workspace si te vas a ese ese fichero a ese directorio pones aquí 01:51:38

un ls ves que están justo tres directorios que corresponden en principio a los tres proyectos 01:51:47

que tenemos a hola y hola 2 como lo haya llamado tu proyecto pues habrá un directorio en particular 01:51:54

vamos por aquí también y lo vemos en paralelo en la misma secuencia a través del terminal y 01:52:01

del proyecto entonces entrando en el proyecto en particular sobre el que quieras pasarme la 01:52:06

información, tiene dos carpetas, una que es bin y otra que es src. Entramos en los dos, lo vamos 01:52:12

haciendo en paralelo. En el bin, ahora voy para atrás, están los .class, están los bytecode que 01:52:19

va generando Eclipse. Esto no me lo envíes porque esto no es elegible para mí, podría ejecutarlo, 01:52:27

pero prefiero ver vuestro código por si me parece que hay alguna cosa que os vaya a comentar. Donde 01:52:31

está el código fuente, el que se puede ver es en source, en src. Y aquí tienen los ficheros .java, 01:52:36

donde está tu código. 01:52:45

Entonces, como en este primer ejercicio 01:52:47

solamente habrás trabajado en un fichero .java, 01:52:48

pues me pasas este ficherito y es suficiente. 01:52:51

En este caso tengo dos ficheritos .java, 01:52:56

pues porque el proyecto la este2 01:53:00

de cuando hemos ido haciendo pruebas, 01:53:01

pues tiene dos ficheros creados. 01:53:03

Hoy hemos estado trabajando todo el rato en hola2, 01:53:06

este no lo hemos usado, 01:53:08

pero por eso tiene allí dos ficheros java, 01:53:09

porque el proyecto en sí tiene dos ficheros. 01:53:12

Entonces me pasas el fichero java y ya está. 01:53:17

a partir de ese yo lo suba eclipse 01:53:19

lo veo el código y lanzó un par de ejecuciones y ya pues te comento si me parece alguna cosilla que comentarte y ya está 01:53:22

bueno pues nada aquí lo dejamos voy a parar la grabación 01:53:32

2024-10-28-Programacion - Contenido educativo

Del mismo autor…

Entregar un enlace (link,URL) en una tarea del Aula Virtual

informe sciri 2024

PAYASA CORALINA

Unidad 3 - LMM

El museo

Navidad 2025

Bici Manuel 2