Saltar navegación

240920 java básico 2 - 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 20 de septiembre de 2024 por Stefano C.

33 visualizaciones

Más información Transcripción

Descargar la transcripción

vale entonces hemos creado un workspace vale nuestro workspace era la carpeta donde vamos 00:00:00
a crear todo que estaba en algunos pero es digamos en la carpeta donde van todos los 00:00:10
proyectos ese es el workspace dentro del workspace hemos creado un nuevo proyecto 00:00:15
que se llama ejercicios básicos dentro del ejercicio básicos hemos creado un fichero 00:00:20
una clase hello world vale que va en el fichero hello world punto java lo hemos asociado al 00:00:27
package al paquete ejercicios porque ahora nos pide es precisamente de poner un ejercicio un 00:00:32
paquete vale estamos aquí en automático él me ha dicho ya que este clase pertenece a este para este 00:00:38
paquete vale al paquete ejercicios vale y me ha creado la base el public clase el word abierta 00:00:47
llaves a cerrada de llaves ¿vale? ahora aquí dentro yo puedo 00:00:56
desarrollar mi proyecto, mi ejercicio 00:01:00
entonces el primer ejercicio es hola mundo, si os acordáis 00:01:03
aquí tengo que poner public 00:01:08
static void main 00:01:12
string args 00:01:15
esto es la declaración 00:01:20
Que esto es el punto de acceso 00:01:32
A mi programa 00:01:34
Y mi programa tiene que empezar desde aquí 00:01:35
Desde aquí dentro 00:01:37
Y aquí le digo system.out.println 00:01:38
Y le digo 00:01:44
Hola mundo 00:01:48
Y ya está 00:01:52
Fijaos que este entorno de aquí 00:01:56
Es mejor que el 00:01:59
Notepad 00:02:01
El blog de notas 00:02:03
Me está ya poniendo en rojo 00:02:04
Las palabras 00:02:06
específicas del lenguaje me está poniendo en azul así lo que son las palabras vale ya veremos qué 00:02:08
son estas comillas de aquí cuando vemos los tipos me marca eso también en azul por alguna razón que 00:02:17
todavía no sabemos me marca en un color raro esta cosa aquí porque es el nombre de una variable me 00:02:23
da ayudas con colores. Si me equivoco me marca que hay un error. Veis que aparece un error 00:02:30
aquí al lado y aparece un error aquí. Si voy encima me dice error de sintaxis, inserta 00:02:38
un punto en coma para completar una sentencia. O sea que esto es como si fuera una precompilación 00:02:51
Que está haciendo constantemente el entorno de ejecución 00:03:01
Y algunos de los errores me los detecta él automáticamente 00:03:06
Si yo aquí dentro le escribo hola mundo 00:03:11
Se enfada 00:03:15
Porque me dice, oye mira, aquí encima a ver qué error es 00:03:18
Me dice hola mundo no puede ser resuelto como una variable 00:03:23
No es una variable 00:03:28
¿Vale? No has declarado una variable 00:03:30
De hecho, como nos lo ha escrito entre comillas 00:03:32
Él se espera que por algún lado tú hayas definido que es este hola mundo 00:03:34
Él se espera que este hola mundo sea una variable 00:03:40
No sabemos qué es una variable, lo veremos en breve 00:03:42
Pero tiene que ser algo que tú no has declarado 00:03:44
Tú en ningún momento has dicho que es hola mundo 00:03:48
Entonces él te dice, no lo puedo resolver, no puedo hacer nada con él 00:03:50
Entonces aquí te dice, ah, claro, es que faltan las comillas 00:03:54
Pongo así y él se enfada 00:03:57
Porque he abierto las comillas, he empezado a escribir un texto y no las he cerrado 00:03:59
Entonces para él todo esto es texto y falta un punto y coma 00:04:05
Me dice, el literal, lo que estabas escribiendo no ha sido cerrado propiamente 00:04:09
Properly closed, ¿vale? 00:04:17
Entonces, ah, no, que me falta aquí también 00:04:19
Y ahora ya no hay errores sintácticos 00:04:21
Si no hay errores sintácticos, fijaos que en la carpeta que vosotros habéis utilizado como workspace, se ha creado una carpeta que es vuestro proyecto. 00:04:25
dentro del proyecto se han creado varias carpetas 00:04:43
está la carpeta src con el módulo ejercicios 00:04:49
y esto es vuestro fichero, el fichero que estáis editando es este de aquí 00:04:54
pero también se ha creado bin con ejercicio con un class 00:04:57
él está haciendo constantemente un javac 00:05:04
Mientras yo edito esto 00:05:11
Cuando lo guardo, él me creará una nueva compilación de este programa 00:05:15
Cuando le doy a este botón de aquí, run Hello World.java 00:05:25
Lo que me hará por debajo será un Java Hello World 00:05:32
O sea, ejecutará este programa 00:05:36
Le doy al botón verde 00:05:39
Y veo que aquí abajo 00:05:41
Me aparece el resultado 00:05:43
Ahora es muy cómodo porque está todo en la misma página 00:05:45
Si yo quiero ver qué pasa 00:05:52
Si escribo lo mundo 00:05:54
Qué tal 00:05:55
Guardo, lo lanzo otra vez 00:05:56
Y aquí veo que ha pasado 00:06:03
Puedo modificar 00:06:05
Cuando me da la gana 00:06:10
Mi programa 00:06:11
Línea 2 00:06:14
Vale, he añadido otro system.auto.println 00:06:19
con escrito línea 2, veo que, veis que aquí está un asterisco, esto es que no está guardado 00:06:23
todavía, por lo tanto lo guardo, veis que desaparece el asterisco y ahora con el botón 00:06:31
este de aquí de play, lo puedo ejecutar y veo aquí abajo que hace mi programa y así 00:06:41
es como vais a trabajar vosotros con los ejercicios 00:06:51
vosotros hacéis los ejercicios 00:06:54
aquí, lo guardáis 00:06:56
y le dais al play a ver si funciona o no 00:06:58
si hay errores o cosas por el estilo 00:07:00
probablemente os lo dice 00:07:02
yo le digo guardar y luego le digo 00:07:03
play y me dice 00:07:06
oye, hay errores 00:07:08
¿quieres ejecutarlo igualmente? 00:07:10
te digo que aquí 00:07:14
existen errores 00:07:15
hay errores por algún lado 00:07:17
Pero si tú me dices 00:07:19
Como están en todo el workspace 00:07:20
Tú me dices que para ti está bien 00:07:22
Y quieres seguir adelante 00:07:25
Hasta si hay errores, pues sigue adelante 00:07:26
Y yo digo adelante, pues explota 00:07:28
Me dice hay un error 00:07:30
No se ha podido compilar 00:07:33
Y por lo tanto como no se ha podido compilar 00:07:35
Pues no lo puedo ejecutar 00:07:38
Vale 00:07:39
Entonces tengo que venir aquí, buscar cuál es el error 00:07:41
Y darle a la lema, falta el punto y coma 00:07:43
Venga 00:07:45
Que le quito el static 00:07:46
El error es que hicimos la otra vez 00:07:48
Guardo, lanzo 00:07:49
Todo va bien 00:07:52
Pero aquí me explota y me dice 00:07:54
No está el método main 00:07:56
De hecho me dice 00:07:59
Please define the main method 00:08:00
Por favor, define el método main 00:08:02
A ver si está aquí 00:08:05
No, esto no es el método main 00:08:06
Esto es un método que has hecho tú 00:08:07
Que se llama main 00:08:10
Pero no es el punto de acceso 00:08:10
Para ser el punto de acceso 00:08:13
Necesita aquí un static 00:08:14
Si yo le pongo aquí S minúscula 00:08:15
Me lo marca 00:08:22
Me dice esta cosa aquí no existe 00:08:23
Tú no has definido que es string con la S minúscula 00:08:25
Porque string con la S mayúscula lo reconozco 00:08:29
Sé que es 00:08:33
Pero S minúscula no 00:08:34
Si yo le pongo así 00:08:36
Lanzo 00:08:40
Se enfada 00:08:46
El método main es esto 00:08:48
Y lo que tú has puesto no es eso 00:08:51
¿Sí? Entonces, la idea es que vosotros, paso a paso, aprendáis a hacer las cosas bien, a utilizar el IDE, a pensar un algoritmo, plasmarlo con el lenguaje de programación dentro de este sistema, 00:08:56
Y él intentará en cada momento ayudaros 00:09:16
Pillándoos los errores de sintaxis 00:09:20
Intentando daros un mensaje de error cuando explota algo 00:09:23
A veces tenéis suerte y el mensaje es muy claro 00:09:26
Te falta un punto y coma 00:09:31
Y a veces el mensaje es un poquito más complejo 00:09:32
Tiene una parrafada de texto de no sé qué 00:09:36
Y con el tiempo ya aprenderéis a entender cuáles son los varios errores 00:09:39
¿Vale? 00:09:44
Eso la primera vez que sale un null pointer exception 00:09:45
Levantas la mano y dices 00:09:48
¿Qué es un null pointer exception? 00:09:49
Ah, pues te lo digo yo 00:09:51
¿Sí? 00:09:52
¿Lo das? 00:09:55
Sí 00:09:56
Si verás que tienes un error aquí en el word 00:09:56
En la parte izquierda 00:10:13
Borra este fichero 00:10:15
Si borras el fichero module te funciona 00:10:16
La alternativa es 00:10:20
En vez de hacerlo con el default package 00:10:22
Ponlo en un package 00:10:24
Entonces te funciona también 00:10:24
más dudas la java no necesita que tú lo ponga en mayúscula como la los nombres 00:10:26
de de los métodos en minúscula los nombres de braves minúscula es un son 00:10:47
convenciones son convenciones pensadas para que cuando luego tú veas el código 00:10:51
de otra persona si lo que está usando el nombre que está usando empieza por 00:10:57
mayúscula sabes que va a ser un objeto se empieza por minúscula sabe que se va 00:11:01
ser un método simple. Y cuando te dice utiliza el método main, tú sepas 00:11:04
cómo escribirlo. O usa el método get 00:11:09
new property. Y tú sabes que se escribe get en mayúscula new 00:11:12
property. Eso. Y cada, por un lado, 00:11:16
cada lenguaje de programación tiene sus propias 00:11:21
reglas, ¿vale? De cómo se nombran las cosas. Y 00:11:24
a veces también las propias 00:11:28
empresas os dan reglas 00:11:33
de cómo se nombran 00:11:35
por ejemplo las variables, los métodos y cosas así 00:11:37
a veces os fuerzan a poner 00:11:39
después de una variable, el tipo de la variable 00:11:41
si yo quiero hacer nombre, pues 00:11:43
lo llamo nombre string 00:11:45
para que en el propio nombre de la variable 00:11:46
sepa que tipo es 00:11:49
eso ya lo veremos 00:11:50
dudas hasta aquí 00:11:52
vale, entonces, ahora podéis jugar 00:11:53
con lo que tenéis, que es muy poco 00:11:57
es escribir en pantalla, podéis escribir 00:11:59
lo que os da la gana, vale 00:12:01
Cada vez que escribís un println 00:12:02
Este ln está por line 00:12:08
Entonces esto se escribirá en una línea 00:12:10
Cuando se acaba esta cosa de aquí 00:12:13
Vamos a una línea nueva 00:12:15
Entonces esto se escribirá en la primera línea 00:12:16
Y este de aquí en la segunda 00:12:19
Y hasta aquí es 00:12:21
Lo que sabemos 00:12:24
Repito que esta parte de aquí 00:12:26
Prácticamente te la 00:12:29
incluido esto, te la hace en automático 00:12:31
él, por ejemplo 00:12:34
si yo voy aquí a ejercicios 00:12:35
me creo un nuevo 00:12:38
clase 00:12:39
que llamaré Ejer2 00:12:43
fijaos que habiéndolo hecho 00:12:46
en el package, ya está 00:12:48
ya está seleccionado que es ese package 00:12:50
y luego le doy 00:12:52
a este botón de aquí 00:12:54
cuando le doy finish 00:12:55
pues me ha creado Ejer2.java 00:12:57
de la clase Ejer2.java 00:13:00
Me ha puesto ya el método main 00:13:02
Y me dice aquí 00:13:05
Para hacer 00:13:06
Generar el método 00:13:07
Stub 00:13:10
O sea, sustancialmente 00:13:11
Rellenar este método 00:13:12
¿Dudas? 00:13:15
Pues vosotros esto por ahora no 00:13:20
Por ahora vosotros lo escribís 00:13:22
5, 6, 7 veces 00:13:25
Cuando pensáis que lo tenéis ya en mente 00:13:27
Pues entonces haced lo que queráis 00:13:29
¿Vale? 00:13:30
¿Dudas? 00:13:37
Entonces, hemos ejecutado el load 00:13:37
¿Vale? Aquí os da más o menos 00:13:44
Un paso por paso 00:13:46
Lo que hemos hecho, cambiará un poquito 00:13:48
La imagen 00:13:50
Pero la idea es esa, crear 00:13:52
Una nueva clase, etc, etc 00:13:53
Veis que aquí nos deja 00:13:55
Crear el 00:13:58
El package, porque en las versiones anteriores 00:13:59
No dejaba, o sea, no era 00:14:02
Necesario 00:14:04
Pues aquí os dice los nombres de clases 00:14:05
Empiezan siempre por mayúsculas 00:14:08
No es necesario, pero 00:14:09
como se dice, consejable 00:14:15
vamos a hacer 00:14:18
un par de ejercicios 00:14:21
claro, entonces 00:14:22
hechos los ejercicios, os pongo 00:14:27
aquí un ejemplo por si 00:14:29
alguien en el vídeo lo quiere ver 00:14:31
vale, este es un ejercicio 00:14:33
de la ensalada de fruta 00:14:35
vale 00:14:36
aquí 00:14:37
seguimos adelante, vale, entonces 00:14:40
En Java habréis notado que existen unas palabras reservadas, o sea, Java para poder escribir sus cosas tiene algunas palabras que son suyas y que tú no puedes utilizar como te da la gana, porque tienen un significado especial, como por ejemplo public, como por ejemplo class, como por ejemplo static. 00:14:43
Las palabras reservadas son las que aparecen en rojo, o morado, o este color de aquí, pues en el editor. 00:15:04
Estas palabras de aquí son reservadas y no las puedo utilizar como me da la gana. 00:15:17
Cuando yo escribo public, Java lo va a interpretar como una palabra suya que tiene un significado concreto. 00:15:23
Si yo quiero utilizarla en otro contexto, no puedo. 00:15:31
Tengo que inventarme algo distinto 00:15:34
Lo llamo public 1 00:15:39
O lo llamo public con la P mayúscula 00:15:40
O lo que sea 00:15:43
Pero esta palabra de aquí es una palabra reservada 00:15:44
Para el lenguaje 00:15:47
No se puede utilizar en otros entornos 00:15:48
En otros contextos 00:15:50
¿Sí? 00:15:53
Vale, y las iréis descubriendo 00:15:54
O sea, con el ID es fácil 00:15:57
Si vosotros queréis usar una palabra 00:15:58
No sabéis si es reservada o no, la escribís 00:16:00
Si os sale en rojo, pues está reservada 00:16:02
Esta no la uso 00:16:03
Si sale con un colorín 00:16:04
Pues tiene un significado 00:16:10
Entonces cuidado con lo que haces 00:16:12
Y ahora ya veremos 00:16:13
De qué color nos pones las variables 00:16:16
Y cosas por el estilo 00:16:18
Entonces empezaremos a entender 00:16:19
Estas son 00:16:21
Las palabras reservadas 00:16:25
O algunas de las palabras reservadas 00:16:28
Que están dentro de Java 00:16:29
Entonces si intentáis usar estas 00:16:31
Pues os saldrán de un color rojo 00:16:33
Y no os permitirá utilizarla 00:16:35
Por ejemplo, para hacer el nombre de una variable 00:16:37
O el nombre de un método 00:16:39
O otras cosas, referencias 00:16:40
Que nos puedan servir 00:16:43
¿Las tenéis que saber de memoria todas? 00:16:44
No, tenéis que saber de memoria 00:16:47
Las que usáis 00:16:49
Synchronized, por ejemplo 00:16:50
Se utiliza para 00:16:52
Cosas avanzadas de programación 00:16:54
Paralela 00:16:57
Y hasta que no hagáis segundo de 00:16:58
DUM 00:17:01
Posiblemente no la vais a ver 00:17:01
¿Sí? 00:17:04
Comentarios 00:17:07
A veces, mientras yo hago un programa 00:17:08
Quiero dejar comentarios a este programa 00:17:10
O sea, decirle 00:17:14
Describir lo que estoy haciendo 00:17:16
Pero diciéndole al compilador 00:17:19
Oye, compilador, lo que voy a escribir aquí no es Java 00:17:21
Es lenguaje mío 00:17:25
Esto, sáltatelo 00:17:26
Esto de aquí no lo consideres 00:17:27
Porque si yo voy aquí y escribo, este es un programa para hacer una ensalada de fruta, pues él se enfada, dice, no entiendo nada, hay un montón de cosas que has metido aquí, que no sé, el compilador se está enfadando, ¿vale? 00:17:29
Porque esto no es Java 00:17:57
Pero si yo le digo, no, mira, compilador, ignóralo 00:17:58
Barra, barra 00:18:02
Entonces, él dice, ah, vale, muy bien 00:18:04
Cuando voy a compilar esta línea de aquí, me la salto 00:18:07
No la considero 00:18:11
Y entonces, ahora mi programa funciona perfectamente, sin errores 00:18:14
Porque esto se lo ha saltado 00:18:18
Y si es un comentario largo, de varias líneas 00:18:21
Puedo utilizar esto 00:18:25
Entre este símbolo y este símbolo 00:18:26
Todo lo que escribo es considerado un comentario 00:18:43
Entonces puedo, este es un sistema para hacer no sé qué, no sé cuánto 00:18:47
¿Para qué sirven los comentarios? 00:18:52
A vosotros os sirven para tomar apuntes directamente sobre el programa 00:18:54
¿Queréis saber qué hace el System.out? 00:19:01
Aquí os hacéis un comentario y dice 00:19:05
Println escribe en una línea 00:19:06
Escribís lo que os da la gana 00:19:11
Esto puede servir 00:19:16
En la vida real hay dos escuelas de pensamiento 00:19:17
Una que dice que el código debería ir bien comentado siempre 00:19:22
Yo hago un producto, hago un código 00:19:26
Y considero que si otro compañero de mi empresa viene y lee mi código 00:19:30
Tiene que entenderlo, entonces si yo le escribo allí, ¿qué hace? 00:19:35
Cuidado, no se comenta línea por línea 00:19:39
Porque yo lo sé que hace un System.Auto, sé que hace un IF 00:19:41
Pero a lo mejor un trozo de código, pues le escribo antes una descripción 00:19:44
Para hacer entender a quien va a leerlo, qué debería hacer 00:19:49
Este es un código para buscar alumnos dentro de la base de datos 00:19:52
Vale, fenomenal, y luego el código 00:19:56
Si hay trozos de código un poco raros, un poco más complejos 00:19:57
Pues ahí yo pongo otro comentario de aquí es donde hago el acceso a la base de datos 00:20:02
Esta es donde construyo la query 00:20:06
Ahora, la segunda escuela de pensamiento dice que el código no se debería nunca comentar 00:20:07
No deberían existir comentarios 00:20:16
Porque el código debería ser suficientemente limpio 00:20:19
Es suficientemente sencillo 00:20:22
es suficientemente bien hecho 00:20:24
para que quien lo lea no se pierda en él 00:20:26
¿cuál de las dos 00:20:28
escuelas es mejor? 00:20:32
ni idea, vosotros entráis en una empresa 00:20:34
y veis vuestro jefe que quiere 00:20:36
si quiere comentarios o no 00:20:38
técnicamente 00:20:40
los comentarios 00:20:44
las empresas 00:20:46
más 00:20:49
formal, más 00:20:50
conservadoras 00:20:52
quieren comentarios 00:20:54
Las empresas más modernas quieren código bien hecho, no comentar 00:20:56
Si tú llegas a tener que comentar algo, es que tu código es demasiado retorcido 00:21:02
Busca una forma de hacerlo más sencillo o pilla un trozo de este código, sácalo fuera en otro módulo, otro método y cosas por el estilo 00:21:08
Y que se te quede aquí bonito limpito y luego hay los módulos más pequeños 00:21:17
Lo hablaremos 00:21:21
¿Ahora mismo vosotros sabéis programar bien? 00:21:22
No, porque si sabéis programar bien no estaríais aquí 00:21:27
Estaríais ganando millones de euros 00:21:30
Entonces tenéis que esperar un rato para programar bien 00:21:32
Por lo tanto a vosotros os puede servir como mecanismo para tomar apuntes 00:21:35
Para apuntar lo que queréis hacer y luego no lo habéis sido capaz de hacer 00:21:39
O para dejar una parte de vuestro programa más adelante 00:21:44
Tú metes un comentario diciendo 00:21:48
Mira, aquí pongo que el valor que me han dado es siempre 5 00:21:50
Más adelante tendré que cambiar esto con un código que me pille el valor directamente desde el teclado 00:21:54
Lo dejas allí como comentario diciendo, mira, no lo he hecho ahora porque voy a hacer la parte importante de este programa 00:22:01
Después, cuando tengo tiempo, modifico esto y pongo el otro 00:22:09
Por ejemplo 00:22:12
Dudas 00:22:13
Entonces, ya sabéis cómo poner un comentario 00:22:15
Fijaos que como reconozco un comentario 00:22:19
Porque sale en verdito 00:22:21
Tened en cuenta también que 00:22:23
Estos códigos de colores son los colores por defecto 00:22:25
Vosotros trasteando por aquí 00:22:29
Podéis encontrar formas para cambiar todos los colores 00:22:31
Es que las palabras reservadas en vez de rojo sean amarillas 00:22:35
Y que el comentario en vez de verde sea azul 00:22:39
Lo podéis hacer 00:22:42
Os aconsejo que no lo hagáis 00:22:43
Al menos en los ordenadores de aquí 00:22:45
Porque cuando luego en el examen nos cambia de ordenador 00:22:47
De repente todos los colorines son distintos 00:22:50
Entonces intentad por favor 00:22:53
No hacer la vida imposible 00:22:55
A vuestros compañeros 00:22:57
¿Dudas? 00:22:59
¿Más cosillas? 00:23:03
¿Comentarios? 00:23:05
Aquí siempre los comentarios de una línea o de varias líneas 00:23:06
Mira 00:23:12
Estoy escribiendo un comando 00:23:15
Y cuando acaba el comando 00:23:20
no lo puedo meter dentro de un comando 00:23:21
¿vale? porque a partir del barra barra 00:23:23
todo es un comentario 00:23:25
esta toda esta línea 00:23:26
a partir de aquí todo el resto 00:23:29
de la línea, mientras este aquí es desde aquí 00:23:31
hasta aquí 00:23:33
aún así yo comentarios 00:23:34
incrustados no lo he visto nunca, en el medio 00:23:36
de un, o sea, una instrucción 00:23:39
y por encima comentas que hace ese trozo 00:23:41
de código 00:23:43
variables, vale, ok 00:23:43
ahora empezamos 00:23:49
la primera cosa importante de este curso 00:23:50
que son las variables, las variables es un concepto relativamente sencillo 00:23:55
que pero en algunos contextos, a algunos de vosotros 00:24:00
le puede resultar un poquito raro 00:24:03
y entonces tardará un rato en entenderlo, sobre todo porque 00:24:07
como utilizaremos al principio las variables, será un modo sencillo, cuando empezaremos 00:24:11
a combinarlas con otras cosas y a complicar un poco 00:24:15
Se complica. ¿Qué es una variable? La variable es una representación simbólica de un dato. Es una zona de memoria a la que le asigno tres cosas. Un nombre, un valor y un tipo. 00:24:19
Las variables son trocito de memoria RAM 00:24:38
Que yo digo al sistema, resérvamela 00:24:44
Porque yo aquí dentro voy a meter un tipo de datos 00:24:49
Por ejemplo, aquí voy a meter enteros 00:24:53
O aquí voy a meter letras 00:24:56
O aquí voy a meter palabras 00:24:58
O aquí voy a meter números pero con coma 00:25:00
Allí dentro pondré una de estas cosas 00:25:03
Si he dicho que pongo enteros, pues pondré un entero. 00:25:09
Siete, su valor. 00:25:12
Si he dicho que pongo una palabra, pondré hola. 00:25:14
Es su valor. 00:25:17
Si digo que pondré un booleano, que son valores de verdad, verdadero o falso, pues pondré o verdadero o falso. 00:25:18
Y a esta celda de memoria que tiene un tipo y tiene un valor, la llamo de alguna forma. 00:25:27
La llamo nombre. 00:25:35
Entonces tengo un trozo de memoria que dentro tiene palabras, dentro tiene el valor Estefano, y la llamo nombre. 00:25:36
Ahora, en mi programa, cuando uso la palabra nombre, me estoy refiriendo a ese trozo de memoria. 00:25:46
¿Se entiende? 00:25:55
Es un cajón la variable. 00:25:57
Yo tengo un cajón donde digo aquí dentro pongo solo números. 00:26:00
Vale, fenomenal. 00:26:04
Y este cajón lo llamo datos 00:26:06
Entonces, cuando luego quiero ver qué hay dentro datos 00:26:08
Pues abro el cajón con la pegatina datos 00:26:12
Y miro dentro y me encuentro 7 00:26:15
Vale, perfecto 00:26:17
Dentro del cajón datos que puede contener números 00:26:18
Tengo un 7 00:26:21
¿Sí? 00:26:22
Tipos, unos cuantos 00:26:29
Ahora, ahora lo veremos 00:26:31
Estos son los básicos 00:26:32
¿Vale? 00:26:36
Pero luego ya veremos más 00:26:38
Entonces, por ejemplo, si yo creo la caja edad, ¿vale? 00:26:39
Que contiene 18 y solo puede contener enteros, ¿vale? 00:26:49
La creo de esta forma 00:26:55
Esta de aquí, este comando de aquí me está diciendo 00:26:56
Crea una caja, crea una variable que se llama edad 00:27:00
El tipo de datos que puede entrar allí dentro son enteros 00:27:03
Int, integer en inglés 00:27:08
Y el valor que le ponga ahora dentro es 18 00:27:10
Se acaba la instrucción 00:27:17
A partir de esta línea, por debajo, si yo uso la palabra edad 00:27:19
Pues edad será una referencia a esta caja que tiene dentro un 18 00:27:28
Edad vale 18, hasta que no la modifique, edad vale 18 00:27:33
Pero es una variable, o sea que su valor puede cambiar 00:27:37
veremos como 00:27:41
puedes cambiar su valor 00:27:43
y poner 19 por ejemplo 00:27:46
pero no puedes poner salmón 00:27:48
porque salmón no es un entero 00:27:50
entonces si yo ahora a edad 00:27:52
le digo que vale 19 00:27:54
pues perfecto 00:27:56
es quitado el 18 que tenía antes 00:27:58
le he puesto un 19 dentro 00:28:01
y como es un entero 00:28:03
que lo he declarado aquí que es un entero 00:28:05
pues entonces 00:28:07
todo perfecto 00:28:09
Pero si ahora le digo una palabra, hola, salmón o verdadero, 00:28:10
como verdadero o salmón no son enteros, se va a enfadar. 00:28:16
Dice, no, no puedo guardarlo dentro del cajón, 00:28:21
porque me habías dicho que el tipo de esta variable eran enteros. 00:28:23
Entonces, solo puedes meter enteros aquí dentro. 00:28:28
Puedes cambiar el entero que hay, pero no puedes poner algo que no es un entero. 00:28:31
¿Dudas? 00:28:38
fijaos también en la diferencia entre int edad igual 18 y edad igual 19 00:28:38
en la primera estoy declarando una nueva variable 00:28:45
edad no existía y ahora ya he creado un cajón que se llama edad 00:28:49
que contiene enteros y le he puesto 18 00:28:55
la segunda vez cuando hago edad igual 19 00:28:57
este edad ya existe, ya lo he declarado antes 00:29:00
entonces no hace falta que te vuelva a decir icon enteros 00:29:04
Porque ya sabemos de qué estamos hablando 00:29:07
No puedo crear dos variables que tengan el mismo nombre 00:29:09
Si no tendría dos cajones con escrito edad 00:29:13
Y cuando te digo cuánto vale edad 00:29:16
No sabría cuál de los dos cajones tengo que mirar 00:29:18
¿Dudas? 00:29:20
No necesariamente 00:29:26
Aconsejable 00:29:27
Lo que se llama inicializar una variable 00:29:29
Yo puedo dejar una variable no inicializada 00:29:31
Pero explota a mí el sistema 00:29:33
Si intento ir a leer una variable que no ha sido inicializada 00:29:36
Por lo tanto, sí, se suele inicializar. 00:29:39
De hecho, en algunos casos, el sistema te la inicializa en automático a un valor por defecto. 00:29:42
Que, por ejemplo, para los enteros es cero. 00:29:48
¿Sí? 00:29:52
Vale. 00:29:57
¿Cómo se dan los nombres a las variables? 00:29:57
¿Vale? 00:30:00
Se componen de una serie o más de caracteres que son letras, mayúsculas y minúsculas, números, guión bajo o símbolo de dólar. 00:30:01
¿Vale? 00:30:11
Pero no se suele utilizar en Java. 00:30:11
Y a estos dos se suele utilizar para gozar en Java. 00:30:12
¿Vale? No puede comenzar por número. No puede hacer int, 1, edad y algo. Se enfada. Tiene que empezar por letra. Normalmente minúscula. 00:30:15
No pueden coincidir con ninguna palabra reservada. Aquí viene el problema de antes. No puede hacer int static es igual a 10. Se enfada porque static es una variable reservada. 00:30:30
Es case sensitive 00:30:40
Es decir, que no es lo mismo 00:30:44
Edad todo minúsculo 00:30:46
Que edad todo mayúsculo 00:30:47
Que edad con la E mayúscula 00:30:48
Y el resto minúsculo 00:30:51
¿Sí? 00:30:52
Concatenar los identificadores compuestos de varias palabras 00:30:55
Poniendo una letra, una mayúscula 00:30:57
Como fecha, D mayúscula D 00:30:59
N mayúscula nacimiento 00:31:01
En lugar de fecha de nacimiento 00:31:03
Que se puede hacer, pero en Java 00:31:05
Es más normal esto 00:31:07
que este de aquí. ¿Sí? En la primera letra de un identificador de variable, un método 00:31:10
es minúscula. Los identificadores de variables o métodos se ponen en minúscula. ¿Qué 00:31:15
es un literal? Un literal es un valor concreto. Un valor concreto de un determinado tipo. 00:31:24
O sea, tres, el entero tres, es un literal de tipo int. Gato, entre comillas, es un literal 00:31:30
De tipo palabra 00:31:42
El tipo palabra en Java es 00:31:44
String 00:31:47
Con la S mayúscula 00:31:48
Que ya habéis visto por alguna 00:31:51
La A 00:31:53
Fijaos, no entre comillas 00:31:57
Sino entre apóstrofes 00:31:59
Esto, sí 00:32:01
Es un literal de tipo carácter 00:32:01
¿Vale? 00:32:04
Una palabra es una secuencia de carácteres 00:32:06
¿Vale? 00:32:09
Entonces tengo dos tipos, que es un carácter solo 00:32:10
que es el tipo char 00:32:13
y una secuencia de carácteres 00:32:14
que es el tipo string 00:32:17
ahora tanto lo repasamos 00:32:18
por ejemplo 9,993 00:32:21
es un literal, es un valor concreto 00:32:24
de tipo decimal 00:32:26
con punto 00:32:27
true 00:32:28
es un literal de tipo booleano 00:32:31
y estos son los tipos 00:32:34
que tenemos 00:32:40
tenemos 00:32:41
booleano 00:32:42
Sus valores son verdadero o falso, se usan para lógica 00:32:44
Esto es donde se usan, son en los if, en los while 00:32:48
¿Os acordáis cuando hablamos de que había la posibilidad de hacer 00:32:53
Si algo es verdadero, hago una determinada acción 00:32:57
Y si no es verdadero, hago otra 00:33:02
Pues para eso, verdadero o falso, uso tipos booleanos 00:33:04
Lo veremos 00:33:08
Tipo carácter, ¿vale? 00:33:10
Un tipo carácter se llama tipo char 00:33:12
Char es un carácter solo, una letra, un símbolo, un punto 00:33:14
Y va entre apice, abóstrofe 00:33:19
Luego está byte, short e int, el long 00:33:24
Byte, short e int, el long, que son todos enteros 00:33:28
Lo que pasa es que son rangos distintos 00:33:32
Byte es un número que ocupa solo un byte de memoria, 8 bits 00:33:35
Entonces puede hacer, con 8 bits 00:33:40
Se pueden hacer 2 a la 8 distintos valores 00:33:44
Eso quiere decir que puede hacer 256 valores distintos 00:33:49
Y considerando que hay negativo y positivo 00:33:53
Es un numerito que va desde menos 128 a más 127 00:33:56
Este es un byte 00:34:01
Es un entero entre menos 128 y 127 00:34:02
El short es un entero pero que en memoria no ocupa un solo byte 00:34:08
Pero ocupa dos bytes 00:34:14
Y con dos bytes puedes hacer dos a la 16 distintos valores 00:34:15
Que son 65.000 más o menos 00:34:20
Que va desde menos 32.768 a más 32.767 00:34:26
Y el int, lo que hemos visto 00:34:35
Es un entero que ocupa 4 bytes 00:34:37
Dos a la cuatro 00:34:39
Dos a la cuatro son cuatro mil millones de valores 00:34:40
Más o menos 00:34:43
¿Sí? 00:34:44
No dos a la cuatro, dos a la treinta y dos 00:34:46
¿Vale? Porque son cuatro bytes 00:34:49
¿Sí? Cuatro por ocho 00:34:51
Y entonces 00:34:53
Tengo este rango de valor 00:34:55
Y luego está el long que ocupa ocho bytes 00:34:56
O sea, dos elevado a la ocho 00:34:59
Perdón, dos elevado a la 00:35:01
8 por 8, 64 00:35:03
y entonces me puede hacer 00:35:06
estos numerones grandes aquí 00:35:08
¿qué quiere decir esto? 00:35:10
que cuando yo utilizo los enteros 00:35:12
¿vale? normalmente 00:35:14
usaré los int, pero así 00:35:16
mi problema es la memoria 00:35:18
¿vale? a lo mejor en vez de 00:35:20
utilizar enteros, que cada entero que 00:35:22
utilizo me ocupará 4 bytes de 00:35:24
memoria, pues si son 00:35:26
números pequeños, por ejemplo estoy 00:35:28
calculando la edad de las 00:35:30
personas. ¿Habrá personas que tienen 2 millones de años? No. Entonces, llegar hasta el valor 00:35:32
2 millones a lo mejor no me interesa. Con que llegue a 127 es suficiente. Si yo calculo 00:35:40
la edad como byte en vez de como int, estoy ahorrando 3 bytes por cada variable de ese 00:35:48
tipo que utilizo. Entonces, gasto menos memoria. Imaginémonos que ahora en vez de estoy 00:35:54
misurando las distancias astronómicas que son gigantescas en metros. Pues a lo mejor 00:36:01
este número de aquí en metros es muy pequeño, no me llega. Entonces, en vez de utilizar 00:36:07
int, utilizaré algo que puede contener más, como por ejemplo el long. Ocupa más memoria, 00:36:13
pero me permite tamaños más grandes de enteros. ¿Dudas? Entonces, estos cuatro, byte, short, 00:36:22
Intel long, sustancialmente 00:36:31
Son números enteros 00:36:33
El byte se usa también para otras cosas 00:36:35
Pero por ahora lo dejamos aquí 00:36:37
¿Vale? 00:36:38
Y si en vez no quiero números enteros, sino quiero números con coma 00:36:40
Tengo float 00:36:43
Y double 00:36:44
Float es 00:36:45
Número con decimal que ocupa 4 bytes 00:36:48
Y double es lo mismo 00:36:50
Pero que ocupa 8 bytes 00:36:52
Entonces puede hacer números más grandes 00:36:54
Y más precisos 00:36:56
¿Sí? 00:36:58
Vale, pruebas 00:37:00
Vamos aquí 00:37:02
Y en un ejercicito 00:37:05
O sea, en un 00:37:09
Cualquiera de estos 00:37:11
Vamos a crear una variable 00:37:12
Creamos la variable 00:37:14
Nombre 00:37:16
¿Cómo se llama la variable nombre? 00:37:18
Nombre 00:37:21
¿Sí? ¿De qué tipo es? 00:37:22
String 00:37:28
¿Y qué le pongo dentro? 00:37:28
Stéfano 00:37:34
¡Vale! He creado una variable. Esta variable tiene tipo palabras, tiene dentro el literal Stefano y se llama nombre. Le he dicho al sistema, créame un trozo de memoria donde dentro pones los carácteres S, T, E, F, A, N, O y solo puede contener strings allí. 00:37:34
Creamos un número de teléfono 00:38:02
Int 00:38:07
Tel 00:38:16
Es igual a que 00:38:18
9, 1, 0, 0, 0, 0 00:38:20
Creamos una variable 00:38:24
Pública 00:38:38
Que representa 00:38:39
No lo sé 00:38:41
Cuantos empleados públicos hay 00:38:43
Vale 00:38:45
Son entero 00:38:46
Public, el nombre de mi variable 00:38:48
Es igual 00:38:51
a 100.000 empleados públicos. 00:38:52
¿Por qué me enfado? 00:38:56
Porque public no la puedo usar como nombre de variable. 00:39:00
Es una palabra reservada. 00:39:04
Lo puedo llamar público. 00:39:07
O empleados públicos. 00:39:10
Con la P mayúscula. 00:39:17
¿Dudas? 00:39:24
Int 00:39:25
Números 00:39:30
De estrellas 00:39:33
¿Cuántas estrellas hay? 00:39:35
Muchas 00:39:41
Me enfado 00:39:42
¿Por qué me enfado? 00:39:47
Porque este señor de aquí no es un entero 00:39:51
¿Por qué no es un entero? 00:39:54
Porque hemos dicho que los enteros 00:39:56
Llegan hasta este valor de aquí 00:39:58
2.000 millones 00:40:02
Aprox 00:40:04
Y yo le he metido un número más grande 00:40:05
Entonces, ¿cómo hago? 00:40:07
Pues le digo 00:40:10
Que esto es un long 00:40:12
Pero él sigue enfadándose 00:40:13
Diciendo, oye, mira, no 00:40:17
Porque tú me estás dando esto como entero 00:40:18
Y esto no es un entero 00:40:21
Ah, perdona, es un long 00:40:22
Se enfada, a mí me ha llegado grande igualmente 00:40:25
Quitamos los 1-0 00:40:34
Ahí, ya está, suficientemente 00:40:37
Esta L al final, esta es una L, me está diciendo que este número de aquí no lo quiero considerar como entero 00:40:39
Pero lo quiero considerar como un long 00:40:51
Y entonces luego lo puedo guardar en un long 00:40:54
Este número de aquí es más grande que este número de aquí 00:40:58
Y por lo tanto no es un long 00:41:09
¿Y qué hago entonces? 00:41:15
Doble 00:41:19
¿Por qué? Porque si os habéis fijado en la transparencia 00:41:20
Cuando voy a trabajar con Float Double 00:41:29
La representación que se hace 00:41:33
Es una representación matemática con e elevado a la 00:41:36
Y entonces el Double no solo me permite 00:41:40
Punto y que sean números muy precisos 00:41:45
Sino que me permite también números muy grandes 00:41:48
Ahora nosotros con estos números muy grandes no vamos a trabajar 00:41:51
Pero es una forma de empezar a trabajar con los tipos 00:41:57
Cada literal tiene un tipo 00:42:01
Nosotros tenemos que ser capaces de reconocer qué tipo es 00:42:03
Tres 00:42:07
A ver, ¿qué tipo tiene esto? 00:42:08
Int 00:42:18
Esto, string 00:42:18
Esto, char 00:42:23
Dependiendo de lo que estoy utilizando 00:42:28
Es una cosa y otra 00:42:35
¿Y qué puedo hacer con estas cosas? 00:42:37
Y probablemente acabamos 00:42:40
Por ejemplo, yo he escrito aquí mi nombre 00:42:42
Y ahora lo que puedo hacer es 00:42:45
System.out.println 00:42:47
Nombre 00:42:51
Comento esto que tanto no se utiliza 00:42:54
He creado nombre y he puesto nombre 00:43:00
Fijaos que antes, él se enfadaba 00:43:04
Decía, nombre no sé qué es, no me lo puedo poner así 00:43:08
Pero ahora, yo he creado, he definido qué es nombre 00:43:12
Entonces, cuando tú lo utilizas aquí, lo que estás diciendo es 00:43:18
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
33
Fecha:
20 de septiembre de 2024 - 12:44
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
43′ 23″
Relación de aspecto:
16:10 El estándar usado por los portátiles de 15,4" y algunos otros, es ancho como el 16:9.
Resolución:
1152x720 píxeles
Tamaño:
119.85 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid