Saltar navegación

20240930 ProgrEstruct-EjerciciosYString - 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 30 de septiembre de 2024 por Raquel G.

18 visualizaciones

Más información Transcripción

Descargar la transcripción

Gracias por hacer depósitos. 00:00:00
¿Qué? 00:00:01
Gracias por hacer depósitos. 00:00:02
Ah, ¿la veis por hecho que podía no hacerlos? 00:00:05
Sí. 00:00:09
Ah, bueno, no, entonces no los hago. 00:00:10
Yo es que pensaba que era obligatorio. 00:00:11
Pero si existe la opción de no hacerlos... 00:00:13
Bueno, a ver, que yo también lo necesito, 00:00:16
no solo vosotros, así que no os asustéis. 00:00:19
Vale, pues entonces, todo... 00:00:22
Ya. 00:00:25
Todo este rollo último era 00:00:27
para ver que realmente existe una diferencia 00:00:29
entre poner uno y dos 00:00:33
para que no os quedéis como diciendo 00:00:35
pues para que hay dos y hacen lo mismo 00:00:37
pues no hacen exactamente lo mismo 00:00:39
pero repito 00:00:41
la única trascendencia es cuando la segunda expresión 00:00:43
de condición 00:00:47
implica que además se asigne valor a alguien 00:00:48
si implica eso 00:00:52
tiene trascendencia porque ese valor no se asignaría en algunos casos 00:00:53
En los casos en los cuales no haga falta 00:00:57
Evaluar esa condición porque ya sea falsa la primera 00:00:59
Pero en la mayoría 00:01:02
De los casos, que son los casos en los cuales 00:01:04
No trabajamos así 00:01:06
¿No? 00:01:08
Por ejemplo yo aquí 00:01:09
Si descomento esto 00:01:10
Si lo descomento 00:01:13
Aquí entonces ya no necesito 00:01:15
Leer esto 00:01:17
Entonces ahora ya en este caso 00:01:19
Así 00:01:26
Pues en este caso 00:01:32
en el cual me sobra 00:01:34
no, está bien 00:01:36
vale, en este caso 00:01:38
esta 00:01:39
expresión de evaluarla 00:01:41
o no, no hay ninguna diferencia práctica 00:01:44
porque no hay ninguna asignación de variable 00:01:46
escondida dentro, no hay nada 00:01:47
entonces, en este caso 00:01:49
¿por qué pongo el 2? 00:01:51
entonces, por defecto siempre ponemos 00:01:54
dos operadores, porque 00:01:56
ahorras tiempo 00:01:58
pasas de la segunda si no hace falta 00:01:59
pero, cuidado 00:02:02
Cuidado en los casos en los cuales 00:02:04
Esta es de ejecución forzosa 00:02:05
Por lo que sea 00:02:07
Bueno 00:02:08
Este ejercicio está claro 00:02:11
Se supone que nos ha servido 00:02:14
Para acabar de entender 00:02:17
Este operador 00:02:19
Si no lo entendíamos bien 00:02:20
Y además para vislumbrar 00:02:21
Un poquito 00:02:25
La razón de que haya dos versiones 00:02:25
¿Qué más cosas tenemos por aquí? 00:02:28
Este sería 00:02:35
igual pero de tres condiciones 00:02:35
esto podéis hacerlo vosotros 00:02:38
y quien tenga dudas que lo diga 00:02:40
este está claro que sería un or 00:02:44
es lo mismo pero un or 00:02:45
se leen dos notas 00:02:47
y mostrar un mensaje diciendo 00:02:49
si aprobó al menos una de ellas 00:02:52
entonces si la primera nota mayor que 5 00:02:54
o la segunda nota 00:02:56
mayor que 5 00:02:58
entonces aprobó alguna 00:02:59
si no, no 00:03:02
vale, entonces 00:03:02
como muchos de estos ejercicios 00:03:05
son ya 00:03:11
de mostrar mensajes en pantalla 00:03:13
condicionado, estamos ya 00:03:15
estamos ya 00:03:17
usando un montón de veces 00:03:19
esto 00:03:21
que son cadenas de texto 00:03:22
lo estamos usando un montón de veces 00:03:26
ahora mismo lo estamos usando solo 00:03:28
para pasárselo a los 00:03:30
system.out.println para que lo muestren por pantalla 00:03:32
lo estamos usando solo para eso 00:03:34
no vamos a usarlo para nada más 00:03:36
y a veces lo usamos pasándole 00:03:38
dos posibilidades, o uno o el otro 00:03:40
¿vale? 00:03:42
entonces ya estamos empezando efectivamente 00:03:44
a usar un montón 00:03:45
lo que se llama cadena de caracteres 00:03:47
¿verdad? cadenas de caracteres, que son texto 00:03:49
entre comillas dobles 00:03:52
y exclusivamente entre comillas dobles 00:03:53
pero entre comillas simples sería unicochar 00:03:56
¿vale? 00:03:58
bueno, pues entonces, para hacer 00:03:59
los programas un poquito más operativos 00:04:01
y no estar todo el rato arrastrando esto 00:04:03
dentro de un system out, porque es 00:04:05
en un único sitio, de ahora mismo lo podemos usar 00:04:07
pues vamos a introducir 00:04:09
un poquito de otro tipo de 00:04:11
dato, más allá de los 00:04:13
siete primitivos que no sabemos 00:04:15
el byte, el short, el in, el log 00:04:16
el double, el float, el dicho siete 00:04:19
y son ocho, el boolean y el char 00:04:21
esos son los ocho datos 00:04:22
de tipo, los ocho tipos de datos primitivos 00:04:25
que sabemos exactamente 00:04:27
cómo funcionan 00:04:29
pues vamos a 00:04:30
introducir, lo tenéis 00:04:33
en los apuntes de la aula virtual 00:04:35
una pequeña introducción a string 00:04:37
que tenéis ahí, pero vamos, que todo eso son resumencillos 00:04:39
para no perder el hilo 00:04:41
de lo que estamos haciendo, pero no es material de estudio 00:04:43
el estudio es lo que hacemos en clase 00:04:45
y lo que trabajáis en casa 00:04:47
lo que sube a lo virtual 00:04:48
son como pequeñas guías para que sepáis lo que estamos 00:04:50
haciendo, pero no es material para 00:04:53
estudiar para el examen, el examen es estudiar 00:04:55
haciendo ejercicios a lo bestia 00:04:57
vale, bueno, pues entonces 00:04:59
vamos a ver por tanto 00:05:02
Un poquito de un tipo de dato adicional 00:05:08
De cara 00:05:10
A poder hacer los ejercicios 00:05:12
Con un poquito más de 00:05:14
Sí, más que soltura 00:05:16
Más cómodo 00:05:19
Más cómodamente 00:05:23
Más cómodamente 00:05:23
Vale, pues venga 00:05:25
Vámonos, venga, pues no, que estoy del pein 00:05:27
Hasta los cataplines 00:05:30
Así que 00:05:32
Vamos a poner esto 00:05:33
vale, pues vamos a ver 00:05:36
ese tipo de dato adicional 00:05:47
recordad que los tipos de datos 00:05:48
que hemos visto 00:05:50
son estos, que a nadie se les olvide 00:05:52
byte 00:05:54
short 00:05:57
int 00:06:00
y long, esto para números enteros 00:06:01
con diferente 00:06:04
cantidad de bits 00:06:05
float 00:06:07
y double para números reales 00:06:11
con diferente cantidad de cifras decimales 00:06:14
char para un único 00:06:16
carácter 00:06:19
y boolean 00:06:20
para una condición 00:06:23
algo que puede ser 00:06:25
true o false, vale, estos eran los 00:06:27
tipos de datos primitivos 00:06:29
bueno, ya hemos dicho varias 00:06:30
veces que estos tipos de datos 00:06:37
tienen el uso 00:06:38
que tienen, que es números, un char 00:06:41
y una condición, nada más 00:06:43
las aplicaciones suelen trabajar con 00:06:44
cosas un poquito más complejas, con un 00:06:47
cliente que tiene un nombre 00:06:49
o una edad, un DNI 00:06:51
con un equipo informático 00:06:53
que tiene 00:06:55
el identificador 00:06:56
de la placa base, lo que sea. Normalmente 00:06:59
trabajamos con cosas 00:07:01
cuya información no se puede 00:07:02
recoger solo o en un byte o en un 00:07:05
short o en un int. 00:07:07
Bueno, pues para eso existen otros tipos de datos 00:07:08
que no son los primitivos 00:07:11
que son 00:07:13
los tipos de datos objeto. 00:07:15
¿Vale? 00:07:23
entonces los tipos de datos 00:07:23
objeto, hay que hacerlos 00:07:25
hay que fabricarlos, se construyen 00:07:27
hay que fabricarlos, no los trae Java 00:07:29
de serie, los que trae de serie 00:07:31
son los primitivos 00:07:33
los tipos de datos objeto hay que construirlos 00:07:34
no los trae de serie 00:07:37
¿en qué se diferencian los tipos de datos 00:07:37
objetos y los primitivos? 00:07:41
aparte de que hay que construirlos, ya veremos cómo 00:07:43
aparte de que hay que construirlos 00:07:45
se diferencian en la forma de almacenamiento 00:07:46
¿vale? 00:07:49
son varios primitivos 00:07:50
Sí, pero no solo 00:07:55
Por ejemplo, cuando uno declara un tipo primitivo 00:07:58
Por ejemplo, como el empero 00:08:07
En n, ya sabemos lo que eso implica 00:08:09
Para la máquina virtual y para nuestra aplicación 00:08:14
Que automáticamente aparece un espacio en memoria 00:08:16
De 32 bits en este caso 00:08:19
Con un nombrecito n 00:08:20
Bueno, cuando declaramos un tipo objeto 00:08:22
Vamos a suponer que yo he construido ya un tipo objeto 00:08:27
para una variable que quiero que sea una variable 00:08:30
que guarda los datos de un cliente. 00:08:33
Entonces, repito, como los datos de un cliente son muchos, 00:08:36
no me caben en un byte, son muchos, 00:08:39
pues yo construyo, ya veremos cómo, 00:08:42
construyo un nuevo tipo de datos que lo llamo cliente. 00:08:44
Ese sería un nuevo tipo de dato que me he construido yo 00:08:48
y que le he dado el nombre cliente. 00:08:51
Ya veremos cómo se construye. 00:08:53
Entonces, una vez que el tipo de dato está construido, 00:08:56
uno puede ya declarar variables de ese tipo 00:08:58
igual que aquí hemos declarado variable 00:09:00
n de tipo int, pues 00:09:02
podríamos declarar variables 00:09:04
de tipo cliente 00:09:06
por ejemplo, imaginaos que yo 00:09:08
declaro aquí una variable 00:09:10
mi cliente, vale 00:09:12
pues he declarado una variable mi cliente 00:09:15
con el nombre que hay me ha dado la gana 00:09:18
pero su tipo de dato 00:09:19
es un tipo de dato objeto que he construido 00:09:21
yo para que le quepan varias cosas 00:09:24
dentro, etcétera, ya veremos cómo 00:09:25
bueno, pues cuando estamos 00:09:27
declarando esto, la máquina virtual que está haciendo 00:09:30
mi cliente en realidad 00:09:32
esta variable 00:09:34
en realidad 00:09:36
físicamente es una 00:09:38
dirección de memoria, eso es lo que es 00:09:40
es una dirección de memoria RAM 00:09:42
y es 00:09:44
una dirección de memoria 00:09:48
que será la dirección de memoria de algún sitio 00:09:49
de la memoria RAM, de algún sitio, porque es una dirección 00:09:51
de memoria, recordad que 00:09:54
la memoria RAM pues son 00:09:56
todos los espacios, los bytes, cada uno de ellos tiene una dirección asociada. 00:09:57
Pues es una dirección de memoria de un espacio en memoria RAM 00:10:03
donde ahora están ya todos los datos de ese objeto cliente, 00:10:06
los que sean, que pueden ser tropecientos, un montón. 00:10:10
Pues es la primera diferencia entre una variable de un tipo primitivo 00:10:16
y una variable de un tipo construido objeto. 00:10:21
En este caso, la variable es propiamente el dato, 00:10:24
directamente la variable se refiere al espacio de memoria 00:10:27
donde está el dato, el 7, el 8, lo que sea 00:10:30
y en este otro caso 00:10:32
la variable se refiere a una dirección de memoria 00:10:34
y ya esta dirección de memoria 00:10:38
si yo la sigo, ya veremos cómo seguirla 00:10:40
si yo la sigo, ya sí que nos lleva al espacio de la RAM 00:10:42
donde está todo, lo que sea 00:10:46
entonces esa es la primera diferencia 00:10:48
esa diferencia tenemos que 00:10:51
por supuesto ser plenamente consciente de que existe 00:10:55
porque tiene un montón de implicaciones 00:10:58
ahora de la ejecución de un programa 00:11:00
es que esto es un puntero 00:11:01
claro, claro, es que 00:11:05
en la aplicación de entradas de objetos 00:11:07
el antiguo puntero de C 00:11:09
o de otros lenguajes es un objeto 00:11:11
¿vale? 00:11:14
entonces, eso es la primera cosa 00:11:16
que tenemos que tener clara, que es distinto 00:11:18
y luego, y tiene muchas 00:11:20
implicaciones ahora de la ejecución de 00:11:22
un programa, lo que pasa es que 00:11:24
ahora lo programa una vez que no lo tiene claro 00:11:26
pues ya no está todo el rato pensando que eso es una dirección 00:11:27
no lo está pensando, no hace falta 00:11:30
estarlo pensando todo el rato 00:11:32
no puede ya programar con tranquilidad 00:11:33
sin estar todo el rato pensando 00:11:36
que eso es una dirección 00:11:38
a diferencia de los antiguos punteros de C que sí que tenías que tenerlo pendiente 00:11:39
para ponerle delante el simbolito 00:11:42
de sacar la dirección, aquí no, aquí es todo mucho más fácil 00:11:44
claro 00:11:46
pero sí que hay que entender que son distintos 00:11:48
porque a veces nos hay errores de ejecución 00:11:50
y esto 00:11:52
porque es, ah, claro, es que esta variable 00:11:54
ya no es eso, ¿vale? 00:11:56
Bueno, eso por un lado. 00:11:58
Vale, bueno, pues siguiente cosa. 00:12:00
De estos tipos que 00:12:03
construimos, muchísimos 00:12:04
ya están hechos afortunadamente. 00:12:06
Muchos ya están hechos. 00:12:08
¿Y quién los trae? La propia Java 00:12:10
Virtual Machine, la máquina virtual que ejecuta 00:12:12
los programas, ya hemos visto 00:12:14
alguna vez, que trae de serie incorporadas 00:12:16
un montón de punto class 00:12:18
dentro, ¿verdad? Un montón de punto class. 00:12:20
Pues muchos de esos punto class 00:12:22
son tipos de datos ya construidos 00:12:24
que nosotros podemos aprovecharnos 00:12:26
de ellos. Y aparte 00:12:28
podemos hacer los nuestros, que de eso se trata 00:12:30
todo el curso, de hacer nuestros propios tipos de datos 00:12:32
o objetos. Pero hay muchos 00:12:34
que ya vienen hechos y construidos y están 00:12:36
en la máquina virtual y yo los puedo usar. 00:12:38
Vale, pues muchos de ellos 00:12:40
bueno, pues muchos ya están 00:12:42
en la 00:12:48
Java Virtual Machine. 00:12:50
Vale, pues 00:12:53
uno de ellos 00:12:54
uno de ellos lo usamos desde ya 00:12:55
lo tenemos que usar desde ya porque es imprescindible 00:12:57
pues uno de ellos es este tipo 00:12:59
el tipo string 00:13:02
con la S en mayúscula 00:13:05
los objetos siempre suelen ir con la primera mayúscula 00:13:07
sí, eso es justo lo que iba a decir 00:13:12
el nombre del tipo de dato 00:13:14
uno le puede poner el que le dé la gana porque no se lo inventa 00:13:16
pero de nuevo, si seguimos 00:13:19
ciertos estilos de programación 00:13:20
vamos a hacer nuestros programas más legibles 00:13:22
entonces se asume 00:13:24
que cuando te inventas un tipo de dato 00:13:26
nuevo objeto 00:13:29
dale un nombre que empiece en mayúscula 00:13:30
dale un nombre que empiece en mayúscula 00:13:33
porque así el que use 00:13:35
la aplicación, el que vea el código 00:13:36
va a hacer asociaciones mentales más rápidas 00:13:38
va a decir, ah, esto es un tipo de dato construido 00:13:40
es un objeto patatín, entonces respetémoslo 00:13:42
y de hecho en la máquina virtual 00:13:45
pues todos los tipos de objetos construidos 00:13:46
que te dan empiezan con mayúscula 00:13:48
entre ellos el stream 00:13:50
bueno, pues el stream 00:13:52
tiene un uso muy concreto 00:13:55
Vale, pues como podemos sospechar 00:13:56
Por su nombre 00:14:05
¿El string para qué vale? 00:14:06
Para guardar muchos charts 00:14:08
Para eso vale el string 00:14:09
Eso, internamente 00:14:12
Internamente, físicamente 00:14:16
Está almacenado como una raíz de chart 00:14:18
Lo que pasa es que no lo puedes usar como una raíz de chart 00:14:19
Porque está envuelto en este tipo 00:14:22
Guarda 00:14:24
¿No lo podrías usar como una raíz de chart 00:14:27
Para distinguir una letra 00:14:29
Ante las terceras letras? 00:14:31
Sí, pero no accediendo a la posición del array, 00:14:32
porque el array está oculto, 00:14:35
sino accediendo a través del método que te ofrezcas. 00:14:36
Este tipo envuelve al array 00:14:41
y te da una nueva forma de usar ese array 00:14:43
que no es la tradicional. 00:14:45
Guarda muchos caracteres en fila. 00:14:49
¡Hala! Por ponerlo así. 00:14:51
Pues estupendo, porque muchos caracteres en fila 00:14:55
es una cadena de caracteres, 00:14:58
lo que nosotros usamos tan a menudo que nos es muy útil. 00:14:59
para guardar nombres, para poner mensajes. 00:15:01
Las cadenas de carácteres las necesitamos desde ya. 00:15:05
Estamos todo el rato mostrando cadenas de carácteres ahí, 00:15:07
poniéndolas tal cual, 00:15:10
cuando a lo mejor podríamos haberlas guardado en un objeto, 00:15:12
en una variable de esas, 00:15:15
y habría sido más cómodo. 00:15:17
Bueno, pues entonces, 00:15:20
ya sabemos que ese tipo de dato existe 00:15:21
y para qué vale. 00:15:23
¿Cómo lo usamos? 00:15:25
Esto tiene millones de métodos, de historias y de rollos, 00:15:27
pero vamos a ver el uso básico 00:15:29
para poder trabajar con él 00:15:32
pues yo declaro una variable string 00:15:33
como declara cualquier otra variable 00:15:35
igual que yo declaro una variable entera 00:15:37
poniendo tipo de dato y el nombre 00:15:39
que a mí me dé la gana 00:15:41
pues declaro una variable 00:15:42
cadena de caracteres 00:15:44
poniendo el tipo de dato 00:15:47
y aquí el nombre 00:15:49
de la variable que a mí me dé la gana 00:15:53
pues ya está 00:15:54
ya me he declarado una variable tipo 00:15:56
cadena de caracteres o variable string 00:15:58
Exactamente igual que me declaro un name 00:16:00
Exactamente igual 00:16:03
Vale, lo que pasa es que ahora 00:16:04
Esta variable sirve para guardar 00:16:07
Cadenas de caracteres 00:16:09
Y solo para eso, para guardar cadenas de caracteres 00:16:10
Por tanto, si yo quiero hacer una asignación 00:16:15
Pues tendré que hacer una asignación 00:16:17
Compatible 00:16:23
Por ejemplo, nombre igual 00:16:24
¿Y qué le podemos asignar a nombre? 00:16:30
Algo que sea cadena de caracteres 00:16:32
Como por ejemplo, esto 00:16:33
Ahí sí que tienes que ponerle antecomunidad 00:16:35
claro, porque esto es el valor 00:16:38
de esa cadena, yo quiero que esta cadena 00:16:41
tenga como contenido 00:16:43
esto, echamos otro asunto 00:16:44
esto, pues ya está, es una asignación válida 00:16:46
con espacios 00:16:48
claro, cualquier sucesión de caracteres 00:16:50
de la tabla ASTI, cualquiera 00:16:53
la que te dé la gana, es una cadena de caracteres 00:16:54
se le asignas la variable nombre 00:16:56
y ya está 00:16:58
y haces asignaciones exactamente igual 00:16:59
como que otra variable 00:17:03
imaginemos que tenemos otra variable 00:17:04
string que se llama apellido 00:17:06
por ejemplo, ahora tengo dos variables 00:17:09
string, por ejemplo 00:17:11
pues esto 00:17:13
podría hacer esto aunque no tenga sentido 00:17:16
pero en términos de 00:17:19
java es válido 00:17:21
al string apellido 00:17:22
le asigno lo que tenga nombre 00:17:25
lo que tenga nombre, entonces le estaría 00:17:27
asignando lo que tiene nombre que es Carlos 00:17:29
exactamente igual cuando trabajo con asignaciones 00:17:31
enteras, cuando hago 00:17:33
n igual a m 00:17:35
lo que tiene m 00:17:36
se lo asigno a n, porque ambas son 00:17:39
enteras, lo puedo hacer 00:17:41
pues aquí lo mismo, lo que tiene nombre 00:17:42
se lo asigno a apellido 00:17:45
porque ambas son este y lo puedo hacer 00:17:46
ya está, no pasa nada 00:17:48
entonces lo podemos usar como cualquier otro tipo 00:17:50
de dato, aunque internamente no funciona así 00:17:53
y es 00:17:55
¿vale? y ahora 00:17:56
nosotros ya hemos visto que el operador más 00:18:05
ya hemos mencionado, cuando trabaja con 00:18:07
cadenas de caracteres, concatena 00:18:09
Pues puedo concatenar string 00:18:11
Porque los string son cadenas de caracteres 00:18:14
Por ejemplo podría hacer esto 00:18:17
Y esto es una operación válida 00:18:19
Porque el operador más 00:18:27
Tiene una cadena a un lado 00:18:28
Y otra cadena al otro 00:18:30
Luego más es concatenación 00:18:31
Concatena esta cadena con esta cadena 00:18:34
Y la concatenación de ambas 00:18:37
Aquí 00:18:38
Vale, entonces 00:18:39
Bueno pues ved cualquier variable 00:18:41
Claro, claro, seguido 00:18:45
Si yo quiero un espacio, con catena entre medias 00:18:48
Una cadena espacio, lo que yo quiera 00:18:49
¿Vale? Entonces ves una variable string 00:18:51
Como una cadena de caracteres, sin más 00:18:54
Me da igual tener la cadena así puesta 00:18:56
Que tenerla guardada en una variable 00:18:58
Porque es lo mismo 00:19:00
Entonces, como variables para guardar valor 00:19:02
No tienen más que esto 00:19:06
Ahora ya el tema es 00:19:07
Si queremos hacer cosas con esas cadenas 00:19:10
Como por ejemplo 00:19:12
Ver, por ejemplo 00:19:13
ver el carácter que tengo en una posición 00:19:15
ver el tamaño que tiene 00:19:18
si quiero hacer eso 00:19:20
me puedo aprovechar 00:19:22
de que los objetos 00:19:23
como ya he dicho alguna vez 00:19:25
son variables 00:19:28
con muchas cositas dentro 00:19:30
y eso es lo que son físicamente 00:19:31
variables con muchas cosas dentro 00:19:33
pero 00:19:36
además de eso 00:19:37
son capaces de hacer cosas 00:19:39
que es lo que una variable 00:19:42
primitiva no es capaz 00:19:44
Entonces, como esto es una variable objeto 00:19:45
Aparte de tener su valor cadena dentro 00:19:52
Es capaz de hacer cosas 00:19:54
Y esa capacidad de hacer cosas 00:19:56
Nos va a permitir a través de esas cosas que es capaz de hacer 00:20:00
Obtener, por ejemplo, el char en una posición 00:20:03
Ver la longitud, cosas de esas 00:20:06
Es como cuando veíamos el escáner 00:20:09
El objeto escáner 00:20:11
vale, creo que he grabado con la otra cámara 00:20:12
porque se veía muy bien, o sea que vas ahí en el tejo 00:20:22
pero bueno 00:20:23
vale 00:20:24
vale, vamos a hacer 00:20:52
en una clase aparte 00:20:56
un ejemplo con string 00:20:57
pero la idea que he dicho 00:20:59
es, por ejemplo, ¿qué otro ejemplo de variable 00:21:02
de tipo objeto hemos usado hasta ahora? 00:21:04
pues el scan 00:21:06
¿verdad? ya en su momento 00:21:07
cuando lo usamos lo dijimos, dijimos, ojo 00:21:09
scan es una variable 00:21:11
más, lo que pasa 00:21:14
es que es una variable de un tipo construido 00:21:16
que se llama scanner 00:21:18
entonces aparte de guardar un valor 00:21:20
dentro, lo que sea que guarde 00:21:22
es capaz de hacer cosas 00:21:24
como esta 00:21:26
quedarse esperando a un boolean 00:21:27
recogerlo y 00:21:30
mandarlo para afuera a la variable que uno le dé 00:21:32
¿vale? entonces scan 00:21:34
como es una variable 00:21:36
de un tipo construido objeto 00:21:37
aparte de tener su propio valor 00:21:40
es capaz de hacer cosas 00:21:42
y ese hacer cosas se hace 00:21:43
nombre de variable, punto 00:21:46
y la acción que uno quiera hacer 00:21:48
pues string igual 00:21:49
string, además de guardar dentro su valor 00:21:51
que son todos los caracteres en filita 00:21:54
es capaz también de llamar a cositas 00:21:55
para hacer cosas 00:21:58
y vamos a ver las básicas en un ejemplo 00:21:59
tienen muchísimas 00:22:02
claro, pero con una cadena 00:22:04
te puede interesar a ti hacer mil cosas 00:22:05
entonces, por ejemplo 00:22:07
a ver 00:22:09
lo vamos a hacer en un proyecto aparte 00:22:10
aunque solo sea una clase 00:22:15
para subir la ola virtual 00:22:16
ejemplo stream 00:22:19
venga, vamos a hacernos 00:22:26
una nueva clase 00:22:43
ejemplo stream 00:22:44
venga 00:22:49
mi ejemplo stream 00:22:55
vamos a declararnos primero una cadena 00:23:00
Para guardar un nombre 00:23:04
Pues string, declaradísima 00:23:06
Nombre ahora ya me vale solo 00:23:11
Para guardar nombres 00:23:13
Ala 00:23:16
Ya está, una asignación perfectamente válida 00:23:19
Vale 00:23:22
Y efectivamente puede ser 00:23:23
Que yo tenga aquí 00:23:25
Otro nombre 00:23:27
Dos 00:23:29
Y tal y como hemos dicho 00:23:32
A nombre dos 00:23:34
Le puedo asignar nombre 00:23:36
O lo que a mí me dé la gana, por ejemplo, le voy a asignar la concatenación de nombre más nombre. 00:23:38
Entonces, si lo muestro, pues ya sabemos lo que nos va a salir, obviamente. 00:23:46
El nombre de arriba dos veces seguido. 00:23:49
Bueno, como nos podíamos esperar. 00:24:02
Bueno, pues esto es lo básico. 00:24:04
Vale, entonces, ahora, esta variable, por ser de tipo objeto, 00:24:09
aparte de recibir valor 00:24:17
y entregarlo en las expresiones 00:24:18
que haga falta, aparte de recibir 00:24:21
valor y entregarlo, puede 00:24:23
ejecutar acciones 00:24:24
que es lo que nunca haría un número 00:24:26
un char no puede ejecutar acciones 00:24:28
este sí puede 00:24:31
por ejemplo, ¿qué acciones puede 00:24:32
ejecutar? pues gracias a que tenemos 00:24:35
un entorno de desarrollo, pues el entorno de desarrollo ya no 00:24:37
chiva 00:24:39
¿vale? entonces ejecutar una acción 00:24:39
para que una variable ejecute una acción 00:24:42
Esto en términos de sintaxis 00:24:44
Tiene que ser poniendo un punto 00:24:47
Y aquí tenemos las tropecientas 00:24:48
Mil acciones 00:24:51
Que me puede hacer eso 00:24:52
Ahora mismo nos van a interesar poquísimas 00:24:54
Por ejemplo 00:24:57
Esta 00:24:59
Esta acción 00:25:01
¿Qué hace? 00:25:04
Asigna un número 00:25:06
No, asigna no 00:25:07
Tú le pasas un entero 00:25:10
Y te devuelve el char 00:25:12
que está 00:25:14
dentro del string, en esa posición 00:25:16
¿vale? 00:25:18
empezando por la 0 00:25:21
en la 00:25:23
posición 00:25:26
asumiendo que la primera es la 0 00:25:30
¿vale? entonces 00:25:34
si mostramos esto 00:25:40
pues nos va 00:25:42
a mostrar efectivamente 00:25:45
la posición 00:25:47
3 es 00:25:49
esta 00:25:51
esta, es la 3 00:25:52
vale 00:25:54
entonces si ejecutamos esto, pues obviamente nos muestra 00:25:55
la posición 3 00:25:58
vale, entonces este método 00:25:59
es uno de los 3 básicos 00:26:04
que vamos a mencionar ahora simplemente 00:26:07
pero bueno, son básicos para cualquier cosa 00:26:09
entonces que uno quiere de una cadena 00:26:11
el carácter de una posición 00:26:13
que puede quererlo a veces 00:26:15
llama aquí 00:26:17
y le da la posición 00:26:18
cuidado porque si nos pasamos 00:26:20
imaginaos que yo le digo la posición 98 00:26:22
esa posición no existe 00:26:24
si nos pasamos 00:26:25
pa, excepción 00:26:28
ya sabemos que cuando un programa 00:26:30
cuando la máquina virtual no sabe 00:26:32
qué hacer y se encuentra en una situación rara 00:26:34
te lanza una excepción y se para 00:26:36
pues es lo que ha hecho 00:26:38
te ha lanzado una excepción de qué tipo 00:26:40
string in travel bounds 00:26:42
te has salido de las 00:26:44
fronteras del string 00:26:46
y si vamos bajando 00:26:47
vamos bajando hasta 00:26:50
vamos bajando hasta que lleguemos 00:26:51
al primer código nuestro 00:26:53
que en este caso sería este 00:26:55
pero todos estos no son nuestros, son de la máquina virtual 00:26:57
pinchamos y se va 00:26:59
a donde dio el error 00:27:01
¿vale? 00:27:02
a ver, porque yo decía 00:27:08
dame el carácter de esta cadena, nombre 00:27:09
la puse 98, si 98 00:27:11
me he salido, solo tiene 0 00:27:13
1, 2, 3, 4 00:27:15
como le dé de la 5 en adelante 00:27:17
la máquina virtual no sabe 00:27:20
qué hacer 00:27:22
y cuando la máquina virtual no sabe qué hacer 00:27:23
para el programa, pum, parado 00:27:25
y además te dice todo eso 00:27:28
entonces 00:27:29
está ya 00:27:32
lógicamente que nos vaya sonando 00:27:34
si nos sale 00:27:36
esta excepción es porque en algún sitio 00:27:38
hemos intentado acceder 00:27:40
a una posición 00:27:42
de variable que no está 00:27:43
¿vale? 00:27:45
vale 00:27:47
bueno este método está claro como funciona 00:27:52
que otros dos 00:27:55
métodos necesitamos a 00:27:59
cortísimo plazo 00:28:01
cuando digo método, digo método 00:28:02
porque es un nombre técnico 00:28:05
pero 00:28:07
entended que es la acción 00:28:09
que este objeto es capaz de realizar 00:28:10
este objeto nombre es capaz 00:28:13
de buscar en sí mismo el char de posición 00:28:15
3 y entregarlo para afuera 00:28:17
vale, que más acciones es capaz de 00:28:18
Realizar una variable objeto string. 00:28:21
Pues una muy interesante que es contarse y decir cuántos caracteres tiene. 00:28:24
Esta es una también muy interesante. 00:28:31
Sí, no quiero poner ñ porque en función de dónde trabaje uno, pues sí o no. 00:28:38
¿La Java Virtual Machine tiene ñ? 00:28:51
A ver, es que la Java Virtual Machine no entiende de caracteres. 00:28:57
Entiende solamente de punto class. 00:29:01
Te refieres al Java C. 00:29:02
Si el Java C admite 00:29:04
Si le pones el 00:29:06
Claro, el módulo correspondiente 00:29:08
O sea, Java C tiene que 00:29:10
Admitir eso dentro de sus caracteres 00:29:12
Pero hay que ponerle un módulo aparte 00:29:15
De todas formas, yo creo que ahora mismo 00:29:16
Tal y como lo tenemos nosotros, sí que admite 00:29:18
La ñ 00:29:20
Pero como recomendación habitual 00:29:21
Caracteres raros 00:29:24
Con tildes, con cosas raras, nunca 00:29:26
Alfanuméricos 00:29:28
Barras bajas 00:29:31
Y el dólar es que se usa bastante 00:29:32
como para variables de control 00:29:34
que empiezan por dólar 00:29:36
entonces el dólar se admite en todos los 00:29:37
voy a dejar la ñ a propósito a ver si 00:29:39
vale, y entonces ahora pongo 00:29:41
vale 00:29:44
entonces, ¿esto qué hace? 00:29:48
se va a guardar en un int 00:29:51
la longitud del dólar 00:29:52
claro, este método o esta acción 00:29:53
cuenta los caracteres 00:29:56
de esta cadena, los cuenta 00:29:59
y los guarda aquí 00:30:00
y los guarda aquí 00:30:02
y ahora lo muestro 00:30:04
No, los que tienes 00:30:05
Si tienes 7, 7 00:30:10
O sea, no te muestra la última 00:30:11
En Anita tendría 5 00:30:13
Los cuenta 00:30:16
1, 2, 3, 4, 5, 6 00:30:17
Eso, no cuenta 0, 1, 2, 3 00:30:18
No cuenta 1, 2, 3, 4 00:30:22
Vale, entonces si ejecutamos esto 00:30:24
Pues 5 00:30:26
Vale, entonces al compilador 00:30:29
Este javacea, la versión de jdk 00:30:30
O javacenuestro 00:30:32
La ñ no la han gusteado mucho 00:30:33
no, que no le ha angustiado 00:30:35
le ha gustado, pero 00:30:38
es muy mal hábito ese 00:30:40
así que 00:30:43
lo ponemos 00:30:45
me ha salido 5 00:30:47
que es el que tiene 00:30:56
me ha salido 00:30:57
hay un 5 00:31:00
Vale, y ya último 00:31:01
Último 00:31:14
¿Qué hacemos muy a menudo 00:31:19
Hasta ahora con nuestros números, nuestras cosas? 00:31:22
Pues mirad 00:31:25
Los igualábamos, ¿verdad? 00:31:26
Igualábamos, n es igual a m 00:31:28
Pues entonces no sé qué 00:31:30
O sea, el ser igual a 00:31:31
Lo hemos usado mucho entre números, ¿verdad? 00:31:32
Este número es igual a este otro 00:31:35
bueno, pues algo que también podemos 00:31:36
necesitar hacer es ver si una cadena es igual a otra 00:31:38
vale 00:31:41
pues ver si una cadena es igual a otra 00:31:42
para hacer una condición de igualdad 00:31:45
esta cadena es igual a esta otra 00:31:46
puede ser algo que queramos hacer 00:31:48
ver si una cadena es igual a otra 00:31:51
entonces uno podría 00:31:52
ir así tranquilamente 00:31:54
boolean 00:31:56
iguales, vamos a meter aquí 00:32:02
la condición de que nombre 00:32:05
sea igual a nombre 2 00:32:07
¿Vale? 00:32:08
Entonces la condición de que nombre sea igual a nombre 2 00:32:19
La pondríais así, ¿verdad? 00:32:22
¿Vale? 00:32:34
Entonces en este caso me va a dar false 00:32:38
Porque nombre 2 tiene Anitta Anitta 00:32:39
Y nombre tiene Anitta Paloseco 00:32:41
No son iguales 00:32:43
Entonces me va a dar false, ¿verdad? 00:32:44
Vale 00:32:47
Pero, cuidado 00:32:47
Cuidado 00:32:50
Y esto lo tenéis que grabar en la cabeza 00:32:55
no se comparan 00:32:57
la comparación de igualdad 00:32:59
si un objeto es igual que otro 00:33:01
sea string, sea el que sea 00:33:02
nunca jamás se haría con esto 00:33:04
nunca jamás se hace con eso 00:33:07
el doble igual vale solo 00:33:08
para ver si son iguales variables primitivas 00:33:10
solo para eso 00:33:14
si un int es igual a un int 00:33:15
si un char es igual a un char 00:33:16
solo para ver si dos variables primitivas son iguales 00:33:18
cuando las variables 00:33:21
son variables de tipo objeto 00:33:23
y el string lo es 00:33:24
nunca se las compara con doble igual 00:33:26
sino que se las compara 00:33:28
llamando a una acción 00:33:30
que es la que se encarga 00:33:32
de hacer la igualdad 00:33:34
así si se compara 00:33:35
que esta variable 00:33:38
objeto string 00:33:39
sea igual a esta otra variable 00:33:41
objeto string 00:33:43
te devuelve true si son iguales 00:33:44
o false si no 00:33:47
es que es completamente 00:33:48
porque es muy distinto 00:33:54
vamos a poner las dos expresiones 00:33:56
Vamos a poner las dos expresiones 00:33:57
Que vais a entender la diferencia 00:34:02
Porque no tiene nada que ver 00:34:04
Hacer esto con hacer esto 00:34:06
Y esta es la base 00:34:10
De la programación de entrada de objetos 00:34:11
En realidad 00:34:14
Y de no entenderlo muy bien 00:34:15
Más adelante, ya estamos con objetos 00:34:17
Pueden ser unos errores que no veas 00:34:19
Vosotros diríais 00:34:20
Que esto de arriba en realidad es esto de abajo 00:34:22
¿Por qué inventarse otra forma? 00:34:26
Porque esto de arriba no es esto de abajo 00:34:28
Son dos formas 00:34:30
es distinto, ¿y por qué es distinto? 00:34:31
vamos a ver, vamos a 00:34:34
poner el paint 00:34:36
¿por qué es distinto? 00:34:37
el paint, a ver, se ve, ¿no? 00:34:42
a ver 00:34:45
yo tengo aquí 00:34:46
una variable string nombre 00:34:49
vale, que es 00:34:50
esta, ahí 00:34:56
vale 00:35:01
¿qué tengo cuando tengo una variable objeto 00:35:02
string? ya lo hemos dicho lo que teníamos 00:35:05
que tenemos en realidad 00:35:07
una dirección de memoria, tenemos esto 00:35:08
y la verdadera variable 00:35:11
en este caso las cadenas de caracteres 00:35:13
están aquí, aquí está la nita 00:35:15
aquí está la nita 00:35:17
nombre, tira dirección de memoria 00:35:18
vale, ahora ponemos nombre2 00:35:20
vale, pues nombre2 00:35:22
estará aquí 00:35:25
ah, te va a medir 00:35:26
si la cantidad de memoria usada 00:35:29
es igual 00:35:31
no, no exactamente 00:35:31
ay que pena, bueno se ve ¿no? 00:35:34
Es que ya volver a situar ese 00:35:36
Ya va a ser muy complicado 00:35:42
Bueno, da igual, se ve que es nombre 2 00:35:43
¿No? Ese... Vale 00:35:50
¿Nombre 2 qué es? En realidad 00:35:52
Nombre 2 es la dirección de memoria 00:35:54
De otro sitio en la RAM 00:35:56
Donde está 00:35:58
La otra sucesión de cadenas 00:35:59
¿Vale? Está claro que esto es lo que 00:36:01
Tenemos físicamente cuando 00:36:04
Declaramos un string nombre y string 00:36:06
Nombre 2, cuando declaramos 00:36:08
String nombre tenemos 00:36:10
bajo nombre la dirección 00:36:11
de memoria que está apuntando 00:36:14
al contenido 00:36:16
y bajo nombre 2 tenemos la dirección 00:36:17
de memoria que está apuntando al contenido, la cadena 00:36:19
vale, pues cuando 00:36:22
hacemos 00:36:23
es para que se apunte a la misma 00:36:24
igual, igual, exacto, a ver 00:36:27
cuando hacemos nombre 00:36:29
igual a nombre 2 00:36:30
cuando hacemos 00:36:34
esta sentencia, esta condición 00:36:35
¿qué estamos haciendo con esta 00:36:37
condición, ver si esta 00:36:40
dirección es igual a esta 00:36:42
eso no nos importa nada 00:36:43
no nos importa nada, lo que queremos ver 00:36:45
es si la cadena de caracteres 00:36:48
que hay aquí es igual que la cadena de caracteres 00:36:50
que hay aquí, eso es lo que queremos ver 00:36:52
porque aquí puede haber Anitta 00:36:53
y aquí Anitta 00:36:56
pero si yo hago nombre doble igual 00:36:57
nombre dos, me va a decir 00:36:59
las direcciones de memoria 00:37:01
son distintas, porque es lo que compara 00:37:03
compara la propia variable 00:37:05
y la variable tiene la dirección 00:37:07
Entonces el doble igual 00:37:08
Te está comparando el contenido de la variable 00:37:11
Y el contenido es la dirección 00:37:13
No queremos comparar las direcciones 00:37:14
Queremos comparar que el contenido 00:37:17
Lo que apunta 00:37:20
Sea igual 00:37:21
A lo que apunta 00:37:23
¿Puede estar duplicado? 00:37:24
Sí, pero a nosotros no nos importa 00:37:27
Lo que nos importa es que sea el mismo texto 00:37:28
Entonces en ese caso 00:37:29
Nunca haríamos esto 00:37:32
Haríamos esto otro que os he dicho 00:37:33
vale 00:37:40
y esto 00:37:47
ahora ya sí, esto es un comportamiento 00:37:48
una acción a la que llama esta variable 00:37:52
y esta acción ya implica muchas cosas 00:37:54
esta acción implica 00:37:56
vete a la dirección a donde apunta 00:37:58
nombre, ahora 00:38:00
vete a la dirección a donde apunta nombre 2 00:38:02
cuando tengas esas dos cadenas 00:38:04
mira a ver si son iguales char por char 00:38:06
uno tras otro, pin, pin, pin 00:38:08
mira a ver si son iguales 00:38:10
Y si son iguales todos los char, devuelve true. Eso es todo lo que hace esto, que es un montón de cosas. Sin embargo, el doble igual no hacía nada de eso. El doble igual decía, oye, lo que hay bajo este nombre es igual que lo que hay bajo este nombre. 00:38:12
No, ya está. Pero esa acción no nos interesa para nada. Nos interesa esta otra. Ver si esta cadena de caracteres es igual, chara, chara, esta otra. Pues eso hay que construirlo mediante una acción. Y esa acción está construida con este nombrecito. 00:38:26
está construida con ese nombre 00:38:43
vale 00:38:45
vale, pues entonces 00:38:46
ahora mismo serían 00:38:53
estos tres 00:38:55
estas tres acciones 00:39:00
podemos irlas llamando métodos ya 00:39:02
para usar lenguaje técnico un poco más 00:39:04
estos tres métodos 00:39:06
el charat, el length y el equals 00:39:07
los que más nos importan de string 00:39:10
¿Vale? Los que más nos importan porque para ser operativos desde ya y poder hacer pequeñas cositas en nuestros programas, pues que menos que poder acceder a la posición, al carácter de una posición, saber la longitud para no pasarnos y ver si una cadena es igual a otra. 00:39:12
que hay más métodos 00:39:30
por supuesto, hay tropecientos mil 00:39:35
están todos ahí 00:39:37
y en el aula virtual 00:39:38
en el aula virtual 00:39:41
he puesto una 00:39:43
donde pone ejercicios para practicar 00:39:45
con métodos de stream 00:39:47
pues hay ahí unos pequeños ejercicios 00:39:48
que son simplemente 00:39:51
para 00:39:53
usar diferentes métodos que tiene 00:39:54
por si uno los quiere usar 00:39:57
pero ahora mismo no nos importa 00:39:58
ni os voy a examinar 00:40:00
el examen del 11 00:40:03
el examen sorpresa del viernes 11 00:40:04
no va a ser de esos métodos 00:40:08
de string para nada 00:40:09
estos tres básicos sí que pueden 00:40:10
estos tres básicos sí 00:40:13
porque es que esto es para cualquier cosa que hagamos 00:40:14
que involucre una cadera va a hacer falta 00:40:17
pero los demás ya son 00:40:18
pero los demás poco a poco 00:40:20
si no se va familiarizando a incorporarlos mejor 00:40:23
¿vale? 00:40:25
Vale, vale. Bueno, a ver, que estáis recogiendo muy rápido. 00:40:28
Bueno, venga, anda, nada, ya. 00:40:34
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
18
Fecha:
30 de septiembre de 2024 - 22:11
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
40′ 41″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
917.94 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid