Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 12-12-23 - 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 18 de diciembre de 2023 por Raquel G.

4 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues venga, estábamos programando esta clase, ¿vale? 00:00:00
Por ahora habíamos dicho que una vez decidida la clase, esto empezaba 00:00:05
con la palabra CLAS, todo en minúscula, y el nombre que nosotros decidíamos 00:00:11
como pauta que deberíamos seguir de estilo, empezando en letra mayúscula 00:00:16
y lo más explicativa posible. 00:00:21
Vale, bueno, pues ¿ahora qué hacemos dentro? 00:00:23
¿Ahora qué hacemos dentro? 00:00:25
Pues dentro esencialmente hay dos partes. 00:00:27
A ver, yo todo lo que os voy contando es... 00:00:29
Iba a decir es pseudo-mentira, no es que sea mentira. 00:00:36
Lo que pasa es que, claro, hay que incorporar, robo, tantísimas cosas 00:00:38
que hay muchas cosas que no os voy a decir. 00:00:43
Entonces vos veis a lo mejor una clase, veis el programa y decís 00:00:45
¡Uy, pero esta parte me falta! 00:00:47
Vale, es que no podemos meternos todo de golpe ni hablarlo todo, ¿vale? 00:00:49
Vamos progresivamente. 00:00:53
Bueno, pues esencialmente una clase tiene dentro dos partes. 00:00:55
Dos partes. 00:01:03
Una parte es la de las propiedades 00:01:06
y otra parte es la de los métodos. 00:01:14
Esas dos partes son las que tiene, la de las propiedades y la de los métodos. 00:01:20
Bueno, pues en la parte de las propiedades, ¿qué codificamos? 00:01:26
Ahí codificamos las propiedades que hemos decidido nosotros 00:01:30
que necesitamos para caracterizar el pedido. 00:01:36
Ahí ponemos lo que nos interesa que caracterice a los pedidos. 00:01:39
Las cosas que nos interesan, no. 00:01:43
Entonces si hemos decidido, después de hacer un buen diseño, 00:01:46
que el pedido sólo necesita para caracterizarse su código y su descripción, 00:01:49
pues esas son sus dos propiedades, código y descripción. 00:01:56
Y ahora toca declararlas aquí. 00:01:59
¿Cómo se declaran las propiedades de una clase? 00:02:02
¿Cómo se declaran las variables? 00:02:05
Exactamente igual, no hay ninguna diferencia. 00:02:07
Bueno, pues si yo he decidido que una propiedad del pedido es el código, 00:02:09
pues tengo que pensar, vale, ¿y el código qué tipo de dato es? 00:02:13
Pues tiene que ser uno de los tipos de datos de Java que conocemos. 00:02:17
Venga, el código va a ser un número entero, vale, 00:02:20
pues declaro esa propiedad como declaro cualquier variable entera. 00:02:23
Int, tipo de dato y el nombre de la propiedad. 00:02:27
Entonces esto es como declarar una variable, exactamente igual. 00:02:35
Exactamente igual. 00:02:38
La puedo inicializar también, aunque eso por ahora vamos a dejarlo, 00:02:40
porque ya veremos eso qué implica. 00:02:43
Sigue el mismo criterio de estilo que las propiedades que empiecen con minúscula, 00:02:48
porque en realidad eso es una declaración de variable, 00:02:54
pero es una declaración de variable hecha dentro de una clase. 00:02:57
¿Eso qué significa? 00:03:01
Que esta variable es una propiedad del pedido. 00:03:02
Eso significa, vale. 00:03:07
Bueno, pues ya tengo mi primera propiedad declarada. 00:03:10
Pues los pedidos se caracterizan por su código. 00:03:13
Pues ya está, pongo aquí su propiedad, vale, 00:03:16
y la declaro como cualquier otra variable. 00:03:19
A ver qué más propiedades hemos decidido que interesan para caracterizar un pedido. 00:03:21
Hemos dicho que la descripción. 00:03:25
Bueno, pues ahora pensamos, vale, la descripción, 00:03:27
¿qué tipo de dato le interesa? 00:03:29
Pues si es una cadena pedido de bolis. 00:03:31
Pues string, es el tipo de dato que le interesa. 00:03:33
Pues entonces lo declaramos como cualquier otra variable. 00:03:36
String, string y el nombre de la variable. 00:03:39
Vale, entonces nombres lo más explicativos posibles. 00:03:48
Cuando hay una clase con propiedades X e Y, 00:03:53
eso es horroroso. 00:03:56
¿X y qué propiedad es X? 00:03:57
¿Y qué propiedad es Y? 00:03:59
Sin embargo aquí uno ve código de descripción 00:04:00
y rápidamente ya entiende que va a contener esto. 00:04:03
Pues esto va a contener un código, el del pedido. 00:04:07
Esto va a contener una descripción, el del pedido. 00:04:09
Si yo la llamo X e Y, ¿qué va a contener X e Y? 00:04:11
Lo sabrá él que las ha declarado y las va a usar, 00:04:14
pero nadie más sabe qué va a contener X e Y. 00:04:16
Entonces vamos a elegir nombres explicativos 00:04:19
que empiecen con minúscula, no obligatorio, 00:04:22
pero es un criterio de estilo que deberíamos seguir, recomendable, 00:04:24
y tipo de dato de los que conocemos, de Java. 00:04:30
Bueno, pues nuestro pedido. 00:04:33
Si ya no tiene más propiedades, 00:04:34
porque no le hacen falta más, 00:04:36
ya hemos acabado con la parte de propiedades, 00:04:38
ya la hemos terminado. 00:04:39
Ya está, ya no hay más que poner nada más. 00:04:40
Cuidado. 00:04:43
Entonces ahora habría que hacer la parte de métodos. 00:04:44
Pero antes de meternos con la parte de métodos, 00:04:48
vamos a entender ahora cómo funciona una aplicación 00:04:50
que tiene pedidos. 00:04:53
Porque esta clase pedido, ¿ahora qué? 00:04:54
¿Y los pedidos dónde están? 00:04:55
¿Y el pedido qué código tiene? 00:04:57
¿Y cuántos pedidos tengo? 00:04:59
¿Y si mi aplicación tiene 20 pedidos? 00:05:00
¿Qué tengo, 20 clases? 00:05:03
O sea, ese tipo de cosas se han quedado como... 00:05:04
¿Y qué significa una clase pedido? 00:05:06
¿Y ahora esto cómo se usa? 00:05:08
¿Cómo se usa esto? 00:05:09
Bueno. 00:05:11
A ver, todo esto que estamos viendo ahora 00:05:14
es lo más importante de entender. 00:05:16
Porque una vez entendido el funcionamiento, 00:05:18
luego ya los detalles de cómo se codifica esto, 00:05:21
cómo se codifican los métodos, 00:05:24
son detalles de sintaxis. 00:05:25
Eso no es el problema. 00:05:27
El problema es entender la filosofía 00:05:28
de la relación entre dos objetos. 00:05:30
Bueno, pues hasta aquí estamos simplemente 00:05:32
en que hemos decidido que haya una clase pedido 00:05:34
porque mi aplicación va a trabajar con pedidos. 00:05:37
Va a trabajar con ellos. 00:05:40
Entonces tiene sentido que haya una clase pedido. 00:05:41
Tiene sentido. 00:05:43
Y una vez que lo he decidido, 00:05:45
codifico, declaro las propiedades que lo caracterizan. 00:05:47
Ahora ya vendría la pregunta natural de 00:05:51
¿y mi aplicación funcionando dónde está? 00:05:53
¿Dónde está mi aplicación que yo arranco, 00:05:55
le doy al play de la aplicación 00:05:57
y dónde está esa aplicación? 00:05:59
¿Y pedidos? 00:06:01
¿Cuántos puedo tener? 00:06:02
¿20, 30? 00:06:03
Porque ahí solo tengo una clase. 00:06:04
¿Puedo tener 20 pedidos? 00:06:06
Pues sí, eso es una aplicación que trabaja con pedidos 00:06:07
y debería poder tener 30, 40, 50. 00:06:09
Entonces, ¿qué? 00:06:11
¿Eso cómo encaja con que haya una sola clase? 00:06:12
¿Cómo lo ha...? 00:06:14
¿Cómo encaja? 00:06:15
Bueno, pues entonces, 00:06:16
vamos a seguir construyendo esta mini aplicación. 00:06:18
Vale, pues efectivamente 00:06:22
tiene que haber una aplicación que arranque en algún lado. 00:06:24
Tiene que haber una aplicación que arranque. 00:06:27
Que yo le dé al play y la aplicación arranque. 00:06:28
Para que empiece yo a poder trabajar con pedidos y con cosas. 00:06:30
Tiene que haber una aplicación que arranque. 00:06:33
Efectivamente. 00:06:35
Bueno, pues en mi aplicación, 00:06:36
aparte de mis clases entidad, 00:06:38
mi clase pedido, mi clase cliente. 00:06:40
Tiene que haber una clase. 00:06:42
Tiene que haber otra más. 00:06:44
Tiene que haber otra. 00:06:46
Que tenga el famoso método ese 00:06:48
que ya nos hemos tudo de memoria. 00:06:51
Public, static, void, main, bla, bla, bla. 00:06:53
Este método que hemos escrito tantísimas veces. 00:07:03
Bueno. 00:07:17
Vale. 00:07:24
Vale, pues otra clase más de mi aplicación. 00:07:26
Otra más. 00:07:29
Tiene que ser una clase que no es ni entidad ni es nada. 00:07:30
No es ni pedido, ni es cliente, ni es nada. 00:07:33
No es entidad ni es nada. 00:07:35
Es una clase 00:07:36
que tiene 00:07:38
este método, esta función, 00:07:40
como la queremos llamar. 00:07:42
La veremos aquí dentro, que la hemos usado siempre. 00:07:43
Que es el punto de arranque de la aplicación. 00:07:45
Aquí es donde la aplicación arranca. 00:07:48
Ahí arranca. 00:07:51
Entonces, esto es una clase sin más. 00:07:56
De hecho, empieza con class. 00:07:58
La hemos hecho hasta ahora. 00:08:00
Empieza con class y le hemos dado un nombre. 00:08:01
El nombre que nos dé la gana. 00:08:03
Bueno, como esta clase, 00:08:04
que es una clase más, 00:08:06
es la clase que es el punto de arranque 00:08:07
de la aplicación, de la aplicación arranca, 00:08:09
pues normalmente 00:08:11
uno la suele ver identificada 00:08:13
pues con el nombre de main en mayúscula 00:08:14
o principal, 00:08:16
o como uno la quiera llamar. 00:08:18
Es la clase, es el punto de arranque. 00:08:20
Porque la aplicación, 00:08:22
cuando se está ejecutando, 00:08:24
es una sentencia tras otra, eso sí o sí. 00:08:26
Que las sentencias estén en clases diferentes. 00:08:28
Da igual, pero es esta 00:08:30
y de aquí saltará aquí, de aquí saltará aquí. 00:08:32
Bueno, pues el punto de arranque, 00:08:34
donde la aplicación arranca, ¿cuál va a ser? 00:08:36
Aquí. 00:08:37
Tendré yo mi clase principal 00:08:39
con esto dentro 00:08:41
y aquí arranca mi aplicación. 00:08:43
Entonces, cuando mi aplicación 00:08:45
con todas las clases, las que sean 00:08:46
uno o mil, en este caso dos, 00:08:48
esta y esta, en este caso dos, 00:08:50
cuando mi aplicación arranque, 00:08:52
donde va a arrancar es aquí. 00:08:54
En la primera sentencia del main. 00:08:56
Ahí es donde va a arrancar. 00:08:58
Y ahí empiezan a pasar cosas. 00:09:00
Bueno, y ahí que empieza a pasar 00:09:02
lo que a mí me dé la gana. 00:09:04
Empieza a pasar lo que a mí me dé la gana. 00:09:06
Vale, pues ¿qué es lo primero que vamos a hacer? 00:09:08
En esta aplicación. 00:09:10
Pues crear un pedido. 00:09:12
No es una aplicación que trabaja con pedidos, 00:09:14
vamos a crear uno. 00:09:16
Voy a escribir esto aquí un poquito mejor 00:09:18
para traer espacio. 00:09:20
¿Qué? 00:09:26
¿En qué método? 00:09:28
No, no, no. 00:09:30
Hemos dicho que esto por ahora 00:09:32
lo dejamos vacío, ¿vale? 00:09:34
Puede estar vacío, no es obligatorio que tenga algo. 00:09:36
Esta clase tal y como está, si la escribís, 00:09:38
es una clase perfectamente válida. 00:09:40
Lo que importa es que las dos partes estén rellenas. 00:09:42
Vamos a hacer la principal, 00:09:44
esta de aquí. 00:09:46
Vale, y esta clase principal es la que tiene 00:10:02
ese main ahí. 00:10:04
Como es muy largo, bueno, 00:10:08
lo pongo así. 00:10:12
Vale. 00:10:16
Vale, entonces tengo dos clases, 00:10:22
esta y esta. 00:10:24
Arranco la aplicación, 00:10:26
la máquina virtual automáticamente 00:10:28
se va a buscar este main, 00:10:30
se va a buscar esto, 00:10:32
navega por todas las clases, 00:10:34
ya veremos también cómo, tenemos millones de cosas que ver. 00:10:36
La máquina virtual, cuando yo le digo 00:10:38
arranca la aplicación que tiene todas las clases, 00:10:40
todas, arráncala, el navega, blablabla, 00:10:42
hasta que encuentre esto. 00:10:44
Como no encuentre esto, te dice, 00:10:46
no puedo arrancar la aplicación. 00:10:48
Y como haya dos clases 00:10:50
que las dos tengan eso, 00:10:52
tampoco puede porque se hace un lío. 00:10:54
Con lo cual tiene que haber una única clase 00:10:56
que tenga esto. 00:10:58
Pues entonces, arrancamos esta aplicación 00:11:00
con dos clases. 00:11:02
La máquina virtual, blablabla, se va buscando, 00:11:04
ah, vale, ya lo encontré, 00:11:06
ya tengo donde arrancar, aquí arranco. 00:11:08
Bueno, ¿qué es lo primero que vamos a decirle que haga? 00:11:10
Pues que cree un objeto pedido. 00:11:12
Y aquí ya he mencionado 00:11:14
la palabra clave, objeto. 00:11:16
Yo hasta ahora no la he mencionado. 00:11:18
Es, programación de entradas de objetos, 00:11:20
es como se llama, y por ahora no he mencionado 00:11:22
la palabra objeto. He mencionado la palabra clase, 00:11:24
que es esto. 00:11:26
Entonces, clase, ¿qué es? 00:11:28
Clase tiene que verlo como una plantilla vacía. 00:11:30
Una clase indica 00:11:32
cuando haya pedidos, 00:11:34
cuando haya, que todavía no los hay en ningún lado, 00:11:36
cuando haya, 00:11:38
esos pedidos se caracterizarán 00:11:40
por un código y una descripción. 00:11:42
Eso es lo que significa clase. 00:11:44
Una plantilla 00:11:46
de lo que puede haber 00:11:48
en el futuro, y si lo hay, 00:11:50
qué propiedades va a tener. 00:11:52
Pero todavía no hay ningún objeto pedido 00:11:54
concreto. ¿Vale? 00:11:56
Es como 00:11:58
persona sería 00:12:00
la clase. 00:12:02
Y ahora ya, de esa clase, 00:12:04
hay casos concretos, ¿no? 00:12:06
Pues ya es, Adrián, que es un caso 00:12:08
concreto de persona, 00:12:10
Miguel, que es otro caso concreto de persona, 00:12:12
Alejandro es otro caso concreto de persona. 00:12:14
Pues aquí igual. 00:12:16
Del concepto pedido, 00:12:18
que está aquí declarado en plan plantilla, 00:12:20
es decir, bueno, cuando haya 00:12:22
pedidos, tendrán código y 00:12:24
descripción. Pues de la clase pedido, 00:12:26
que es la descripción del concepto, 00:12:28
ahora ya habrá pedidos concretos. 00:12:30
Pedido de bolis, pedido 00:12:32
de gomas, pedido de sacapuntas, 00:12:34
puede haber uno o mil 00:12:36
pedidos de estos. 00:12:38
Pues cada uno de los casos concretos 00:12:40
de una clase es el objeto. 00:12:42
¿Vale? 00:12:44
Bueno, pues la clase entonces es 00:12:46
la plantilla que se 00:12:48
escribe y se declara una única 00:12:50
vez, y que te dice 00:12:52
cuando haya de esto 00:12:54
tendrá estas propiedades, pero 00:12:56
todavía no hay nada, esta es la plantilla, 00:12:58
y el objeto es cada uno 00:13:00
de los casos ya concretos que 00:13:02
existen de pedido. 00:13:04
¿Vale? 00:13:06
En el otro ejemplo, 00:13:08
la persona como tal no existe, 00:13:10
la persona es un concepto, 00:13:12
es un concepto platónico, la persona, 00:13:14
quien existe es Adrián, Miguel, 00:13:16
Alejandro, la persona no, la persona 00:13:18
es una definición, pero no 00:13:20
existe, es una definición. 00:13:22
Luego ya existen casos concretos, objetos 00:13:24
concretos. Pues esto igual, 00:13:26
esto es una definición, 00:13:28
es un concepto, y ahora 00:13:30
ya existen 00:13:32
todos los casos 00:13:34
concretos de pedido que la aplicación quiera, 00:13:36
si quiere 20, 20, si quiere 36, 37, 00:13:38
todos los que quiera, y cada uno 00:13:40
de esos casos concretos es un 00:13:42
objeto. ¿Vale? 00:13:44
Luego tenéis que tener muy clara 00:13:46
la diferencia entre 00:13:48
clase y objeto. 00:13:50
¿Vale? 00:13:52
Primera cosa con la que tenéis que ir muy clara hoy en la 00:13:54
cabeza, clase y objeto. 00:13:56
La clase es la plantilla. ¿Vale? 00:13:58
Pues ahora ya cuando la aplicación arranca, 00:14:00
ahora ya la aplicación 00:14:02
lo que ya hace es crear objetos concretos. 00:14:04
Ahora ya sí, 00:14:06
cuando la aplicación entra en ejecución, 00:14:08
ahora ya aparecen 00:14:10
los pedidos concretos, aparecen 00:14:12
los objetos, en el momento en que eso arranca. 00:14:14
Cuando todavía no ha arrancado, 00:14:16
esto está escrito en los ficheritos guardados, 00:14:18
aquí no hay ningún objeto ni nada. 00:14:20
El objeto aparece 00:14:22
cuando la aplicación ya arranca, cada pedido 00:14:24
concreto. Bueno, pues vamos 00:14:26
a hacer, vamos a crear un objeto. 00:14:28
Aquí. 00:14:30
Uno concreto. 00:14:34
¿Vale? 00:14:40
Pues el objeto 00:14:42
ya es un caso concreto 00:14:44
de esta plantilla, es un caso 00:14:46
concreto, de los mil que puede 00:14:48
haber, uno concreto. 00:14:50
Bueno, pues lo primero que tengo que decidir es darle un nombre. 00:14:52
Darle un nombre. 00:14:54
¿Vale? Igual que él se llama Adrián, y él se llama 00:14:56
Miguel, siendo personas, 00:14:58
pues el pedido tiene que tener su propio nombre 00:15:00
para distinguirlo del resto de los objetos 00:15:02
pedido. Pedido 00:15:04
bolis. Pues venga, pedido bolis, 00:15:06
que es muy bonito el nombre. Pues ya está, 00:15:08
le doy su nombre. 00:15:10
Pedido bolis. 00:15:12
Ahora, 00:15:14
tengo que indicar que este objeto 00:15:16
pertenece a esta clase, 00:15:18
que es un objeto pedido 00:15:20
y no un objeto cliente, un objeto mesa. 00:15:22
Pues lo pongo 00:15:24
poniéndolo delante como si ese fuera su tipo 00:15:26
de dato. Y es que lo es. 00:15:28
¿Veis? Pedido 00:15:30
y el nombre que a mí me dé la gana. 00:15:32
Entonces, es 00:15:34
exactamente igual que cuando declaro una variable. 00:15:36
Cuando declaramos una variable entera 00:15:38
poníamos int 00:15:40
y el numerito. 00:15:42
Perdón, y el nombre. 00:15:44
Este es el nombre que yo decidía, 00:15:46
N, el que yo decidía, 00:15:48
N, y aquí ponía el 00:15:50
tipo de dato que iba a contener. 00:15:52
Pues, con el objeto 00:15:54
igual, yo decido el nombre 00:15:56
de mi objeto, el que 00:15:58
me dé la gana el nombre, un nombre 00:16:00
concreto, Miguel, Adrián, 00:16:02
un nombre concreto, y digo 00:16:04
de qué tipo es ese objeto. 00:16:06
Pues este objeto es de tipo pedido. 00:16:08
Igual que aquí el numerito 00:16:10
N es de tipo entero. 00:16:12
Pues este objeto es de tipo pedido. 00:16:14
¿Vale? 00:16:16
Bueno, he hecho parte 00:16:18
para crear un objeto, pero no he hecho todo. 00:16:20
¿Qué he hecho con eso? 00:16:22
He hecho 00:16:24
simplemente esto. 00:16:26
Pues 00:16:28
cuando la máquina virtual se encuentre esta 00:16:30
ya automáticamente me crea 00:16:32
ahí una variable 00:16:34
a la que le da ese nombre 00:16:36
igual que cuando se encuentra esto me crea una variable 00:16:38
¿verdad? a la que llama N. 00:16:40
Igual que cuando se encuentra esto se crea N, 00:16:42
un espacio para el numerito entero. 00:16:44
Pues aquí igual, se crea en memoria principal 00:16:46
una variable que se llama 00:16:48
pedidoBolis 00:16:50
¿y qué va a contener esa variable? 00:16:52
Pues esta variable al ser de tipo 00:16:54
objeto, al ser de tipo 00:16:56
objeto, porque su tipo de dato es una 00:16:58
clase, no un primitivo 00:17:00
es una clase, al ser de tipo objeto 00:17:02
lo que contiene esa variable 00:17:04
es una dirección de memoria 00:17:06
igual que los Arrays. 00:17:08
Cuando declaramos un Array, en realidad 00:17:10
el Array contiene la dirección de memoria. 00:17:12
Pues cuando uno declara una variable 00:17:14
que es de tipo objeto 00:17:16
porque su tipo es el de una clase 00:17:18
lo que en realidad está 00:17:20
haciendo aparecer en memoria 00:17:22
es un espacio con ese nombre 00:17:24
que contiene 00:17:26
una dirección de memoria 00:17:28
y en esa dirección 00:17:30
esa dirección ya apunta 00:17:32
al espacio para contener los datos 00:17:34
del objeto concreto. 00:17:36
Este objeto 00:17:38
tiene que tener dentro 00:17:40
su código y descripción 00:17:42
porque los objetos tienen su código y descripción 00:17:44
entonces esta dirección de memoria 00:17:46
tiene que apuntar a un sitio 00:17:48
para que quepan 00:17:50
dentro el código y la descripción 00:17:52
igual que cuando uno declara un Array 00:17:54
sabe que automáticamente 00:17:56
aparece una variable en memoria 00:17:58
con la dirección 00:18:00
y esa dirección me lleva al espacio 00:18:02
para contener todas las posiciones 00:18:04
pues aquí hemos hecho esto 00:18:06
pero con esa línea sin más 00:18:08
esta dirección de memoria 00:18:10
está a medias 00:18:12
se queda apuntando 00:18:14
a lo que llamamos null 00:18:16
en Java 00:18:18
que null es espacio inhábil 00:18:20
la nada de memoria RAM 00:18:22
espacio inhabilitado 00:18:24
solo con esta línea 00:18:26
yo tengo la dirección de memoria 00:18:28
se me ha pedido Boris 00:18:30
pero ahora mismo apunta a un espacio inhabilitado 00:18:32
vale 00:18:34
pues siguiente paso 00:18:36
tendremos que crear 00:18:38
vamos a crear el espacio 00:18:40
para ya los datos de este objeto 00:18:42
en este caso serían dos 00:18:44
para código 00:18:46
y descripción 00:18:48
vale 00:18:50
para código y descripción 00:18:52
vamos a crear esto 00:18:54
bueno pues como creamos el espacio 00:18:56
pues muy parecido a lo que hacíamos con Arrays 00:18:58
ya en la misma línea en la que lo declaramos 00:19:00
vamos a 00:19:02
new 00:19:04
nombre de la clase 00:19:06
y por ahora 00:19:08
porque no hemos visto nada más 00:19:10
por ahora 00:19:12
paréntesis vacíos 00:19:14
paréntesis vacíos 00:19:16
ahora ya sí 00:19:18
ahora 00:19:20
hemos declarado la variable que se llama 00:19:22
pedido Boris 00:19:24
y hemos hecho aparecer 00:19:26
con el new 00:19:28
un espacio en memoria 00:19:30
capaz 00:19:32
de contener 00:19:34
todas las propiedades de pedido 00:19:36
código 00:19:38
y descripción 00:19:40
ahora 00:19:42
ya sí tenemos todo esto 00:19:44
y esto ya sí es un objeto 00:19:46
o sea un objeto es ya 00:19:48
un espacio en memoria principal 00:19:50
para contener unos datos concretos 00:19:52
los datos de un pedido concreto 00:19:54
esto ya es un objeto 00:19:56
un objeto concreto 00:19:58
ahora mismo 00:20:00
este objeto que características 00:20:02
tiene en código y descripción 00:20:04
no tiene nada 00:20:06
bueno 00:20:08
vamos a darle valores a este pedido en concreto 00:20:10
bueno pues como 00:20:12
accedemos 00:20:14
a las partes del objeto 00:20:16
como accedemos a este espacio código 00:20:18
pues accedemos con este 00:20:20
operador 00:20:22
voy a acceder al código para darle 00:20:24
7 por ejemplo 00:20:26
pues pongo 00:20:28
pedido Boris 00:20:32
punto 00:20:34
y nombre de la propiedad 00:20:36
tal y como aparece en la clase 00:20:38
en la plantilla 00:20:40
pedido Boris 00:20:42
punto código 00:20:44
igual a 7 00:20:48
bueno pues 00:20:50
automáticamente la máquina virtual 00:20:52
va al pedido Boris 00:20:54
aquí a donde me llevas de pedido Boris 00:20:56
te llevo a código 00:20:58
porque es punto código 00:21:00
te llevo a código 00:21:02
vale ya estoy aquí 00:21:04
que haces asignarle el 7 00:21:06
pues ala ahí se crea el 7 00:21:08
esto es como una asignación cualquiera 00:21:10
una variable 00:21:12
lo que pasa es que a la variable 00:21:14
a la que estamos accediendo 00:21:16
es la propiedad código 00:21:18
del objeto pedido Boris 00:21:20
¿cuál es la posición a este objeto? 00:21:22
pues pedido Boris 00:21:26
que es el nombre del objeto 00:21:28
así lo tengo que llamar, pedido Boris 00:21:30
punto propiedad a la que quiero acceder 00:21:32
esta es un string 00:21:38
le tengo que asignar un tipo 00:21:40
compatible, claro 00:21:42
o yo que se, ala, Boris 00:21:44
vale 00:21:48
bueno pues automáticamente 00:21:50
aparecerá aquí 00:21:52
ala pues ya tengo un objeto 00:21:56
un objeto creado en memoria 00:21:58
este es el objeto, lo que existe en memoria 00:22:00
que tiene un nombre 00:22:02
el que a mi me ha dado la gana 00:22:04
y tiene un contenido 00:22:06
un contenido concreto 00:22:08
tiene un contenido concreto 00:22:10
y este objeto 00:22:12
sigue esa plantilla 00:22:14
que yo he tenido que programar aparte una clase 00:22:16
vale 00:22:18
que quiero hacer más objetos 00:22:20
hago todos los que me den la gana 00:22:22
que quiero ahora un pedido 00:22:24
de gomas 00:22:26
pues igual 00:22:28
pedido gomas 00:22:30
igual a new 00:22:34
pedido 00:22:36
ala ya tengo otro objeto 00:22:40
en memoria principal me aparecerá otro 00:22:42
vale 00:22:48
que apunta un espacio 00:22:58
código descripción 00:23:04
vale 00:23:10
ya tengo los objetos 00:23:12
son dos objetos diferentes 00:23:14
ambos de tipo pedido 00:23:16
y mi aplicación puede tener 00:23:18
mil, dos mil 00:23:20
los que necesite, todos los pedidos que quiera 00:23:22
y todos ellos 00:23:24
siguen esa plantilla en cuanto a que tienen 00:23:26
todos ellos dos propiedades 00:23:28
y yo con esas propiedades las relleno 00:23:30
hago lo que haga falta como si fueran variables 00:23:32
la única diferencia es que la forma 00:23:34
de acceder a ellas es de esta manera 00:23:36
nombre del objeto 00:23:38
punto nombre de la descripción 00:23:40
que quiero acceder aquí 00:23:42
pedido gomas punto código 00:23:44
igual a lo que sea 00:23:46
que quiero acceder aquí 00:23:48
pedido gomas punto descripción 00:23:50
bueno las grabaciones de hoy no van a empanar 00:23:56
porque aquí tampoco había puesto la cámara 00:23:58
en fin 00:24:00
se ha grabado pero 00:24:04
vale pues 00:24:08
este es un funcionamiento 00:24:10
muy muy muy resumido y sin detalles 00:24:12
de una aplicación de todos los objetos 00:24:14
lo que hace es esto 00:24:16
uno decide las clases que necesita 00:24:18
porque son las que representan 00:24:20
los conceptos 00:24:22
clase persona, clase jefe, clase empleado 00:24:24
clase, representan los conceptos 00:24:26
esas son plantillas 00:24:28
en las que pone las propiedades que lo va a caracterizar 00:24:30
y en esa plantilla 00:24:32
el jefe le va a caracterizar 00:24:34
pues el sueldo, el nombre, el DNI 00:24:36
el empleado 00:24:38
lo va a caracterizar 00:24:40
pues el código, la fecha de incorporación 00:24:42
de cada clase 00:24:44
uno decide lo que lo va a caracterizar 00:24:46
y luego ya habrá una aplicación 00:24:48
perdón, habrá una clase 00:24:50
con este main 00:24:52
que es el punto de arranque 00:24:54
y a partir de ahí ya la aplicación ya creando objetos 00:24:56
lo que haga falta 00:24:58
lo que se pida, lo que haga falta 00:25:00
entonces los objetos 00:25:02
ya aparecen en tiempo 00:25:04
de ejecución 00:25:06
cuando la aplicación está ejecutando 00:25:08
ya van apareciendo 00:25:10
que son espacios de memoria 00:25:12
cada uno de ellos con un nombre distinto 00:25:14
y puede haber tantos objetos 00:25:16
de la misma clase como hagan falta 00:25:18
tantos objetos como hagan falta 00:25:20
entonces claro, una aplicación de pedidos 00:25:26
pues tendría sentido hacerlo así 00:25:28
si yo no trabajo con clases 00:25:30
que me hago variables sueltas 00:25:32
que sean código del pedido 1 00:25:34
una variable entera suelta 00:25:36
otra variable insuelta, código del pedido 2 00:25:38
pues hombre, lo puedo hacer así 00:25:40
descripción del pedido 1, una variable string suelta 00:25:42
descripción del pedido 2, otra variable string suelta 00:25:44
pues lo puedo hacer con variables sueltas 00:25:46
pero hombre, que horrorosa 00:25:48
y que fea y que complicada 00:25:50
es mucho más fácil si yo tengo 00:25:52
una variable pedido bolis 00:25:54
dentro de la cual si quiero 00:25:56
me voy a las propiedades 00:25:58
otra variable pedido gomas, de la clase pedido 00:26:00
dentro de la cual ya si quiero 00:26:02
me voy a las propiedades 00:26:04
mucho más organizada así 00:26:06
mucho más bonita 00:26:08
que no con variables sueltas 00:26:10
código pedido 1, código pedido 2 00:26:12
mucho mejor así, con una clase pedido 00:26:14
con mis pedidos en variables separadas 00:26:16
cada una de ellas teniendo sus propiedades 00:26:18
va a quedar mucho más claro y mejor 00:26:20
que ahora me hago otra aplicación 00:26:22
que también trabaja con pedidos 00:26:24
anda, pues esta misma clase pedido 00:26:26
que ya tengo hecha 00:26:28
en mi caso es que hay dos líneas 00:26:30
pero esta clase que ya tengo hecha 00:26:32
voy a llevármela a mi otra aplicación 00:26:34
no tengo que volver a hacerla 00:26:36
no tengo que volver a hacerla 00:26:38
gracias a que ya tengo una clase pedido hecha 00:26:40
a cualquier otra aplicación que os he pedido 00:26:42
sale, ahí me la llevo 00:26:44
y ya tengo ese trabajo 00:26:46
puedo reutilizar el código de las clases 00:26:48
¿vale? 00:26:52
venga, pues para 00:26:54
asegurarnos de que esto está claro 00:26:56
vais a programar vosotros ahora 00:26:58
esta misma clase 00:27:02
esta misma clase 00:27:10
vais a programar una aplicación 00:27:12
con estas dos clases 00:27:14
¿vale? 00:27:16
la clase pedido 00:27:18
con las propiedades que hemos dicho 00:27:20
con el código 00:27:22
y la descripción 00:27:26
y la descripción 00:27:28
y ahora vais a hacer una aplicación 00:27:30
un método main 00:27:32
que haga lo siguiente, tiene que hacer 00:27:34
crear dos objetos pedido 00:27:36
y rellenar 00:27:38
sus propiedades 00:27:40
no con valores que yo le he asignado a capón 00:27:42
como aquí, sino con valores que habéis 00:27:44
editado por teclado 00:27:46
¿vale? 00:27:48
eso es lo primero que vamos a hacer, rellenar 00:27:50
en mi main 00:27:52
dos objetos 00:27:54
pedido 00:27:58
con valores 00:28:00
solicitados 00:28:02
por teclado 00:28:04
los dos códigos 00:28:06
y solicitados 00:28:08
por teclado 00:28:14
vale, y una vez 00:28:16
hecho eso 00:28:18
lo que vais a hacer va a ser 00:28:20
vais a 00:28:22
mostrar 00:28:24
una utilidad un poco 00:28:26
extraña, pero bueno 00:28:28
vais a mostrar 00:28:30
la descripción 00:28:32
del pedido cuyo código 00:28:34
sea mayor, ya está 00:28:36
ahora mismo 00:28:42
me da igual, pero como todavía no hemos visto 00:28:44
paquetes ni entendemos lo que es 00:28:46
si lo queréis hacer en un paquete, me da lo mismo 00:28:48
pero yo no doy todavía los paquetes 00:28:50
por tabla, porque no los hemos visto 00:28:52
en default está bien por ahora 00:28:56
mostrar la 00:29:00
descripción 00:29:02
la utilidad de los paquetes 00:29:04
aparece efectivamente cuando viene la aplicación 00:29:06
tiene muchas clases, si tiene muchas 00:29:08
conviene organizar diferentes paquetes 00:29:10
pero esto tiene un funcionamiento específico 00:29:12
que todavía nos falta volver también 00:29:14
mostrar la descripción 00:29:16
del pedido 00:29:18
con código 00:29:20
mayor 00:29:22
venga pues esto 00:29:26
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
4
Fecha:
18 de diciembre de 2023 - 13:55
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
563.79 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid