Saltar navegación

20250926-ProgEstr-String - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 28 de septiembre de 2025 por Raquel G.

3 visualizaciones

Más información Transcripción

Descargar la transcripción

vale, pues vamos a revisar 00:00:00
ahora sí, de nuevo 00:00:02
os aviso de que es un poco rollo, pero 00:00:04
esta parte 00:00:06
es así, vale, vamos 00:00:08
a revisar, ahora ya 00:00:10
sí que sí, de qué operadores 00:00:12
disponemos para 00:00:15
construir ya expresiones en Java 00:00:16
vale, conocemos 00:00:18
lógicamente algunas cosas básicas 00:00:20
que hemos usado para hacer algunas cosas básicas 00:00:22
para ver 00:00:25
un poquito de qué va el rollo de las variables, lógicamente 00:00:26
Conocemos el operador de asignación 00:00:29
¿Verdad? 00:00:33
Conocemos los aritméticos 00:00:35
Conocemos los de comparación 00:00:37
Claro 00:00:42
Menor que, mayor que, menor o igual 00:00:42
Mayor o igual 00:00:45
Entonces algunos operadores ya los conocemos 00:00:46
¿Y cómo los usamos para construir expresiones? 00:00:49
Pues como los usamos en el contexto de las matemáticas 00:00:52
También, claro 00:00:55
Pues cualquiera de estos operadores 00:00:56
tendrá un operador delante y otro detrás 00:00:58
y me devolverá un resultado 00:01:01
que a su vez asignaré a otro sitio 00:01:04
¿vale? 00:01:06
estos operadores también funcionan 00:01:08
con un operando delante y otro detrás 00:01:11
lo que pasa es que lo que obtengo ahora 00:01:13
como vimos el otro día 00:01:16
ahora no será un número 00:01:17
no será un valor numérico 00:01:22
ahora será un valor booleano 00:01:24
lo que obtenemos será un true o un false 00:01:26
Entonces estos operadores básicos de asignación, aritméticos y de comparación 00:01:28
Ya los hemos usado para hacer expresiones sencillas 00:01:34
Que involucraban valores variables 00:01:37
Me daba un resultado que yo usaba para guardar una variable 00:01:40
Pero hay más operadores que admite el lenguaje Java 00:01:45
Para poder hacer expresiones un poquito más complejas 00:01:50
Que reflejen más situaciones, más posibilidades 00:01:54
bueno, pues en el aula virtual hay un pequeño compendio 00:01:57
que lo podemos usar 00:02:01
como referencia para no perdernos 00:02:03
entonces 00:02:06
si abrimos el aula 00:02:11
virtual 00:02:23
uy, ya me he metido en el que no es 00:02:25
este, vale, pues si nos metemos 00:02:43
aquí 00:03:05
Porque se ha quitado 00:03:06
Si estaba antes puesto 00:03:13
Ah, es que no lo he conectado 00:03:14
A la 00:03:17
Pantalla 00:03:19
Lo he conectado a la otra 00:03:22
Ahora sí 00:03:25
Pues aquí en el aula virtual 00:03:56
Vale 00:04:00
Tenemos aquí 00:04:02
Que habíamos dicho que antes de meternos 00:04:07
En operadores íbamos a incorporar 00:04:10
el string, aunque fuera tipo 00:04:12
objeto, fue lo último que dijimos el 00:04:14
miércoles, es verdad 00:04:16
que ayer, claro, no tuvimos clase y ayer 00:04:18
no lo hicimos, vale, vale, vale, dijimos que 00:04:20
comprar el string para poder trabajar con 00:04:22
cadenas de texto, vale, que eso no 00:04:24
vale, vale, vale 00:04:27
pues antes de revisar los operadores 00:04:27
vamos a incorporar 00:04:30
ese tipo de dato 00:04:31
el noveno 00:04:34
tenemos ocho tipos de datos primitivos 00:04:35
que ya sabemos cómo funcionan 00:04:39
pero cuando queremos trabajar con un texto al completo 00:04:40
una frase, un nombre, ninguno de esos tipos nos vale 00:04:44
porque el char es solo un carácter 00:04:47
entonces, como desde ya nos viene bien 00:04:49
poder trabajar con textos completos 00:04:54
vamos a incorporarlo, aunque sea un tipo de dato 00:04:56
no primitivo, sino objeto 00:05:00
todo eso ya lo explicamos el otro día 00:05:02
que un tipo de dato objeto es un tipo de dato 00:05:04
que se construye como una agregación 00:05:07
de datos primitivos 00:05:10
dentro, entonces el 00:05:12
string en particular es una 00:05:14
agregación de muchos char 00:05:16
vale 00:05:18
entonces vamos a verlo en una 00:05:19
clase 00:05:22
que sea ejemplo 00:05:23
string 00:05:26
y ya está 00:05:28
ahora lo vemos 00:05:29
admite una 00:05:41
cadena de texto, entonces 00:05:43
una cadena de texto puede tener muchas palabras 00:05:44
porque están separadas por espacios que a su vez 00:05:47
son booleanos 00:05:49
perdón, chat 00:05:49
vale, pues venga 00:05:51
sí, pero es que esto vosotros 00:05:54
organizados como queráis 00:05:56
vosotros ya sabéis 00:05:58
crear un proyecto 00:06:01
y dentro del proyecto crear 00:06:02
diferentes paquetes para 00:06:04
dividir conceptualmente vuestros programas 00:06:06
y dentro de cada paquete ya hacéis vuestras clases 00:06:08
o programas 00:06:10
que para nosotros ahora son sinónimos 00:06:12
ahora ya vuestra organización interna para las cosas 00:06:14
ya la vuestra 00:06:16
no tenéis que hacer así a tiro fijo 00:06:19
todo lo que yo vaya haciendo aquí 00:06:20
¿vale? entonces 00:06:22
si tú te quieres organizar todas las clases en un proyecto 00:06:24
en diferente proyecto 00:06:27
yo voy a hacer una clase, un programa 00:06:28
para ejemplificarlo de stream 00:06:30
¿vale? yo cada cosa que 00:06:33
vayamos explicando 00:06:34
la iré poniendo en práctica 00:06:36
a través de un 00:06:39
programa, de una clase 00:06:40
¿dónde guardéis ese programa vosotros? 00:06:42
pues según vuestra organización de proyectos, de paquetes 00:06:44
la que queráis 00:06:46
vale, pues entonces 00:06:47
estoy quitando 00:06:52
estoy quitando el public todo el rato 00:06:57
porque como no hace, da igual 00:06:59
podéis no quitarlo y no pasa nada 00:07:01
pero precisamente 00:07:03
como no sabemos lo que significa 00:07:05
y realmente que esté o no esté 00:07:07
da igual, porque no lo estamos usando 00:07:09
porque no sabemos lo que significa, pues por eso lo quito 00:07:11
para no meter cosas que no hemos dado 00:07:13
vale, pues ya tengo 00:07:15
yo un programita limpio 00:07:17
ahí vacío para empezar a hacer cosas con él 00:07:19
¿Qué queríamos ahora mostrar? 00:07:21
Queríamos mostrar un noveno tipo de dato que nos puede ser útil 00:07:26
Por ejemplo, imaginad un programa que necesita nombres de usuarios 00:07:29
Entonces el programa, pues quiere un nombre 00:07:35
Introduzca su nombre 00:07:42
Para hacer cosas con el nombre, yo que sé, para hola o para saludarte, para cualquier cosa 00:07:43
introduzcas un nombre que yo te voy a saludar 00:07:49
o voy a hacer cualquier cosa con tu nombre 00:07:52
entonces aquí ya se nos plantea 00:07:54
el problema 00:07:57
de que un nombre 00:07:58
es una cadena de texto 00:08:00
es decir, muchos caracteres 00:08:02
no es solo uno 00:08:04
entonces, para guardar 00:08:05
el dato nombre 00:08:08
¿qué variable utilizo? 00:08:09
esa 00:08:14
porque las que yo tengo 00:08:14
ahora no me vale ninguna 00:08:17
esta no me vale para guardar un nombre 00:08:18
ni por supuesto un número int 00:08:20
ni un número double 00:08:22
¿qué tipo de dato puedo poner ahí? 00:08:23
bueno pues afortunadamente 00:08:26
hay ya un tipo de dato construido 00:08:27
por Java 00:08:30
que sirve para guardar 00:08:31
una cadena de caracteres 00:08:34
y ese tipo 00:08:36
de dato ¿cómo se llama? 00:08:38
se llama string con la S en mayúscula 00:08:39
¿vale? 00:08:42
entonces 00:08:46
esta variable nombre 00:08:47
Ahora ya vale para guardar una cadena de caracteres 00:08:48
En una variable de tipo string 00:08:53
¿Qué es lo que guardamos? 00:09:01
Se guardan cadenas de caracteres 00:09:04
Y cuando digo una cadena de caracteres 00:09:08
Digo cualquier sucesión de caracteres de la tabla ASCII 00:09:12
Incluyendo espacios, saltos de línea 00:09:16
por ejemplo, un párrafo con varias líneas 00:09:19
también es un string 00:09:22
porque es una sucesión de los caracteres 00:09:24
el carácter salto de línea 00:09:27
que también es un carácter ASCII 00:09:28
el carácter espacio, el carácter que sea 00:09:30
cualquier sucesión de caracteres 00:09:33
que está en la tabla ASCII 00:09:35
se puede guardar en una variable string 00:09:37
ahora otra cosa ya es 00:09:39
¿cómo se va a imprimir eso cuando se muestre? 00:09:42
bueno, pues si tiene un salto de línea 00:09:45
ahí metido dentro de esa cadena 00:09:47
pues se imprimirá en líneas separadas, claro, pero eso es otra cosa, 00:09:48
¿cómo se imprime? Pero string lo que guarda es una cadena de cualquier 00:09:52
sucesión que a mí me dé la gana y de cualquier tamaño 00:09:56
de cadenas de caracteres que están en la tabla ASCII. 00:10:00
¿Vale? Entonces, si a esta variable 00:10:05
nombre yo le quiero hacer una asignación, 00:10:12
se la haré como siempre, como siempre hacemos, con 00:10:19
nombre de la variable, igual 00:10:22
el valor que yo le quiera dar. 00:10:24
¿Qué valor le 00:10:27
podemos dar a una variable de tipo stream? 00:10:28
Lo acabamos de decir, una 00:10:31
cadena de caracteres. 00:10:32
Y una cadena de caracteres para 00:10:34
Java, ¿cómo se 00:10:36
representa? Como 00:10:38
el texto que yo quiera, 00:10:40
entre comillas, dobles. 00:10:42
Nunca entre simples, porque 00:10:45
simples tiene ya una función, 00:10:46
que es un único carácter. 00:10:48
Entonces, 00:10:51
Esto es una cadena de caracteres perfectamente válida, ¿vale? 00:10:52
Porque son todo caracteres de la tabla ASCII, el espacio, la o tildada, etcétera, son todo caracteres de la tabla ASCII. 00:11:00
Y como se los he dado a Java entre comillas dobles, pues le estoy diciendo a Java, es el texto este tal cual, el texto tal cual, entre comillas dobles, ¿vale? 00:11:08
Si tú no pones las comillas 00:11:22
Entonces Java interpretará que lo que le estás dando 00:11:27
Es el nombre de una variable 00:11:29
Claro, aquí te daría un error 00:11:31
Porque no hay ninguna variable que se llame Pepito 00:11:35
¿Vale? 00:11:37
Entonces 00:11:39
Voy a quitar el espacio porque así ya, claro 00:11:40
Esto es la cadena 00:11:42
De texto Pepito 00:11:45
Pero esto 00:11:46
Asigna a nombre el contenido 00:11:52
ido de la variable que se llame Pepito. 00:11:56
La máquina virtual, ¿hay alguna variable que se llame Pepito? 00:11:58
No. 00:12:01
Por eso te da el error. 00:12:02
Pero podría haberla. 00:12:03
Podría haberla. 00:12:04
Podría haber una cadena que se llama Pepito por ahí. 00:12:05
Una variable. 00:12:10
String Pepito igual a lo que sea, por ejemplo. 00:12:16
Aquí tenemos una variable perfectamente declarada de tipo 00:12:22
string y además inicializada con un valor correcto para el 00:12:27
string, que es una cadena de texto entre comillas 00:12:32
doble, variable 00:12:34
ningún problema 00:12:36
ahora dos asignaciones que hacen cosas 00:12:37
completamente distintas, claro 00:12:40
aquí a la variable 00:12:41
nombre le estamos asignando 00:12:44
directamente la cadena pepito 00:12:46
lógicamente 00:12:48
entonces si nosotros aquí mostráramos 00:12:49
lo que tiene nombre 00:12:52
está claro lo que nos mostraría, el valor 00:12:53
que le hemos asignado, que es la cadena 00:12:56
de texto pepito tal cual 00:12:58
ahora yo hago otra asignación diferente 00:12:59
la de abajo 00:13:02
la de abajo es una asignación 00:13:03
completamente distinta a la de arriba 00:13:06
porque esto no está entre comillas 00:13:08
dobles, luego eso 00:13:10
significa, oye como no estoy 00:13:12
entrecomillado, yo soy el 00:13:14
nombre de una variable, búscame 00:13:16
a ver que tengo 00:13:18
y lo que yo tenga se lo das a este 00:13:20
pues eso es lo que hace la máquina 00:13:22
virtual, busca la 00:13:24
variable con este nombre 00:13:26
coge lo que tenga 00:13:27
y se lo da a este 00:13:30
la variable tiene que estar declarada 00:13:30
previamente, si no el compilador 00:13:33
nos habría dejado ejecutar esto 00:13:36
lo está 00:13:37
y además tiene que tener un valor 00:13:38
porque si no, también nos saldría 00:13:41
el error de, oye 00:13:44
que valor cojo yo de aquí 00:13:45
en este caso están las dos 00:13:47
condiciones satisfechas 00:13:49
la variable pepito existe 00:13:51
porque está declarada previamente 00:13:53
aquí está declarada 00:13:55
y además tiene un valor 00:13:56
luego todo perfecto 00:13:58
la máquina virtual irá a esta variable 00:14:01
cogerá lo que tiene dentro 00:14:04
y se lo asignará a la otra variable nombre 00:14:05
¿no? 00:14:09
entonces si volvemos a mostrar lo que tiene nombre ahora 00:14:11
pues ahora nombre tendrá esto de arriba 00:14:14
¿verdad? 00:14:16
¿vale? 00:14:28
la primera vez ha mostrado efectivamente 00:14:29
ha mostrado 00:14:33
lo que tiene la variable nombre 00:14:36
que es tal cual esa cadena 00:14:38
tal cual 00:14:40
la segunda vez le he asignado a nombre 00:14:40
una variable 00:14:43
la máquina virtual 00:14:45
ve que no hay comillas 00:14:48
es una variable, me voy a la variable 00:14:49
cojo su valor y se lo asigno 00:14:51
y cuando lo muestro 00:14:54
efectivamente tiene ese contenido 00:14:55
vale 00:14:58
entonces texto entre comillas 00:14:59
dobles es una cadena 00:15:03
de texto tal cual, literal, ¿para qué las usamos? 00:15:05
para asignárselas a variables string, que son las variables 00:15:09
que nos sirven para guardar cadenas de texto, para eso las usamos 00:15:13
entonces de nuevo comprobemos que aquí no vale poner 00:15:16
una comilla simple, la comilla simple ya tiene 00:15:23
una función, que es indicar un carácter astiliteral, solo uno 00:15:27
entonces la comilla simple si tiene 00:15:31
sentido si yo pongo un solo carácter 00:15:35
pero claro, se la tendría que asignar 00:15:37
a un char, no a un string 00:15:41
un único carácter 00:15:42
entre comillas dobles 00:15:45
es un char y tiene que ir a char 00:15:46
¿vale? 00:15:49
vamos a, por ejemplo, yo aquí tengo mi variable 00:15:53
char carácter 00:15:55
a mi variable char carácter 00:15:56
le puedo asignar la p 00:16:01
ningún problema 00:16:04
¿vale? es un único carácter 00:16:05
entre comillas simples 00:16:08
a mi variable char 00:16:09
carácter no le puedo asignar 00:16:11
esto, no le puedo asignar 00:16:13
la p entre comillas dobles 00:16:17
esto no puedo 00:16:19
esto si puedo 00:16:21
esto no puedo 00:16:23
porque al tener aquí comillas dobles 00:16:24
la máquina virtual interpreta 00:16:27
que eso es un tipo cadena de caracteres 00:16:29
¿qué es una cadena de caracteres 00:16:31
solo con uno? bueno, solo con uno 00:16:33
pero es una cadena de caracteres 00:16:35
no es un carácter solo 00:16:36
entonces no es lo mismo como se almacena por dentro 00:16:38
en la RAM, algo que va a ser 00:16:40
char toda su vida 00:16:43
que algo que es cadena 00:16:44
de caracteres, entonces 00:16:47
cuando la máquina virtual cree el valor p 00:16:48
para asignárselo a carácter 00:16:51
lo va a crear como char 00:16:52
cuando la máquina virtual cree 00:16:54
el valor p, como ve 00:16:57
que hay comillas dobles 00:16:59
lo crea como string 00:17:00
entonces al crearlo como string 00:17:02
jamás puede ir a un char 00:17:04
entonces me da igual 00:17:06
la cantidad de caracteres que hay adentro 00:17:09
Las comillas dobles implican, tú eres cadena de caracteres, aunque tengas 0, 1, 2, porque podría tener 0 también, esto es una cadena de caracteres válida, tiene 0 caracteres, es perfectamente válida, ¿vale? 00:17:10
Entonces, cuando la máquina virtual ve algo entre comillas dobles, es algo que construye como cadena. Luego solamente se puede asignar a las cadenas, o lo que es lo mismo a los strings, solo. A este no, esto mal, no puede asignar una cadena de caracteres aquí. 00:17:28
vale 00:17:43
esto estaría mal 00:17:45
esto también por lo que hemos dicho 00:17:49
porque nombre es un string 00:17:52
este string que he declarado yo aquí arriba 00:17:53
nombre es un string 00:17:56
entonces como nombre 00:18:00
es un string no puede recibir un único 00:18:01
carácter, no puede recibir 00:18:03
algo entre comillas simples 00:18:05
esto 00:18:07
está mal también 00:18:08
sin embargo si yo lo que quiero 00:18:11
es darle la P 00:18:15
esto ya sí que estaría bien 00:18:16
nombre 00:18:19
igual 00:18:20
a p, esto ya sí 00:18:23
está bien, esto mal 00:18:27
esto bien, ¿por qué? 00:18:31
porque nombre es un string 00:18:33
un string solamente puede recibir 00:18:34
cadenas de caracteres 00:18:37
las cadenas de caracteres se indican a java 00:18:38
que lo son 00:18:41
en comillas dobles 00:18:42
esta tiene solo un carácter, no pasa nada 00:18:44
una cadena de caracteres puede tener uno, no pasa nada 00:18:46
Pero es cadena de caracteres 00:18:49
Bueno, si lo quieres ver así, sí 00:18:50
O sea, yo me construyo mi cadena 00:18:55
Con un carácter, pero me construyo 00:18:57
Una cadena en realidad, y eso tiene unas implicaciones 00:18:59
De almacenamiento interno distintas 00:19:01
Que si solo construyes un chat 00:19:03
¿Vale? Como que habilitas 00:19:05
Dinámicamente espacio, etc. 00:19:07
Entonces 00:19:10
Esto no lo podemos hacer 00:19:10
Esto es como lo tendríamos que hacer si queremos que vaya 00:19:12
Una P aquí 00:19:15
¿Vale? Entonces esto 00:19:16
Y esto ya lo hemos dicho 00:19:21
Todo lo que yo asigne a una variable string 00:19:28
Tiene que ser string 00:19:30
O bien porque sea una cadena tal cual 00:19:31
Que yo he construido 00:19:34
O bien porque sea otra variable que tiene string 00:19:35
Pepito es un string 00:19:38
Pues yo se lo puedo asignar a nombre 00:19:40
Porque es un string 00:19:42
Con lo cual el valor que yo saco de esa variable 00:19:43
Es compatible con este 00:19:46
Y en las asignaciones 00:19:48
Siempre el valor de la izquierda 00:19:50
Tiene que ser compatible con lo de la derecha 00:19:52
Yo a nombre no le puedo asignar un char 00:19:54
No va a hacer una promoción automática 00:20:01
Es decir, yo aquí tengo mi char 00:20:03
Carácter que es P mayúscula 00:20:05
Voy a intentar asignarle a nombre ese char 00:20:08
A mi variable nombre que es string 00:20:12
Voy a tratar de asignarle un único carácter 00:20:19
Una variable char 00:20:22
carácter 00:20:24
la máquina virtual me dice 00:20:26
bueno, ya el compilador no me deja seguir 00:20:29
me dice, no, perdona 00:20:31
carácter es una variable char 00:20:33
no puede ir a una variable stream 00:20:35
hombre, se podría haber hecho 00:20:38
esa es la filosofía de Python, que todo vale 00:20:41
se podría haber hecho en Java 00:20:43
a ver, haz una promoción automática de un char 00:20:45
almacénalo en stream y ya pasáselo 00:20:49
Pues no, no es algo que haga automáticamente 00:20:53
Las cosas que hace automáticamente 00:20:56
Están muy muy limitadas 00:20:58
Y muy pensadas 00:21:00
Para que casi en ninguna circunstancia 00:21:01
Te causen errores 00:21:04
Porque todo lo que él haga automáticamente 00:21:05
Seguramente 00:21:08
Puede ocurrir que tú 00:21:10
A lo mejor no lo querías 00:21:11
Hacer eso, entonces te sale error en tiempo de ejecución 00:21:14
Que es el problema 00:21:16
Entonces Java 00:21:18
Es muy restrictivo 00:21:20
para asegurarse de que lo que tú estás escribiendo 00:21:21
es realmente lo que quieres hacer. 00:21:24
¿Vale? 00:21:28
Y no te cambia las cosas. 00:21:28
Dice, ay, asumo que querías hacer esto. 00:21:29
Él no asume nada. 00:21:32
Dice, no, no, tú escribe lo que quieres hacer realmente. 00:21:33
Yo no voy a asumir nada. 00:21:35
¿Vale? 00:21:37
Bueno, pues esto mal, entonces. 00:21:39
¿Vale? 00:21:42
Si queremos, vamos, como ya estamos leyendo datos de teclado 00:21:46
para poder hacer programas un poquito más interesantes 00:21:50
pues podemos incorporar ya aquí 00:21:54
cómo leo una cadena de texto por teclado 00:21:56
sabemos leer números enteros por teclado 00:21:59
con el next int 00:22:01
sabemos leer números decimales por teclado 00:22:03
con el next double 00:22:06
pues también podemos leer cadenas por teclado 00:22:07
también nos hace falta nuestro objeto famoso 00:22:10
nuestro objeto escáner también nos hace falta 00:22:13
pues vamos a ponérnoslo aquí arriba por ejemplo 00:22:16
vale 00:22:20
vamos a ponernos nuestro objeto 00:22:34
famoso 00:22:36
esto, si lo queréis llamar 00:22:37
de otra manera 00:22:43
llamadlo como queráis, esto en realidad 00:22:44
aunque no sepamos muy bien lo que es 00:22:47
un objeto ni este en particular 00:22:49
nos suena a declaración 00:22:51
de variable, porque es lo que es 00:22:53
declaramos una variable de este 00:22:55
tipo raro 00:22:57
que desconocemos de donde ha salido 00:22:58
pero es un tipo más 00:23:01
y además le damos un valor a esta variable 00:23:02
¿por qué se lo damos de esta manera tan extraña? 00:23:05
no sabemos todavía, pero le estamos dando un valor 00:23:08
bueno, pues este 00:23:10
es una variable más 00:23:11
pero es una variable de tipo scanner 00:23:13
igual que int n 00:23:15
n es una variable de tipo int 00:23:17
pues esta es una variable más 00:23:19
lo que quiero decir con esto es que si no os gusta el nombre scan 00:23:21
y queréis llamarlo 00:23:24
mi super lector del teclado 00:23:25
es un nombre de variable, elegís el que queráis 00:23:26
¿vale? el que queráis 00:23:29
lo decía por eso 00:23:31
bueno, pues nosotros creamos 00:23:33
Nuestra variable esta 00:23:34
De este tipo raro 00:23:36
Que se crea 00:23:38
Se le da este valor extraño 00:23:40
Que no sabemos por qué se le da ese 00:23:42
Ya lo entenderemos 00:23:44
Y de repente nos aparece ahí 00:23:45
Algo que sabe leer del teclado 00:23:47
¿Vale? 00:23:51
Pues como en particular leeríamos un nombre 00:23:52
Vamos a leerlo aquí 00:23:54
String nombre 00:23:56
Este nombre 00:23:57
Vamos a darle 00:24:00
El resultado de leer 00:24:03
por teclado una cadena de texto 00:24:06
pues scan en lugar 00:24:08
de next in, next double 00:24:10
como u 00:24:12
pues next line 00:24:13
ya está, con scan 00:24:20
punto next line 00:24:27
que hace el programa 00:24:28
va por aquí, paso por paso 00:24:30
llega aquí 00:24:32
se queda aquí atascado 00:24:34
y aquí se queda 00:24:37
cruzado de brazos 00:24:39
nuestra máquina virtual hasta el infinito 00:24:41
hasta que alguien decida 00:24:43
que va al teclado a escribir algo 00:24:45
cuando alguien por fin ha decidido 00:24:47
que va al teclado a escribir algo 00:24:50
ya la máquina virtual despierta 00:24:51
de aquí, que estaba aquí parada durmiendo 00:24:54
despierta 00:24:56
coge esa cadena de texto 00:24:57
que haya escrito el usuario 00:24:59
y se la guarda aquí 00:25:01
¿vale? 00:25:03
exactamente igual que hacían NextIn y NextAble 00:25:07
también se quedaban ahí cruzados de brazos 00:25:09
esperando que alguien escriba 00:25:11
en el teclado 00:25:13
cuando alguien escribía un número 00:25:14
esto despertaba de su ensueño 00:25:17
cogía ese numerito y lo guardaba en la variable 00:25:20
pues aquí igual 00:25:22
entonces vamos a 00:25:23
saludar 00:25:30
vale, ahora 00:25:32
vamos a incorporar desde ya que es fácil 00:25:36
y que luego cuando veamos 00:25:39
los operadores ya lo vamos a entender rápido 00:25:41
para que 00:25:43
para confirmarlo 00:25:44
el system.out.println 00:25:47
lo hemos estado usando 00:25:50
para mostrar o bien texto 00:25:52
directamente por consola 00:25:54
poniéndolo entre comillas 00:25:56
o bien una variable, le pasábamos una variable 00:25:57
sin más y el system out 00:26:00
cogía el contenido de la variable 00:26:02
y lo mostraba 00:26:04
vale, pero podemos hacer que el system out 00:26:05
me muestre 00:26:08
las dos cosas 00:26:09
un texto y además el contenido 00:26:11
de una variable, porque aquí a mi me gustaría 00:26:14
mostrar hola coma 00:26:16
y el nombre que fuera aquí 00:26:18
entonces en este system out 00:26:20
bueno, podría 00:26:22
no hacerlo así 00:26:23
no combinarlo 00:26:26
y hacerlo de esta manera 00:26:27
hola y aquí poner nombre 00:26:29
con dos system out 00:26:32
¿vale? 00:26:35
entonces este programa 00:26:37
me pide el nombre y luego me dice 00:26:39
hola, no sé quién 00:26:40
y ya está, luego sigue haciendo cosas 00:26:41
¿no? 00:26:44
vamos a comprobarlo 00:26:46
hola Lara 00:26:48
y luego ya el resto de cosas que le hemos puesto 00:26:57
de que mostrar, asignar 00:26:59
pero el system out 00:27:01
podemos hacer, pero eso 00:27:05
ahora que vamos a repasar los operadores 00:27:06
pues mediante el operador de concatenación 00:27:08
podemos hacer que 00:27:11
en una sola llamada 00:27:13
el system out me concatene 00:27:15
tanto esto como esto 00:27:16
pero bueno, como vamos a ver a los operadores 00:27:18
vamos a esperar 00:27:21
a ver el operador de concatenación y ya está 00:27:23
bueno, el tipo string 00:27:24
¿vale? 00:27:27
el tipo string 00:27:29
lo podemos usar así como cualquier otro 00:27:30
tipo de dato 00:27:33
asignándole cadenas 00:27:34
de texto, mostrándolas 00:27:37
y poco más, podemos usarlo así 00:27:39
pero el tipo string, como dije 00:27:41
el miércoles 00:27:45
tiene una particularidad 00:27:48
y es que 00:27:50
es un tipo 00:27:51
objeto 00:27:52
no es primitivo 00:27:54
como los ocho anteriores 00:27:56
y la particularidad 00:27:58
de un tipo objeto es que es una especie 00:28:00
de dato 00:28:02
que tiene muchas cosas primitivas 00:28:03
dentro, este en particular 00:28:06
no es fácil entender 00:28:08
que tiene dentro, pues mucho chat 00:28:09
tiene un chat, tiene un chat 00:28:11
tiene un chat, muchos 00:28:14
eso es lo que tiene dentro 00:28:15
y eso le convierte en tipo 00:28:18
objeto, el tener muchos primitivos 00:28:20
dentro 00:28:22
entonces 00:28:22
el tipo de dato objeto afortunadamente 00:28:26
ya está construido, no lo tenemos que construir 00:28:28
nosotros, lo podemos usar siempre que queramos 00:28:30
¿qué más particularidades 00:28:32
tiene una variable 00:28:36
que es de tipo objeto? 00:28:38
pues tiene algo 00:28:40
estupendo 00:28:42
que no tienen las variables 00:28:44
de datos primitivas 00:28:46
como las variables int, float 00:28:47
tiene algo que no tiene las variables de datos primitivas 00:28:50
y es que además de 00:28:52
tener un valor dentro 00:28:54
como este que tiene su valor, Pepito, Juanito 00:28:55
el que sea, además de tenerlo 00:28:58
son capaces de lanzar código 00:28:59
¿vale? 00:29:01
entonces una variable de tipo objeto 00:29:04
es capaz de llamar 00:29:06
a funciones que hagan cosas 00:29:08
una variable primitiva, no una variable 00:29:09
primitiva, solamente vale 00:29:12
para tener un valor dentro guardadito 00:29:14
y cuando alguien 00:29:16
lo usa para asignarlo a otra 00:29:18
pues lo ofrece, lo entrega 00:29:20
y se asigna, pues una variable objeto 00:29:22
además de eso 00:29:24
es capaz de llamar 00:29:26
a funciones para que hagan cosas 00:29:28
con su propio dato 00:29:30
con su propio dato 00:29:31
esta es la base de la operación de entorno de objetos 00:29:33
que ya entenderemos un poco más adelante 00:29:36
pero que ahora mismo 00:29:38
podemos simplemente 00:29:40
incorporar dos, tres 00:29:42
cositas a las que puede 00:29:44
llamar una variable string 00:29:46
porque esas dos, tres cositas 00:29:49
a las que va a poder llamar no son muy útiles 00:29:50
para poder hacer cosas desde ya 00:29:52
entonces vamos a 00:29:54
ponerlo aquí y ya está 00:29:59
y luego ya revisamos los operadores 00:30:01
entonces 00:30:03
las variables string entonces por tanto 00:30:05
por ser objeto 00:30:11
y no primitivas 00:30:15
pueden además 00:30:18
de tener almacenado un valor 00:30:27
que eso es para 00:30:29
lo que vale una variable esencialmente 00:30:31
para tener un valor dentro 00:30:33
Además de para guardar un valor 00:30:34
Que es para lo que valen las variables 00:30:42
Pues además de para esto 00:30:44
Valen 00:30:48
Pueden, perdón, además de para 00:30:49
Guardar 00:30:56
Joder, qué mal 00:30:57
Qué mal expresado 00:30:59
Pues además de eso valen para 00:31:01
Llamar 00:31:09
A funciones 00:31:11
Que hagan cosas 00:31:13
Con ese valor que tienen guardado dentro 00:31:15
Además valen para eso 00:31:20
yo como soy variable objeto, variable string 00:31:28
valgo como caja que guarda un valor 00:31:32
y además soy capaz 00:31:34
de llamar a funciones, de tener un comportamiento 00:31:37
que se llama para hacer cosas con ese valor que tengo dentro 00:31:40
además valgo para eso porque soy un objeto 00:31:43
es decir, los objetos tienen datos 00:31:46
y los objetos además pueden hacer cosas 00:31:48
esa es la diferencia entre una variable objeto 00:31:51
y una variable primitiva 00:31:55
las variables primitivas 00:31:56
solamente valen 00:31:58
para tener un dato dentro 00:32:00
se acabó 00:32:01
si alguien quiere luego ya 00:32:02
usarlas en una expresión matemática 00:32:05
las usa 00:32:07
pero solo valen para tener un dato dentro 00:32:08
las variables objeto valen para tener un dato dentro 00:32:11
y además para llamar 00:32:14
código, a funciones 00:32:18
lo que llamaremos método más adelante 00:32:20
que hacen cosas con ese valor 00:32:22
que tengo dentro y eso es muy útil 00:32:24
por ejemplo 00:32:26
esta variable string nombre 00:32:28
esta variable string nombre 00:32:32
podemos mostrar su valor 00:32:34
ya lo hemos mostrado 00:32:38
pero a lo mejor a lo mejor a mí también me interesa 00:32:39
ver 00:32:42
cuál es su longitud 00:32:43
cuántos caracteres tiene 00:32:45
bueno pues eso ya es hacer algo 00:32:47
contar la cantidad de caracteres 00:32:49
que tiene un string ya es hacer algo 00:32:52
entonces podría yo hacerlo 00:32:54
por programa si es que sé hacerlo 00:32:56
y o digo, anda, nombre es una variable objeto. 00:32:59
Además, puede hacer cosas con el dato que tiene dentro. 00:33:05
Una de esas cosas, por casualidad, 00:33:10
será contar los caracteres que tiene, 00:33:12
porque si una de esas fuera eso, qué suerte, 00:33:15
llamo a esa función y ya tengo eso que yo quería hacer. 00:33:18
Bueno, pues efectivamente, las variables string, 00:33:22
entre todas las cosas que pueden hacer, 00:33:26
que son muchas, hay una que es 00:33:28
contar los caracteres que tengo 00:33:30
dentro y entregártelos 00:33:32
como resultado 00:33:34
vale, pues como hacemos para que una variable 00:33:35
objeto llame 00:33:38
a las funciones 00:33:40
que puede invocar 00:33:42
porque cada variable objeto puede invocar un montón de 00:33:44
funciones propias suyas 00:33:46
para hacer cosas con lo que tiene dentro 00:33:48
pues esto es parte de la aplicación 00:33:50
de entrada de objetos, pero ahora mismo podemos ponerlo 00:33:52
para que 00:33:54
para usar las funciones básicas 00:33:55
pues si en una variable objeto 00:33:57
se pone un punto 00:33:59
automáticamente después de poner el punto 00:34:01
ya podemos poner 00:34:07
un nombrecito 00:34:09
que es la llamada 00:34:10
a ese código que a mi me interesa ejecutar 00:34:12
claro 00:34:15
el nombre de ese código 00:34:17
que a mi me interesa ejecutar 00:34:19
lo tengo que saber 00:34:20
tengo que saberlo 00:34:22
no me lo puedo inventar 00:34:24
bueno pues el que hizo 00:34:26
el tipo de dato string 00:34:29
decidió 00:34:31
la cantidad de cosas 00:34:33
a las que podía llamar la variable 00:34:35
y le puso un nombre a cada una 00:34:37
pues yo lo tengo que averiguar 00:34:38
me tendré que ir a la documentación de Java 00:34:40
de Oracle, a ver, oye 00:34:43
¿a qué cosas puede llamar una variable string? 00:34:44
lo tengo que averiguar 00:34:47
ah, mira, puede llamar a esto 00:34:48
que se llama longitud 00:34:50
que me calcula la longitud de la cadena 00:34:52
ah, puede llamar a esto 00:34:54
que se llama 00:34:56
vaciar que me 00:34:58
hace que el string se quede vacío 00:35:00
fíjate, puede llamar a todas estas cosas 00:35:02
con este nombre que me hacen esto 00:35:04
todo eso lo habrá 00:35:06
programado el que hizo ese tipo de string 00:35:08
y estará en la documentación 00:35:10
pues me tendré que ir a buscarlo 00:35:13
a ver que puede hacer 00:35:14
pero bueno, afortunadamente, gracias a que 00:35:15
tenemos un entorno de desarrollo 00:35:18
no tenemos que irnos a la documentación 00:35:20
cada vez que usamos 00:35:23
una variable objeto para ver 00:35:24
qué cosas puede hacer, porque 00:35:26
gracias a que tenemos un entorno de desarrollo 00:35:28
que tiene incorporadas 00:35:30
ayuditas, 00:35:33
pues cualquier entorno de desarrollo 00:35:34
cuando tú pones un punto 00:35:36
él ya automáticamente se va 00:35:38
a la documentación, a la aguja, a todo y te muestra 00:35:40
aquí un listado de todas 00:35:42
las cosas que puede hacer 00:35:44
esa variable por el hecho de ser 00:35:46
objeto, todas las que puede hacer 00:35:48
con su 00:35:50
nombrecito, pues uno 00:35:52
las mira y en cada una de ellas 00:35:54
además le especifica 00:35:56
lo que hace eso. 00:35:58
Nosotros estamos buscando 00:36:01
una, ahora en particular, 00:36:02
que me cuente cuántos 00:36:05
caracteres tiene ese nombre 00:36:06
y que me lo devuelva 00:36:08
como resultado. Pues, hombre, 00:36:09
yo puedo navegar por aquí hasta que encuentre una. 00:36:12
Hasta que encuentre una. 00:36:16
Lo normal, el que programó ese 00:36:17
objeto stream, si lo hizo 00:36:19
bien y fue listo, 00:36:22
pues a los nombrecitos 00:36:24
de esas funciones 00:36:25
les dio nombrecitos lo más 00:36:26
explicativo posible, porque si no es 00:36:28
un rollo. Entonces, si yo 00:36:30
quiero ver si hay 00:36:32
alguna funcionalidad 00:36:34
para algo relacionado con la longitud, pues tendré 00:36:36
que buscar algún método 00:36:38
que tenga dentro 00:36:40
el término lens, que menos, ¿no? 00:36:42
Entonces, uno va buscando por aquí 00:36:45
a ver si hay alguno, le suena 00:36:46
papapá, llega 00:36:50
lens. 00:36:53
Anda, qué suerte 00:36:55
Hay una funcionalidad 00:36:57
Que oficialmente se llama método 00:37:00
Podemos llamarlo método desde ahora 00:37:04
Y así adelantamos trabajo 00:37:06
Hay un método de esta variable string 00:37:07
Que se llama led 00:37:10
Que si yo miro lo que hace 00:37:12
Te devuelve la longitud del string 00:37:14
Uy, justo lo que yo quería 00:37:17
Qué suerte 00:37:18
¿Vale? Me devuelve la longitud del string 00:37:19
Justo lo que yo quería 00:37:22
Dime 00:37:23
El LEN 00:37:25
Bueno, no, habrá 00:37:27
Muchas otras tipos de datos 00:37:28
Que tendrán su propio método LEN que hará otras cosas 00:37:30
Ah, vale, pero el LEN es 00:37:33
No, no, no, el LEN no 00:37:34
O sea, el LEN 00:37:36
Que este método se llame LEN 00:37:38
No significa que ese nombre ya esté prohibido 00:37:40
Para cualquier otro tipo de dato objeto 00:37:42
Yo me puedo inventar un tipo de dato objeto 00:37:45
Pues 00:37:48
Usuario, me lo invento 00:37:49
Y dentro de ese mismo tipo de dato objeto 00:37:51
pues meto un string 00:37:54
un int para la edad 00:37:57
todo lo que yo quiera, me consigo un objeto primitivo 00:37:59
y ahora le voy a programar 00:38:01
yo funcionalidades 00:38:03
puedo programarle una que se llame led 00:38:04
si me da la gana 00:38:07
y esa led que sea a lo mejor 00:38:07
el tamaño de su 00:38:10
apellido, lo que sea 00:38:13
es decir 00:38:14
que tenga string un método que se llama 00:38:15
led, no significa que otros tipos de datos 00:38:19
no puedan tener otro que se llame led, claro que sí 00:38:21
No, no, no. Esto que pone después de los dos puntos 00:38:22
es el tipo de dato del resultado que te entrega. 00:38:28
Entonces, length es para contar. Luego te entrega 00:38:32
un entero. Claro. Entonces, la ayuda que te da el eclipse 00:38:36
efectivamente te dice 00:38:40
te dice 00:38:43
qué tienes que llamar para hacer lo que quieres hacer. 00:38:45
y luego te dice qué tipo de dato te va a entregar en respuesta. 00:38:51
¿Vale? 00:38:57
Bueno, pues este en particular me va a entregar un numerito, 00:38:58
por eso me pone int. 00:39:01
¿Vale? 00:39:03
Y así hay un montón de métodos, 00:39:04
pero ahora mismo nos falta un montón de información 00:39:06
para entender todo esto que ponías aquí del stream, 00:39:08
del no sé qué, del void, de bla, bla, bla, de object. 00:39:11
Pero alguno básico de stream ya sí que podemos usar. 00:39:14
Entonces, hemos dicho 00:39:17
Qué suerte que he encontrado 00:39:20
Que mi variable objeto nombre 00:39:22
Puede llamar a una funcionalidad 00:39:23
También llamada método 00:39:26
Que hace lo que yo quiero 00:39:28
Pues ya está, ahí la tengo 00:39:30
Claro, me devuelve esto 00:39:32
Me devuelve un numerito 00:39:36
Ese numerito, ¿para qué lo usaré? 00:39:39
Para asignárselo a una variable numerito 00:39:43
claro, por ejemplo 00:39:46
esta 00:39:50
vale 00:39:55
pues entonces 00:39:57
esta variable string 00:40:00
por ser objeto 00:40:03
ha podido llamar con este operador 00:40:04
punto a una 00:40:07
funcionalidad 00:40:09
que sirve porque alguien 00:40:10
la programó así 00:40:13
sirve para 00:40:14
devolverme 00:40:16
el número de caracteres de este 00:40:18
string, de este string que está aquí 00:40:21
de este que está aquí 00:40:23
eso que me devuelve 00:40:24
lo normal es que yo lo use 00:40:27
para asignárselo a alguien 00:40:30
en una sentencia de asignación 00:40:32
vale, pues aquí solo asigno el número de caracteres 00:40:33
entonces aquí podría poner, pues por ejemplo 00:40:37
tu nombre 00:40:40
tiene esto 00:40:43
caracteres 00:40:58
vale, entonces si 00:41:06
ejecutar, entonces 00:41:24
esto de llamar 00:41:30
a una funcionalidad 00:41:32
que te va a hacer un código 00:41:34
con el dato que hay aquí dentro 00:41:36
y te va a devolver un valor 00:41:38
estas cosas solo 00:41:40
la pueden hacer las variables que sean 00:41:42
objeto, y string 00:41:44
es la primera variable objeto con la que estamos trabajando 00:41:46
pero sin saberlo, ya lo hemos hecho 00:41:48
otras veces, con el scan 00:41:52
fijaos que hemos hecho con el scan 00:41:53
El scan es una variable más nuestra 00:41:56
Pero es una variable objeto 00:41:59
No es primitiva 00:42:01
Sería primitiva si fuera indavel 00:42:02
Lo que fuera su objeto 00:42:04
¿Y cómo hemos hecho para leer un número? 00:42:05
Hemos hecho scan. 00:42:09
La llamada a algo 00:42:12
Pues ya habíamos hecho algo antes 00:42:13
Lo de hacer que un objeto 00:42:15
Llame a un método que desencadee una acción 00:42:18
Ya lo habíamos hecho aquí 00:42:20
Mi objeto es selector 00:42:22
que yo había creado arriba 00:42:24
mi objeto lector llama 00:42:26
a esto 00:42:28
y esto que hace por dentro 00:42:29
un montón de cosas, se va el teclado 00:42:31
mira lo que hay en el buffer, lo coge 00:42:34
y te lo entrega 00:42:36
y se lo estamos asignando 00:42:38
lo que te ha entregado a esto 00:42:39
luego en realidad ya estamos usando 00:42:41
dos variables objeto 00:42:46
aún sin entender muy bien que es una variable objeto 00:42:47
esta variable scan 00:42:50
que es de tipo 00:42:52
Scanner, que es un tipo objeto 00:42:55
y por el hecho de ser tipo objeto 00:42:57
ha sido capaz de llamar 00:43:00
a funcionalidades para hacer cosas 00:43:03
está muy sofisticada de hecho 00:43:06
porque está implicada y se ha teclado el RFT 00:43:08
pero también lo estamos haciendo con String 00:43:11
String es una variable objeto 00:43:13
y aquí hemos podido llamar 00:43:15
a esta funcionalidad 00:43:19
que en particular me ha contado 00:43:21
cuantos caracteres tiene este 00:43:24
una variable primitiva 00:43:26
como esta 00:43:28
por ejemplo 00:43:30
nunca jamás podría 00:43:31
llamar a nada, no un punto 00:43:34
es que Eclipse 00:43:36
no me ofrece nada después de hacer no un punto 00:43:38
porque una variable 00:43:41
primitiva no puede llamar 00:43:43
a ninguna funcionalidad 00:43:44
una variable primitiva solamente vale 00:43:46
para tener un valor dentro almacenado 00:43:48
y para que luego 00:43:50
otra sentencia la use en una expresión 00:43:52
pero no vale para llamar 00:43:54
a nada, las variables 00:43:56
objetos sí 00:43:58
¿vale? 00:43:59
venga, pues vamos a parar aquí un momentito 00:44:04
bueno y ahora 00:44:06
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
3
Fecha:
28 de septiembre de 2025 - 19:11
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
44′ 08″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
844.87 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid