2024-11-04-Programacion | Mediateca de EducaMadrid

Ya estamos grabando. Pues nada, ¿tenéis alguna cosilla por ahí que queréis que comentemos antes de repasar otras cosas por ahí? ¿Alguna duda que tengáis de lo que hayáis podido ver en el tema 2? 00:00:00

Este tema 2 es sencillo en principio, el tema 3 tampoco introduce así gran complejidad 00:00:14

Pero claro, es muy fácil decirlo si ya has programado antes, como es mi caso y el caso de muchos de vosotros 00:00:25

Por lo que he podido ver en las tareas, pero claro, para quien está empezando quizás sí que sea un nuevo mundo 00:00:31

Y necesite su tiempo para asentar los conceptos 00:00:37

En cualquier caso, no me habéis preguntado mucho por ahí por el foro, así que entiendo que algunos no habréis podido dedicar quizás el tiempo que os hubiera gustado y otros no habéis tenido dudas. ¿Alguna cosita queréis comentarme antes de arrancar? 00:00:43

Vale, pues mañana abrimos el tema 3 ya. El tema 3 introduce, digamos, normalmente cuando tenemos un proyecto, ya hemos hablado que arrancan nuestros proyectos, arrancan en una determinada clase. 00:01:01

en Java todos son clases en principio, voy a crear un proyecto 00:01:29

que se llame prueba y todo proyecto necesita tener un método 00:01:35

en una de sus clases que sea el método main, porque el inicio 00:01:44

de los programas, como hemos dicho ya, empiezan en ese método. 00:01:47

Es cierto que varias clases pueden tener un método main y 00:01:52

digamos tener diferentes puntos de entrada, bueno, pues porque 00:01:56

si queremos probar ciertas cosas en particular de una clase, podemos ponerle el método main 00:01:59

para probarla de forma individual, pero como proyecto 00:02:04

en su conjunto, lo normal es que haya un único método de este tipo, método main 00:02:08

para todo el proyecto y a partir de ahí, bueno, pues se empiece a llamar 00:02:11

a diferentes métodos o a quien vaya correspondiendo. 00:02:15

Se vayan creando objetos, todo lo que venimos hablando ya estos días y que continuaremos 00:02:19

a lo largo del curso. Entonces, cuando tú tienes 00:02:23

una, bueno, pues a partir del método main o en cualquier otra 00:02:30

sentencia, pues el código va 00:02:33

de forma secuencial ejecutándose de arriba a abajo. 00:02:36

Vamos a poner aquí clase print, voy a crear una clase. 00:02:41

La asignatura o 00:02:48

digamos cabecera de 00:02:50

un método, se suele llamar asignatura 00:02:53

como firma, firsignatur, del método 00:02:56

main es esta public static 00:02:59

void main 00:03:01

string 00:03:03

al s 00:03:05

todas estas palabras claves 00:03:09

aportan algo al método 00:03:13

y ya lo iremos comentando 00:03:15

a lo mejor hoy vamos hablando ya un poquillo de ello 00:03:17

aunque en temas posteriores 00:03:19

se va haciendo un desarrollo 00:03:20

se va haciendo una revisión de cada una de estas 00:03:22

etiquetas para lo que sirven 00:03:25

de la de static ya estuvimos hablando 00:03:27

estos días atrás 00:03:29

cuando vayamos haciendo algún ejercicio 00:03:30

redundamos un poquito en su 00:03:33

descripción y luego los métodos os decía cuando teníamos una clase en este caso la clase print 00:03:35

pues estaba compuesta por una serie de atributos que son características propias de todo objeto 00:03:43

que tenga que ver con esta clase y clase print bueno pues una clase que he creado para trabajar 00:03:49

en el proyecto pero típicamente pues sería como os decía la clase persona pues sus atributos serían 00:03:54

características particulares de toda persona todo objeto de la clase persona que fuéramos 00:03:59

construyendo como podrían ser en diferentes contextos serían diferentes atributos pero 00:04:05

bueno podría ser en este caso el nombre el apellido el dni todo este tipo de información 00:04:09

típica de las personas en un coche pues si fuera la clase coche pues los objetos de clase coche 00:04:14

con atributos podrían tener pues la cilindrada ser el motor tipo de motor marca bueno diferentes 00:04:21

características propias de los coches y luego decíamos que teníamos los métodos que son los 00:04:28

a los que invocamos, a los que vamos llamando 00:04:34

para que vayan realizando acciones. 00:04:37

Los métodos que tienen que ver con acciones 00:04:40

dentro del método tienen un ámbito, 00:04:43

una llave de apertura y cierre, que es 00:04:47

todo el ámbito donde trabaja el método y por aquí 00:04:49

iremos metiendo la secuencia de instrucciones 00:04:52

que se ejecutan cuando invocamos ese 00:04:55

método en particular. La ejecución de un método, 00:04:58

de todo método en Java, pues se hace de forma secuencial, va de arriba a abajo. 00:05:03

En esta asignatura vemos, el año que viene veréis una asignatura que es la asignatura 00:05:09

de programación de servicios y procesos, que permiten la ejecución de diferentes líneas de código 00:05:15

de forma paralela, aprovechando que las máquinas, los ordenadores, pues pueden tener varios procesadores, 00:05:21

pues decir, mira, si no es obligatorio tener los resultados de unas instrucciones anteriores 00:05:27

para ejecutar las siguientes, podemos dividir esas instrucciones en dos bloques 00:05:32

y que cada uno de esos bloques lo ejecute uno de los procesadores que tiene mi equipo. 00:05:37

De tal forma que ganamos ahí en velocidad de ejecución, en rendimiento de nuestro programa. 00:05:42

Para eso lo tiene que permitir el programa, no tiene que haber una obligatoriedad 00:05:49

de secuenciación de unas instrucciones con otras. 00:05:54

y bueno, esto sería una forma de trabajar en base a procesos o a hilos, pero bueno, si ya os digo que corresponde a la asignatura de programación de servicios y procesos que igual curséis el año que viene. 00:05:57

En esta solamente trabajamos con un procesador y va todo de seguido, con lo cual el método main, si tenemos aquí una instrucción 1, 00:06:09

instrucción 1, pues después de la instrucción 1, pues ejecuta la instrucción 2, luego la 3 y de esta forma secuencial una detrás de otra. 00:06:18

es decir, el flujo de programa por defecto es una instrucción detrás de otra 00:06:27

pero tenemos la opción de poder ejecutar un bloque de instrucciones 00:06:32

y que se repita o meter una condición en un momento dado 00:06:37

para que unas instrucciones se ejecuten o no 00:06:42

estas son las estructuras de control que vamos a ver en el tema que viene 00:06:45

y que muchos de vosotros en esta primera tarea 00:06:50

ya incluso habéis utilizado, bien porque las habéis investigado o bien porque tenéis ya cierta experiencia programando 00:06:55

y como son conceptos de inicio de todos los lenguajes de programación, pues ya más o menos lo conocíais. 00:07:02

Bien, esto es lo que vemos en el tema 2. En el tema 3, las secuencias de control condicionales, es decir, 00:07:10

Si pasa algo, se cumple una determinada condición, pues ejecuto una serie de instrucciones. 00:07:19

La A, la B, la C. 00:07:26

Si no pasa eso, si no pasa ese algo, pues podemos ejecutar otras instrucciones. 00:07:29

Entonces, en esa secuencia lineal del programa, de arriba a abajo, cuando llega aquí, 00:07:38

si esto es cierto, lo que se ejecuta son este primer bloque de instrucciones, pero estas no. 00:07:42

Y si eso no es cierto, estas no se ejecutan y las que se ejecutan serían estas otras. 00:07:47

Es decir, son instrucciones de control de selección. 00:07:53

Y luego están las instrucciones de control de repetición que vienen a ser mientras hay diferentes alternativas con la sintaxis, 00:07:58

pero mientras esté pasando algo, mientras un número sea menor de 10. 00:08:06

pues entonces ejecuto aquí una serie de instrucciones 00:08:13

las que pongamos 00:08:16

y se va repitiendo 00:08:17

normalmente dentro de este código 00:08:20

se producirá algún cambio 00:08:23

para que esto no se convierta en un bucle infinito 00:08:25

y se quede el programa eternamente aquí 00:08:27

imaginaos que la condición es una variable de tipo entero 00:08:29

mientras la variable S sea menor de 10 00:08:32

entonces aquí típicamente podríamos tener que 00:08:35

esa variable va incrementando su valor 00:08:38

de uno en uno, de dos en dos, bueno, según el algoritmo nos lo requiera 00:08:42

y tras una serie de pasadas, como esto va cambiando su valor x, 00:08:47

pues habrá un momento en el que dejará esto de ser cierto 00:08:54

y dejará de producirse la repetición. 00:08:56

En ese caso, este bloque que está relacionado con este bucle, 00:08:58

esta estructura de control repetitiva, terminaría y el programa seguiría por aquí. 00:09:03

Bueno, sobre esto trabajaremos. 00:09:11

tenemos, me parece que son dos o tres semanas para este segundo tema 00:09:12

y los conceptos, aunque son imprescindibles de manejar bien 00:09:16

porque en todos los programas nos van a aparecer estructuras de control 00:09:20

de estos dos tipos, yo creo que se cogen más o menos rápido 00:09:23

entre que repasamos los conceptos y luego hagamos ejercicios 00:09:28

pues lo tendremos ahí resuelto. 00:09:31

Probablemente hablemos de esto la semana que viene 00:09:37

o no sé si hay un poquito, si luego nos apetece 00:09:38

antes de arrancar el tema. 00:09:43

¿Cosas del tema 2 que quedaron por comentar? 00:09:45

Pues bueno, en verdad pocas, ¿no? 00:09:49

Sí que he visto, bueno, las prácticas, los que habéis tenido la oportunidad del ratillo para poder hacerlas y entregarlas, 00:09:51

estaban bastante bien en líneas generales. 00:09:58

Es cierto que todavía no tenían mucha complejidad la práctica de este tema. 00:10:00

Y bueno, simplemente comentaros al menos un par de cosas. 00:10:05

cuando hablábamos en las 00:10:08

tutorías anteriores que nuestros programas los comunicamos 00:10:12

con el mundo exterior a través de flujos de datos 00:10:15

y teníamos estos flujos de datos 00:10:18

decíamos que había tres flujos de datos estándar, ahora 00:10:21

los retomamos y luego podíamos habilitar otro tipo de 00:10:24

flujos de datos para comunicación entre aplicaciones como 00:10:27

podían ser los sockets, un flujo de datos para leer 00:10:30

información o escribir información en ficheros 00:10:33

pues ahí abrimos también un flujo de datos, una tubería 00:10:36

desde nuestro programa, cuyo destino en este caso 00:10:39

si vamos a escribir es un fichero y la lectura 00:10:41

pues el origen de los datos sería el fichero y el otro lado 00:10:45

de la tubería del flujo de datos se enchufa 00:10:48

en nuestro programa. 00:10:51

Cuando es un socket, pues un lado de la tubería está enchufado 00:10:54

en nuestro programa y el otro lado en otro programa diferente. 00:10:57

Al final es un caminito por el cual trasladamos información 00:11:00

a nuestro programa desde el mundo exterior. 00:11:03

Y por defecto, os decía el otro día que se habilitan 00:11:07

tres flujos de datos en todos los programas, 00:11:10

que son el STDIN, el STDOUT y el STSTANDARDERROR. 00:11:13

El STDIN está asociado, los tres tienen uno de los lados 00:11:25

de la tubería enganchado en nuestro programa 00:11:30

y el otro, en el caso del STD in en el teclado, el STD out en pantalla y el STD air en pantalla. 00:11:32

Java tiene medios para poder enchufar el otro extremo, el que no está conectado a nuestro programa, 00:11:43

de cualquiera de estos tres flujos, digamos a otro elemento que no sean los que tienen considerados por defecto, 00:11:49

pero en principio, bueno, no nos interesa. 00:11:57

Junto a los flujos de datos que se activan por defecto, 00:12:01

existen, bueno, se te di en System Name, ¿no? 00:12:04

System Name, ¿no? 00:12:08

Vale, junto con los flujos de entrada, 00:12:11

pues tenemos una serie de librerías. 00:12:15

Y estas librerías en Java, lo que nos proporcionan, 00:12:17

en nuestros programas, decíamos dos días atrás, 00:12:20

que están compuestos por las clases que nosotros desarrollamos, 00:12:23

que en principio buscarán dar respuesta, tendrán los elementos principales para dar respuesta al algoritmo que queremos resolver 00:12:26

y junto a nuestras clases sobre las que trabajamos nosotros directamente incluimos otras clases que Java ha desarrollado para nosotros 00:12:34

y que las tiene en librerías. Las librerías de Java ya tienen por ejemplo desarrolladas clases que nos facilitan cómo poder acceder 00:12:44

a la información desde teclado, de este flujo de datos. 00:12:54

Entonces, el hecho de tener esa posibilidad nos permite que simplemente 00:12:59

llamando a esas clases, a sus métodos y a sus parámetros, podamos tener 00:13:04

un mecanismo sencillo y no tengamos que hacer nosotros ese desarrollo 00:13:08

por completo. Una de esas clases, en particular, para acceder, para leer 00:13:12

información desde flujos de datos externos, podría ser desde el teclado, 00:13:17

desde System.in o podría ser desde un fichero, pero para 00:13:22

inyectar, digamos, información en nuestro programa, en la clase Scanner. 00:13:26

Habíamos hablado el otro día de ella. Vamos a hacer un mini repaso y 00:13:33

aprovecho para comentaros algo que os he puesto 00:13:36

en los comentarios de las tareas alguno. Entonces, 00:13:38

y como siempre, nos vamos parando muy poco a poco 00:13:49

en cada instrucción y vamos repasando un poco conceptos 00:13:57

de los que tenemos en este tema. 00:14:01

Mirad, directamente en cualquiera de nuestros programas, 00:14:04

junto a nuestras clases, tenemos importadas, 00:14:08

es decir, tenemos ya disponibles sin necesidad de informarlo 00:14:12

de forma explícita, como estamos haciendo aquí para Scanner, 00:14:17

todas aquellas clases que pertenecen al paquete JavaLang. 00:14:20

Es decir, hay una serie de cosas en un paquete que es el JavaLang 00:14:26

desarrolladas y como son de uso tan común, dicen 00:14:30

mira, lo vas a tener disponible sin necesidad de importarlo. Y luego existen 00:14:34

muchas otras clases que están en otros paquetes. 00:14:37

Muchas también se utilizan habitualmente, aunque no 00:14:42

con tanta frecuencia como pueden ser las de Java Lang. Es el caso 00:14:46

de la clase Scanner. La clase Scanner se encuentra en el paquete Java 00:14:50

útil. Entonces, si nosotros por defecto no ponemos aquí este import, 00:14:54

Scanner se nos queja. Dice, oye, la clase Scanner no la conozco. 00:14:57

¿Por qué? Porque no la tengo definida en mi proyecto y tampoco es 00:15:02

de aquellas clases que están importadas de forma 00:15:06

estándar, de forma directa. Entonces, para poder utilizarla 00:15:09

tengo que identificarla en mi programa y avisarle al programa 00:15:14

que, oye, mira, quiero utilizar la clase Scanner en particular del paquete 00:15:18

JavaLang. Y a partir de ese momento, en ese paquete, tiene definida esta clase 00:15:22

y ya me deja hacer uso de ella. 00:15:25

Esta instrucción, ¿qué es lo que estamos haciendo? 00:15:29

Pues mirad, de una clase existente ya en mi programa, 00:15:32

aunque no la he codificado yo, 00:15:35

defino un objeto. 00:15:37

Recordad, las clases en sí vienen a ser un esquema 00:15:41

de cómo se comportarían los objetos. 00:15:44

La clase persona, en principio, 00:15:47

no es ninguna persona en particular. 00:15:49

Es el esquema de aquellas características 00:15:52

que van a tener aquellos objetos de la clase persona que definamos 00:15:54

como parámetros, definidos como parámetros, y los métodos que van a ser 00:15:57

cómo se van a comportar aquellas personas a las que demos vida 00:16:01

en nuestro programa a través de distanciarlas. 00:16:04

Pues es lo mismo que sucede aquí. Scanner, en principio, 00:16:07

es el esquema de una clase. Es una clase y tendrá un esquema 00:16:10

de parámetros y métodos disponibles. 00:16:13

En sí, para utilizar algo de Scanner, necesito definir un objeto. 00:16:16

Y este objeto ya sí que es algo que cobra vida en mi programa y que se instancia de acuerdo a esta clase. 00:16:20

Si definimos mi scan así, directamente con punto y coma, sin hacer el resto de esta instrucción, 00:16:32

lo que vendría a ser es, como un dedito, un puntero que señala hacia un objeto de la clase Scanner, 00:16:38

Pero no sería el objeto en sí. ¿Por qué? Porque necesito solicitar al sistema operativo espacio en memoria RAM y recursos para que este objeto pueda participar activamente en mi programa. 00:16:46

Entonces, eso lo hago con la palabra reservada new. Entonces, aquí ya sí que el programa le solicita al sistema operativo ese espacio para que haga todas las reservas necesarias para el objeto MyScan, que es de este tipo de clase. 00:16:59

Y después de este new siempre aparece aquí algo que si os fijáis está entre paréntesis, entonces los paréntesis hemos venido diciendo que cuando hablamos de una clase corresponden a los métodos, tenemos los parámetros que definimos más los métodos. 00:17:16

Fijaros, main, un método, en este caso de la clase print, está entre paréntesis. 00:17:35

Entonces, esto es un método definido en la clase scanner. 00:17:44

Si os fijáis, en particular, este método tiene el mismo nombre exactamente que la clase. 00:17:48

Entonces, estos métodos se llaman métodos constructores. 00:17:53

Es el constructor, un constructor de la clase scanner. 00:17:56

Y estos métodos, los constructores, se suelen utilizar o están pensados para ser utilizados en la inicialización del objeto. Entonces, fijaros que junto al momento en el cual definimos el objeto, hacemos la reserva de memoria y llamamos a un constructor que inicializará, según el código que tenga, este objeto de la clase Scanner. 00:18:00

Luego, tenemos aquí que otra de las características que tenemos en la programación orientada a objetos, aprovechamos fijaros en cada línea para hablar un poco de todos los conceptos y hacer un repaso, otra de las características que tenemos en la programación orientada a objetos es la sobrecarga. 00:18:25

Sobrecargar viene a decir que, digamos, reutilizar algo para que tenga diferentes funcionalidades. 00:18:45

Podríamos pensarlo de esta forma. Entonces, fijaros, podemos coger y tener sobrecargados operadores. 00:18:56

En otras clases hablábamos, por ejemplo, el más. El operador más, dependiendo de lo que se encuentre 00:19:06

a la izquierda o a la derecha, hace diferentes cosas. 00:19:12

Si se encuentra una variable numérica a la izquierda y a la derecha, 00:19:16

lo que hace es sumar dos números. 00:19:19

Si se encuentra un 3 y un 5, lo que hará será dar como resultado 00:19:21

hacia la izquierda de esta suma, es una suma típica de números, un 8. 00:19:26

Pero si lo que tenemos son dos cadenas de caracteres, 00:19:31

Que las cadenas de caracteres, recordadlas, encerramos entre dobles comillas. 00:19:34

Lo que hace es concatenarlas. Lógicamente AA más WWW no tiene ningún sentido. 00:19:50

Entonces esto lo que devuelve hacia la izquierda es otra cadena de caracteres que sería de este estilo. 00:19:56

Es decir, el operador más está sobrecargado y tiene diferentes comportamientos dependiendo de lo que se encuentra a derecha e izquierda. Java permite la sobrecarga de operadores, como estamos comentando, pero no permite, este lenguaje en particular, crear nuevas funcionalidades para un operador, cosa que sí sucede en otros lenguajes de programación. 00:20:02

podríamos definir nuevos comportamientos y lo que te encuentras a la izquierda es algo en particular 00:20:23

que el más haga una cosa diferente de las que tiene preestablecidas por defecto para lo que 00:20:27

esté programado hasta ahora java no lo permite está sobrecargado los operadores pero no permite 00:20:33

sobrecarga definir tus sobrecargas para operadores pero en cambio si lo permite para métodos entonces 00:20:39

imaginaros que aquí en clase principal tuviésemos un método que es public void saludar 00:20:45

Y aquí ponemos un System, Intel N. 00:20:57

Bueno, aquí tendríamos un método que es una de las acciones 00:21:16

que es capaz de hacer todo objeto de la clase, clase print. 00:21:19

En particular, si llamamos para un objeto de la clase print 00:21:24

al método saludar, lo que hará será sacar por pantalla un hola. 00:21:27

Si ponemos aquí el método saludar de nuevo para que saque un hola 2, 00:21:31

fijaros cómo ahora ya no le gusta. 00:21:40

nos deja de compilar aquí, veis que se ha puesto los dos saludar en rojo 00:21:42

y aquí me avisa, que es lo que sucede, que si yo ahora cojo 00:21:46

y llamo a un objeto de la clase print 00:21:49

vamos a definir un objeto de la clase print, mi objeto 00:21:54

hacemos un new, si yo ahora hiciese 00:21:59

esto, mi off y pusiera aquí saludar 00:22:12

este objeto intentaría saludar, pero resulta que en mi código 00:22:14

hay dos opciones, es decir, no se puede ir a una de ellas 00:22:20

de forma particular. No sabe si ejecutar esta parte del código o esta 00:22:24

cuando le digo saludar. Con lo cual, ante esta discrepancia, me dice 00:22:28

esto no es posible, no dejo que compiles. Y eso que los dos métodos 00:22:32

reciben el nombre saludar. Existe la posibilidad de sobrecargar 00:22:36

el método saludar si aquí dentro de los paréntesis 00:22:40

meto algo diferente. Entonces, aquí le estoy diciendo 00:22:44

un método saludar con los parámetros en blanco y aquí podría poner 00:22:48

por ejemplo un string ssal 00:22:52

entonces fijaros como ya si que me compila, ya se ha quitado 00:22:55

el error, el hecho de que se quite el error quiere decir que si yo ahora 00:23:00

llamo a mi og y llamo a saludar sin nada entre los paréntesis 00:23:04

no hay lugar a dudas entre si quiero ejecutar este o este 00:23:08

porque cual de los dos es el que no tiene nada entre los paréntesis, este verdad 00:23:12

En definitiva, me pondría hola. Si yo ahora cojo y pongo mi obj.saludar, fijaros, este tiene la posibilidad de recibir aquí una variable que es de tipo string. 00:23:16

¿Veis? Entonces aquí le podría pasar yo una variable de tipo string o un string. Voy a poner hola desde main. Entonces si yo llamo a este, está claro que durante la ejecución, en el momento de ejecución, sabe si llamar a este saludar o llamar a este otro. 00:23:33

¿Por qué? Porque el único que recibe una cadena de caracteres es este segundo saludar, con lo cual este otro, la ejecución que haría sería esta. 00:23:53

Entonces esto, como el método en ambos casos se llama saludar, se entiende que ese método está sobrecargado y tiene comportamientos diferentes en función de los parámetros de entrada que tenga el método. 00:24:03

estos parámetros de entrada se pueden utilizar como variables internas dentro del método esto ya hablaremos de ello pero bueno os voy contando cosas aunque luego lo volvamos a contar fijaros aquí podemos poner un system of println de ese sal y mirad si aquí definimos un string para que tengáis toda la jugada ponemos aquí variable interna podríamos poner un system of println de esta otra variable 00:24:14

Mira, si repasamos este código, ¿qué es lo que haría? Bueno, tenemos aquí el escáner y luego vamos a empezar a hacer estas cosas para hablaros de la sobrecarga y que entendáis por qué este tiene algo aquí en la llamada. 00:24:49

Esta llamada es equivalente a esta otra. ¿Por qué? Porque es un método constructor que en particular es capaz de recibir como parámetro un flujo de datos, igual que este es un método, en este caso no es constructor, es el método saludar, que es capaz de recibir como parámetro una cadena de caracteres. 00:25:08

ahora retomamos lo del escáner que os iba a contar 00:25:33

pero vamos a terminar de ver esto que os estaba poniendo 00:25:36

por aquí, la secuencia del programa 00:25:39

aquí definiríamos un flujo de datos al teclado 00:25:42

que en principio en este código no estamos utilizando 00:25:45

después, pero bueno, ahí está 00:25:48

luego definimos un objeto, miog, de la clase print 00:25:50

le pedimos al sistema operativo 00:25:54

que haga las reservas necesarias para que miog 00:25:57

tenga sus espacios de memoria y sus recursos 00:26:00

para ir trabajando, llamamos a un método, fijaros que es un método 00:26:03

como os digo, en este caso se llama igual que la clase 00:26:07

con lo cual es un método constructor, que nos serviría 00:26:11

para meter cosas de inicialización a este objeto 00:26:16

si no lo hemos construido, se crea uno por defecto que hace poca 00:26:19

cosa, pero bueno, para poder hacer el new de un constructor 00:26:23

aunque no lo tengamos nosotros puesto aquí en el programa, y luego para ese objeto 00:26:28

hemos hecho una sobrecarga del método saludar, definiendo 00:26:31

dos veces ese método, como veis, y está 00:26:36

sobrecargado, porque es el mismo método, en ambos casos se saluda 00:26:39

y nos permite la compilación porque hemos puesto en su 00:26:44

asignatura, en su cabecera, la diferencia 00:26:47

en tanto en cuanto tiene parámetros de entrada diferentes, este no recibe ningún 00:26:51

parámetro de entrada y este recibe uno. Por aquí, no hay 00:26:55

lugar a dudas a qué método saludar llamamos al no pasarle parámetros con lo cual se ejecutaría 00:26:59

este hola y cuando llamemos a este tampoco hay lugar a dudas porque estamos llamando al que 00:27:04

tiene una cadena de caracteres de entrada con lo cual correspondería a este fijaros si aquí 00:27:09

pusiésemos mi op punto saludar y decidimos pasarle algo diferente a que este vacío o a que sea una 00:27:16

cadena de caracteres, ponemos aquí un número, un 1, pues ya este se queja, dice mira, sé que quieres 00:27:26

llamar a un método saludar, tengo conocimiento de que lo tienes sobrecargado, pero justo no has 00:27:32

hecho una sobrecarga en la cual se reciba como parámetro de entrada un número, con lo cual este 00:27:39

no te lo acepto. Si quieres poder llamar a un método saludar en el cual se recibe un número 00:27:44

entero, tendrás que definirme el método sobrecargado que tenga como parámetro de entrada un entero. 00:27:51

Este lo quitamos de momento y cuando llamamos a este fijaros lo que pasa. El código viene por aquí, la secuencia del código vendría, haría esto, haría este saludar, haría un paréntesis aquí en el main y se vendría a ejecutar esto, ejecutaría todo el código del método y a la que termina volvería por aquí y continuaría con la secuencia de instrucciones que tenemos en el main. 00:27:58

luego llamaría a este otro y se pondría a ejecutar todo este método main 00:28:22

al ejecutar este método main estamos definiendo una variable 00:28:26

sbar int, la hemos dado un valor inicial de variable interna 00:28:31

sacamos por pantalla un literal 00:28:35

con lo cual pondrá holador directamente, sacamos por pantalla 00:28:39

la información que tiene sbar int 00:28:43

con lo cual es previsible que nos va a decir hola var interna 00:28:46

Y luego sacamos por pantalla la información que tiene una variable, ese sal, que justo es la que hemos recibido aquí como parámetro. 00:28:50

Y en esta variable lo que se carga es justo el valor que le hemos puesto aquí en la llamada. 00:29:00

Con lo cual, en el momento de llamarlo, ese sal cogerá el valor que le estemos pasando aquí en la llamada como parámetro. 00:29:07

Con lo cual, ese sal valdrá hola desde main. 00:29:14

mirad, si hacemos aquí una ejecución 00:29:16

pues nos dice 00:29:20

un hola, que corresponde a este 00:29:22

hola, cuando llega por aquí 00:29:24

me muestra 00:29:26

este hola 00:29:28

luego llama a saludar2 00:29:29

que nos muestra un hola2 00:29:31

nos muestra la información 00:29:34

de ese var interna, hola var interna 00:29:36

veis, y luego 00:29:38

hola desde main, que es la información 00:29:40

que tiene ese sal, porque se ha 00:29:42

cargado hola desde main aquí 00:29:44

Si hiciéramos otra llamada a este mismo método, cambiando la información de la cadena de caracteres que pasamos como información en el parámetro, si le damos otra ejecución nueva, fijaros cómo nos muestra este hola primero, que corresponde a esta llamada. 00:29:45

luego llama este y nos dice 00:30:08

hola2 00:30:11

la información que tiene la variable interna 00:30:13

que es lo siguiente que mostramos es hola var interna 00:30:17

ese sal y en esta primera llamada es 00:30:19

hola desde main y luego en la segunda 00:30:22

llamada volvemos a mostrar hola2 ese var interna 00:30:26

y en esta ocasión ese sal 00:30:29

dice hola desde main2 pues concepto de sobrecarga 00:30:31

concepto de sobrecarga y ver 00:30:36

la posibilidad de pasar parámetros 00:30:41

a un método, este caso es el método 00:30:43

constructor, pero podría ser 00:30:45

cualquier otro método de los que tengamos 00:30:47

definidos, como por ejemplo el método saludar 00:30:49

si os surge en duda 00:30:51

me vais parando, me vais diciendo 00:30:56

si no yo os sigo contando 00:30:57

pues 00:30:59

hablado un poquito de eso, seguimos con 00:31:02

lo que os iba a comentar del escáner 00:31:05

disculpad, vale pues aquí 00:31:07

Lo que hemos hecho, haciendo un repaso de esta instrucción, ha sido crear en definitiva un objeto MiSCAN. 00:31:11

Y le hemos dicho que el otro lado de la tubería se conecta a System.im, que hemos comentado que es uno de los flujos de entrada estándar, que es el teclado. 00:31:17

Para que en el programa nos salga algo por pantalla cuando nos pide información, podemos poner un System.out. 00:31:27

Dime un valor numérico. 00:31:45

Mira, antes os he dicho, en Java son todo clases, siempre son todo clases. Para trabajar con un objeto, para llamar a métodos, la norma general es crear un objeto. ¿Por qué? Pues como hemos hecho antes con la clase, clase print, que hemos creado un objeto y luego hemos llamado a los diferentes métodos saludar que estaban sobrecargados. 00:31:50

cada vez que creamos un nuevo objeto 00:32:24

se hace con el new, se hace una reserva de memoria 00:32:27

para las variables de ese objeto y se llaman a una serie de métodos 00:32:31

que están particularizados para ese objeto, es decir, cada uno 00:32:36

tiene cada nuevo objeto, si pensamos en la clase persona 00:32:39

si creamos la clase persona per1 new persona 00:32:44

pues cada per1 tendrá su espacio de memoria donde podremos 00:32:47

a guardar su nombre, su edad y podremos llamar a unos métodos 00:32:51

que son particulares suyos. Si aclaramos la clase persona 00:32:55

per dos, pues al hacer el new en otro espacio de memoria 00:32:59

de la RAM, reservaremos un trocito en el cual 00:33:03

podremos guardar su nombre, su edad, los parámetros que hayamos definido 00:33:07

en ese proyecto para la clase persona. 00:33:11

La semana pasada ya os hablaba de la etiqueta static. 00:33:15

La etiqueta static lo que hacía era que los parámetros y los métodos, en este caso está aplicado al método main, los parámetros y los métodos que definamos como estáticos, en lugar de ser particulares de cada objeto y tener una copia para cada uno de los objetos que definamos, 00:33:19

Por ejemplo, como decía, el objeto per1 de persona tendrá un espacio para su nombre y sus apellidos y su DNI y el objeto per2 de la misma forma. Si definimos algún parámetro o algún método de forma estática, eso es común para todos los objetos que pertenezcan a esa clase. 00:33:40

Es decir, que si modificamos el espacio de memoria es único correspondiente a la clase y en un espacio de memoria diferente para cada uno de los objetos. 00:34:00

¿Qué es lo que sucede aquí? Fijaros, println tiene pinta de ser un método, ¿verdad? Porque está aquí entre paréntesis. 00:34:10

un método que recibe un parámetro alfanumérico, pero para utilizar println en nuestro código por aquí no hemos instanciado un objeto de ninguna clase, 00:34:19

directamente lo hemos llamado. ¿Por qué sucede esto? Pues porque el método println, en primer lugar, system.out pertenecerá a la clase java.lang, 00:34:31

porque no hemos necesitado importarlo. 00:34:43

Y en segundo lugar, hemos llamado a println un método 00:34:46

sin haber instanciado, sin haber hecho un new de ningún objeto. 00:34:48

¿Eso por qué es? Porque println está definida 00:34:52

en las librerías de Java, en particular 00:34:55

la librería java.lang está definido como un método 00:34:58

estático, con lo cual podemos poner el nombre de la clase 00:35:01

que es out del paquete system 00:35:04

y utilizar directamente el método sin haber instanciado 00:35:06

nada. Puedo ir fijando conceptos del estático y ir entendiendo cada una de las líneas que vamos 00:35:10

poniendo. Bien, pues entonces aquí podríamos definir una variable int y valor. Y valor, volvemos a repasar 00:35:17

conceptos del otro día. Y valor es una variable de tipo int. Hay una serie de tipos de datos que son 00:35:29

los tipos de datos primitivos de Java. Estos tipos de datos dan un pasito más allá y para hacer la 00:35:35

reserva de memoria RAM en la cual se van a guardar estos, es un tipo 00:35:43

de datos primitivo. Entonces, para hacer la reserva de memoria RAM 00:35:47

no necesitamos, como en los referenciados, hacer el new para solicitarse 00:35:50

al sistema operativo. Directamente, a la hora de definir un tipo 00:35:55

de datos de los primitivos, que son el int, el long, el float, todos estos, 00:35:59

ya se hace esa reserva de memoria, donde se va a guardar 00:36:04

la información. Y aquí ponemos mi scan, 00:36:07

ponemos un igual por aquí 00:36:11

igual miScan 00:36:15

punto, entonces decimos que 00:36:22

esta variable, hacemos una lectura de derecha 00:36:26

a izquierda, a esta variable se le va a asignar 00:36:28

lo que pongamos por aquí 00:36:30

devuelva hacia la izquierda 00:36:32

miScan es un objeto de la clase Scanner 00:36:34

y tiene un montón de métodos 00:36:36

por aquí 00:36:38

este es un objeto 00:36:38

que tiene a su disposición todo 00:36:41

método que esté definido en el esquema 00:36:43

de la clase Scanner 00:36:46

y entre ellos, pues fijaros, tenemos un 00:36:47

si lo seleccionamos aquí nos dice que busca el siguiente token de una entrada que sea de tipo entero 00:36:49

entonces utilizamos nesynth, en principio esto leerá un entero desde el flujo de entrada que hayamos definido 00:36:58

para mi scan, objeto de la clase scanner, que en particular en el constructor le hemos dicho que sea system.min 00:37:07

con lo cual sabemos que es el teclado, si nosotros hacemos aquí un system.out.print 00:37:12

el n de y valor 00:37:19

si ejecutamos ahora, se me queda aquí, dime un valor numérico porque me ha mostrado 00:37:22

esto, el programa no ha continuado porque se ha quedado aquí esperando hacer esta 00:37:32

lectura, si yo ahora pongo aquí un 4, este 4 lo he escrito yo con 00:37:36

el teclado, doy enter, pues fijaros, carga el 4 00:37:40

aquí, me lo muestra por pantalla y ha ido todo correcto 00:37:44

lo que pasa es que cuando nosotros, si estamos haciendo con 00:37:47

escáner una lectura desde teclado si nosotros ponemos un 4 y enter lo que estamos haciendo es 00:37:52

meter digamos dos caracteres uno que es el 4 y otro el carácter así no me acuerdo qué número es 00:37:58

que es el enter o incluso el ente a lo mejor son dos son retorno de carro y nueva línea en 00:38:05

definitiva para que esto siga adelante hemos metido el 4 y el ente y éste en el sindh me 00:38:11

se encarga de coger el número entero, el 4 00:38:18

y el enter no le preocupa tanto. Entonces fijaros, 00:38:22

imaginaros que nosotros estuviésemos aquí en nuestro 00:38:26

programa lo siguiente. Queremos coger un valor entero 00:38:30

y decimos system out, println 00:38:34

dime tu nombre. 00:38:42

Porque queremos coger un valor entero, imaginaos en lugar de un valor 00:38:50

numérico dime tu edad y luego dice dime tu nombre dice pues mira la edad la vamos a con un es ind y 00:38:54

el nombre vamos a definir una variable de tipo string ese nombre y aquí cogemos y hacemos un 00:39:01

scan y aquí para el nombre bueno pues queremos una línea porque podemos poner un nombre con varias 00:39:11

palabras pues hacemos un es line vale pues parece que tiene sentido que aquí cogemos y decimos vamos 00:39:16

a meter de edad 18 años 18 y luego cuando me pida el nombre vamos a poner un nombre que sea noa por 00:39:26

ejemplo y luego ya una vez que tengo todos los datos vamos a coger y vamos a sacar el resultado 00:39:34

aquí ese nombre que me diga primero la edad me escriba por pantalla la edad y luego el nombre 00:39:42

Aquí ponemos edad, utilizamos el operador más para concatenar y nombre. Entonces fijaros, si yo cojo ahora y le doy aquí a ejecutar esto, dice dime tu edad, voy a poner que tiene 18 años y le doy enter y fijaros lo que pasa. 00:39:48

que me ha mostrado nombre y me lo ha mostrado 00:40:14

en blanco, que es lo que ha sucedido 00:40:17

cuando yo he puesto 00:40:19

aquí 18 y le he dado enter 00:40:21

el 18 me lo ha cargado en iValor 00:40:23

el enter no me lo ha considerado 00:40:25

ha escrito dime tu nombre 00:40:27

y 00:40:29

en el siguiente nestline 00:40:31

ha considerado el enter pero el enter 00:40:33

que había metido cuando he puesto el 18 del 00:40:35

nesint, con lo cual ha cogido 00:40:37

un enter, aquí ha cargado algo vacío 00:40:39

y cuando ha mostrado nombre 00:40:41

no me ha puesto ningún dato 00:40:42

aquí es muy lineal y se ve claro, pero si en diferentes partes 00:40:44

del programa estuviera este código, hubiera muchas líneas 00:40:52

entre medias o incluso un bucle que parece que te lleva a otra zona de código 00:40:56

a verlo o la llamada a una función o algo de eso 00:41:00

podríamos perder de vista que es esto lo que está pasando y es un típico 00:41:03

error que para darte cuenta que el problema es que el enter de este 00:41:08

es el que está leyendo aquí, cuesta a veces 00:41:12

y te puede volver loco puedes revisar el programa mil veces y parecerte que está correcto qué 00:41:16

soluciones tenemos pues como si queréis mantener utilizando el nes int porque alguien le gusta 00:41:22

mucho en la práctica no se daba este error pero como yo lo conozco ya otras veces pues os lo he 00:41:28

advertido en los comentarios de la práctica y os lo lo refiero aquí una de las posibilidades que 00:41:33

podríamos tener aquí es poner hacer un es line aquí me va a leer el número y aquí va a leer el 00:41:38

enter pero en realidad después de la lectura como no se lo estoy asignando a nadie por aquí es como 00:41:50

que no pasa nada entonces esto con esto limpiaría el enter del nes int y luego ya se me quedaría 00:41:55

aquí porque no he introducido dos enter cuando meto la edad de si yo ejecuto esto ahora dice 00:42:04

dime tu edad. Y digo 18. Y ahora dice dime tu nombre. ¿Veis que no ha ido 00:42:11

todo de corrido? ¿Por qué? Porque el enter del nesin lo he limpiado aquí. 00:42:15

Y ahora pongo aquí noa. Voy a enter 00:42:19

y ya lo coge bien. Aquí carga noa. Ya me dice la edad y el nombre. 00:42:23

Esa sería una alternativa. Limpiarlo haciendo un nesline 00:42:27

para quitar ese enter que en realidad está asociado con el número que hemos metido 00:42:31

desde teclado. Y otra de las opciones, yo no la suelo utilizar más 00:42:35

pero bueno, si tenéis cuidado para que no os pase 00:42:41

pues vale cualquiera y si no se da esta situación 00:42:44

pues vale con que lo leáis con un Synth 00:42:48

y la otra opción es hacer siempre 00:42:50

aquí un Sline, es decir, cogerlo 00:42:54

siempre como una cadena de caracteres 00:42:57

claro, una cadena de caracteres nos recoge 00:43:02

el valor como un String, vamos a crear una variable 00:43:11

auxiliar y ahora en sí 00:43:15

aquí lo que haríamos sería coger el número, pero 00:43:22

si metemos un 18, en realidad 00:43:26

estaría cargando el 18, pero lo estaría cargando de esta forma, porque lo estamos cargando 00:43:31

en una cadena de caracteres, en un string. Y lo que 00:43:35

queremos, finalmente, para luego operar con ello, en el ejercicio es 00:43:39

un valor entero, el que nos vale a partir 00:43:42

de aquí es este y no este, que es el que hemos cargado desde el 00:43:47

next line. Entonces aquí lo que vamos a utilizar es la clase 00:43:50

integer, parseInt, que recibe como parámetro 00:43:54

una cadena de caracteres, que es la variable 00:44:02

en este caso que tiene el número de esta forma, como cadena de caracteres, y lo que 00:44:06

hace es convertirlo a una variable de tipo entero, devuelve 00:44:10

una variable de tipo entero, con lo cual ya tendríamos aquí el iValor. 00:44:14

Aquí no tenemos el problema del enter de esto, porque 00:44:21

del problema que se nos daba antes con el enter 00:44:23

cuando hacíamos un nesint, porque estamos leyendo una línea entera 00:44:26

ya, con lo cual nos estamos ya quitando del medio 00:44:29

el enter, cogemos el número, lo convertimos 00:44:32

a entero y luego nos pedirá el nombre 00:44:36

que cogemos el nombre y ya mostramos los dos datos. 00:44:38

Entonces decimos 18, dime tu nombre 00:44:44

Noah y ya nos funciona bien. 00:44:46

Entonces esta sería otra alternativa. 00:44:50

Si ponéis esto siempre, pues sabéis que luego no vais a tener 00:44:53

problemas posteriores no si lo manejáis cogiéndolo con un slide y haciendo la conversión que toque 00:44:56

mira si lo que tenéis es un double pues existe la clase double punto parce double 00:45:04

según el tipo suele haber una clase de asociada a ese tipo que nos permite bueno que tiene muchos 00:45:14

parámetros tienen muchos métodos y parámetros por aquí como podéis ver pero uno de ellos es 00:45:22

es el parse, parse double 00:45:26

recibe una cadena de caracteres y la convierte 00:45:28

en este caso a un double 00:45:31

una variable con 00:45:32

decimales, otra cosa 00:45:34

bueno esta 00:45:39

era la jugada de lo del 00:45:42

escáner que os quería comentar, de la mano 00:45:44

de esto, fijaros 00:45:46

como aquí estamos utilizando 00:45:48

una clase integer 00:45:50

resulta 00:45:52

que los tipos primitivos 00:45:54

cuando nosotros 00:45:56

definimos en java 00:45:58

por ejemplo, la clase Scanner en las librerías o una de nuestras clases, 00:45:59

decimos que tenemos parámetros sin métodos. 00:46:03

Para estas clases, además, tenemos que hacer un new. 00:46:07

Los tipos primitivos de Java no tenemos que hacer el new, como hemos dicho. 00:46:11

Pero, además, no tienen disponible en principio métodos, las variables primitivas. 00:46:17

Cuando trabajamos con una variable primitiva y queremos utilizar métodos que típicamente estarían definidas en una clase relacionada con este tipo de datos, por ejemplo, la posibilidad de convertir una cadena de caracteres que tenga un valor entero en lo que es el número, en Java existen unas clases que se llaman clases envoltorio, clases wrapper y cada uno de los tipos primitivos tiene una asociada. 00:46:25

