2024-12-09-Programacion | Mediateca de EducaMadrid

vale ya estamos en marcha pues nada comentarme si tenéis alguna cosita como siempre antes de 00:00:00

arrancar alguna duda que tengáis que queréis aclarar a ver si podemos resolverla entre todos 00:00:07

nada en principio vale mañana empezamos un nuevo tema el tema 5 todavía todavía son conceptos bueno 00:00:11

no sé si se va haciendo duro por lo menos a los que estáis empezando a programar este año algunos 00:00:28

Ya os conozco del año pasado, entonces estos primeros temas supongo que los llevaréis razonablemente bien. 00:00:33

Los que estáis probando de nuevas, pues no sé si os estará costando más o menos. 00:00:39

El tema 5 todavía no introduce cosas muy nuevas. 00:00:43

Todavía estamos aterrizando en los conceptos de programación orientado a objetos y aplicados al lenguaje de programación Java. 00:00:48

Y como desde el día 1 ya estábamos utilizando las clases y los objetos, 00:00:56

entonces ahora estamos durante todos estos temas formalmente asentando esos conocimientos 00:01:02

entonces ya os digo que todavía el tema 5 pues seguimos un poco hablando de cosas con las que 00:01:08

venimos trabajando desde el día 1 bueno pues no vendrán seguramente para nada mal el repaso de 00:01:14

ello pero pero no tiene cosas nuevas no ya no sé si es el tema 6 o a partir del tema 7 ya dejamos 00:01:20

de trabajar sobre las cosas que todo programa Java 00:01:27

tiene, pues todos tienen clases, en todas hay estructuras de control 00:01:30

de bucle o de condición o de selección 00:01:33

y ya pues bueno, pues hablaremos de ficheros 00:01:36

pues unos programas tendrán ficheros y otros no 00:01:40

es una herramienta muy utilizada, siempre en todos los lenguajes de programación 00:01:42

leer y escribir en ficheros, pero no necesariamente 00:01:45

de hecho hemos hecho hasta ahora programas en los que no hemos escrito 00:01:48

en ninguno fichero, ni hemos leído de ficheros 00:01:51

bueno, pues conoceremos esa herramienta y aquello sí que será 00:01:53

digamos una cosa adicional nueva que veremos en ese tema 00:01:57

y no habremos hablado con anterioridad de ello 00:02:00

pero ya os digo, el tema que viene todavía 00:02:02

seguiremos profundizando en cosas de clases, programación orientada a objetos 00:02:04

conceptos, bueno, pues igual algunas cosas las repetiremos 00:02:08

de otras tutorías, pero bueno, no viene mal yo creo 00:02:11

mañana cerramos la 00:02:14

tarea del tema 4, la semana que viene 00:02:16

que ya es la última que tenemos antes de navidades 00:02:20

si no tenéis nada pendiente, bueno, pues podemos 00:02:23

dedicar para dejar totalmente cerrado este tema que tenemos ahora mismo abierto 00:02:26

hacer la tarea y alguna otra cosita 00:02:30

que nos surja y ya bueno, pues ya a partir de la semana 00:02:33

que viene ya os digo, ya luego tendremos un par de semanas en las cuales podréis descansar 00:02:38

un poco, por lo menos de mis charlas aquí en las tutorías 00:02:42

otra cosa es que si tenéis algún ratillo lo dedicáis a hacer algún programilla 00:02:45

bueno, dicho esto, en el guión que tengo yo aquí 00:02:49

que no sigue fielmente 00:02:54

justo los contenidos del tema, aunque más o menos 00:02:56

pues vamos hablando de lo mismo 00:02:58

para hablaros durante el tema 4 00:02:59

pues estuve contando unas cuantas 00:03:02

cosas la semana pasada 00:03:04

y bueno, mi intención es seguir contándoos 00:03:05

otras poquitas durante el día de hoy 00:03:08

así que vamos a ponernos manos a la obra 00:03:10

a ver, teníamos aquí un 00:03:12

proyecto que era tema 4, podemos 00:03:15

reutilizarlo para seguir trabajando con él 00:03:17

con dos clases 00:03:19

bueno, habíamos definido por aquí una clase persona 00:03:22

que tiene por ahí varias cosillas 00:03:34

Estuvimos hablando el otro día de la sobrecarga de métodos, si os acordáis, que era dar el mismo nombre a un método y podíamos diferenciarlos en función del número de parámetros que recibía. 00:03:35

Y de esta forma, cuando utilizábamos un método saludar u otro, el programa era capaz de entender si queríamos que ejecutara este código o este otro en función del número de parámetros y del tipo de los parámetros que recibía durante la llamada. 00:03:48

Supongo que por aquí tendremos llamadas, diferentes llamadas a saludar. Bueno, pues ya sé que se quedó eso ya perdido. Igual hoy volvemos a hablar otro ratito de todo eso. 00:04:05

Otra cosa de la que estuvimos hablando el otro día era, habíamos empezado a hablar de diferentes etiquetas que podemos poner a los métodos o a los parámetros. Y aquí tenemos tres de ellas. Creo que habíamos arrancado hablando de las etiquetas que tiene, por ejemplo, el método main, que también son válidas para otras. 00:04:17

Vamos a repasarlas. De esta, por lo menos, seguro que no habíamos hablado. 00:04:33

La etiqueta public tiene varias alternativas, que son excluyentes. 00:04:39

Podemos utilizar la etiqueta bien public, bien protective, bien privada, private, o no poner nada. 00:04:46

Es decir, sería el valor por defecto. 00:05:01

sería, bueno, justo en el método main no me lo permite, o sí, incluso si me compila el método main si no lo pongo, aunque el método main siempre suele ir con justo estas etiquetas, la de public, si no ponemos nada es equivalente a el tipo de etiqueta package, de paquete, mira cuando organizamos el código de un programa, os he enseñado en varias ocasiones como se guarda aquí en el sistema de archivos, 00:05:03

Eclipse en particular tiene una zona de trabajo 00:05:32

y a partir de esta zona de trabajo crea un directorio 00:05:39

para cada uno de los proyectos que estamos construyendo 00:05:42

si os fijáis estos proyectos, no sé si habremos borrado alguno 00:05:45

coinciden con los que tenemos aquí activos en Eclipse 00:05:48

cada vez que creamos un nuevo proyecto 00:05:51

construye un nuevo directorio 00:05:53

justo colgando el Workspace 00:05:57

justo en particular estamos trabajando sobre el proyecto 00:05:59

¿he dado a grabar? 00:06:03

Sí, está grabando. Justo ahora mismo estamos trabajando sobre el proyecto del tema 4 y os decía que tenemos la información distribuida del proyecto en dos carpetas. 00:06:05

la carpeta bin, que es donde están los puntos class con el base code compilado 00:06:19

de nuestras clases, este proyecto está compuesto de dos clases 00:06:23

la clase inicio java y personaje.java 00:06:26

con lo cual tenemos aquí dos ficheritos con código compilado 00:06:30

el base code de esas dos clases, y luego 00:06:34

el código source, por aquí, que estos ficheritos 00:06:38

son justo los que tenemos abiertos ahora mismo aquí en Eclipse, que si vamos de uno a otro 00:06:43

lo podemos ir viendo, pues justo está abriendo los ficheros que están colgando en la carpeta source. 00:06:47

Fijaros como aquí hemos dicho que este código se meta en un paquete que es el paquete de por defecto. 00:06:52

Resulta que es posible organizar, bueno, estos programitas que estamos haciendo son muy sencillos, 00:07:01

los metemos todos juntitos, digamos, en un mismo cajón, en un mismo paquete y ya está, 00:07:07

y tiramos para lo que estamos haciendo hasta ahora. 00:07:12

Pero suponed que estamos haciendo un proyecto grande, 00:07:15

imaginaos que es el proyecto de un banco, 00:07:17

y, bueno, pues a lo mejor el conjunto de ese proyecto 00:07:20

ya implica tener, yo qué sé qué decir, 00:07:24

por poner un número vamos a decir 80 ficheros.java. 00:07:26

Entonces, si del tirón ponemos los 80 ficheros.java 00:07:30

en un único directorio, a lo mejor es un poco caótico. 00:07:34

Entonces, ¿qué podemos hacer? 00:07:37

Pues mira, vamos a hacer una organización del código 00:07:38

y de los ficheros .java que soportan cada una de las funcionalidades, 00:07:41

vamos a identificar las funcionalidades. 00:07:46

Entonces podemos decir, pues el banco tiene una línea de trabajo, 00:07:49

una funcionalidad que tiene que ver con préstamos 00:07:53

y otra que tiene que ver con cuentas de ahorro 00:07:55

y otra que tiene que ver con lo que sea, 00:07:58

diferentes funciones que tenga la banca. 00:08:00

Si para con una de estas funciones necesitamos cinco .java, 00:08:04

cinco ficheros .java para poner todo su código, 00:08:07

estando todos juntos pues sería un poco un poco desorganizado digamos el intentar identificar en 00:08:09

qué ficheros tenemos código relativo a cada una de las funcionalidades entonces qué podemos hacer 00:08:15

pues podemos organizar en paquetes en bloques los ficheros punto java que dan cada una de esas 00:08:20

funciones es decir si decimos mira la parte de préstamos pues estos cinco ficheros vamos a 00:08:26

crear un paquete vamos a suponer que dentro un armario hacemos un cajoncito un apartado para 00:08:33

los préstamos y en ese paquete de préstamos 00:08:39

metemos los cinco ficheritos que tienen que ver 00:08:42

con préstamos. Entonces si cuando 00:08:45

tengamos que trabajar para hacer un mantenimiento 00:08:48

o meterle más funcionalidad a la parte 00:08:50

de préstamos, si lo tenemos todo así bien organizadito 00:08:54

cuando vayamos a trabajar sobre esto 00:08:57

nos iremos directamente a esos ficheros.java que están muy bien 00:08:59

organizados en esa sección de préstamos, en ese paquete 00:09:03

y de la misma forma podemos hacer con las cuentas 00:09:05

de ahorro y bueno, pues con otros servicios que pueda tener el banco 00:09:08

lo organizamos en paquetes. Y en cada uno de ellos metemos 00:09:12

los ficheros .java que tienen que ver con esa funcionalidad. ¿Cómo se organizaría 00:09:16

eso dentro del proyecto? Pues todo colgaría del 00:09:20

SRC y en el SRC, en Eclipse, tendríamos 00:09:24

un directorio por cada uno de los paquetes. 00:09:28

Entonces imaginaos que tuviéramos en Mecadir aquí, creamos un directorio 00:09:33

finanzas aquí tendríamos los ficheros punto java que están en el paquete por defecto que es el que 00:09:36

venimos utilizando en los ejemplos hasta ahora y todo lo que tuviera que ver con finanzas lo 00:09:45

meteríamos dentro de este directorio de finanzas podríamos tener otros directorios más y aquí 00:09:50

colgando también del src pues podríamos tener otro que fuera un directorio de cuentas corrientes 00:09:56

voy a borrar este finanzas aquí, ahí está borrado, entonces eso se organizaría aquí en el sistema de archivos 00:10:01

con esa estructura de carpetas y aquí pues también veríamos esa estructura de carpetas de la misma forma 00:10:17

y los ficheros .java los iríamos colocando en cada uno de esos paquetes 00:10:22

¿Cómo podemos hacer para que un código esté en un determinado paquete? 00:10:25

pues aquí en la cabecera podemos poner la etiqueta 00:10:34

package, vamos a hacerlo aquí para el inicio que es el que tiene el .me 00:10:38

vamos a hacerlo por ejemplo aquí para el de personas, no sé si me va a 00:10:44

crear Eclipse directamente el paquete, tenemos la posibilidad de crear 00:10:53

a ver, vamos a ver si lo creamos, vamos a crear 00:11:02

el paquete, un nuevo paquete aquí en el proyecto 00:11:07

new, fijaros aquí me da la opción de crear un nuevo paquete 00:11:10

veis, me ha creado aquí esta estructura, fijaros, colgando de source 00:11:14

aparte de estos dos, si nos vamos aquí, ponemos ls 00:11:24

y tenemos el directorio finanzas que me acaba de crear ahora 00:11:27

y si yo ahora cojo y creo aquí una nueva clase 00:11:31

vamos a llamarla clase finanzas 00:11:34

bueno, pues la he metido ahí y fijaros como lo que estaba yo intentando escribir 00:11:39

pero como no estaba en el paquete de finanzas, no me lo ponía 00:11:46

en la cabecera del fichero para identificar que se encuentra 00:11:49

en el paquete de finanzas, pues le ponemos aquí la etiqueta 00:11:52

esta package finanzas. Todo lo que tenga que ver 00:11:55

con código relacionado en Java con las finanzas 00:11:59

pues lo podemos poner en esta carpeta. 00:12:02

Esto las ventajas que tiene, ya os digo 00:12:05

si tenemos 00:12:07

muchos ficheros .java 00:12:10

de diferentes funcionalidades todos metidos aquí, igual nos resulta 00:12:13

más complicado localizar una actualización que tuviera 00:12:16

que ver con la funcionalidad de finanzas. Pero 00:12:20

si abrimos el proyecto, en un proyecto que sea muy grande, con 00:12:23

muchos paquetes y muchos ficheros, y sabemos que 00:12:25

tenemos que corregir una cosa relacionada con finanzas, pues convenirnos 00:12:28

a este paquete, si lo hemos estructurado todo bien, 00:12:31

en las dos o tres ficheros .java será donde tengamos 00:12:35

que tocar y no en otras zonas. 00:12:37

Otra de las ventajas que tiene esto, es que imaginaros que estamos 00:12:40

haciendo el organizar los proyectos por paquetes 00:12:43

Imaginaos que estamos haciendo un proyecto para un banco en particular, me da igual, el Santander digamos, y tiene todo su código aquí que da servicio a ese proyecto y de repente otro banco resulta que le interesa que le hagamos también un desarrollo. 00:12:46

no quiere el desarrollo completo de este primer banco pero sí que el paquete de finanzas le parece 00:13:06

que es muy interesante pues podemos coger todo el paquete de finanzas que lo tenemos muy bien 00:13:11

organizadito y metido aquí importar este paquete en el nuevo proyecto con lo cual toda esta parte 00:13:15

de código lo tenemos ya desarrollada y en principio incluso probada. Aquí tenemos la clase 00:13:22

finanzas que podemos poner, vamos a poner aquí un método public, public void, finanzas, public void, saluda, finanzas, vamos a poner, si este no es println, método simplemente que saque por pantalla algo, entonces si nos venimos aquí al inicio, fijaros el inicio está en el paquete por defecto, no está directamente metido en ningún directorio, 00:13:30

Si nosotros queremos construir aquí un objeto de la clase finanzas, ponemos finanzas, fin, igual a new, finanzas, el constructor, como os comentaba el otro día. 00:14:21

Y esto no me compila, esto de finanzas no entiendo, no sé yo lo que es. 00:14:38

Entonces, ¿qué tenemos que hacer? En cambio, si yo pongo aquí persona miper igual a new persona, 00:14:43

este persona no se me queja y se me compila. 00:14:55

¿Qué sucede? Que persona está en el mismo paquete que inicio, pero finanzas está en un paquete diferente que inicio. 00:14:58

¿Qué está intentando desde la clase inicio en el método main? ¿Dónde está intentando localizar el paquete, es decir, la clase finanzas para construir un objeto que se llame fin? 00:15:04

Pues lo está intentando localizar donde él se encuentra y como donde él se encuentra, que es en el paquete por defecto, no existe el fichero finanzas java, que es el que tiene el código de la clase finanzas, pues no me compila. 00:15:19

En cambio, persona, como si se encuentra en su mismo paquete, pues lo ha localizado y directamente me lo permite. 00:15:32

¿Qué tenemos que hacer si dentro de la estructura que hemos organizado por paquetes en mi programa 00:15:39

quiero tener acceso, en este caso, desde inicio que está en el paquete default a una clase que está en el paquete finanzas? 00:15:44

Pues necesito importarlo. 00:15:52

Entonces yo cojo y digo import finanzas aquí. 00:15:53

Vamos a decirle que nos ayude aquí para ponerlo. 00:16:07

aquí lo que me dice es, importa 00:16:09

del paquete 00:16:16

finanzas, la clase finanzas 00:16:18

es decir, desde la ruta 00:16:20

donde yo me encuentro 00:16:22

paquete finanzas, aquí lo tenéis 00:16:23

el paquete finanzas y dentro de ese paquete 00:16:28

metido en la clase 00:16:30

finanzas tenemos 00:16:36

metido en el 00:16:37

fichero finanzas.java tenemos la clase finanzas 00:16:40

entonces en el momento que ya se lo 00:16:42

identificamos aquí, decimos importa al proyecto 00:16:43

la clase finanzas que se encuentra 00:16:45

en el paquete finanzas pues ya coge y me funciona esto en realidad no es nada nuevo lo único que 00:16:47

estamos utilizando una clase de un paquete que hemos construido a nosotros pero ya en su caso 00:16:54

habíamos hecho escáner mi scan verdad en algunos ejercicios igual año escáner si está en punto in 00:17:00

y esto no me compila va porque no me compila va a escáner bueno pues porque no se encuentra 00:17:09

cargado dentro de mi proyecto. Entonces, ¿qué hacíamos aquí? 00:17:14

Le poníamos tal que aquí, decíamos import y fijaros 00:17:17

lo que me hace aquí. Impórtame del paquete 00:17:20

Java útil la clase 00:17:23

Scanner, que viene a ser el equivalente de importame 00:17:26

en nuestra clase, importame de finanzas 00:17:29

la clase finanzas. Un poquito lo mismo. 00:17:32

Es decir, ya lo estábamos haciendo en realidad, pero desde paquetes 00:17:35

que tenemos en las librerías de Java. 00:17:38

y luego es verdad que también se comentaba en algún momento que teníamos por ejemplo el método 00:17:40

system.out.println utilizamos este y decíamos oye este método no hemos importado nada y estamos 00:17:46

utilizando un método de algo bueno pues que está en el paquete system.out este paquete system.out 00:17:57

el método println donde está pues lo que sucede es que este este paquete está dentro de la librería 00:18:04

java lang y la librería java lang tiene funciones tan comunes en el uso de todos los programas de 00:18:12

java que para ahorrar ya que se entiende que son de uso muy común para estar ahorrando importarlas 00:18:19

automáticamente se importan en todos los proyectos entonces que tenemos que importar aquello que no 00:18:25

está en java lang y lo que no está en java lang pueden ser clases de paquetes no es propios o 00:18:31

clases de paquetes que se encuentran en la librería de java pero no en java lang en este 00:18:36

caso es java útil para escáner vale pues bueno contado esto de cómo podemos organizar nuestro 00:18:41

código en paquetes y un poco para qué nos puede servir tener estos paquetes nos facilita el 00:18:50

mantenimiento ya que tenemos más ubicado el código relacionado con ciertas funcionalidades y luego 00:18:57

hace que nuestro programa sea más portable si sólo queremos el paquete finanzas en un segundo 00:19:02

proyecto cogemos este directorio y sabemos que va auto contenido hay toda la información que 00:19:06

necesitamos para ese desarrollo pues regresamos un poco a esto que estábamos hablando del public 00:19:11

cuando nosotros estamos definiendo algo como public lo que estamos haciendo es que este 00:19:17

método al que está haciendo referencia este public pueda ser ejecutado desde cualquier sitio de todo 00:19:26

mi proyecto vamos a definir aquí un método mirad aquí public public saludar este método public 00:19:35

saludar puede ser ejecutado desde, vamos a ver, finanzas, mejor. Mirad, este public saludar finanzas puede ejecutarse 00:19:41

desde cualquier sitio en todo mi proyecto. Si yo, de hecho, yo me vengo aquí, ahora que tenemos un objeto de la clase 00:19:50

finanzas y digo fin objeto de la clase punto y llamo al método saludar si ejecuto me lo ejecuto 00:20:00

correctamente si yo esta etiqueta que tengo que definida como public la defino como private 00:20:14

lo que sucede es que estoy diciendo que este método solamente sea ejecutable desde otros 00:20:21

métodos de mi clase si yo tengo mirad como esto me deja 00:20:30

veis como ha dejado de compilar aquí porque por qué 00:20:35

la clase inicio lógicamente no es la clase finanzas el hecho de haber 00:20:40

definido este método como private es el ámbito de ejecución de este método es mi 00:20:44

clase con lo cual solamente podría llamar a saludar finanzas desde 00:20:50

cualquier otro sitio de mi propia clase y así yo comento aquí esto para que me 00:20:55

compile el proyecto y creo aquí otro método fijaros public 00:21:01

llamar saludar y aquí lo que hago es llamar este método digo que no devuelva 00:21:09

nada public voy llamar saludar fijaros como aquí a pesar de ser privado ya sí 00:21:26

que me compila me compila perfectamente porque porque la llamada la estoy 00:21:31

haciendo desde un método que pertenece a la clase de finanzas el hecho de que 00:21:34

este método sea privado, nos permite que llamadas desde su método sí le valgan, pero llamadas desde su clase sí me valgan, pero desde otras clases no. 00:21:38

Aquí si pongo fin, punto. Observad como ahora ya aquí al poner fin, punto, como ese método ya es privado, el id, si intento buscar saludar, ya no me lo ofrece. 00:21:50

¿Por qué? Porque es privado. Realmente desde este ámbito no está disponible el método saludar. El que sí que está disponible será el método llamar saludar. ¿Por qué? Porque el método llamar saludar, fijaros, lo he definido como público. 00:22:04

Entonces, si ahora llamo a llamar saludar, llamar saludar, sí que lo llama, ¿veis? Y llamar saludar está llamando a saludar finanzas, con lo cual el resultado es que me lo muestra por aquí por pantalla. 00:22:22

Podríamos pensar, ¿qué utilidad tiene el definir algo aquí privado? 00:22:37

Mirad, un ejemplo clásico que yo creo que es bastante ilustrativo. 00:22:43

Imaginaos que, vamos a la clase persona, tenemos aquí una edad, ¿verdad? 00:22:48

En principio se supone que es la edad que va a tener una persona. 00:23:01

Esta edad está definida como pública. 00:23:04

El concepto de público y privado para parámetros y para métodos es igual, es decir, el hecho de que este método, esta variable sea pública quiere decir que está accesible desde cualquier parte de todo el proyecto por ser pública. 00:23:12

Fijaros como aquí podemos poner persona miper igual a new persona, creo un objeto de la clase persona y pongo miper punto y edad y le digo que tenga 10 años. 00:23:25

se ha podido acceder a la edad de una persona esta edad justo aquí en persona está definida 00:23:42

como pública como podéis ver entonces está disponible en cualquier parte de todo el 00:23:50

proyecto desde cualquier paquete de todo el proyecto desde cualquier clase en todo el 00:23:55

proyecto si yo esta clase la defino como private privada esta clase no este parámetro este atributo 00:23:59

fijaros como ahora me deja de compilar porque me deja de compilar pues la misma jugada que hemos 00:24:07

tenido antes con saludar finanzas como ahora es privado el ámbito en el cual podemos modificar 00:24:12

la edad es única y exclusivamente desde la propia clase por ser privada antes que era pública 00:24:18

podríamos desde cualquier sitio que podemos decir y que utilidad tiene el hecho de que sea privado 00:24:24

pues mira una primera situación que podemos plantearnos es que imaginaos que esto es un 00:24:31

proyecto gigantesco y trabajan 60 personas y a ti te dan la responsabilidad de desarrollar 00:24:37

la clase persona entonces tú coges haces todo tu gesto a tu gestión de la clase persona y si 00:24:44

tú dejas y a lo mejor tu requisito es que las personas pueden tener una entre una edad entre 00:24:50

entre cero los recién nacidos hasta bueno por la persona más longeva vamos a poner que somos 00:24:57

generosos si llegamos hasta 150 años, ¿no? 00:25:04

Pero, oye, te dicen, mira, es impensable pensar que una persona 00:25:07

va a llegar a 300 años, es que eso no va a pasar, ¿no? 00:25:10

Entonces, no quiero que la edad pueda tener un valor mayor de 150 años. 00:25:13

Tú eres el responsable de la clase persona y casi estás un poco 00:25:22

comprometiéndote a que esta variable de edad nunca sea menor de cero, 00:25:25

porque no consideramos que sean personas pendientes de nacer 00:25:30

ni personas que tengan más de esta edad. 00:25:34

Si tú coges y lo dejas esto como público, 00:25:38

resulta que alguien ajeno a ti, 00:25:41

es decir, quien está desarrollando la clase inicio, 00:25:44

puede coger y decirte que una persona tiene 300 años 00:25:48

y durante la ejecución de tu programa 00:25:51

la edad de una persona resulta que está siendo 300. 00:25:52

Y eso, según los requisitos que te habían dicho a ti, 00:25:56

no era válido. 00:25:59

Entonces, ¿qué podemos hacer? 00:26:00

Pues podemos coger y decir, mira, yo voy a poner la edad aquí, privada, private, y así tengo el, ya que yo soy el que programo la clase persona, nadie más va a tocar este código, desde aquí nadie me va a poner una edad de 300 años, ¿por qué? Porque no se lo voy a permitir. 00:26:01

En cambio, como sí que necesito que desde diferentes partes del código se puedan ir asignando edades a personas, estamos dando de alta aquí personas y queremos asignar edades, pero queremos que estén controlados en ese rango de edad. 00:26:19

Entonces lo que puedo hacer es crear aquí un método que sea público, es decir, que tenga acceso desde todo el proyecto. Vamos a poner aquí asignar edad. Ahora después hablamos de estos métodos de asignar. 00:26:33

Vamos a decir, el otro día hablábamos que los métodos pueden recibir cierta información a través de parámetros, vamos a decir aquí que se reciba una edad int y e, vamos a llamarlo, esta variable va a ser una variable local al método asignar edad y se aplicará en el momento en el que hagamos una llamada a ese método. 00:26:50

Entonces tendremos la posibilidad aquí de coger y decir mi per, objeto de la clase persona, punto, aquí tengo accesible los métodos y los parámetros, quiero utilizar el método asignar edad y digo por ejemplo que quiero asignar la edad de 30 años. 00:27:25

¿Qué decíamos el otro día que sucede aquí? Voy a ponerme a ejecutar asignar edad, en particular de esta persona, pasándole como valor 30, con lo cual cuando vengo aquí a hacer la ejecución, en esta variable se carga la información que le estoy pasando en la llamada, con lo cual esta variable arrancará la ejecución del método asignar edad con el valor 30. 00:27:44

Y esta variable es una variable local al ámbito del método, con lo cual es local aquí a la apertura y cierre de llaves. 00:28:07

Justo el hecho de que todo acceso que vaya a hacer esta variable voy a obligar al resto del programa que lo haga a través de asignar edad, es lo que me va a permitir bloquear estos valores. 00:28:18

Entonces yo puedo coger y decir aquí, if, sí, y e, es decir, la edad que estás intentando asignar, que se lo has pasado aquí como parámetro, es menor que 0, aquí podría decir que y e sea igual a 0, con lo cual, si alguien aquí me está intentando cargar como edad una cosa que no tenía permitido en los requisitos de mi desarrollo de la clase persona, menos 30 años, resulta que esto se cargará, este menos 30 se cargará. 00:28:30

en y está allí al ser menor que cero lo estoy aplicando el valor cero 00:29:04

también puede decir el cif sí 00:29:10

y es mayor que 150 pues tampoco tampoco me gusta entonces que podría hacer pues podría 00:29:13

acoger y decir y es igual a 150 estoy bloqueando los valores y si no es ni esto ni es menor que 00:29:22

cero ni es mayor que 150 resultará que estará dentro del margen que me gusta con lo cual no 00:29:30

sobre escribo la variable y con ningún valor y aquí puedo coger y poner y edad igual allí de 00:29:35

esta forma he conseguido mediante el método público que está accesible desde cualquier 00:29:45

parte del programa proteger mi variable y edad para que el rango esté cubierto con 00:29:49

las posibilidades que me marcaba a mí el enunciado otra posibilidad habría sido imaginaos que ya 00:29:57

dependerá de en el enunciado en los requisitos que tengamos para el proyecto las condiciones 00:30:10

que tengamos a lo mejor podríamos poner mira vamos para mantener esto lo que vamos a hacer 00:30:17

base no va a ser bloquear el valor de la edad sino que si la edad no me gusta porque no es 00:30:21

un valor válido le devuelvo un mira la edad no ha sido asignada entonces fijaros podríamos decir 00:30:28

poner aquí un boolean por ejemplo es decir en lugar de no devolver nada también lo hablábamos 00:30:37

el otro día en la tutoría que mi método devuelva un boolean en el momento que tengo aquí un boolean 00:30:46

me obliga a poner un retorno por eso no me compila ya en el momento que ponga aquí que devuelve una 00:30:51

variable de cualquier tipo. Entonces aquí lo que podríamos decir es poner boolean b asignada, 00:30:56

suponer que la edad se asigna correctamente, inicializamos la variable asignada a que se 00:31:05

asigna de forma correcta y luego decir aquí y si la edad es menor que 0 o podemos poner y e es mayor 00:31:11

que 150 en cualquiera de los dos casos podríamos hacer que la edad no sea asignada es decir no 00:31:21

falsa la edad no se asigna y si resulta que ha sido correcta en ese caso podemos poner aquí 00:31:29

que sí que asigne la edad y luego hacer aquí un retorno así nada fijaros a todos los efectos aquí 00:31:37

lo que estamos haciendo es que solamente le estamos actualizando la edad en el caso de 00:31:53

que esté dentro del rango que me gusta si no está dentro del rango que me gusta no estoy modificando 00:31:57

la variable edad pero para que desde donde se llama tengan una idea de si se ha asignado la 00:32:03

edad que estaban proponiendo no bueno pues hemos añadido que el método sea capaz de volver una 00:32:09

información de tipo boolean que puede ser verdadera o falsa como he inicializado aquí a true si no 00:32:15

entro por aquí en el momento que lleguemos aquí esto se mantiene con la inicialización con lo 00:32:21

cual su valor será true y si resulta que el rango en la edad que intentaba aplicar no estaba dentro 00:32:27

del rango estaré modificando esta variable a falsa con lo cual el return de volver a falsa y esto que 00:32:32

devolvemos donde de dónde podemos sacar provecho aquí en la llamada y podemos poner asignar dos 00:32:40

y aquí podemos poner una edad que puede estar dentro del rango o fuera de él vamos a poner 00:32:51

en mil años no está dentro del rango y aquí podríamos justo en la zona donde estamos llamando 00:32:58

a ese método que es en la clase inicio en el método main podríamos definir una variable b 00:33:04

result que tenga el resultado esta variable b result se va a cargar con lo que devuelva este 00:33:13

método es decir se va a cargar con verdadero o si se actualiza aquí falso en qué momento en el 00:33:23

momento que termina el método porque es lo que estamos devolviendo es el valor que tenga aquí 00:33:30

asignada se cargará aquí en esta variable después de ejecutar el programa esta variable tendrá 00:33:34

verdadero o falso según se haya o no asignado la edad a la variable que tiene la persona y aquí 00:33:43

bueno pues dentro de el método main podríamos tener una referencia de cómo ha ido la ejecución 00:33:49

de la asignación de la edad 00:33:55

utilizando esta variable 00:33:57

boolean, entonces podemos decir 00:33:59

if si bresult 00:34:01

es igual a true 00:34:07

poner este bresult 00:34:09

es igual a true es equivalente a poner 00:34:13

si bresult 00:34:14

recordad que 00:34:17

if necesita algo que sea aquí 00:34:19

verdadero o falso, aquí decimos 00:34:20

si true 00:34:23

es igual a true 00:34:24

pues entonces devuelve true 00:34:26

pero como bresult da la casualidad 00:34:28

que que si es true ya es true directamente sería equivalente poner cualquiera de estas dos y si 00:34:30

ve result viene siendo falso pues false no es igual a true con lo cual se convertiría en false 00:34:37

que sería equivalente a la información que tendría en ese caso vea result entonces aquí por ejemplo 00:34:42

por ejemplo podemos poner System.out.println edad actualizada, correctamente, o lo que pongáis. 00:34:50

Else, si nos devuelve el false, decimos edad no actualizada. 00:35:10

Si ahora ejecuto este código, haciendo una llamada con 1000, fijaros como dice edad no actualizada. 00:35:24

porque porque este 1000 ha llegado por aquí inicialmente habíamos dicho por defecto que 00:35:33

fuera true pero como 1000 se pasa de 150 ha entrado por aquí no ha hecho el else con lo 00:35:40

cual no ha asignado la edad y sí que al venir por él por el if de asignada vale falso devuelve falso 00:35:47

que se carga en b result y este b result al no ser verdadero es el else y me dice edad no actualizada 00:35:56

si yo pongo aquí que tenga un añito pues me dice edad actualizada correctamente recapitulando un 00:36:04

momento que lo que hemos hecho pues fijaros hemos puesto esta variable este parámetro de form privado 00:36:17

con lo cual ya no está accesible desde todo el proyecto solamente está accesible desde la propia 00:36:24

clase, fijaros si está accesible este parámetro en la propia clase 00:36:28

que lo estamos actualizando desde un método que pertenece a la 00:36:33

clase, es decir, aquí sí que lo está, pero por ser privado ya solamente 00:36:37

está en la propia clase. Y nos ha permitido, entre otras 00:36:40

cosas, pues el tener un control del rango 00:36:45

que queremos que tenga de edad. Además, entre uno y otro 00:36:48

aquí, al devolver un void, otra de las 00:36:53

cosas que tenemos en los métodos de las etiquetas que vamos a ir repasando, este asignar edad en principio no devuelve nada, no devuelve nada para que tenga una gestión de cómo ha ido la cosa desde donde lo hemos llamado, asigna o no asigna la edad a iedad, siempre asigna la edad a iedad pero si era menor de 0 en este caso aplicaba un 0, si era mayor de 150 aplicaba el techo de edad que podíamos tener 150, en este caso bueno pues teníamos un requisito diferente a la hora de gestionar la edad y era 00:36:57

que solo se actualizase en caso de que estuviera dentro del rango. 00:37:29

Y además nos estábamos obligando a que este método informase de cómo había ido su ejecución 00:37:33

a través de un boolean en particular que nos devolvía true si la actualización había sido correcta 00:37:40

y false si no lo había sido. 00:37:46

¿Y cómo lo hemos capturado aquí? 00:37:48

Pues en la llamada hacia la izquierda del igual nos devuelve lo que hayamos puesto en el return. 00:37:51

Entonces, BRSUL se ha cargado con verdadero o falso y aquí hemos hecho una gestión que es la que nos ha parecido oportuno. Podría haber sido otra. Podría haber sido el programa. Si resulta que se actualiza la edad, tenemos que dejar un log en un fichero diciendo edad actualizada. 00:37:57

Pues en lugar de escribir por pantalla, si el denunciado nos dijese eso, tendríamos que abrir un fichero y escribir un registro. Y si no, en una base de datos de errores, dejar un log. Pues a lo mejor tendríamos que insertar en una base de datos en el else, en lugar de este system of println, pues poner el código equivalente al acceso a la base de datos, crear un registro y almacenar que se ha producido ese error en el log. 00:38:13

Ya lo que nos pide el programa, cuando la cosa va bien o cuando va mal. La cosa es que aquí tenemos el resultado de cómo ha ido la actualización de la variable. 00:38:35

Bien, pues como siempre vamos dando diferentes vueltas a cada cosa, pero el objetivo inicial es repasar los posibles valores que tenemos para la etiqueta public. 00:38:47

Entonces tenemos que cuando es público está accesible desde todo el proyecto. Cuando es privado, hemos visto que está accesible solamente desde la propia clase. Y nos queda por hablar de dos, la protective y la de no poner nada. 00:39:01

Bueno, que la llaman package o la llaman también friendly, amigable. 00:39:18

Cuando no ponemos nada en un método o en un parámetro, el ámbito del acceso es en el paquete. 00:39:27

Es decir, podemos acceder a esta variable desde la propia clase siempre y desde cualquier clase que pertenezca a tu paquete. 00:39:41

si acudimos y la edad la ponemos como y edad sin poner nada aquí es equivalente es él 00:39:51

esa etiqueta se considera friendly de si ponemos aquí mi per punto y edad fijaros que ya lo tengo 00:40:02

disponible donde lo tengo disponible lo tengo disponible en la clase inicio porque porque 00:40:14

persona e inicio están en el mismo paquete y edad ahora está aquí y ya si yo intento acceder a edad 00:40:21

así que la tengo disponible volvemos un momento a ponerlo privado y fijaros cómo ya no es no vale 00:40:33

para cualquier clase de todo el paquete sino que sería por privado en la misma clase y ya me deja 00:40:48

de compilar, lo quito, se convierte en su ámbito de paquete y puedo acceder desde cualquier clase 00:40:53

que esté en su paquete pero no desde otros paquetes, fijaros finanzas que está en un paquete 00:41:03

diferente de inicio, si definimos aquí una variable, vamos a ver si nos funciona, int y fin, vamos a llamarlo 00:41:07

vamos a suponer que necesitamos esta variable, si le ponemos private y nos venimos a inicio, recordad 00:41:18

que inicio está en el paquete de por defecto y finanzas está en el paquete finanzas como tengo 00:41:26

aquí el objeto fin si yo ahora pongo fin punto hemos definido y fin privada con lo cual solamente 00:41:33

debe estar disponible dentro de su propia clase entonces fijaros como no me ofrece esta variable 00:41:42

porque la hemos definido como privada si yo cojo y defino esta public estaría disponible en todo 00:41:51

el proyecto si yo ahora como pongo aquí y fin fijaros como ya me la ofrece porque porque es 00:41:58

pública accesible en todo el proyecto y si yo la dejo sin nada en principio su ámbito de alcance 00:42:05

del paquete fijaros como ya no la tengo disponible en la clase inicio el paquete que está en el 00:42:14

paquete por defecto ya que y fin le hemos definido sin ninguna etiqueta con lo cual está disponible 00:42:24

en su paquete no la tenemos aquí cosa muy diferente a lo que nos pasa con y edad que 00:42:34

edad fijaros como si la tengo disponible a pesar de no tener ningún identificador aquí la tengo 00:42:40

disponible en inicio ya que inicio y personas están en el mismo paquete si no ponemos nada 00:42:49

disponible en el paquete si ponemos privada solamente en su clase si ponemos protective 00:42:58

si ponemos pública en todo el proyecto y si ponemos protective bueno pues hay un hay un 00:43:02

concepto nuevo que tenemos que repasar aunque lo veremos luego en más detalle pero pero bueno lo 00:43:12

voy a enseñar aunque luego ya lo veremos otro día para ilustrar un poco la etiqueta en public 00:43:20

fijaros si vamos a crear una nueva clase aquí en finanzas a la clase no vamos a crear la mejor 00:43:28

aquí, en la de por defecto 00:43:48

yo creo 00:43:52

vamos a crear en finanzas 00:43:52

y la voy a llamar clase hija 00:44:04

ahora entenderéis por qué 00:44:15

y aquí voy a crear otra clase 00:44:16

y lo cuento 00:44:35

paso a paso 00:44:38

aquí voy a llamar una que sea clase 1, no tiene mucho 00:44:38

sentido estos nombres pero 00:44:42

es para que lo veáis, mirad 00:44:43

si yo cojo y pongo aquí 00:44:48

en la clase 1, defino un parámetro 00:44:49

int y valor 1 00:44:51

esta clase estaría dando el servicio que fuese 00:44:54

no lo hemos definido de ninguna de las formas, simplemente es para 00:44:58

contaros lo que quiero, voy a dar un nombre un poquito 00:45:03

a la clase un poquito más entendible 00:45:11

tenemos la clase persona y 00:45:14

un tipo de persona que tenemos son por ejemplo los alumnos 00:45:19

voy a crear la clase alumno, entonces los alumnos pueden tener una nota 00:45:23

int, vaya se me ha ido a la clase finanzas 00:45:37

a ver si arrastrándolo así al paquete por defecto, lo ha arrastrado a la clase paquete por defecto, tenemos en la clase paquete por defecto la clase alumno y el alumno tiene un identificador, un entero. 00:45:40

En Java tenemos una organización jerárquica de clases. Esto quiere decir que tenemos la posibilidad de, bueno, es una de las características de la programación orientada a objetos, que es la herencia. 00:46:07

hablaremos de ella en otro no sé si en el tema siguiente o más adelante pero lo introduzco un 00:46:22

poquito para contaros esto entonces la herencia lo que nos permite es definir clases a un nivel 00:46:30

de jerarquía superior vamos a poner la clase persona y decir que una por debajo colgando 00:46:36

digamos de la persona podemos decir que existe la clase alumno y por ejemplo la clase profesor 00:46:47

ambos dos son personas, es la característica que tienen. 00:46:53

Entonces, en la clase persona podríamos definir una serie de atributos, 00:46:57

por ejemplo, int y edad, y esta edad es común tanto al alumno como al profesor. 00:47:02

Si nosotros queremos que los alumnos tengan edad y que los profesores tengan edad, 00:47:08

podríamos definir en cada una de ellas un iedad, 00:47:12

con lo cual podríamos acceder a la edad del alumno y en el profesor un int y edad también, 00:47:16

y por ejemplo vamos a suponer que las personas pueden saludar public void saludar y los alumnos 00:47:22

efectivamente también pueden saludar y los profesores también pueden saludar claro tanto 00:47:32

los alumnos como los profesores tienen una edad y son capaces de saludar dar porque en realidad 00:47:45

bueno pues son personas ambos dos luego el profesor pues tendrá el mejor en habrá dado 00:47:50

un número de cuenta 00:47:57

y NUM cuenta 00:47:59

y a lo mejor el alumno 00:48:01

tristemente no cobra aquí por estudiar 00:48:02

y no tiene un número de cuenta. 00:48:05

En cambio el alumno sí que tiene 00:48:07

INT y 00:48:08

NUM matrícula. 00:48:09

Alumnos y profesores 00:48:17

por una característica que suelen ser 00:48:18

de las personas, tienen una edad. 00:48:21

Alumnos y profesores 00:48:23

por el hecho de ser 00:48:24

alguna característica que tienen por ser personas 00:48:26

son capaces de saludar y los alumnos tienen un número de matrícula 00:48:28

y los profesores tienen un número de cuenta, los alumnos no tienen 00:48:33

un número de cuenta, los profesores no tienen un número de matrícula. 00:48:37

Estas dos características que son comunes podemos coger y no definirlas 00:48:41

aquí inicialmente y aún así estar disponibles en el alumno y el profesor 00:48:46

si las pueden recuperar de forma heredada desde la clase persona. 00:48:50

Y en Java, para hacer eso, lo que se pone aquí es la etiqueta Stents. Les decimos que un alumno hereda todas las características que tenga una persona. Con lo cual, sin definirla en la clase alumno, resulta que está teniendo una edad y la posibilidad de saludar según se haya definido en el método de la clase persona. 00:48:55

Y si de la misma forma queremos que un profesor tenga esas posibilidades, cogemos y ponemos aquí Stents, Persona, entonces ambos dos, tanto el alumno como el profesor, tienen estas características de forma heredada desde la persona, es decir, somos capaces de asignarles una edad y de saludar según se haya puesto en la clase Persona, en los alumnos y los profesores. 00:49:18

Y luego aparte, los alumnos tienen sus propios parámetros y sus propios métodos que pudiéramos poner aquí. Un alumno le podemos asignar un número de matrícula y un profesor su número de cuenta. 00:49:44

Entonces si nosotros ponemos aquí extends persona, fijaros que esto es un alumno, nosotros podemos venir aquí, es una clase alumno, podemos instanciar aquí un objeto de la clase alumno, como siempre, ¿verdad? Con el new, el constructor, y ahora podemos poner aquí mi alum, punto, y fijaros como me ofrece aquí la edad, ¿por qué me ofrece la edad? 00:49:54

porque el alumno, aunque no tiene aquí definida una edad, 00:50:37

estamos diciendo que hereda de persona. 00:50:41

Y persona, hemos cogido y le hemos dicho que tiene aquí una edad, 00:50:43

como podéis ver. 00:50:47

Entonces, tiene disponible, gracias a la herencia, 00:50:48

la posibilidad de asignarle una edad. 00:50:50

A ver, entonces, si cogemos y a la edad que tiene la clase persona 00:51:14

le decimos que sea private, 00:51:20

cuando definimos algo privado, que hemos dicho que solo estaba disponible 00:51:28

en su clase. Entonces, si yo ahora pongo aquí 00:51:31

mi alumno y edad, esta edad 00:51:34

a pesar de que el alumno 00:51:39

hereda a través del Stance las características de la clase 00:51:42

persona, como hemos dicho que la edad es privada, solamente es modificable 00:51:49

por objetos de la clase persona. 00:51:53

Y por ese motivo, aquí ya coge y no me compila. 00:51:56

pero tampoco me va a compilar, yo creo que si le pongo 00:52:00

protective, que es lo que iba a decir 00:52:09

protective, tampoco me va a dejar 00:52:10

vale 00:52:12

así con protective ya sí, con protective 00:52:14

me deja porque 00:52:17

este valor ya está 00:52:18

disponible, tanto 00:52:21

está disponible para aquellos 00:52:23

objetos, para 00:52:27

aquella información que 00:52:28

está heredada, es lo que añade 00:52:30

el privado 00:52:32

el package al 00:52:34

A ver qué os digo. El protective lo que añade respecto al de paquete, las variables paquete están disponibles desde cualquier objeto que esté definido en el mismo paquete, desde cualquier clase que esté definida en el mismo paquete. 00:52:36

Y en cambio las que están protective están disponibles en el mismo paquete y para aquellas clases que heredan de una que esté en el mismo paquete. 00:52:55

Mirad, aquí la clase alumno, bueno, en realidad alumno y persona están en el mismo, con lo cual también le vale el package. 00:53:16

Vamos a hacer que la clase hija herede de la clase persona. 00:53:24

Stance, create, import, no me deja importar por estar en la clase persona, por estar en el paquete por defecto. 00:53:31

Mirad, la tabla como queda entonces es de la siguiente forma. 00:54:03

Si tenemos public, está accesible desde cualquier parte del proyecto. 00:54:06

Si está el otro extremo respecto a public, es private. 00:54:22

Está accesible solo desde la propia clase. 00:54:32

Luego tenemos no poner nada, que sería equivalente a la etiqueta package. 00:54:42

también le llaman friendly, en ese caso estaría disponible desde cualquier sitio en su propio paquete. 00:54:54

Y luego está la protective, que este sería igual que la de por defecto, sería la de por defecto, 00:55:17

efecto es decir desde cualquier sitio de su propio paquete más desde clases heredadas 00:55:29

para que sea esta situación si está en el mismo paquete que en realidad este ejemplo que estábamos 00:55:40

poniendo estaba en el mismo paquete alumno y persona estaría con protective en el mismo 00:55:47

paquete y para desde clases heredadas necesitaríamos que la herencia fuera desde una clase a otra que 00:55:54

estuviera en otro paquete tallesta en realidad son como muy comunes típicamente las clases heredadas 00:56:00

van a estar dentro del mismo paquete porque van a ser típicamente van a ser de funcionalidades 00:56:07

comunes y como los paquetes los solemos crear por funcionalidades van a estar el mismo paquete 00:56:13

entonces la de por defecto y la la y la protective son como muy parecidas y las que marcan más 00:56:18

diferencias son la privada y la pública se entiende se vale pues nada genial 00:56:24

hablando de paquetes y librerías ya lo hemos repasado un poquito lo tengo por aquí marcado 00:56:43

para contarlo los modificadores estos de public protect is el friendly o para casi el private 00:56:49

método main más cosas que tiene el método main static ya hemos hablado varias veces de ella 00:56:55

cuando definimos algo estatis bien sea un método bien sea un parámetro resulta que se convierte en 00:57:03

un método propio de toda la clase y para acceder a él no es necesario instancia instancia objetos 00:57:10

lo habíamos visto por ejemplo con más más punto apps de bueno el valor absoluto de un valor pues 00:57:19

accedemos directamente a un método de la clase math poniendo el nombre de la clase sin necesidad 00:57:28

de haber creado un objeto de esa clase típicamente desde un método estático si yo pongo aquí yo creo 00:57:34

aquí un valor que sea y valor si yo pongo aquí y valor igual a 5 ya os he comentado pues no me 00:57:49

compila. ¿Por qué no me compila? Porque en realidad, si yo instancio 00:58:00

diferentes objetos de la clase inicio, cada uno de ellos tendrá 00:58:04

en zona RAM su espacio diferente. Entonces, este iValor 00:58:08

me diría, sí, muy bien, quieres asignar iValor, pero 00:58:12

¿a dónde? ¿a cuál de ellos? De todos los posibles objetos que podríamos tener. 00:58:15

En cambio, si yo esto lo defino como static, como ya es único 00:58:21

para toda la clase y lo estoy ejecutando desde un método que es único 00:58:24

para toda la clase ya no hay lugar a dudas dice oye pues se debe referir a la única posición de 00:58:28

memoria que tengo para la variable y valor dentro de la clase para todos los objetos entonces aquí 00:58:33

lo tendría fijaros aquí en finanzas si definimos por ejemplo y fin o vamos a definir static 00:58:39

int y valor también, vamos a llamarlo 00:58:48

por ejemplo, si tuviéramos 00:58:53

como parámetro de clase un entero llamado y valor 00:58:55

y acordamos definirlo como estático 00:59:00

si nosotros venimos aquí, fijaros, podríamos acceder directamente 00:59:03

a ese valor que es estático con el nombre de la clase 00:59:08

aquí finanzas, punto, bueno me pide que le identifique el paquete 00:59:11

también en el paquete finanzas clase finanzas punto y valor porque no me deja acceder y valor 00:59:37

si lo he definido como estático a ver que vea por aquí no entiendo a ver bueno no me está no me lo 00:59:49

está ofreciendo precisamente por algo que hemos estado hablando antes fijaros este no le he puesto 01:00:19

ningún identificador ni de privado ni público ni nada con lo cual tiene la etiqueta friendly la 01:00:25

etiqueta friendly corresponde a su propio paquete y resulta que inicio está en un paquete y finanzas 01:00:32

está en otro justo estoy estaba sufriendo algo de lo que os estaba contando antes entonces para 01:00:39

poder acceder desde diferentes clases este y valor tendrá que ser public y ahora ya lo tengo 01:00:44

disponible ahora ya se me deja tener disponible y a lo que iba es que ha cedido a finanzas se ha 01:00:58

accedido a un valor que es estático sin necesidad de utilizar un objeto de la clase finanzas como 01:01:09

era este si quito esto también me va también me da como lo tengo importado aquí también me da 01:01:14

digo de la clase finanzas en sí antes distanciar incluso un objeto ya tengo disponible la variable 01:01:20

y valor porque porque es estática que es un poco lo mismo que como digo hacemos aquí con el math 01:01:27

cualquiera de todos estos métodos 01:01:34

o cualquiera de estos, el tau 01:01:37

debe ser un valor 01:01:39

vamos a ver que vale 01:01:41

println, vamos a mostrarlo 01:01:46

por pantalla, no sé que será 01:01:50

el tau este de matemáticas 01:01:57

vamos a ver 01:01:58

a lo que voy, tenemos disponible 01:01:59

este parámetro de la clase 01:02:03

matemáticas porque en la clase matemáticas 01:02:05

estará definido como estático 01:02:07

tau vale eso 01:02:09

parece que es el doble de pi 01:02:11

628, 31 01:02:15

doble más cosas que tenemos aquí en el método main pues tenemos el void voy también hemos 01:02:17

hablado de ello todo método exceptuando los constructores que no devuelven nada pero no 01:02:29

se indica haremos un constructor otra vez que hablábamos el otro día tienen que avisar de 01:02:34

si devuelven algo no devuelve nada puede ser que no devuelva nada aquí persona en este habíamos 01:02:40

dicho que no devolviera nada, no tenía un return, como no devolvía nada, tenía el void 01:02:49

y cuando lo hemos llamado por aquí, no hemos hecho ninguna gestión con 01:02:52

o no sé si lo hemos terminado de llamar, no hemos hecho ninguna gestión con la información que 01:02:56

devolvía porque de hecho no devolvía nada. O puede ser que devuelva 01:03:00

un tipo de datos, bien primitivo o bien referenciado. Puede devolver un 01:03:04

entero, un boolean, un string, lo que corresponda. 01:03:08

Si devuelve algo, acordaros que dentro del 01:03:13

método, este por ejemplo devuelve 01:03:16

un boolean, tendremos que poner un return 01:03:18

porque en el momento que devuelve algo 01:03:20

si no obtengo un return ya no compila 01:03:22

y lo que debe devolver es algo del mismo 01:03:24

tipo que tiene aquí 01:03:26

identificado en la cabecera, en este caso es un boolean 01:03:28

y esto lo devuelve 01:03:31

trae la ejecución 01:03:32

hacia la izquierda en la llamada 01:03:34

y me lo carga aquí en la variable 01:03:36

para que luego aquí desde el sitio de la llamada 01:03:41

pueda hacer la gestión que corresponda 01:03:44

coordinando lo que devuelve y lo que 01:03:45

esperamos que devuelva con lo que haya devuelto 01:03:47

Luego aquí tenemos el nombre del main y por aquí tenemos la posibilidad de pasarle parámetros para su ejecución. 01:03:54

Dentro de pasarle parámetros, el main es así, porque como es estrictamente así, ya que es el punto de entrada al programa, 01:04:01

pero aquí el otro día hablábamos de diferentes alternativas, fijaros, a la hora de pasarle parámetros. 01:04:09

El hecho de tener métodos con el mismo nombre es la característica de la programación orientada a objetos de sobrecarga, 01:04:16

En este caso es sobrecarga de métodos, pero para diferenciar y que en la llamada se ejecute un método u otro, diferenciamos uno u otro en función del número de parámetros y el tipo de los parámetros que reciba. 01:04:24

Aquí estuvimos haciendo sobrecarga del método saludar. 01:04:38

Y en el main habíamos dicho que recibe una serie de parámetros que justo se cargan en el inicio del programa a través de la llamada del intérprete de Java, cuando le ponemos el Java nombre del programa y le podemos pasar una serie de strings que separados por espacios se van cargando en este array para que luego podamos manejarlo. 01:04:41

Y desde Eclipse, recordad que habíamos hablado que lo teníamos, a ver si lo vemos, el otro día, era aquí, coverage configuration, a ver, sí, aquí, de hecho, aquí tenemos del ejemplo del otro día que decíamos que en el inicio de la ejecución los argumentos de inicio del main cargue, bueno, por dos palabras, hola, con un espacio aquí dos, habíamos puesto. 01:05:07

Y esto se cargaba, como os decía, como un array en el array de strings ARS, con lo cual si ponemos aquí system.out.println ARS0 y ARS1, hacemos una ejecución y fijaros como aquí nos sale el hola y adiós que corresponden a estos dos datos que tenemos puestos aquí. 01:05:36

Y bueno, pues esto es entendiendo un poquito en qué consiste el main y realmente todas estas funciones que son extrapolables a otros métodos por ahí. 01:06:07

Más métodos interesantes y un poquito diferentes, y hablando de cosas de métodos, en el siguiente tema volvemos a hablar de métodos, igual repasamos todo esto de nuevo. 01:06:24

Los métodos por convenio suelen tener nombre en singular, primera letra en singular, perdón, en minúsculas. Si el nombre del método tiene varias palabras, pues minúsculas y luego la siguiente palabra, saludar mucho, pues la segunda palabra si quisiéramos ponerlo, pues la ponemos en mayúsculas, si tiene varias palabras. 01:06:34

Y si tuviera otra palabra adicional, pues volveríamos a poner la primera letra en mayúsculas. 01:07:01

Más cosas de los métodos que contaros. 01:07:10

Vale, tenemos, decimos que los métodos siempre tenemos que indicar que devuelven, excepto los métodos constructores. 01:07:15

Recordad, los métodos constructores son los que llamamos cuando hacemos el new. 01:07:23

Entonces, en estos métodos se definen como públicos. 01:07:28

Persona justo no tiene ninguno, a ver. 01:07:34

aquí tenemos métodos constructores, son los que se llamamos con los news, no devuelven nada pero no se indica, ¿por qué? pues bueno, así lo definieron, esto en realidad sería como si tuviera un void, 01:07:37

pero si tiene un void no se considera ya el método constructor, sino que no hay que poner nada, y bueno, así que se va un poco de la regla de que los métodos empiezan con minúsculas, 01:07:52

porque como se tienen que llamar obligatoriamente igual que la clase y la clase nos obliga también la norma que la llamamos con letra mayúscula, pues los constructores tienen que ser con letra mayúscula. 01:08:04

Otros métodos que también se suelen utilizar y van un poco en relación a lo que os comentaba antes de definir, por ejemplo, los métodos private y que se pueda acceder a ellos solamente desde la clase, 01:08:19

de tal forma que protegemos los posibles valores que pueda terminar teniendo la edad. 01:08:31

Fijaros, en el momento que he puesto ya este y edad como privado, 01:08:36

me ha dejado compilar ya por aquí en un acceso que tenía directamente a la variable, 01:08:42

pues de esta forma nos estamos obligando a que los accesos se hagan a través de métodos públicos 01:08:47

que tenga la clase y en estos métodos públicos nos permite tener un determinado control, 01:08:53

Lo que os he contado antes. Pues estos métodos que están pensados no para hacer funcionalidades propias de la persona, como pueda ser saludar o si fuera un alumno hacer examen, estos cuya finalidad es gestionar el acceso a variables, a parámetros de clase, se los suelen llamar métodos de establecimiento o de recuperación o en inglés getter o setters. 01:08:59

getter o setter. Entonces estos getter o setter 01:09:25

lo que hacen es devolver el nombre 01:09:31

y si es para este sería devolver el nombre 01:09:35

el getter y el setter sería asignarlo. Y bueno, entre medias 01:09:39

puedes poner cierto código para controlar los posibles valores que tenga. 01:09:43

Entonces estos métodos getter o setter, como son 01:09:48

muy típicos, los ides ya tienen por aquí una función 01:09:50

que nos permite crearlos de forma bastante automática. 01:09:55

Vamos a intentar localizarlo. 01:09:58

Fijaros aquí en la opción Source. 01:10:00

De Clise tenemos Generate, Getter y Setter. 01:10:04

Si lo pulsamos, fijaros cómo nos localiza 01:10:08

las variables de clase que tenemos, 01:10:12

ese nombre y edad e iValor. 01:10:14

Y dice, selecciona para cuál quieres crear. 01:10:17

setters, getters 01:10:19

o 01:10:21

bueno, para 01:10:23

generarlos, entonces vamos a por ejemplo a generar 01:10:25

getter y setter de IEDAD 01:10:28

no vamos a marcar los otros dos, podríamos marcar todos 01:10:30

pulsamos 01:10:34

y por aquí abajo 01:10:35

o por aquí en medio 01:10:37

o no sé dónde 01:10:39

fijaros aquí como me ha creado un getter 01:10:40

y un setter, voy a subirlos arriba 01:10:44

para tenerlos localizados 01:10:46

aquí arribita, los he cortado y los he pegado 01:10:47

en realidad el programa 01:10:50

lo único que hace es, pues el getter 01:10:53

que lo que va a hacer va a ser devolverme la información de iedad 01:10:56

que en principio la hemos definido como privada para que no haya 01:11:00

acceso directamente a la variable 01:11:02

lo único que hace a la hora de generarlo de forma automática es devolver 01:11:04

precisamente ese valor y como iedad es 01:11:08

un parámetro de tipo entero 01:11:11

pues lo que hace es el método de devolver un entero 01:11:14

y en el caso de asignar el setter, no necesitamos que devuelva nada, 01:11:17

pero lo que queremos es asignar un valor a un parámetro de la clase, 01:11:24

con lo cual el valor que vamos a asignar lo recibe como parámetro 01:11:29

y se lo asigna la variable de clase. 01:11:32

Fijaros que este setter es muy parecido a lo que hemos hecho aquí antes, 01:11:36

recibir el valor y terminar asignándoselo a la variable aquí. 01:11:41

Lo único que bueno, aquí nosotros hemos añadido cierto código porque nosotros sí sabíamos lo que queríamos que pasara con la edad, Eclipse inicialmente no lo sabe, entonces este setter ahora podríamos nosotros actualizarlo, más allá de que no devuelva nada, podríamos actualizarlo para que asignase la edad en función de estos criterios. 01:11:49

Este asignar edad podría ser ese setter. La variable aquí se ha llamado iedad. Este método sería este otro que hemos puesto nosotros aquí, asignar edad, que habíamos hecho en realidad un setter, no se llamaba con el set, pero era lo que estábamos haciendo. Cierta lógica para asignar una información. 01:12:10

fijaros que aquí esta variable se llamaba y era una variable local a nuestro método 01:12:45

y esta edad si la marco fijaros como se me asigna justo a la edad que tenemos definida como parámetro 01:12:53

entre este no hay lugar a dudas este método la única variable y que conoce o la variable y que 01:13:02

conoce, es una variable local que la tiene en su propio ámbito 01:13:11

definida, con lo cual no hay lugar a dudas que es esta la que ejecuta, si marco 01:13:15

sobre ella, aquí lo tenemos, y si pulsamos sobre esta, esta variable 01:13:19

yedad disponible en el método asignar edad, como no la tiene 01:13:23

definida en su ámbito más local, que es en la definición del propio método, se va 01:13:27

al ámbito más grande, que es el de la clase, y fijaros como me está 01:13:31

marcando esta yedad. En cambio en el setter, esta 01:13:35

y edad es esta, la local, pero se lo está asignando 01:13:39

a esta variable, que si os fijáis 01:13:43

vuelve a ser esta, con lo cual en realidad no estaríamos actualizando la edad que tiene 01:13:46

la persona en la clase. Esto ha sucedido porque 01:13:51

tenemos coincidencia de nombre en la variable, entonces si la tenemos 01:13:55

definida en un ámbito más amplio, como en la clase persona 01:13:59

y en el ámbito también del método de forma local a través del 01:14:02

atributo de a través del parámetro de entrada la tenemos definida con el mismo nombre el método se 01:14:07

queda con la digamos más próxima a la más cercana que es esta otra como podemos hacer que esta edad 01:14:13

que se recibe aquí en realidad se asigne a la variable de edad de toda la persona utilizando 01:14:20

la etiqueta this this significa yo como objeto que estoy ahora mismo en ejecución este método 01:14:26

se estará ejecutando para un determinado objeto pues yo mismo mi variable y edad entonces si ahora 01:14:35

marcamos está fijaros como ya no se marca esta y sí que me identifica ese y edad no como la variable 01:14:41

local sino como la variable de objeto esto ha sucedido porque el set era hecho coincidir los 01:14:47

dos nombres de la variable en este caso no había lugar a dudas porque como no coincidía esta edad 01:14:55

está y edad no está definida en el ámbito del método y solamente está definido en el ámbito 01:15:02

de la clase, con lo cual no había problemas. 01:15:07

Igualmente podríamos haber puesto aquí 01:15:09

el dis, también hubiera sido 01:15:11

tampoco un problema, aunque 01:15:12

no había conflicto, pero bueno 01:15:15

con el dis todavía queda quizás 01:15:17

más claro que se está refiriendo a la variable 01:15:19

de la clase. A ver, ¿qué más cositas 01:15:21

por ahí tengo para contaros? 01:15:27

Public Protective, Friendly, 01:15:29

los Getter y los Setter. Entonces los 01:15:32

Getter y los Setter, pues son estos métodos 01:15:33

para asignar valores 01:15:36

y para recibirlos. Mirad, 01:15:37

aquí 01:15:41

en la edad, nosotros estábamos intentando asignar valores, pero si yo 01:15:41

cojo y digo system.auth.println 01:15:45

y digo voy a sacar por pantalla 01:15:51

la edad de mi pair, un objeto de la clase persona. Bueno, directamente 01:15:55

no me deja poner y edad, ¿por qué? Pues porque y edad está 01:16:02

definido como privado. Y la forma de saber la edad 01:16:06

la puedo obtener a través del getter, que es 01:16:10

público si yo pongo aquí y per punto get y edad cuando ejecutó este método se viene aquí y que 01:16:14

hace un retorno de edad del valor que tiene esta variable devuelve un entero lo devuelve digamos 01:16:27

hacia la izquierda es decir se lo devuelve al paréntesis del println y mostrará la edad que 01:16:33

si damos aquí una ejecución pues yo creo que estamos por aquí en este 0 01:16:39

vamos a comentar cosas por ahí para poder seguirlo más fácil 01:16:45

esto del tau que parece que era el doble de pi 01:16:52

vamos a comentar esto también 01:16:54

este o la 2 que uno lo está mostrando desde aquí también lo comentamos 01:16:58

y ya si ejecutamos lo primero que nos encontramos es el 0 01:17:10

que es esta edad 01:17:17

¿por qué nos ha dado de vuelto 0? 01:17:20

pues bueno pues los valores las variables numéricas por defecto se inicializan a cero 01:17:21

resulta que hemos intentado que asignar una edad llamando a este método asignar edad con valor 01:17:31

menos 30 y si nos ponemos aquí recordad que cuando llamamos a este método si el valor era menor de 01:17:35

0 directamente la asignaba como valor un 0 y vamos a poner que si el valor es muy pequeño 01:17:45

la asignó un 1 para hacer una proyección claro es como ya nos asigna el 1 y luego el get y edad 01:17:50

nos ha devuelto la información el getter nos ha devuelto la información de la variable y edad 01:17:58

que era este 1 y el sistema println no ha sacado por alguna duda mirad más cosas que os cuento las 01:18:03

términos términos que tenemos en java cuando llamamos ejecutamos métodos desde aquí del 01:18:24

inicio aquí por ejemplo estamos ejecutando estamos ejecutando el método llamar saludar 01:18:34

de un objeto fin que es de la clase de finanzas a nivel terminología cuando ejecutamos un método 01:18:46

lo que se dice es que estamos mandando un mensaje 01:18:54

desde el método main de la clase inicio 01:18:58

al objeto fin, es decir, poner en ejecución 01:19:03

un método es enviar un mensaje, eso es lo que luego por ahí 01:19:07

por el temario cuando veáis mensajes, es a lo que hace referencia 01:19:09

luego, las clases hemos dicho que tienen 01:19:14

atributos, aquí tenemos dos 01:19:18

o parámetros y tienen 01:19:22

métodos. Pues la forma de interactuar 01:19:25

con objetos de la clase finanzas desde otras clases 01:19:28

es enviándole mensajes, como os decía, 01:19:31

y a través de sus 01:19:35

métodos. Entonces, cuando los métodos, digamos 01:19:37

que es el interfaz de la clase. En un momento dado se dice 01:19:40

¿cuál es el interfaz de la clase finanzas? Pues son los 01:19:43

métodos saludafinanzas y 01:19:46

llamarsaludar, que en realidad saludafinanzas está bloqueado 01:19:49

su acceso porque es privado para que lo llamen desde otras partes, pero bueno 01:19:52

formaría parte de su interfaz aunque solo fuese para ser llamado 01:19:56

desde otros métodos de la propia clase. Entonces el interfaz es el conjunto 01:20:00

de métodos con el cual nos podemos comunicar con los objetos de la clase 01:20:04

finanzas. ¿Y cómo nos comunicamos? A través del envío de 01:20:08

mensajes, que básicamente es dar la instrucción de que se 01:20:12

ejecute un método del objeto de esa clase. 01:20:16

más cosas, los ámbitos de las variables que también hemos hablado de ellos 01:20:20

si nosotros tenemos aquí la variable, por ejemplo el método set y edad 01:20:29

esta es una variable, la que recibe como parámetro una variable local al método 01:20:34

y si nosotros definimos aquí una variable también local a este método 01:20:39

como está definido en este ámbito, cuando acaba este ámbito la variable desaparece 01:20:46

que desaparezca la variable quiere decir que deja de estar accesible desde otras partes del código 01:20:51

y que, como ya no está referenciada, nos interesa que se libere la memoria RAM que estaba ocupando. 01:20:56

Aquí, cuando hemos definido una variable, no hemos hecho el new porque es un tipo string, 01:21:05

está entre medias de primitivo referenciado, pero bueno, por la característica de tipo primitivo, 01:21:10

no hemos tenido que hacer el new, pero lógicamente se ha reservado un trocito de memoria RAM 01:21:15

para guardar su información, para que no se quede bloqueada de por vida en el momento en el que ya 01:21:19

No es una variable accesible desde el programa, es decir, si es una variable local al método, una vez que termina el método, lo que interesa es que se libere esa memoria RAM para que nuestro propio programa o cualquier otro programa que esté en ejecución en el ordenador sea capaz de utilizar esa memoria RAM. 01:21:24

¿Quién se encarga de hacer esto en Java? Pues no lo hacemos nosotros directamente 01:21:40

está el recolector de basura, así se llama, que se va dando cuenta de variables 01:21:44

que ya no están siendo utilizadas y que están bloqueando memoria RAM en el ordenador 01:21:51

y empieza a liberarlo, dice bueno pues ya como ya no se utiliza esa memoria RAM 01:21:57

te la devuelvo al sistema operativo para que la utilices convenientemente 01:22:01

con el programa que te interese, el recolector de basura 01:22:05

Si la variable está definida en este ámbito de la clase persona, pues ¿cuándo cobran vida estas variables de clase? Estas variables de clase cobran vida en el momento que hacemos el new y llamamos al constructor, cuando creemos una nueva persona. 01:22:09

entonces, ¿cuál es la existencia de estas variables 01:22:25

mientras esa persona exista? si nosotros definimos 01:22:29

dentro de un método una persona 01:22:32

aquí por ejemplo el objeto 01:22:37

mi alum de alumno, en este caso cuando acabe el main 01:22:40

como ya este alumno se va del ámbito de donde ha sido definido 01:22:44

ya deja de tener sentido, y si deja de tener sentido el recolector de basura 01:22:49

igual que había hecho antes con la variable ese no se dará cuenta que ya no se utiliza y como 01:22:53

no está referenciado liberar a esa memoria entonces bueno por ahí tenemos momentos en 01:22:59

los que se crean variables ámbitos en los que están disponibles y cuando son eliminados que 01:23:08

se encarga de ello el recolector de basura hay lenguajes como también orientados a objetos como 01:23:15

C++, que tienes que hacer también las instrucciones 01:23:21

equivalentes al new para hacer la reserva de memoria para tipos referenciados 01:23:25

pero luego no existe un recolector de basura, con lo cual si tú 01:23:28

cuando está acabando el ámbito en el que utilizas esa variable, no te preocupas de 01:23:33

liberar la memoria por código, ese código se va quedando ahí bloqueando 01:23:37

memoria RAM y bueno, imaginaos que está en un bucle que se ejecuta a menudo 01:23:41

en cada una de esas ejecuciones haría una nueva reserva de memoria 01:23:45

y los recursos del ordenador poco a poco se irían irían escaseando hasta que sí bueno si está 01:23:49

muchísimo tiempo pues igual terminaría el programa por dejar de funcionar porque no tendrían nueva 01:23:55

memoria ram disponible para seguir trabajando cosas que tenemos por ahí más con el tipo 01:24:02

referenciado ya hemos hablado las clases graper tengo por aquí apuntado acordaros para los tipos 01:24:12

primitivos necesitan ciertas funciones que nos las proporcionan las clases 01:24:19

grupper en una clase que sea referenciada como por ejemplo mat 01:24:24

nosotros ponemos aquí está escribiendo lo fuera de un método si ponemos aquí 01:24:31

más punto pues fijaron la clase más nos ofrece cosas por aquí todos estos como 01:24:43

una instancia de un objeto de la clase más serán todos ellos estáticos cambios 01:24:50

si nosotros ponemos aquí int y definimos una variable y ponemos aquí 01:24:55

un punto, si ponemos aquí y punto, 01:25:00

pues no me ofrece nada. ¿Por qué? Porque son los tipos primitivos, con sus 01:25:05

características que ya hemos hablado. No hay que hacer el new, pero no tienen cosas disponibles. 01:25:08

Entonces, hay definida una clase integer 01:25:13

que implementa 01:25:15

funciones que van de la manita de las variables de 01:25:20

tipo int para que tengamos disponibles 01:25:24

todas aquellas funciones que 01:25:26

la clase primitiva int no 01:25:28

tiene. Estas son las clases 01:25:30

Wrapper, ya hemos hablado de ellas otras 01:25:32

veces. Mirad, el método 01:25:34

toString. El método toString 01:25:39

hablaremos también de él 01:25:43

más veces, pero es 01:25:45

bastante interesante. 01:25:46

Cuando nosotros 01:25:49

y útil, habrá momentos en los que 01:25:49

tendremos que trabajar con él bastante intensamente 01:25:53

cuando hablemos de colecciones. 01:25:55

Os cuento un poco el toString. 01:25:57

claro en la clase finanzas tenemos el método si ponemos a punto intentamos utilizar tu string ya 01:26:00

no lo está ofreciendo cambio en finanzas no hemos definido ningún método tuestre que sucede que hay 01:26:23

una serie de características que toda clase en java va a tener siempre porque dentro de esa 01:26:30

estructura que os decía de jerarquías que iban de arriba abajo antes cuando se hablaba de las 01:26:36

herencias arriba del todo en la estructura ahí está la clase object y esta clase object de alguna 01:26:42

forma todas sus características son heredadas por cualquier clase que tenga todo programa en 01:26:51

java me da igual sea un programa mío sea de quien sea sea una clase sea otra sea de librerías todas 01:26:57

ellas tienen características que están definidas en object con lo cual todo objeto siempre va a 01:27:03

tener una serie de métodos disponibles y uno de ellos es el tu string el método como herencia 01:27:10

digamos desde hoy de las herencias hablaremos que la herencia tiene que ser única desde una clase 01:27:21

con excepción de esta herencia que os digo desde hoy pero ya hablaremos de herencia otro día 01:27:26

entonces el método tu string está disponible en todas partes nosotros cuando ponemos aquí 01:27:33

un system.out.println 01:27:37

pongamos lo que pongamos aquí, en realidad nos funciona y nos 01:27:40

saca información, si nosotros ponemos aquí un int i igual a 5 01:27:47

ponemos aquí un i, nos saca el 5 01:27:50

pero si ponemos aquí un string, ese info 01:27:54

igual a hola, nosotros ponemos aquí un system.out.println 01:27:58

y también nos funciona, y si ponemos un system.out 01:28:11

.println 01:28:18

de i más 01:28:20

pongo aquí 01:28:24

una sas yo directamente y pongo aquí 01:28:26

ese info, pues también 01:28:28

no va 01:28:35

entonces que pasa que 01:28:35

si este .println se traga aquí 01:28:38

cualquier cosa, pues si se lo traga 01:28:40

pero porque 01:28:43

para cada una de las cosas que pongamos aquí 01:28:44

lo que hace 01:28:47

es convertirlo antes 01:28:49

a un string 01:28:50

con lo cual esto que es un entero lo convierte primero en un string y luego lo que hace es concatenar ese string con esto que es otro string y si esto no fuera un string que ya lo es pues lo convertiría también un string fijaros si ponemos aquí más vamos a poner aquí unos espacios y ponemos aquí a recordad que a es el objeto de la clase de finanzas también me compila 01:28:57

recordad que antes hemos puesto aquí el tu string este y que devuelve tu string devuelve un string 01:29:24

entonces cualquier cosa que pongamos aquí lo convierte en un string y luego concatena todos 01:29:30

esos strings para sacar un resultado conjunto de lo que pongamos en el sistema println en el 01:29:36

que hay casos en los que está muy claro lo que lo que va a suceder si yo pongo aquí un entero 01:29:44

pues resulta que la clase, seguramente el grupper este integer, si ponemos aquí integer.toString, fijaros como lo tiene, recibe un entero y nos devuelve un string y conviérteme a string un valor entero, está claro que este método, esta clase integer tendrá escrito, estará sobrescribiendo lo que recibió de object, 01:29:50

Recordad que antes os he dicho que por herencia tenemos disponibles los métodos que estén definidos en las clases de las cuales se heredan. 01:30:19

Object, digamos que podría ser un estilo de herencia, todas las clases se heredan de object. 01:30:27

Entonces todas tienen un toString. 01:30:32

Pero resulta que, ¿cómo quiero que me convierta? 01:30:35

fijaros, si de object tiene la clase 01:30:40

wrapper integer 01:30:43

el comportamiento que esté definido en la clase object para el método 01:30:44

toString, es decir, el código toString de la librería 01:30:49

de la clase object, intentará 01:30:52

convertir un integer a algo 01:30:55

pero ese mismo código, porque el código es único 01:30:58

tendrá el mismo toString 01:31:01

y ese mismo toString estará heredado para 01:31:03

en este caso mi clase finanzas. 01:31:07

También mi clase finanzas por herencia. 01:31:11

Vamos a poner un poco entrecomillado la herencia, porque es así, pero 01:31:16

la herencia tiene que ser simple, ya os contaré. 01:31:19

Pero bueno, por herencia, la clase finanzas tiene el método toString 01:31:24

y el comportamiento de los objetos de la clase finanzas 01:31:28

será el que esté definido en la clase object. 01:31:33

entonces convertir un objeto de la clase finanzas a una cadena de caracteres 01:31:35

cuando tiene estas características puede ser muy diferente a convertir a un string 01:31:41

un objeto de la clase integer 01:31:46

entonces que es lo que habrá hecho la clase integer con el toString que tiene heredado de object 01:31:48

pues lo habrá sobrescrito 01:31:54

para que el comportamiento del método toString 01:31:56

cuando esté relacionado con la clase grupper integer 01:32:06

no sea el que esté ya predefinido en la clase object 01:32:10

porque queremos que convertir un entero sea diferente 01:32:14

a lo que haga la clase object cuando esté intentando convertir 01:32:18

un objeto de la clase finanzas. Tanto la clase finanzas como mi clase 01:32:22

tanto la clase grupper integer como la clase finanzas 01:32:30

de inicio tienen un código común definido en la clase object 01:32:36

para el método to string como convertir en una cadena de caracteres un objeto de la clase 01:32:40

finanzas y un entero es diferente java nos permite sobreescribir el comportamiento veremos ahora como 01:32:46

otro día nos permite sobreescribir el comportamiento entonces si yo en la clase íntegras digo mira ya 01:33:00

deja de utilizar el código de la clase hoy es para tu string y utiliza el que yo te indico en 01:33:06

En la propia clase, el comportamiento que tendrá en la clase Integer será el propio sobrescrito. 01:33:13

Y si en mi propia clase no lo he sobrescrito, utilizará el de la clase Object. 01:33:19

Entonces, la clase Integer, para este entero, lo que hará será convertir a un string un número. 01:33:25

Pero la clase Finanzas, como no tiene aquí escrito el método toString, lo que hará será utilizar el único que tiene disponible, que será el de la clase Object. 01:33:32

De una forma o de otra, cualquiera de ellos devolverá un string y esos strings se concatenan aquí y nos los muestra por pantalla. Fijaros qué información me ha sacado. Me ha sacado un 5. 01:33:44

la clase toString de 01:34:00

el wrapper 01:34:04

integer ha hecho que esto 01:34:05

que es un número lo ha convertido en un string 01:34:07

y lo ha puesto ahí, lo ha concatenado 01:34:09

con una sass 01:34:11

luego ese info lo ha sacado que ya es 01:34:12

directamente un string, con lo cual me ha puesto aquí 01:34:15

hola, me ha puesto 01:34:17

aquí unos espacios y luego 01:34:19

fijaros que a 01:34:21

que es un objeto de la clase finanzas 01:34:23

no tiene definido aquí un toString 01:34:25

con lo cual habrá utilizado el heredado 01:34:27

de la clase object y me ha mostrado aquí que es un objeto de la clase finanzas y me ha puesto 01:34:29

aquí un identificador que probablemente tenga que ver con algo de una posición de la posición 01:34:36

de memoria que tengamos que tengamos donde tengamos donde tengamos reservado espacio 01:34:40

para este objeto igual que habíamos dicho que la que la clase integer que es una clase de 01:34:47

que está definido en las librerías de Java, tendrás sobrescrito el comportamiento de tu string para no utilizar directamente el de object y mostrar en un string el valor del número entero, tenemos la posibilidad de sobrescribir nosotros en nuestras propias clases el método imprimir, el método toString y cualquier otro. 01:34:57

bueno esto no es necesario, si ponemos aquí 01:35:16

public que devuelva un string 01:35:28

un método que sea el método toString 01:35:31

y ponemos aquí return que devuelva 01:35:33

una cadena de caracteres, vamos a poner aquí hola 01:35:43

estamos diciendo que para la clase finanzas 01:35:45

el método toString ya no queremos 01:35:51

que utilice el método, fijaros como aquí 01:35:54

dice está sobre escribiendo el toString 01:35:57

está sobre escribiendo el de object ya no queremos que utilice el de object es 01:35:59

decir cuando al sistema println pasemos un objeto de 01:36:04

la clase finanzas println utilizar el to string para convertir esto en una 01:36:10

cadena de caracteres si yo no tengo definido aquí un to string que es lo que 01:36:15

sucede que utilizará el único que tiene disponible que es el heredado de object 01:36:19

Y me mostrará algo de este estilo. Pero si yo lo sobrescribo aquí, estoy haciendo un ejercicio parecido al que decíamos que hacía la clase Grouper Integer para no utilizar el de Object y como consecuencia, en lugar de mostrarnos algo para el entero de este estilo, nos mostraba su valor numérico como una cadena de caracteres. 01:36:23

ahora estamos diciendo que la clase, el método toString de la clase finanzas 01:36:44

sobreescriba al toString de la clase object 01:36:48

como me dice aquí, fijaros, y me devuelva un string que sea hola 01:36:52

entonces siempre que ponga yo aquí ahora un objeto de la clase finanzas 01:36:56

fijaros lo que sucede, me muestra aquí un hola 01:37:01

¿para qué nos sirve esto? pues nos sirve para 01:37:06

identificar la forma en la que yo quiero que se vean 01:37:10

mis objetos de la clase finanzas cuando se integren en un 01:37:14

System of Println, mirad, en la clase persona 01:37:18

si yo pongo aquí un objeto de la clase persona, si lo meto aquí 01:37:24

en el System of Println, yo ahora ejecuto, y fijaros 01:37:49

ahora lo que me dice es, bueno, todo este 01:37:55

es todo esto, y para mi PER 01:37:58

como en la clase persona, al contrario de en la clase finanzas 01:38:02

no tengo sobre escrito el toString 01:38:07

hemos visto que todo objeto en mi programa 01:38:09

tiene un toString disponible, entonces si yo pongo aquí 01:38:13

miPerl.toString 01:38:16

fijaros que me dice, te devuelvo un string 01:38:17

y está definido en la clase Object, veis aquí como me indica 01:38:22

que lo está definido en la clase Object, y por qué utiliza el que está 01:38:25

definido en la clase Object, porque todo lo tienen disponible 01:38:28

pero aquí no lo he sobre escrito 01:38:31

ahora digo, bueno pues es que esto en realidad no me dice mucho 01:38:32

este toString, fijaros que desde la clase object no puede hacer nada 01:38:37

diferente a mostrarme el nombre de la clase y su posición de memoria 01:38:42

porque como es un código definido de forma común para 01:38:46

todos los objetos que podamos definir en nuestro programa 01:38:50

si no tienen sobre escrito el método toString 01:38:54

que podría la clase object definir allí en sus librerías cuando lo va 01:38:56

utilizar mi programa otro programa una clase de mi programa otra clase de mi programa cualquiera 01:39:02

no habrá habría infinitas combinaciones de clases que podrían llegar a estar utilizando ese código 01:39:09

claro yo pensando en mi programa podría decir mira yo lo que quiero que me identifique una 01:39:14

persona cuando yo lo ponga en el sistema printer en es que salga su nombre pero claro es que ese 01:39:19

código en la clase oye no puede poner un nombre porque en otro programa no hay personas hay 01:39:24

directamente mesas y las mesas no tienen nombre que tienen todos en común absolutamente todos 01:39:29

pues tienen que pertenecer a una clase que te la muestra aquí el tu string y que tiene una zona de 01:39:35

memoria reservada con un identificador entonces como eso sí que es común a todos si no lo has 01:39:40

sobre escrito en aquel código de la clase object lo que me muestra es esto si yo quiero que mi 01:39:46

clase tenga unas características particulares diferentes de esto que en línea general dice 01:39:52

poco pero es lo único común que podemos tener para definir en la clase object para todas las 01:39:56

posibles clases de todos los programas lo que puedo hacer es en cada clase sobre escribir el 01:40:01

método to stream para que tenga un comportamiento acorde al que yo espero que suceda cuando se llame 01:40:07

este método y lo meta en un sistema println qué es lo que hace la clase grúa perder las librerías 01:40:13

la clase grúa per íntegra pues tiene sobre escrito del método to stream para no utilizar 01:40:20

el de object y en particular en ese método 01:40:26

toString equivalente a este return hola que he puesto 01:40:29

lo que hace es fijarse en el numerito que tiene 01:40:32

el entero y devolver ese string, por eso me sale 01:40:35

aquí el 5. ¿Qué es lo que hemos hecho en finanzas? Pues mira 01:40:38

no nos hemos preocupado ni de la información que tiene por aquí finanzas y directamente 01:40:42

hemos dicho que cuando se meta en system.out.println 01:40:46

devuelva un string que sea un hola. ¿Qué es lo que 01:40:49

podemos coger de la clase persona? Pues aquí dependería 01:40:54

de lo que queramos nosotros 01:40:56

en nuestro enunciado, de nuestro ejercicio en particular, igual en un ejercicio 01:40:59

donde tenemos definido una clase persona, voy a sobre escribirlo 01:41:04

me interesa que de esa clase persona se muestre su nombre 01:41:09

pues en el método toString yo pongo 01:41:13

que haga un return de la variable nombre, como veis 01:41:17

entonces si ahora ejecuto aquí, bueno sale null 01:41:21

porque no le hemos asignado un nombre, vamos a asignarle un nombre 01:41:34

ponemos mi per 01:41:36

punto ese nombre 01:41:38

igual 01:41:40

mi per tiene como nombre noa 01:41:42

pongo aquí mi per 01:41:51

dentro del system of println, sabemos que 01:41:52

aquí voy a utilizar el toString, la clase 01:41:55

persona hemos dicho que devuelve al nombre 01:41:56

entonces yo ahora pulso aquí 01:41:58

y fijaros como me sale aquí noa 01:42:01

imaginamos que 01:42:03

en otro ejercicio decimos, es que el nombre 01:42:05

en realidad, en el contexto 01:42:07

del ejercicio anterior estaba bien que 01:42:09

apareciera el nombre, pero aquí lo trascendente, lo importante de las personas cuando salgan 01:42:10

un System of Println es la edad, entonces aquí podríamos poner por ejemplo 01:42:15

string SAUS 01:42:19

igual, mira, llamo al toString 01:42:21

de la clase WorkerInteger, le paso uniedad 01:42:44

con lo cual me va a devolver el número que tenga este, lo meto 01:42:49

en SAUS y aquí devuelvo SAUS, aquí estoy diciendo que 01:42:53

en el toString, cuando lo ponga en un sistema de println, 01:43:00

lo que me importa es que me devuelva 01:43:03

la edad 01:43:05

que tenga justo aquí. 01:43:07

Entonces aquí podríamos coger, 01:43:09

vamos a poner una edad, 01:43:11

a miper, 01:43:14

miper.iedad, 01:43:14

set y edad, 01:43:18

ponemos aquí 15. 01:43:19

Entonces ahora al ejecutar, 01:43:23

fijaros como ya me sale aquí 01:43:25

un 15, ¿por qué? Porque estoy devolviendo la edad. 01:43:26

Podríamos decir, pues, 01:43:31

en otro ejercicio lo que me interesa 01:43:32

lo que identifica es 01:43:35

podría ser el iValor que tenemos aquí 01:43:37

pero no, igual no es ni el 01:43:39

nombre, no es ni la edad, es una 01:43:41

combinación de los dos 01:43:43

entonces que podríamos poner aquí, pues podríamos poner que 01:43:44

ese aus, este string 01:43:47

que es el que estoy devolviendo aquí, fijaros 01:43:49

ese aus, sea 01:43:51

el nombre 01:43:54

imaginaos que con el toString queremos 01:43:56

poner que ese nombre 01:43:58

ese nombre tiene 01:44:01

fijaros aquí estamos cargando en ese aus 01:44:02

una concatenación 01:44:10

de tres strings, este utilizando 01:44:12

el toString por aquí, tiene 01:44:14

el valor de ese nombre, es lo que 01:44:16

devuelve el toString y es el que se utiliza 01:44:18

aquí en el System.out.println 01:44:20

entonces si ahora ejecutamos aquí 01:44:22

fijaros como dice noa tiene 01:44:24

15 01:44:26

en definitiva, ¿qué podemos poner aquí en el toString? 01:44:26

pues cualquier cosa que queramos 01:44:30

una combinación 01:44:32

de todo lo que tengamos por aquí 01:44:34

disponible y que sea 01:44:36

digamos la cara que va a dar una persona cuando se llame a su método 01:44:37

toStream que de forma automática se llama cuando lo incorporamos al system of println 01:44:41

si no tiene sobrescrita la clase 01:44:46

el toStream nos va a mostrar lo que veíamos antes, el único que tiene disponible 01:44:49

heredado desde la clase object, si utilizamos una librería de java 01:44:53

una clase de una librería de java, si lo tiene sobrescrito como la clase 01:44:57

wrapper integer, pues nos va a devolver el stream del entero 01:45:01

si es una clase propia 01:45:05

si no lo hemos sobrescrito 01:45:07

pues nos devolverá eso, si lo hemos sobrescrito 01:45:09

lo que nosotros hayamos devuelto 01:45:11

por aquí como un string, estamos 01:45:13

sobrescribiendo ese método toString 01:45:15

¿Sí? ¿Se entiende? 01:45:17

¿Por ahí más o menos bien? 01:45:29

Vale, pues 01:45:37

pues nada, yo creo 01:45:38

que vamos a parar ya por aquí, son las 01:45:40

7 y 20, el repaso 01:45:42

a lo que tenía apuntado por aquí 01:45:44

del tema 4, ya lo tenemos 01:45:46

volveremos sobre todo esto el tema 5 vuelvo a hablar de todas estas cosas así que bueno 01:45:48

pues aunque repasemos en otra tutoría volveremos a hacerlo y nada poco más que contaros por ahí 01:45:53

sí dime pero con un pad el vídeo si quieres yo creo la mejor forma es que puedas ver el vídeo 01:46:01

¿no? de nuevo quizás 01:46:23

¿no? 01:46:26

no, es que te lo digo porque 01:46:28

no es que sea un tesoro 01:46:29

esto que no quiera compartir con vosotros, ni mucho menos 01:46:31

de hecho está grabado, pero es que 01:46:34

si te lo pongo en un pad como 01:46:35

o sea, que sobre las mismas clases he ido poniendo 01:46:37

y quitando cosas, entonces 01:46:40

hemos perdido ya la traza de muchas de las 01:46:41

cosas que os he ido contando 01:46:43

entonces yo creo que, bueno, si te interesa algún 01:46:45

apartado así más en particular 01:46:47

como os voy a publicar el enlace 01:46:49

de la clase, pues la vuelves a ver y 01:46:51

ahí sobre la marcha lo puedes ir haciendo yo creo mejor 01:46:53

no sé si te parece 01:46:56

¿sí? vale 01:46:56

vale pues pues nada ya tengo la grabación 01:46:59

ya por aquí 01:47:04

2024-12-09-Programacion - Contenido educativo

Del mismo autor…

Proyecto El cuerpo humano 1º Infantil C

Vídeo resumen "Genética mendeliana"

Cierre proyecto El cuerpo 1º infantil C

VPN con OpenVPN en Ubuntu3

VPN con OpenVPN en Ubuntu2

VPN con OpenVPN en Ubuntu1

Programa un rostro que mueve los ojos con Scratch Jr en los primeros cursos