Entonces el tipo int tiene la clase WrapperInteger que tiene a nuestra disposición una serie de métodos y parámetros que suelen estar relacionados con tipos de datos enteros que vamos a tener típicamente almacenados en el tipo primitivo int. 00:46:51

la clase double de valor 00:47:14

pues de valor es un tipo primitivo 00:47:19

para de valor no vamos a tener que hacer un new de la memoria RAM 00:47:23

porque es un tipo primitivo, pero normalmente no va a tener definidos métodos 00:47:28

si queremos trabajar con métodos relacionados con lo que sería el tipo 00:47:32

primitivo double, existe una clase 00:47:36

envoltorio para double que es double 00:47:39

y esta tiene una serie de parámetros y una serie de métodos 00:47:42

que nos permiten trabajar con ello, fijaros aquí tenemos 00:47:56

para double, para integer, tenemos el máximo valor que es capaz 00:48:00

de almacenarse en una variable de tipo double, el mínimo valor 00:48:04

el mínimo valor, el normal value, no sé cuál es 00:48:08

mínimo normal, no sé qué será, bueno y luego métodos 00:48:12

el máximo, fijaros, la clase grupper double nos permite 00:48:18

tiene un método que nos devuelve cuál de los dos 00:48:22

double que le pasemos como parámetros, double A y double B, es mayor 00:48:26

el máximo de los dos, el mínimo, el pase double 00:48:31

que es el que os estoy comentando ahora, bueno, pues un montón, algo que te 00:48:34

devuelve, hace una suma de dos double y te devuelve otro double 00:48:38

bueno, pues sería como poner un más, ¿no? bueno, ya veis aquí 00:48:42

un montón de cosas, ¿vale? es decir, existen las clases 00:48:45

Rapper para los 00:48:50

Tipos primitivos 00:48:52

¿Dudas? ¿Alguna cosilla por ahí? 00:48:54

¿Seguís por ahí, verdad? Eso sí 00:49:04

Ah, vale, vale 00:49:06

Bien, bien, no, no, por si acaso 00:49:11

Yo que sé, os pierdo y como 00:49:13

En alguna otra ocasión nos ha pasado 00:49:15

Que estaba hablando yo solo 00:49:17

Y luego al ratillo me habéis avisado 00:49:20

Como la red a veces va un poquillo mal 00:49:22

Vale, bueno, pues hasta aquí 00:49:24

Alguna cosilla 00:49:25

Intento ir muy despacito contándoos 00:49:26

Cada línea hay mil películas de cada una de las líneas. 00:49:30

Si os aburro, me avisáis. 00:49:33

Si no, pues sigo así. 00:49:35

Vale. 00:49:37

Si no, pues sigo así para ir contando, 00:49:38

haciendo repaso todo el rato de la teoría. 00:49:41

Mirad, otra cosa de las que... 00:49:43

Sí. 00:49:46

Sí, sí, igual que las otras clases. 00:49:51

Sí, sí, la estoy grabando. 00:50:02

Si no tenemos algún problema por ahí técnico 00:50:03

y termina por no grabarse, 00:50:06

en principio he chequeado la grabación 00:50:08

antes de arrancar y parecía que lo hacía bien. 00:50:10

Y las tres últimas no habéis tenido problemas para verlas luego, ¿no? 00:50:12

O sea, ¿están bien? 00:50:16

¿Sí? ¿Bien? Vale. 00:50:18

Pues bueno, pues en principio está igual. 00:50:19

Estoy grabándola igual que las otras, sí. 00:50:22

Vale, pues mirad otra de las cosas que aparecía en el tema 2 00:50:25

y me pusisteis en uno de los silos una pregunta. 00:50:30

Alguien fue en relación a los castings. 00:50:34

como tenemos los tipos de datos primitivos 00:50:37

vuelvo a ellos, por ejemplo el int y valor 00:50:42

pues valor será una variable de tipo entero 00:50:44

y tiene un determinado espacio en memoria RAM para guardar 00:50:49

enteros, de hecho tiene un rango 00:50:54

mirad, integer.masvalue 00:50:57

system.out.println 00:51:02

minValue, vamos a sacar el valor máximo y mínimo que puede tener un entero 00:51:07

pues nada, mirad, cuando definimos una variable de tipo entero 00:51:25

su valor puede ir entre este numerajo en positivo y este numerajo en negativo 00:51:29

si definimos un long 00:51:34

long también es un tipo de valor que admite 00:51:36

enteros, pues aquí podríamos utilizar la clase 00:51:43

graper como os decía antes, long.masValue 00:51:47

para el long y long.minValue 00:51:51

entonces si hacemos otra ejecución por aquí, fijaros 00:51:57

como los long hacen una reserva de un mayor 00:52:02

número de bytes en memoria RAM cuando para este tipo 00:52:06

primitivo se coge espacio y 00:52:10

por lo tanto es capaz de almacenar un rango mucho más grande, los enteros 00:52:13

este, los long este, si nuestro 00:52:18

programa no va a necesitar números mayores que éste, pues definimos enteros y menos memoria RAM 00:52:22

que estamos consumiendo. Si se nos quedan cortos estos números, el número de gotas de agua que 00:52:26

tiene el océano, pues lógicamente esto no nos va a valer, seguramente este tampoco, pero con este 00:52:33

tendremos más posibilidades o una piscina. Entonces tendremos que saber un poco los rangos de valores 00:52:38

que va a manejar nuestro programa para definirlo como long o como entero. ¿Qué sucede si nosotros 00:52:44

cogemos y decimos que y valor es igual a 5 y lo decimos pues mira dentro de mi programa yo quiero 00:52:51

como son los dos valores enteros quiero que el valor que es el long sea igual a y valor pues 00:52:59

esto le vale porque porque algo que podemos guardar un número entero que va desde este rango a este 00:53:09

este negativo si este tiene un rango mucho mayor lógicamente también se podrá guardar tenga me da 00:53:16

igual el valor que tenga el entero, tanto si es un 5 como si es este valor 00:53:23

máximo o este valor mínimo, que entra dentro del rango que es capaz de almacenarme 00:53:27

el long. Con lo cual, coge y dice, esta asignación me gusta. 00:53:31

En cambio, si ahora cojo y digo, iValor 00:53:36

igual a lValor, esto no me 00:53:39

compila. No sé si lo he puesto bien. 00:53:43

No me compila. ¿Y por qué no me compila? Porque el long podría tener 00:53:47

un valor almacenado, dado que su rango lo permite, mayor 00:53:51

que el que podemos guardar un entero. Entonces, si aquí tenemos 00:53:54

en lugar de este numerajo, este número pero acabado en 8, 00:53:59

este número podría ser el que tuviera L valor y si se lo intento meter a un 00:54:03

I valor, no va a entrar. ¿Qué sucedería? Pues que perderíamos 00:54:07

ahí o bien precisión o se podría provocar ahí un error 00:54:11

en ese entero y decir, oye, mira, a partir del programa 00:54:15

no es me fío mucho cuando vayas a trabajar con este entero porque su resultado puede ser erróneo 00:54:19

porque las ha asignado se se prevé que tiene el valor del long y en cambio vete tú sabes lo que 00:54:26

tiene porque no entraba el programa aquí no nos va a dejar continuar no va a compilar no vamos a 00:54:32

tener los puntos class con él con el vice code con lo cual el programa nos sale adelante ahora que 00:54:38

Java dice, yo no quiero que a mí me culpes de este posible error, si se te da más adelante cuando ejecutes el programa. Pero Java dice, si tú aquí de forma explícita me dices que asumes que esto puede tener un error y dices que este L valor lo ajuste al tamaño de un entero, que probablemente si tú lo estás poniendo esto es porque el valor que va a tener el long normalmente va a estar en este rango, con lo cual no va a haber errores. 00:54:45

Pero podría ser que no, claro. Si tú me lo dices de forma explícita, yo aquí ya acabo de firmar un contrato contigo y si luego hay un error, allá tú, tú eres el culpable, no yo, Java. 00:55:15

Entonces esto se llama casting. Cuando un valor que permite un rango mayor de enteros, se lo asignamos a un valor con un rango menor, pues necesitamos hacer un casting. 00:55:25

aquí es necesario el casting no en ningún caso porque java ya tiene seguridad de que no va a 00:55:36

haber error todo lo que guarden en un entero de tipo int va a entrar en el rango de un entero 00:55:42

de tipo logo entonces esto es lo que lo que hace referencia al casting está asignada esta 00:55:48

confirmación desde el código de que a pesar de que ahí se puede producir un error yo lo asumo 00:55:55

y sigue adelante programa si luego se da el error pues aquí lo asumiste esto ya es culpa tuya por 00:56:02

haberlo por haber hecho esta suposición de que el dato del dato del long era válido y de la 00:56:07

misma forma pasa si nosotros cogemos y definimos un double los double pues acordaros que tienen 00:56:14

decimales decimos que vale 2,5 si yo ahora cojo y digo y valor que el entero tenga la información 00:56:24

de mi double, pues se vuelve a quejar. ¿Por qué? En este caso, aparte de que a lo mejor tienen rangos 00:56:36

que no lo aceptaría el entero la información del double, probablemente, pero además es por una cuestión 00:56:44

de precisión. Si aquí voy a tener un valor entero y este tiene decimales, pues todos los decimales 00:56:50

se van a perder. No me compila la misma jugada que estaba sucediendo aquí. Si yo aún así digo, 00:56:55

mira es que en realidad aquí del valor este que viene arrastrando este double lo que me interesa 00:57:03

en la parte entera en esta variable porque voy a hacer no sé qué operaciones con la parte entera 00:57:09

pues le puede hacer un casting entonces puedo y decirle que lo asuma como un entero 00:57:13

si yo hago un sistema punto out punto println del double lógicamente tiene 2,5 que lo que 00:57:22

le hemos asignado y si lo hago de y valor ejecutó pues se perdió 0.5 se ha producido una pérdida de 00:57:35

precisión pues sí efectivamente porque estamos guardando un valor con decimales en un valor 00:57:50

entero pero yo aquí he dicho que eso lo de por hecho si la jugada al agua al revés necesitaré 00:57:55

un casting pues no porque si digo me da bol que sea igual al valor que tiene y valor esto le 00:58:04

parece bien si hay aquí valor igual a 10 habrá algún problema pues ahora esto será una variable 00:58:12

con decimales a la que si asignó el valor 10 entero pues su valor decimal será 10.0 pero no 00:58:21

hay pérdida de precisión es del 10 al 10.0 el mismo número de si yo aquí vuelvo a mostrar los 00:58:29

dos bueno fijaros como el double vale 10.0 porque sólo hemos asignado aquí desde el entero aquí es 00:58:36

necesario un casting no porque porque no hay lugar no hay opción de perder precisión en el otro caso 00:58:49

era necesario el casting pues sí porque se podía pero era había opción de perder precisión entonces 00:58:56

si quieres seguir adelante reconocerlo tú de forma explícita si alguna cosilla se entiende bien esto 00:59:02

también vale pues a ver estoy mirando bueno entre daba un long tenemos el mismo problema que entre 00:59:11

int y double porque como el double admite decimales y el long no sé en la misma circunstancia que 00:59:33

tenemos aquí entre un int y un long ya que el long admite un rango mayor que el link lo tenemos con 00:59:46

decimales entre el double y el float el float tiene un rango menor que el double entonces si 00:59:52

yo aquí cojo y digo 3 perdón vamos a poner vamos a inicializar el labor si digo 3.2 entonces yo hago 01:00:05

efe vale igual a de bal aquí también se me quejas no se me queja en este caso porque uno tenga 01:00:19

decimales y otro no y se pierda la precisión esa sino porque el double al ser un tipo que ocupa 01:00:29

mayor espacio en memoria ram tiene un rango mayor y su valor aunque este no es el caso simplemente 01:00:35

vale 32 en este caso y también lo acepta un flow at pero a la hora de hacer esta validación el 01:00:41

compilador lo que mira es en los tipos entonces dice la información de un double podría llegar 01:00:46

de tener un valor que no me entrase en un flow at que si yo cojo de aquí a un casting a ver no 01:00:53

era hecho a ver que lo que he hecho aquí no me deja ahora aquí hacer esto yo juraría que el 01:01:07

otro día estoy mirando esto y sí que sí que me funcionó desde una variable no me deja el otro 01:01:28

día lo mire a ver perdón a sí vale vale es porque se vale bien es porque utilizado la grupper se 01:01:37

utilizo el dato primitivo, creo que es por eso, a ver, vamos a hacer la prueba y os lo reviso, aquí sí lo traga, vale, no me estaba dejando hacer una conversión desde este double que era la clase stackwrapper que os he dicho que tenía luego parámetros por aquí para poder utilizar, pero si utilizamos los tipos primitivos, igual que habíamos hecho con el long, es decir, en lugar de definir la variable double, la he definido con este double, 01:01:53

pero con la d minúscula, veis que se ha puesto así, ya es el dato primitivo y ya sí que me deja hacer el casting. 01:02:23

Y en cambio aquí, pues no me dejaba. Por el mismo motivo del int y del long de antes, por el tamaño. 01:02:31

Y luego otra cosilla que veíamos era que si poníamos fval igual a 3.4, esto no le gustaba. 01:02:41

Y esto tampoco le gusta, porque este tipo de dato, si lo ponemos aquí directamente, Java lo considera como un double. 01:02:50

Entonces estamos en la misma jugada que si ponemos una variable tipo double asignándosela a un float. 01:02:59

En el momento de no indicar si es un double o un float, Java tendría que tomar una decisión. 01:03:08

¿Lo guardo en un espacio de memoria float o en un espacio de memoria double? 01:03:12

Y por lo que sea, Java está programado para considerarlo un double. 01:03:16

como se lo intentó meter luego un flow at por dice no va a esta información que es un double 01:03:19

en este valor que es un flow at aquí podríamos hacer un casting también y se lo tragaría 01:03:24

o indicar al número si le aquí después le ponemos una f estamos diciendo que este 3.4 en realidad es 01:03:32

un valor que lo considere flow at ya desde este momento entonces aunque no pongamos el casting 01:03:41

le deja, porque este 3,4 en realidad es un float, que se lo estoy asignando 01:03:46

a una variable float. ¿La f minúscula también se la deja? 01:03:50

Sí. Podemos poner la f minúscula, f mayúscula, después del número 01:03:54

para decir, oye, que esto es un float, no es un double. 01:03:58

Si no ponemos nada, lo considero un double. Si ponemos una d, no. 01:04:02

Para que sea un... A ver, si ponemos una d 01:04:05

y hacemos el casting. Bien. Si ponemos una d, lo considera 01:04:09

double, que es igual que no poner nada, si ponemos una F, lo considera float. 01:04:17

¿Sí? ¿Bien? Vale. 01:04:31

Pues mirad. Vale, borro por aquí, si no tenéis ninguna pregunta más 01:04:36

de esto del casting, que era otra de las cosas que nos había quedado un poco por ahí pendientes. 01:04:40

Mirad, más cosas. Cuando nosotros 01:04:51

ponemos el método system.out.println 01:04:55

aquí, entre 01:05:00

paréntesis este método recordar system out para escribir por pantalla si éste no tiene diferentes 01:05:06

opciones fijaros tiene muchos métodos típicamente utilizamos el println pero podemos escribir de 01:05:13

muchas formas tiene muchas alternativas println otra que tiene sprint sin el en el ln que nos 01:05:18

deja el cursor al final de lo que acabamos de escribir normalmente aquí lo que ponemos es una 01:05:28

cadena de caracteres algo o bueno ponemos una cadena caracteres o 01:05:36

cualquier otra cosa pero aquí lo que nos escribe es un texto 01:05:40

si ponemos 01:05:46

in a y val igual a 3 y ponemos aquí el número es igual pues fijaros aquí 01:05:49

tenemos una cadena de caracteres aquí tenemos un valor numérico vamos a ejecutar y lo que nos 01:06:05

saca por pantalla es toda una cadena de caracteres al final todo este conjunto se convierte en una 01:06:12

cadena de caracteres lo que hay entre paréntesis tengamos aquí lo que tengamos una combinación de 01:06:20

cosas una variable solo un literal solo una variable string un literal y un número de 01:06:24

De alguna forma, todo esto lo va a terminar convirtiendo en una cadena de caracteres que nos va a mostrar por aquí por pantalla. 01:06:33

Eso es porque todas las clases de Java, todas, tienen un método que es el método toString, que viene a ser convierte a una cadena de caracteres. 01:06:39

Pero podemos decir, vale, me puedo creer que en las clases que tú importes desde las librerías han puesto el método este toString. 01:07:04

me lo puedo creer. Pero en esta clase que estás definiendo 01:07:15

tú aquí en este programa, yo no veo que hayas programado un método 01:07:19

toString por aquí, por ningún sitio. Luego podremos programar el método 01:07:23

a saludar como antes, los que vayan requiriendo nuestro programa, pero yo no veo que hayas 01:07:27

programado ningún método toString. Y en cambio estamos afirmando 01:07:31

que todas las clases disponen de ese método. 01:07:35

En Java y en otros lenguajes en la programación orientada a objetos, 01:07:39

Otra de las características que tenemos con los temas, hablaremos en profundidad si hay temas que tratan de esto en particular, pero vamos anticipando cosas. Igual que tenemos, por ejemplo, la sobrecarga, principio de métodos que hemos visto antes con el método saludar. 01:07:43

Otra de las características que tenemos es la herencia. 01:08:04

Esto quiere decir que existe una jerarquía de clases en Java 01:08:09

y las va nombrando una jerarquía, digamos, en una estructura tipo árbol, 01:08:12

podemos considerar, en la cual tenemos una clase aquí, clase 1 o clase padre 01:08:20

y luego vamos teniendo, podemos a través de la herencia, 01:08:27

hacer que una clase sea una clase hija de una determinada clase padre esto que implica la 01:08:33

herencia hablaremos de ella vale en uno de los temas esto lo que implica es que esta clase hija 01:08:42

cuando la definimos podemos decir que sea hija de una determinada eres hija de una clase padre 01:08:47

en particular. En este caso, la que hemos llamado clase 01:08:57

p. Entonces, todo lo que hay que definir, la clase 01:09:04

hija tendrá como atributos y como métodos todo lo que definamos 01:09:09

en ella, pues igual que estamos haciendo por aquí, sus métodos 01:09:13

y sus atributos, y por herencia, todos los atributos 01:09:17

y métodos que tenga la clase padre. La forma 01:09:21

en Java, ya os digo que hay temas en los que se habla 01:09:29

en particular de esto. La forma de decir en Java que una clase es hija de otra es a través 01:09:33

de la etiqueta extend. Se extiende o hereda, esta clase hereda de una determinada clase 01:09:39

padre. Sería en la clase hija, pondríamos extends clase p. Y en este caso, todo lo que 01:09:46

tiene definida la clase p, lo tenemos disponible nosotros. Cuando definimos una clase, esta 01:09:54

clase puede ser hija de una única clase padre, de una solo. ¿Por qué? Porque 01:10:02

imaginaos que si pudiera ser hija de varias clases al mismo tiempo y cada una 01:10:10

de estas clases definiese un método saludar diferente, con un comportamiento 01:10:18

diferente, volveríamos a tener discrepancias. Imaginaos que en la clase 01:10:22

P, como parte de su código aquí, hemos definido el método saludar. Y en la clase 01:10:26

J también definimos un método saludar con un comportamiento 01:10:31

distinto. Uno dice hola y otro dice buenos días. Entonces, si 01:10:38

la clase H fuese hija de forma 01:10:42

simultánea de la clase P y de la clase J y un objeto de la 01:10:46

clase H intenta saludar, no sabría si ejecutar lo que tiene la clase P 01:10:50

definido para saludar o lo que tiene la clase J. Habría una discrepancia 01:10:54

ahí y no sería posible. Hay algunos lenguajes de programación orientada a objetos 01:10:58

que lo permiten la herencia múltiple aunque hay que manejarla hay que gestionarla pero en java 01:11:02

no se permite herencia múltiple solamente se puede tener ser hija de una clase en particular no de 01:11:10

varias en este caso por ejemplo la clase p entonces si yo no tengo definido aquí cómo saludar saludaría 01:11:15

de la misma forma que esté definido en la clase p además de la herencia está que podemos identificar 01:11:22

nosotros mediante la etiqueta extend, hay una especie de herencia 01:11:29

en todas las clases de Java de una clase 01:11:33

que está arriba del todo en la jerarquía de clases 01:11:37

de Java, que es la clase object. Y esta clase, aunque no le pongamos 01:11:41

el extend, de esta clase sí que heredan todas, todas. 01:11:48

Y en esta clase object existe, entre otras cosas, 01:11:52

el método toString, que os decía, por aquí 01:11:56

arriba en definitiva en cualquier cualquier objeto de cualquier clase tiene un método tu string que 01:12:00

aunque no lo programamos por esa herencia general no por la que identificamos nosotros en nuestro 01:12:09

programa con stand de la clase object todo objeto tendrá ese método tu string disponible se entiende 01:12:15

Sí, más o menos, sí, vale. Entonces, de forma implícita, no es necesario indicarlo, todo lo que pongamos aquí entre la apertura y cierre de paréntesis, sea una cadena de caracteres, un literal, una variable string, un entero, un long o lo que sea, 01:12:25

antes de escribirse por pantalla en el println 01:12:59

llama al método toString y concatena 01:13:03

todas esas variables. Como consecuencia aquí nos sale siempre 01:13:07

un método toString. Fijaros que toString 01:13:11

viene a significar convertir a string, lo que sea. 01:13:14

Si fijáis, por ejemplo, si ponemos aquí integer, la clase griper de integer, si ponemos 01:13:19

aquí toString, ¿veis? Existe una clase toString que 01:13:23

recibe un entero, el valor entero y nos devuelve 01:13:27

¿qué? nos devuelve una cadena de caracteres, con cualquiera 01:13:31

todas ellas, mira si definimos aquí 01:13:35

clase print 01:13:38

un objeto de mi clase 01:13:43

si pongo mi object.toString, ¿veis? 01:13:48

también la tengo disponible, siempre cualquier objeto 01:14:02

aunque no lo haya identificado, tanto la clase grupper de las librerías 01:14:06

integer, como cualquier otra, como un objeto de una clase 01:14:10

mía propia, aunque no lo haya definido, siempre tiene disponible 01:14:14

el método toString y fijaros, lo tiene disponible, devuelve un string 01:14:18

lo tiene disponible desde una clase, digamos 01:14:22

padre, que es la clase object que os comentaba 01:14:26

esto es lo que permite que el system of println tengas aquí 01:14:29

el tipo de variable que tengas, este método espera siempre que todo esto se resuelva a una cadena de caracteres 01:14:34

que es la que él va a mostrar por pantalla. Y lo que no es cadena de caracteres llamará de forma implícita, 01:14:41

no hace falta que lo hagamos nosotros, al toString que tenga definido para convertirlo en una cadena de caracteres 01:14:48

y que el println lo muestre por aquí. Si es un entero, pues el toString de la clase grupper del entero, 01:14:55

¿qué hará? Pues convertirá este valor numérico, convertirá en este caso como iVal vale 3. 01:15:02

Justo antes de hacer esta conversión, lo que hará será llamar al toString y convertirá ese 3 a este 3, 01:15:13

para que esta cadena de caracteres la pueda concatenar con esta otra y así se nos muestre el resultado de esta forma por pantalla. 01:15:21

Bueno, de momento sobre la clase toString trabajaremos porque la sobrescribiremos en ciertos momentos, pero más adelante. 01:15:29

Ahora bueno, simplemente que tengáis la idea de herencia en Java, vamos introduciéndola. 01:15:48

Nosotros por código podemos poner aquí la etiqueta extends y aquí poner una clase de la cual haría clase print, 01:15:56

con lo cual tendríamos disponible todo lo que pusiéramos aquí, todo lo que tuviéramos definido en la clase que pongamos aquí 01:16:05

y que a partir de esta herencia que tiene que ser única con Stents, tenemos la posibilidad, sabemos que toda clase tiene ciertas características 01:16:11

heredadas directamente, todas ellas, de una clase que digamos está en la jerarquía más alta de las clases en Java, que es la clase Object. 01:16:23

Y entre ellas, pues tenemos, por ejemplo, no solamente este, pero tenemos el método toString, que convierte cualquier valor de esa clase en una cadena de caracteres. A ver qué más cosas por ahí puedo contar. 01:16:32

Mira, si tenemos, aprovechando que estamos hablando del toString, hemos dicho antes que teníamos la posibilidad de poner ival, imaginaos que tenemos un string, ese info, que tiene un valor numérico, un 3. 01:16:51

antes en los ejemplos anteriores lo estábamos cogiendo con netzint a través de 01:17:41

escáner, si este 3 que es una cadena de caracteres 01:17:45

la queremos meter en un valor entero 01:17:49

habíamos visto que tenemos integer, parseInt 01:17:53

esta opción, este método 01:17:57

nos transforma a un valor numérico de tipo entero 01:17:59

un valor que es un número pero que lo tenemos capturado como una cadena de caracteres 01:18:05

Otro método que tenemos también para hacer esto mismo, igual de válida, también de la clase Grouper, Integer y en todas las clases Grouper lo tenemos, es el método ValueOf. 01:18:11

ValueOf viene a hacer lo mismo. Podemos poner aquí ese info y también nos convertiría, la cadena es equivalente a esta otra. 01:18:24

nos metería en el valor numérico el valor de la cadena 01:18:35

y si lo que queremos hacer es lo contrario 01:18:39

es decir, tenemos un valor 3 01:18:42

hemos dicho que si metemos system.out 01:18:47

.println 01:18:51

de ival, println espera sacar por pantalla 01:18:55

lo que tenga aquí dentro pero como una cadena de caracteres 01:19:04

Entonces hemos dicho que de forma implícita llama al método toString, esto es para sacarlo por pantalla, pero imaginaros que de verdad no queremos sacarlo por pantalla, lo que queremos es tenerlo a nuestra disposición una variable de tipo string de momento porque queremos hacer otras cosas diferentes a sacarlo por pantalla. 01:19:08

Entonces podríamos tener una variable de tipo string y para cargar este número como una cadena de caracteres, si yo cojo y pongo y val, pues esto no le gusta, ¿por qué? Porque son tipos incompatibles, una cadena de caracteres con un número no le va bien. 01:19:24

Entonces, ¿qué podríamos hacer? Pues podríamos coger y utilizar de la clase 01:19:43

grouper integer el método toString, que es el que estamos diciendo. 01:19:47

Tenemos un entero en este caso, clase grouper integer toString, 01:19:55

le pasamos el valor y nos devuelve una cadena de caracteres. 01:19:59

Con lo cual, ese val, ¿qué información tendrá? Pues tendrá este 3, 01:20:04

pero lo tendrá en formato de cadena de caracteres, así. 01:20:08

Bien, ¿alguna preguntilla tenéis por ahí? ¿Queréis alguna consulta? 01:20:25

Está siendo un poco cajón desastre, os estoy contando muchas cosas, pero bueno, son conceptos que antes o después nos irán viniendo bien. 01:20:35

Sí, mira, en línea general, bueno, repito la pregunta para que quede en la grabación, me dicen que si podemos repasar un poco otra vez lo de las clases wrapper, el sentido que tienen y para qué se utilizan. 01:20:58

Hemos hablado antes un poquito de ellas, pero bueno, le pegamos otra vuelta. 01:21:16

Los, toda clase, tanto las propias como las de las librerías, están compuestas por una serie de parámetros y una serie de métodos. En las variables referenciadas para hacer la reserva de memoria que necesitan, recordad que tenemos que hacer el new y luego el constructor para inicializar ese objeto. 01:21:20

En cambio, estos días ya, durante esta tutoría y las anteriores, hemos dicho que hay una serie de variables en Java que son las variables primitivas. El int, el long, el string, el double, el float, el boolean, todas estas. 01:21:45

estas variables son un poquito diferentes a las 01:22:02

referenciadas, en primer lugar no necesitamos hacer su new 01:22:06

para tener espacio de memoria, pero luego no tienen 01:22:09

a su disposición una serie de métodos 01:22:12

si os fijáis, si yo defino 01:22:15

vamos a aprovecharnos un poquito de Eclipse 01:22:17

si yo defino un objeto 01:22:20

de la clase que he creado yo aquí 01:22:26

en el proyecto, clase print, si ahora pongo aquí 01:22:30

un punto, Eclipse me está ofreciendo 01:22:32

todos los métodos que están definidos para la clase 01:22:36

print, para el objeto de la clase print y para la clase 01:22:40

print en particular. Fijaros que yo en clase print no he 01:22:44

definido métodos, pero en cambio tengo todos estos, ¿por qué? 01:22:48

Pues los tendré por herencia desde la clase object. 01:22:52

Fijaros como todos aquí a la derecha me dicen object base, ¿por qué los 01:22:56

tiene disponible por esa herencia que os decía de la clase 01:23:00

Object. La única que me aparece aquí como clase Print 01:23:03

es precisamente el método Main, que es el único que tengo definido por aquí. 01:23:06

Todos los demás disponibles a través de la clase Object. 01:23:09

Y Eclipse me los ha ofrecido 01:23:14

poniendo aquí un punto para poder llamarlos. 01:23:15

Si yo pongo aquí valor punto, no me ofrece nada. 01:23:18

¿Veis? ¿Por qué sucede esto? 01:23:21

Porque los tipos primitivos son especiales 01:23:24

En dos aspectos al menos. Uno, que no necesitamos hacer el new como a los referenciados y otro, que no tienen definidos los tipos primitivos métodos que utilizar. Pero a veces nos resultará útil hacer cosas con un entero. Nos vendría bien tener métodos relacionados con este valor de tipo entero. 01:23:27

entonces para tener eso a nuestra disposición en las librerías de java a cada uno de los tipos 01:23:48

primitivos se le para cada uno de los tipos primitivos se han desarrollado de forma paralela 01:23:55

una clase que es la clase grupper en este caso para el tipo entero pues tenemos la clase grupper 01:24:01

integer y este si ponemos aquí sí que nos ofrece ya cosas para hacer todas ellas relacionadas con 01:24:08

enteros, fijaros que casi todas aceptan mínimo 01:24:15

valor de un entero, máximo valor de un entero, tamaño de un entero 01:24:19

entradas de entre dos como parámetros, ¿por qué? porque está pensada 01:24:23

o bien de salida o bien de entrada, siempre hay enteros, está pensada 01:24:27

para dar funcionalidades al tipo primitivo 01:24:31

entero, y esta es la clase Grouper Integer 01:24:35

volviendo a conceptos de los que hemos hablado antes, para la clase 01:24:39

integer, ¿hemos necesitado definir un objeto y utilizarlo? 01:24:45

No, directamente hemos puesto el nombre de la clase y un punto y ya me ofrece 01:24:49

cosas. ¿Qué pasará con todos estos parámetros y métodos que 01:24:53

son estáticos? Son parámetros y métodos de la clase en su conjunto, 01:24:57

no de objetos en particular, por eso están disponibles. 01:25:01

Y estas son las clases graper, clases asociadas a los 01:25:06

tipos primitivos que nos dan aquellas funcionalidades que nos 01:25:09

Vendría bien tener para esos tipos, pero que no están disponibles cuando se definieron. 01:25:13

Y estamos utilizando, ahora hemos hablado de, por ejemplo, en el caso de Integer, 01:25:20

que las tenemos en diferentes, pues tenemos el parseInt, tenemos el valueOf. 01:25:24

Bueno, tenemos muchas, como habéis visto antes, el valor máximo y el valor mínimo. 01:25:29

Tenemos el toString. Bueno, pues muchas de ellas por ahí, ¿vale? 01:25:35

Tenemos todas las que nos salen aquí. Estas son las clases de Wrapper. 01:25:41

no sé si queda claro más o menos 01:25:46

sí, vale 01:25:53

vale, vale 01:25:57

mirad en la 01:26:00

de la 01:26:02

tarea 01:26:03

bueno pues 01:26:04

no sé si habéis tenido la oportunidad de leerla 01:26:06

supongo unos sí, otros no 01:26:09

pedía 01:26:11

meter por teclado 01:26:13

unos números de tres entradas 01:26:14

que las identificaba 01:26:17

un número y luego si era par o impar 01:26:19

nos permitía decir si tenía que ir a una grada azul o a una grada verde. 01:26:21

Bueno, pues por separarlo en pares e impares. 01:26:26

Cosas de la práctica que tenemos. 01:26:30

¿Qué he visto? 01:26:34

Pues, por un lado, el nest int, 01:26:35

aunque no provocaba error en esta práctica, 01:26:39

pues cuidado con el enter del nest int, 01:26:41

que hemos hablado antes de ello. 01:26:43

Luego, si hacíamos la lectura con un nest line, 01:26:45

como pedía que la información se metiera desde el teclado 01:26:48

en una única entrada separado por espacios 01:27:01

tenemos esta cadena, claro, pero esto no es un número, son tres 01:27:05

entonces si lo tenemos en una variable de tipo string 01:27:09

teniendo en cuenta que esto lo hemos cogido desde teclado 01:27:12

con un slide, al final tendríamos en la variable 01:27:17

algo así, pues bueno, os comentaba el otro día que 01:27:23

la clase 01:27:26

stream precisamente 01:27:29

tiene un método que es el método 01:27:31

split. Y el método 01:27:33

split permite separar 01:27:35

en diferentes trozos 01:27:38

considerando un carácter 01:27:39

separador. En este caso podría ser el espacio. 01:27:41

Si hubiéramos dicho en el enunciado 01:27:44

por ejemplo la almohadilla 01:27:45

pues podríamos considerar como carácter 01:27:48

espaciador la almohadilla. 01:27:49

Y lo que querríamos en este caso 01:27:53

es obtener, por un lado el 7, por otro el 6, por otro el 5, sabiendo que está 01:27:55

identificado con la almohadilla del separador, en este caso, el enunciado de la práctica 01:27:59

decía un espacio, pues lo que podríamos hacer es 01:28:03

dividirlo, utilizar un array, que os hablaba el otro día de él, 01:28:07

si ponemos sval.split en el método este, 01:28:16

aquí podemos meter información de la 01:28:22

separación, en este caso sería la almohadilla, y nos cargaría 01:28:24

en un array en esta variable que es un array de strings nos cargaría todos los datos recibidos 01:28:28

desde esta variable que sería un 5 un 6 y un 7 y los array os comentaba el otro día ya hablaremos 01:28:39

de ellos son variables que comparten el nombre pero son tantas variables de este tipo en este 01:28:46

caso string, como el tamaño que tenga el array. Y para acceder a cada una 01:28:58

de ellas, de esas variables, entre los 01:29:02

corchetes ponemos aquí un índice que va desde 0 01:29:08

hasta un número menos del tamaño que tiene el array. En este 01:29:11

caso sería hasta 2. Fijaros, tiene 3 elementos, 1, 2 y 01:29:16

3. Pues la posición 0 en el índice sería 01:29:20

el 5, la posición 1 el 6 y la posición 2 el 7. Y cada uno de ellos 01:29:24

serían un string fijaros esta variable si leemos hacia el 01:29:28

izquierda sería un array de strings conjunto de strings esto que sería la 01:29:35

variable leyendo derecha izquierda en la línea de abajo está de izquierda a 01:29:43

derecha con la información del corchete cada una de ellas sería un string 01:29:47

con lo cual esto es un string esto es un array de strings esto es un string cada 01:29:52

una de ellas. Entonces aquí con el string ya podríamos utilizar 01:29:58

el valueOf, este para pasarlo al número 01:30:02

entero o podríamos utilizar el parseInt 01:30:05

de la clase GrouperInteger. Y luego para comprobar 01:30:09

si es par o impar, tenéis una solución 01:30:17

de las posibles puestas en el 01:30:21

aula virtual. Bueno, pues la forma en la que 01:30:23

lo utiliza teníamos con lo que hemos visto en el contenido del tema 2 una 01:30:29

posibilidad que era la instrucción está con dos operadores 01:30:34

entonces esta que tiene la opción que dices algo 01:30:40

es igual a un valor y dice si vale una si vale verdadero una cosa y si no pues 01:30:46

es otra cosa con esta instrucción es un poco liosa y yo creo mucho más clara lo 01:30:55

que vais a ver ahora en el tema 3 que es utilizar una instrucción de condición 01:31:02

que es si if y aquí pondremos algo que se puede 01:31:07

evaluar como verdadero o falso y hacemos en el ámbito del if una serie 01:31:12

de cosas que pondríamos aquí y el else que es si no es cierto lo que hay aquí pues entonces hace 01:31:18

esta otra serie de cosas mirad aunque esto pertenezca al tema 3 vamos a poner aquí si 01:31:27

es cierto lo más cierto en java a la hora de evaluarlo es poner aquí que es cierto ya 01:31:33

directamente. Entonces decimos 01:31:38

si es true 01:31:40

system.auth.println 01:31:41

escribo 01:31:45

true 01:31:51

y si no es true 01:31:52

escribo false. ¿Esto cómo 01:31:54

funciona? Pues cuando hará 01:31:59

todo este código que no tiene 01:32:00

consecuencias por pantalla ni nada 01:32:02

y luego dirá si es verdadero 01:32:05

lo que hay aquí entre paréntesis 01:32:07

que en este caso lo que evalúa 01:32:09

es que directamente es verdadero 01:32:11

hace el código que hay en el ámbito del if, que es 01:32:12

lo que hay entre esta llave de apertura y cierre. Podríamos tener aquí una serie 01:32:17

de instrucciones, pero en particular hemos puesto una solo, que sería 01:32:21

escribo true. Y si esto se evaluase a falso, 01:32:25

pues entonces, en lugar de ejecutar la serie de instrucciones 01:32:29

que hay en el if, haría la serie de instrucciones que hay en el else, que sería 01:32:33

escribo false. Este if true y else 01:32:36

lo podríamos 01:32:40

hacer con 01:32:43

una instrucción 01:32:45

de la que tiene dos operadores 01:32:46

esta en la que algo es igual 01:32:49

que mira una condición, no sé si habéis visto 01:32:51

la teoría, y si 01:32:53

es cierta pasa una cosa y si es falsa 01:32:54

pasa otra, entonces con el true 01:32:57

yo no sé si alguien 01:33:01

directamente lo ha hecho así, entre los que habéis entrado a la práctica 01:33:03

yo creo que nadie, habéis ido 01:33:05

a este que es el método en el que luego 01:33:07

programaremos durante todo el curso 01:33:09

lo que pasa es que esto en verdad todavía no lo habíamos visto en teoría 01:33:11

por eso yo la solución no la he dado con esta otra alternativa 01:33:14

entonces si ejecutamos por aquí dice escribo true 01:33:17

porque esto se ha evaluado como true y si esto fuese false 01:33:20

escribiría el otro 01:33:23

normalmente los if y los self no tienen aquí true o false 01:33:27

sino que tienen una expresión que se evalúa a verdadero o falso 01:33:31

por ejemplo un valor entero 01:33:34

la edad de una persona 01:33:37

imaginaos que estamos aquí chequeando mayor de edad o menor de edad 01:33:39

Y tenemos aquí una variable int y edad. Aquí llegará con un determinado valor que será consecuencia de la ejecución anterior del código. Entonces si ponemos aquí 15, pues en principio sería menor de edad. 01:33:42

como esto es lo que queremos que pase cuando sea mayor de edad pues podríamos decir si y edad es 01:33:59

mayor de 17 años esto se evalúa true porque y edad efectivamente es mayor que 17 en este caso no si 01:34:06

ponemos aquí de mayor de edad vamos a poner 19 pues si edad es mayor que 17 diría mayor de edad 01:34:15

y si no pues sería menor pero esto lo que vais a ver en este tema este tipo de instrucciones entonces 01:34:27

esta ejecución esto se evalúa a verdadero porque de verdad es verdadera esa comparación de mayor 01:34:35

de edad en cambio si tuviera un 15 aquí como esto se evalúa a falso pues nos mostraría esto 01:34:43

y la otra cosa que es interesante aunque el programa funcionaba perfectamente sin ello 01:34:54

pero es bueno hacer también, es que si abrimos flujos de comunicación 01:35:02

de nuestro programa con el mundo exterior, en este caso teníamos el escáner 01:35:07

al teclado, System.in, por aquí lo utilizamos convenientemente 01:35:14

y en un programa en línea general interesa siempre los flujos de datos 01:35:28

cuando terminas de utilizarlos, pues no dejar pillados recursos. 01:35:33

entonces aquí sería mejor poner un scan close voy a cerrarlo igual que lo abierto aquí por lo 01:35:36

cierro aquí después de haber estado utilizándolo aquí que sucedía en el programa que como el 01:35:42

programa se ejecutaba en el método main hacíamos todo lo que correspondiese y aunque no tuviéramos 01:35:52

esto como acaba el método main acaba el programa y el hecho de acabar el programa liberaba los 01:35:57

recursos y al final pasa un poco lo mismo pero nuestros programas no tienen por qué ser así 01:36:03

de sencillos de empezar y terminar en un método de hecho no lo son normalmente pues tienen mucho 01:36:09

más código y a veces son programas que tienen que permanecer en el tiempo a lo mejor están 01:36:14

dando un servicio de 24 horas entonces interesa que cuando dejemos de utilizar un recurso pues 01:36:18

liberarlo todo lo que no vayamos a utilizar si ya no tenemos que leer más cosas desde el teclado 01:36:25

pues vamos a cerrar ese recurso y no dejamos pillado hay una conexión al teclado que bueno 01:36:31

vete tú a saber si en algún momento me puede terminar dando un problema 01:36:38

y resultarme muy costoso el depurar el código hasta darme cuenta del problema 01:36:41

en otra zona de código puede ser ese 01:36:46

entonces esto también era una cosa interesante de hacer 01:36:49

cerrar los flujos, siempre que usemos un flujo ya no precisemos de su uso 01:36:52

y nada, hay poco más, yo creo que os voy a contar ya por hoy 01:36:58

por aquí 01:37:09

porque no tengo del tema este 2 01:37:11

no tengo más cosas, la semana que viene empezamos a hablar 01:37:14

de lo del tema 3 01:37:16

os abro mañana los contenidos 01:37:18

y si no tenéis 01:37:20

alguna pregunta por ahí que hacerme 01:37:23

pues voy a ir parando la grabación yo creo 01:37:25

y lo vamos dejando por aquí 01:37:28

¿alguna cosita por ahí? 01:37:29

¿qué me queréis comentar? 01:37:33

¿todo bien? 01:37:42

pues si os parece 01:37:47

si no tenéis ninguna pregunta más 01:37:49

paramos para no adelantaros más cosas 01:37:50

ya hemos introducido 01:37:53

un montón de conceptos y hemos repasado 01:37:55

un montón de cosas, así que si 01:37:57

reviséis otra vez la clase 01:37:58

tenéis para entretenernos un poquito 01:38:00

con ella yo creo 01:38:02

pues nada, por aquí lo dejamos entonces 01:38:03

vale 01:38:10

pues nada 01:38:10

la grabación 01:38:15

creo que ahora la voy subiendo 01:38:16

necesito un tiempo de procesamiento hasta que 01:38:19

está disponible, o bien esta noche 01:38:21

Mañana ya os pongo el enlace disponible para que podáis verla de nuevo si queréis. 01:38:23

2024-11-04-Programacion - Contenido educativo

Del mismo autor…

Enunciado y dos demostraciones del Teorema de pitágoras

Halloween, fiesta y costumbres

Utiliza Nezha, programa con MakeCode y Scratch distintas simulaciones de terremotos.

FIESTA DEL OTOÑO 2025

FIESTA DE HALLOWEEN 2025

LaminarTurbulento

Conoce el bloque letra 1 de manzana para trabajar las cifras de un número programando con Scratch.