Saltar navegación

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

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

5 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, a ver. No, no voy a hablar de nada que no queráis que hablemos. 00:00:00
Vamos, que yo no tengo ninguna idea para ese día. 00:00:08
Me dijeron ayer, necesito el tutorial de 9 a 10. Vale, pues ya está. 00:00:11
Ya, ya, ya, ya lo sé. 00:00:16
Venga, a ver. A ver, tenemos esta primera hora intensa. 00:00:19
El domingo si se ponen faltas. 00:00:24
El domingo si se ponen faltas. Si no estás aquí el domingo te pongo una falta gorda, gorda. 00:00:25
No se ponen faltas. Bueno, yo por lo menos no pongo faltas. 00:00:29
Vale, a ver. Tenemos una hora de aquí hasta las 12.40 intensa, 00:00:35
en la que voy a tener que hablar mucho y soltar mucho rollo, 00:00:40
porque luego las otras dos siguientes horas tengo lecturas de proyecto, etcétera, 00:00:42
con lo cual me iré y os podéis quedar haciendo ejercicios. 00:00:47
Y bueno, si alguien sí quiere ir, pues no le vea a que se quede, 00:00:52
porque yo no voy a poder estar aquí. Vale. 00:00:58
Bueno, pues venga, vamos a revisar y añadir unas cuantas cosas 00:01:01
en cuanto a operación y orientación de objetos para que ya en navidades 00:01:07
podáis trabajarlo más a partir de ejercicios que dejemos, 00:01:12
podáis trabajar ya con conocimientos suficientes para hacer un poquito más. 00:01:16
¿Vale? Silencio. Bueno, pues a ver. 00:01:20
Silencio. Bueno, pues a la hora... 00:01:34
A ver, ¿os queréis callar y estar en absoluto silencio, 00:01:40
aunque no me escuchéis que eso me la refanfifla completamente? 00:01:43
Lo que quiero es silencio absoluto. Así. Este perfecto. 00:01:46
Ismael y Ricardo. También aplica. Vale. 00:01:51
Tienes que ser capaces de aguantar callados, de verdad que no es tan complicado. 00:01:56
Así mejor. Vale. Pues todos sabéis lo que es una clase 00:02:00
y luego ya lo que significa crear un objeto de esa clase. 00:02:05
Uno, dos, tres o mil. Vale. 00:02:10
Una clase tiene dos partes. La parte de propiedades, 00:02:13
que también sabemos todos lo que significa. 00:02:17
No repito todo una y otra vez. Y la parte de métodos, 00:02:21
que también sabemos todos lo que significa. ¿Vale? 00:02:25
Lo que va a caracterizar al objeto que exista en el futuro de esa clase 00:02:30
está aquí en propiedades y lo que ese objeto va a poder llamar 00:02:35
para que se ejecute está aquí en métodos. 00:02:40
Bueno, entonces en nuestra clase pedido con nuestras propiedades y nuestros métodos 00:02:43
luego vimos que en una aplicación, ahora ya con un main que se puede ejecutar 00:02:47
en una aplicación, uno crea ya todos los pedidos que dé la gana. 00:02:52
Metidos en un array, sueltos, como sea. 00:02:56
Y cuando lo cree siempre lo va a hacer con algo de este estilo. 00:02:59
Pedido p igual a new pedido. Vale. 00:03:03
Bueno, pues nosotros hemos puesto aquí el new pedido y hemos dicho 00:03:11
con este término new, nombre de la clase y paréntesis, 00:03:16
hemos dicho que lo que ocurre es que de repente aparece un objeto en memoria. 00:03:22
Eso es lo que hemos dicho que ocurría cuando hacíamos esta llamada. 00:03:28
Que de repente aparece un objeto en memoria y este objeto en memoria 00:03:31
se quede apuntado por una dirección que está guardada en esa variable p. 00:03:35
Esto es el resultado de hacer esta llamada new pedido. 00:03:42
Que aparezca esto en memoria. 00:03:46
Y como ya ha aparecido ese espacio en memoria, a partir de entonces 00:03:48
ya podemos mediante p punto no sé cuántos, p punto no sé qué, 00:03:52
acceder al espacio de este objeto para guardar las propiedades. 00:03:56
Pues cliente, identificador, las propiedades que sea. 00:04:02
Bueno, vale, pues tenemos que meternos ahora ya que entendemos 00:04:05
lo que es un método un poquito más con esta llamada. 00:04:09
Que hasta ahora lo único que sabemos es que lo que significa es 00:04:12
que aparece ese espacio en memoria y se queda apuntado a por p. 00:04:15
Vale. Pero es que además esta llamada también hace algo. 00:04:18
Y es llamar a un método, y ya sabemos lo que es un método. 00:04:23
Un método es un trozo de código que hay dentro de la clase, bajo un nombre. 00:04:28
Pues mostrar descripción, lo que sea, un trozo de código bajo un nombre 00:04:34
que se puede ejecutar cuando lo llama el objeto en su método. 00:04:40
Bueno, pues hay unos métodos especiales que no hemos escrito hasta ahora 00:04:43
ni hemos visto porque no es obligatorio que estén, 00:04:48
que son los métodos constructores. 00:04:51
Entonces, y son los únicos especiales. 00:04:56
Vamos a ponerlo aquí. 00:05:02
Dentro de los métodos existen unos especiales, 00:05:04
especiales porque se saltan algunas de las reglas de construcción 00:05:13
de métodos que vimos el otro día. 00:05:17
Bueno, pues dentro de los métodos existe un método especial 00:05:23
que es el método constructor. 00:05:32
Y se llama así, método constructor. 00:05:36
Pues entonces dentro de los métodos que ya hemos visto, 00:05:46
los métodos como se codifican. 00:05:49
Un nombre, parámetros que recibe si es que recibe alguno, 00:05:51
tipo de dato de retorno, el código que tiene dentro. 00:05:55
Ese es el concepto de método que ya sabemos lo que es. 00:05:58
Bueno, pues dentro de todos los métodos que puede tener una clase, 00:06:01
que puede tener uno o mil, uno o mil los que yo quiera programar, 00:06:05
dentro de todos los métodos puede haber uno especial 00:06:09
que todavía no lo hemos incorporado, que se le llama método constructor. 00:06:12
Y vamos a ver este método porque es especial y que hace. 00:06:17
¿Vale? Ese método especial dentro de los métodos. 00:06:20
Vale, pues vamos a verlo. 00:06:23
Vale, pues el método constructor de una clase es un método 00:06:43
que obligatoriamente, obligatoriamente se tiene que llamar, 00:06:47
obligatoriamente se tiene que llamar. 00:06:51
Voy a hacer aquí un método constructor, para esta clase no está pedido. 00:06:54
Pues el método constructor de una clase cualquiera, 00:07:01
pedido, cliente, persona, alumno, la que sea. 00:07:04
El método constructor de una clase cualquiera, 00:07:07
obligatoriamente se tiene que llamar igual que la clase a la que pertenece. 00:07:09
Esa es, obligatoriamente se tiene que llamar, igual que la clase. 00:07:20
¿Vale? Esa es la primera característica que lo hace especial. 00:07:23
Que yo no puedo elegir su nombre. 00:07:27
Se tiene que llamar como la clase a la que pertenece. 00:07:29
Luego este método se salta, ese convenio de programación 00:07:34
de que los métodos empiecen por minúscula. 00:07:38
Porque si se tiene que llamar igual que la clase, 00:07:41
y la clase seguimos el convenio de programación establecido entre todos, 00:07:44
que empiecen con mayúscula, pues el constructor va a empezar con mayúscula. 00:07:48
¿Vale? O sea, el constructor no hay elección. 00:07:52
Se tiene que llamar exactamente igual que la clase. 00:07:54
Si yo hago otro método que se llame así, 00:07:59
pues este será otro. 00:08:02
Este ya no es el constructor, será otro el método que yo quiera hacer. 00:08:03
Ya no será el constructor, será otro método cualquiera. 00:08:07
Con su nombre, sus parámetros, si es que tiene, su valor de retorno, será otro. 00:08:10
Pero el constructor se tiene que llamar igual que la clase. 00:08:14
Y como ya sabéis que esto es sensible a minúsculas y mayúsculas. 00:08:18
Vale, pues esta es la primera cosa que le hace especial. 00:08:21
¿Qué parámetros recibe el constructor? 00:08:26
Los que a mí me dé la gana. 00:08:28
¿Y qué código? Sobre esto nos metemos ahora. 00:08:32
¿Y qué código tiene aquí el constructor? 00:08:35
El que a mí me dé la gana. 00:08:37
¿Vale? 00:08:40
Todavía no me meto con esto. 00:08:41
Entonces, ahora la pregunta sería, ¿vale? 00:08:44
¿Y para qué sirve ese método? 00:08:46
¿Cuándo llamo yo a ese método? 00:08:48
¿Por qué tiene que haber un método que se llame así? 00:08:49
Bueno, pues ahora ya sí que nos vamos aquí. 00:08:52
Cuando se instancia, ya en una clase main, 00:08:57
una clase que ya empieza, que tiene las sentencias que se van ejecutando. 00:09:00
Cuando se instancia, o se crea, 00:09:04
es sinónimo instanciar, crear un objeto. 00:09:06
Cuando se instancia un objeto, 00:09:08
que nosotros sabemos que eso se hace haciendo newPedido, 00:09:11
pues sí, efectivamente no hemos mentido. 00:09:14
Pasa en memoria principal todo lo que hemos dicho. 00:09:17
Que aparecerá un espacio para guardar las propiedades de este objeto P. 00:09:20
Aquí aparece el espacio para las propiedades. 00:09:25
Ese espacio se queda apuntado por la variable P. 00:09:28
Pasa todo eso cuando se hace newPedido. 00:09:31
Pero además pasa que si existe un método constructor, 00:09:34
es decir, un método que se llama igual que la clase, 00:09:38
además la máquina virtual se va a ejecutar. 00:09:41
Si existe, se va a ejecutarlo. 00:09:46
Si no existe, pues no se va a ejecutarlo porque no existe. 00:09:48
Pero si existe, se va a ejecutarlo. 00:09:51
Entonces ese método, ponerlo, nos viene bien 00:09:53
para hacer a lo mejor tareas de inicializar propiedades del objeto 00:09:56
o hacer cosas. 00:10:00
O cualquier cosa. 00:10:03
Por ejemplo, pues avisar. 00:10:04
Se ha creado objeto. 00:10:06
Lo que a mí me dé la gana puedo poner aquí. 00:10:07
¿Vale? 00:10:14
Luego repito. 00:10:15
Lo que tenemos que saber es que este método constructor, 00:10:16
que obligatoriamente se llama igual que la clase, 00:10:18
es un método que se invoca solo, 00:10:20
cada vez que se instancia un objeto a Tableau. 00:10:22
Se invoca solo. 00:10:26
Además de crear el espacio. 00:10:27
Todo eso se llama aquí. 00:10:28
Es decir, no es un método que uno llame a propósito en cualquier momento. 00:10:30
No. 00:10:33
Es un método que está pensado para ser llamado y ejecutado 00:10:34
como consecuencia de hacer la instanciación de un objeto con new pedido. 00:10:38
Entonces se llama automáticamente. 00:10:42
Luego el uso de ese método será hacer pues tareas de inicialización, 00:10:45
de lo que sea, lo que a mí me apetezca vender. 00:10:49
Ahí ya sí que Java no se mete. 00:10:51
Mete ahí lo que quieras. 00:10:52
Lo que quieras que pase en el momento de construir el objeto. 00:10:53
Lo que quieras que pase. 00:10:57
¿Vale? 00:11:00
Bueno, pues entonces, como este método se llama aquí, 00:11:02
no hay valor de retorno posible. 00:11:06
No hay valor de retorno porque es que esto en realidad 00:11:09
está igual que se asigna aquí. 00:11:12
Ya me está condenando. 00:11:15
O sea, el método no tiene donde devolver el valor de retorno. 00:11:16
No es un método que yo llamo y luego puedo asignar a una variable 00:11:19
la llamada al método. 00:11:22
No funciona así. 00:11:24
En este momento, que la sintaxis es esta, 00:11:25
no tengo donde recoger el valor de retorno. 00:11:27
Luego, los métodos constructores nunca pueden devolver nada. 00:11:31
No hay un retún ahí. 00:11:35
Nunca. 00:11:36
No hay un retún. 00:11:37
Jamás van a tener un retún. 00:11:38
Porque no devuelven nada. 00:11:40
Entonces, tanto es así que no devuelven nada, 00:11:42
que son métodos que tienen la característica especial y solo ellos, 00:11:44
que ni siquiera se pone el void. 00:11:48
Prohibido. 00:11:50
Ni se pone el void. 00:11:51
Nada. 00:11:52
No se pone nada. 00:11:53
Así se escribe el constructor. 00:11:54
O sea, son los únicos métodos, 00:11:56
los únicos, 00:11:58
que no tienen nada delante. 00:12:00
Ni void, 00:12:02
ni el tipo de dato de retorno del método que sea. 00:12:04
No tienen nada. 00:12:07
Porque los constructores, por pura definición, 00:12:08
no pueden devolver nada. 00:12:11
Porque son llamados aquí, 00:12:13
y aquí no puedo poner yo aquí una variable para que recoja el valor. 00:12:15
No puedo ponerla, porque ya tengo que poner esto obligatoriamente. 00:12:18
Ya tengo que ponerlo. 00:12:20
La sintaxis es esta. 00:12:21
Entonces no puedo meter en ninguna variable ningún valor de retorno. 00:12:23
Luego no se pone aquí nada para hacer el constructor. 00:12:27
Bueno, pues en este caso ya tendríamos aquí un constructor ya hecho. 00:12:33
Esta clase nuestra ya tiene un constructor. 00:12:37
En este caso el constructor se va a invocar cada vez que yo creo un objeto. 00:12:40
Y lo único que hace es mostrar un mensajito. 00:12:45
Bueno, pues un constructor poco útil. 00:12:47
Lo normal es darles a los constructores un poquito más de utilidad. 00:12:50
¿Cómo? Pues a lo mejor pasándoles parámetros. 00:12:55
Yo este constructor que he hecho no recibe ningún parámetro. 00:12:57
Lo he declarado así porque me ha dado la gana. 00:13:00
Entonces, como lo he declarado así, 00:13:04
en el momento de hacer new pedido, también lo pongo así. 00:13:06
Pero yo puedo hacer constructores que reciban cosas, parámetros, 00:13:11
igual que cualquier otro método. 00:13:14
Eso sí que lo puedo hacer. 00:13:16
No puedo hacer que devuelvan nada, eso es imposible. 00:13:17
Pero si me da la gana, yo puedo hacer un constructor que reciba parámetros. 00:13:19
Y si los recibe, cuando yo haga el new pedido, 00:13:24
se los tengo que pasar aquí obligatoriamente. 00:13:27
Si yo lo he declarado para que reciba parámetros, 00:13:30
se lo tengo que pasar ahí. 00:13:32
Por ejemplo, el uso habitual de los constructores, 00:13:37
que prácticamente siempre se usan para eso. 00:13:40
Pues para ya que creo el objeto, 00:13:43
vamos a aprovechar para inicializar sus propiedades. 00:13:45
Por ejemplo, pedido. 00:13:48
Imaginaos que tiene dos propiedades, 00:13:49
que son el identificador y la descripción. 00:13:51
¿Vale? 00:13:59
Ahora, vamos a hacerle un constructor, 00:14:00
un método constructor. 00:14:02
El método constructor se tiene que llamar pedido. 00:14:03
Aquí ni void ni nada, 00:14:06
porque es el constructor. 00:14:09
Y ahora, ¿qué parámetros decido pasarle? 00:14:11
Venga, pues vamos a pasarle un id y una descripción 00:14:14
desde fuera, cuando lo llamemos. 00:14:18
Vamos a pasárselo por aquí. 00:14:20
Y vamos a usarlo para que inicialice las propiedades. 00:14:22
Así no tenemos luego que inicializarlas 00:14:25
con p.id, p.descripción. 00:14:27
¿Vale? 00:14:30
Pues ¿qué tenemos que pasarle? 00:14:31
Tenemos que pasarle un id. 00:14:32
Pues venga, le voy a pasar un numerito entero para el id. 00:14:34
¿Qué más le quiero pasar a este método? 00:14:37
Una cadena para que inicialice esta. 00:14:39
Pues venga, le voy a pasar como parámetro una cadena. 00:14:41
string descripción. 00:14:45
¿Vale? 00:14:49
Y ahora, 00:14:50
¿el constructor qué queremos que haga con estos parámetros 00:14:51
que le hemos pasado desde fuera? 00:14:54
Pues con estos parámetros queremos que los utilice 00:14:57
para inicializar las propiedades del objeto. 00:15:00
Pues venga, 00:15:03
la propiedad del objeto dis.id, 00:15:04
que se inicialice con esta, 00:15:08
y la propiedad dis.descripción, 00:15:12
que se inicialice con esta. 00:15:20
Pues este es el aspecto típico de los constructores, 00:15:25
porque suelen valer para esto. 00:15:28
Uno puede poner dentro lo que le la gana, insisto. 00:15:30
Si le interesa que pasen más cosas 00:15:33
en el momento de construir el objeto, 00:15:36
lo pone. 00:15:38
Como si pone ahí 10.000 líneas. 00:15:39
Pero bueno, ¿para qué? 00:15:41
Normalmente cuando uno construye un objeto, 00:15:42
lo más que quiere que ocurra con ese objeto 00:15:45
es darle valor a las propiedades. 00:15:47
Es lo más que quiere. 00:15:49
Pues en ese caso pondré este código y ya está. 00:15:51
Bueno, pues es el constructor típico. 00:15:54
Ahora, ¿cómo usaremos este constructor? 00:15:57
Pues vamos a imaginarnos que queremos crear un pedido. 00:16:00
En nuestra aplicación necesita crear un objeto pedido. 00:16:04
Pues eso no cambia. 00:16:07
Por ejemplo, le llamo p a ese objeto pedido 00:16:09
en mi clase main, que estoy ahora en mi clase main. 00:16:12
Pues venga, ¿cómo creamos un pedido? 00:16:15
new, eso no cambia. 00:16:17
new pedido, eso no cambia. 00:16:19
Pero ojo, ahora los paredes ya no se quedan vacíos, 00:16:21
porque ahora tengo un constructor 00:16:25
que necesita recibir dos cosas. 00:16:28
Si yo lo dejar así vacío, 00:16:31
el compilador, ahora lo repasaremos 00:16:34
y lo comprobaremos todo. 00:16:36
El compilador me diría, 00:16:38
me lo pondría rojito y me diría, 00:16:40
perdona, pero no puedo llamar al constructor 00:16:42
sin parámetros, porque es que el constructor 00:16:45
tú lo has hecho para que reciba 00:16:48
un entero y una cadena. 00:16:50
Perdona, lo has hecho para que reciba 00:16:52
un entero y una cadena. 00:16:54
Luego no lo llames así, porque así no va a funcionar. 00:16:56
Bueno, pues entonces aquí tenemos que pasar 00:16:59
obligatoriamente un entero y una cadena. 00:17:01
El uso normal sería que yo hubiera dicho primero 00:17:03
introduzca el código del pedido, patatín. 00:17:05
Introduzca la descripción del pedido, patatín. 00:17:08
Y ahora le paso aquí esas dos variables. 00:17:10
Vamos a suponer que se las doy directamente 00:17:13
a capón aquí, porque no las he pedido por teclado. 00:17:15
Bueno, esta llamada ya sí que es válida. 00:17:18
Entonces con esto, ¿qué estaríamos haciendo? 00:17:20
Construir un objeto pedido, 00:17:23
que se quede apuntado por P. 00:17:25
Y ahora, además de crear el espacio, 00:17:28
saltamos al constructor. 00:17:31
¿Qué hace el constructor? 00:17:33
Coge 5, se lo asigna la propiedad ID del objeto, 00:17:34
que es esta, ahí se queda el 5. 00:17:38
Y coge descripción, que es D, 00:17:41
y se lo asigna la propiedad de descripción del objeto, 00:17:44
que es esta. 00:17:47
Pues ala, esto habríamos conseguido con esta llamada. 00:17:48
No solo crear el objeto, el espacio en memoria para él, 00:17:52
sino además ya de paso, 00:17:55
dar unos valores iniciales a las propiedades. 00:17:57
Dar unos valores iniciales. 00:18:01
Que es el uso habitual del constructor, 00:18:02
cuando existe, el uso habitual. 00:18:04
A partir de aquí, si yo ahora ya tengo P.ID que vale 5, 00:18:06
P.descripción que vale D, 00:18:11
que las quiero volver a cambiar, pues las vuelvo a cambiar. 00:18:14
Pero ya tengo unos valores iniciales. 00:18:17
¿Vale? 00:18:21
En los ejemplos anteriores, 00:18:26
no habíamos puesto método constructor. 00:18:28
Esto no estaba. 00:18:31
Entonces llamábamos sin parámetros, 00:18:33
lo llamábamos así. 00:18:35
Entonces uno diría, uy, pero si no tengo método constructor, 00:18:38
el compilador como verifica que... 00:18:41
A ver, si yo no he hecho método constructor, 00:18:44
Java se inventa uno y lo pone ahí. 00:18:47
Aunque nosotros no lo veamos físicamente. 00:18:49
Lo pone ahí. 00:18:51
Entonces si mi clase no tuviera método constructor, 00:18:52
porque esto no lo tiene, yo no lo he puesto, 00:18:55
es como si existiera esto. 00:18:58
Que la máquina virtual lo pone y se lo inventa. 00:19:02
Es como si existiera esto. 00:19:04
Pedido sin parámetros y vacío. 00:19:06
Se lo inventa. 00:19:09
Y dice, ¿no tienes método constructor? 00:19:10
Vale, me hago uno sin parámetros, sin código. 00:19:12
Y ahí está oculto, aunque no lo veamos. 00:19:15
Ahí está oculto. 00:19:17
Que este es el que se llama el constructor sin parámetros. 00:19:19
Entonces luego por eso, cuando hemos creado los objetos 00:19:22
en nuestros ejemplos anteriores, los hemos creado así, 00:19:25
sin parámetros. 00:19:27
Porque como no habíamos hecho ni un constructor, 00:19:28
la máquina virtual se ha inventado este. 00:19:30
Que es el que se inventa siempre. 00:19:33
Y este no tiene parámetros. 00:19:34
Luego la llamada encajaba. 00:19:36
Porque sin parámetros, sin parámetros. 00:19:37
Pero siempre se llama un constructor. 00:19:40
O bien el que he hecho yo, 00:19:42
o bien el que la máquina virtual se ha inventado 00:19:44
porque no tiene nada. 00:19:46
Vale. 00:19:53
Vamos a verlo en el eclipse, que se va a ver todo más claro. 00:19:55
Bueno, ya sí que están subidas todas las clases. 00:20:01
Aunque alguna puede estar medio rara 00:20:24
porque se me olvidó cortar a veces en eso. 00:20:26
Pero bueno, ya con las últimas ya están mejor. 00:20:30
Y subido al aula virtual ya el proyecto este 00:20:35
con el que vamos a hacer los ejemplos. 00:20:37
Y los ejercicios que subimos ayer, 00:20:40
que eran sobre el primero y parte del segundo. 00:20:42
Vale, pues sobre este mismo proyecto de ejemplo 00:20:47
que estamos usando de pedidos 00:20:50
y que iremos ampliando e incorporando cosas, 00:20:52
vamos a ampliar ahora con los constructores. 00:20:55
¿Vale? 00:20:57
¿Se ve mejor sin la luz? 00:20:59
Bueno, esto es lo de ayer, vamos a olvidarnos. 00:21:14
Vale, a ver, nuestro ejemplo de clases y objetos. 00:21:22
Vale, esta es nuestra clase pedido de partida. 00:21:26
Tenía tres propiedades, un método comprobar cliente 00:21:29
con lo que estuvimos trabajando, 00:21:33
un método actualiza descripción 00:21:35
y luego ya teníamos aquí uno quantum main 00:21:37
para probar cosas. 00:21:39
¿Vale? 00:21:41
Bueno, pues vamos a ampliar ahora nuestra clase pedido 00:21:42
y vamos a ponerle un método constructor. 00:21:44
Le vamos a poner un método constructor. 00:21:47
Vale, pues venga, el método constructor 00:21:50
se suele poner al principio de todos los métodos, 00:21:52
después de las propiedades. 00:21:55
No es que sea obligatorio, 00:21:57
pero insisto, acostumbraos a seguir estilos de programación 00:21:59
que compartimos todos, 00:22:04
porque vuestros programas si no, no van a valer igual. 00:22:06
Da igual que funcionen, 00:22:09
si no siguen esos estilos de programación compartidos 00:22:11
no van a ser legibles fácilmente 00:22:13
y eso les hace poco valiosos. 00:22:16
Vale, pues el constructor, 00:22:18
vamos a hacer un constructor que, 00:22:21
el constructor estándar, 00:22:24
podríamos hacer cualquier cosa, 00:22:26
pero vamos a hacer un constructor que reciba 00:22:28
tantos parámetros como propiedades tiene el objeto 00:22:30
y los use para inicializar 00:22:34
las propiedades del objeto. 00:22:38
Pues entonces en este caso habrá que pasarle 00:22:40
un código, 00:22:43
una descripción, 00:22:47
una array de clientes. 00:22:50
Vale, ¿y para qué puede usar estos parámetros el constructor? 00:23:00
Pues para la propiedad .código, 00:23:03
obligatorio poner el dis, 00:23:06
porque con el nombre que he elegido para el parámetro 00:23:08
tengo que distinguir, 00:23:10
código, 00:23:12
descripción, 00:23:14
para la propiedad del objeto .descripción, 00:23:16
pues descripción, 00:23:24
y para la propiedad .clientes, 00:23:28
clientes. 00:23:36
Vale, este suele ser el aspecto estándar del constructor. 00:23:38
Como veis, yo aquí no he puesto valor de retorno 00:23:41
y el compilador no se queja ni dice nada. 00:23:44
Dice, vale, muy bien. 00:23:47
Pero sin embargo, si en un método normal y corriente 00:23:49
que no es constructor, 00:23:51
le quitara yo el valor de retorno, 00:23:53
le quitara esto, 00:23:55
automáticamente me diría aquí, 00:23:57
oye, lo siento, 00:23:59
pero me está diciendo, 00:24:01
el tipo de retorno te falta, ponlo. 00:24:03
Es lo que me está diciendo esta cosa amarilla, 00:24:06
oye, oye, que te falta, ponlo. 00:24:08
Claro, porque este no es el método constructor, 00:24:10
es un método normalucho y corrientucho, 00:24:12
entonces todos los métodos normales y corrientes 00:24:14
necesitan el tipo de dato. 00:24:17
Pero aquí en este no me lo ha pedido, 00:24:20
porque este sabe que es el constructor. 00:24:22
¿Y por qué sabe que es el constructor? 00:24:24
Porque se llama exactamente igual que la clase. 00:24:26
Si yo le cambio el nombre y lo llamo así, 00:24:30
ya está, dejó de ser el constructor, 00:24:34
porque le he cambiado el nombre, 00:24:36
dejó de ser el constructor. 00:24:38
¿Pasa algo? 00:24:39
No pasa nada, el código está bien, 00:24:40
todo está bien, 00:24:41
pero lo que pasa es que entonces me dice 00:24:42
el compilador, 00:24:44
oye, este no es el constructor, 00:24:45
con lo cual es obligatorio que le ponga 00:24:46
el valor de retorno. 00:24:48
Bueno, pues yo le pongo el valor de retorno 00:24:49
y ya está. 00:24:51
Pero esto ya no es el método constructor, 00:24:52
esto es otro, 00:24:54
con lo cual este no se va a invocar nunca 00:24:55
cuando se hace el mío, nunca, 00:24:57
porque es otro. 00:24:58
Para que sea el constructor, 00:24:59
por tanto, repito, 00:25:01
se tiene que llamar igual que la clase. 00:25:02
¿Vale? 00:25:04
Y en ese caso, 00:25:05
esto ni se pone nada, 00:25:06
se queda en blanco 00:25:08
para que se vea bien claro 00:25:09
que es el constructor. 00:25:10
Y no me quite los avisos de 00:25:11
oye, ese es constructor, 00:25:13
¿para qué le pones void? 00:25:14
Bla, bla, bla. 00:25:15
¿No es un public? 00:25:16
No pasa nada, 00:25:18
pero eso tiene que ver, 00:25:19
de nuevo, 00:25:20
los public, private, protect, etc., 00:25:21
tienen que ver con los paquetes. 00:25:23
Y es que los paquetes 00:25:25
todavía no los hemos contado. 00:25:26
Por eso yo no pongo public en nada, 00:25:27
porque no quiero poner nada 00:25:29
que no entendemos lo que significa. 00:25:30
Tú tranquilo, 00:25:32
que tenemos que ver 00:25:33
cómo construir paquetes, 00:25:34
cómo empaquetar con criterio 00:25:35
y cómo hacer modificadores de acceso. 00:25:36
Public, private, 00:25:38
todos esos modificadores de acceso. 00:25:39
Pero claro, 00:25:41
esos modificadores de acceso 00:25:42
existen de momento 00:25:43
en que existen paquetes. 00:25:44
Si no, 00:25:45
no tiene sentido que existan. 00:25:46
Entonces, 00:25:47
como no estamos todavía 00:25:48
trabajando con paquetes, 00:25:49
obvio los public, 00:25:50
los quito siempre. 00:25:51
¿Vale? 00:25:52
¿Qué los pones? 00:25:53
No pasa nada, 00:25:54
no tiene implicaciones. 00:25:55
Ahora mismo, 00:25:56
porque no tiene implicaciones, 00:25:57
pero todavía no las estamos viendo. 00:25:58
Lo puedes poner. 00:25:59
Vale, 00:26:00
pues este es el aspecto estándar 00:26:01
de un constructor 00:26:02
normal y corriente. 00:26:03
Repito, 00:26:06
uno le puede poner 00:26:07
lo que le dé la gana. 00:26:08
Lo que quiera. 00:26:09
Podríamos poner aquí, 00:26:10
ala, 00:26:11
se ha construido el pedido. 00:26:12
¿Vale? 00:26:15
Y ya está, 00:26:16
se ha construido el pedido. 00:26:17
Vale. 00:26:18
Bueno, 00:26:20
pues entonces, 00:26:21
ahora, 00:26:22
podríamos crear 00:26:23
un objeto pedido, 00:26:24
pero ya tendríamos que pasarle 00:26:25
esto obligatoriamente. 00:26:27
Ups. 00:26:29
Por eso, 00:26:30
en mis main de arriba, 00:26:31
ahora ya se me han puesto 00:26:33
en rojo, 00:26:34
porque ahora ya 00:26:35
el compilador me dice, 00:26:36
eh, 00:26:38
ojo, 00:26:39
ojo, 00:26:40
que cuando construyas el objeto, 00:26:41
el constructor que has hecho, 00:26:43
necesita parámetros. 00:26:45
No me llames sin parámetros. 00:26:48
Es imposible, 00:26:50
por eso se me ha puesto en rojo. 00:26:51
¿Vale? 00:26:52
Ahora le ponemos parámetros 00:26:53
y vamos con ello. 00:26:54
Vale, 00:26:55
volvemos un momento 00:26:56
con el aspecto del código. 00:26:57
Vale, 00:26:58
para no tener que escribir tanto, 00:26:59
este estándar 00:27:01
eh, 00:27:03
de forma tan generalizada, 00:27:04
el uso habitual 00:27:05
de los constructores, 00:27:06
suele ser este, 00:27:07
el uso habitual, 00:27:08
que todos los entornos 00:27:09
de desarrollo, 00:27:10
te facilitan 00:27:11
una forma de, 00:27:12
pam, 00:27:13
que te lo escribe el solo. 00:27:14
¿Vale? 00:27:15
Entonces, 00:27:16
si vosotros dais aquí 00:27:17
al botón derecho del eclipse, 00:27:19
esto es un truco para vagos. 00:27:20
¿Vale? 00:27:21
Si le dais al botón 00:27:22
de derecho del eclipse, 00:27:23
si os vais a source, 00:27:24
fuente, 00:27:25
veis que 00:27:26
se os despliega a la derecha 00:27:27
un generar constructor 00:27:28
usando campos. 00:27:29
Campos son propiedades. 00:27:30
¿Recordáis que cuando dijimos 00:27:32
propiedades lo dije? 00:27:33
Dije, 00:27:34
en inglés 00:27:35
se suele usar el término fill. 00:27:36
Fill significa 00:27:37
propiedad, 00:27:38
que es sinónimo 00:27:39
de atributo, 00:27:40
variable de clase, 00:27:41
etc. 00:27:42
Pues, 00:27:43
generar constructor 00:27:44
usando campos. 00:27:45
Marcáis 00:27:46
todas las propiedades 00:27:47
que queráis 00:27:48
que aparezca 00:27:49
en el constructor 00:27:50
y ala, 00:27:51
te lo genera 00:27:52
automáticamente. 00:27:53
¿Vale? 00:27:54
Y él también, 00:27:55
fíjate que casualidad, 00:27:56
ha escogido 00:27:57
como nombres 00:27:58
de los parámetros 00:27:59
los mismos 00:28:00
que los de la clase. 00:28:02
Para que quede muy claro 00:28:03
que son el mismo concepto. 00:28:04
Pero claro, 00:28:06
eso le obliga 00:28:07
a poner el dis. 00:28:08
Le obliga a poner el dis. 00:28:09
¿Vale? 00:28:11
No olvidéis del dis. 00:28:15
El dis significa 00:28:16
el objeto en el que estoy, 00:28:17
punto, 00:28:19
propiedad del objeto. 00:28:20
Si no ponemos el dis, 00:28:21
si uno dice, 00:28:23
uy, 00:28:24
este dis que me molesta, 00:28:25
lo quito, 00:28:26
ha estropeado el constructor, 00:28:27
porque automáticamente 00:28:29
ahora código 00:28:30
se referirá 00:28:31
a este parámetro. 00:28:32
Y es absurdo. 00:28:34
A este parámetro 00:28:35
darle el valor 00:28:36
de este parámetro. 00:28:37
Que tontería, 00:28:38
no estamos diciendo nada. 00:28:39
Vale. 00:28:43
Entonces, 00:28:44
el super 00:28:45
tiene que ver con la herencia, 00:28:46
no molesta si está ahí. 00:28:47
Porque no hace nada 00:28:48
ahora mismo. 00:28:49
Porque no tenemos superclases. 00:28:50
Y el public 00:28:52
tampoco molesta, 00:28:53
pero tampoco entendemos 00:28:54
exactamente qué significa. 00:28:55
Así que lo podemos quitar 00:28:57
o dejar. 00:28:58
Todavía no entendemos 00:28:59
qué significa 00:29:00
ni una cosa ni la otra. 00:29:01
Bueno, 00:29:02
pues nos ha generado 00:29:03
el mismo código 00:29:04
que hemos hecho nosotros. 00:29:05
O sea, 00:29:06
nos permite generarlo fácil. 00:29:07
Bueno, 00:29:08
ahora ya podemos 00:29:09
crear pedidos, 00:29:10
podemos crear pedidos 00:29:11
usando este constructor 00:29:12
de forma más cómoda. 00:29:13
Vale, 00:29:16
vamos a hacer un main3. 00:29:17
Usando este constructor. 00:29:25
Ahora, 00:29:29
pues para construir un pedido 00:29:31
lo normal ahora sería 00:29:32
que uno pidiera 00:29:33
con antelación, 00:29:34
antes de construirlo 00:29:35
pidiera con antelación 00:29:36
los datos. 00:29:37
Introduzca 00:29:38
descripción, 00:29:39
introduzca no sé qué. 00:29:40
Voy a 00:29:42
copiar de aquí 00:29:43
del otro main 00:29:48
el escáner. 00:29:49
Y ahora voy a copiar 00:29:51
de aquí esto, 00:29:52
introduzca código, 00:29:53
descripción 00:29:54
para que 00:29:55
vale, 00:30:00
introduzca código, 00:30:03
suponer que lo guardamos 00:30:04
en una variable cualquiera, 00:30:05
incódigo, 00:30:06
introduzca descripción, 00:30:10
vamos a suponer 00:30:13
que lo guardamos 00:30:14
en una variable cualquiera. 00:30:15
Vale, 00:30:19
ya tenemos dos valores 00:30:20
leídos, 00:30:21
dos variables, 00:30:22
un código 00:30:23
y una descripción. 00:30:24
¿Para qué las vamos a usar? 00:30:25
Pues las vamos a usar 00:30:27
para crear ahora ya 00:30:28
un nuevo objeto pedido, 00:30:30
pedido p 00:30:32
igual a 00:30:33
new pedido 00:30:34
y ahora tengo que pasarle 00:30:37
los valores 00:30:39
que el constructor me exige. 00:30:40
El constructor me exige 00:30:42
una descripción 00:30:43
y un array 00:30:45
para inicializar las propiedades. 00:30:46
Bueno, 00:30:48
pues el código lo tengo 00:30:49
que lo acabo de leer, 00:30:50
pues se lo paso, 00:30:51
la descripción la tengo 00:30:53
que la acabo de leer 00:30:54
y vamos a crear un pedido 00:30:56
con un array 00:30:57
por ahora nulo, 00:30:58
un array nulo, 00:30:59
ya pues de así 00:31:00
luego lo queremos crear 00:31:01
los clientes, 00:31:02
lo creamos. 00:31:03
Bueno, 00:31:04
pues esta llamada 00:31:05
ya es una llamada válida, 00:31:06
ya hemos creado el objeto. 00:31:07
El objeto 00:31:16
tiene 00:31:17
de id 00:31:20
y vamos a ponerlo aquí, 00:31:22
p.id 00:31:23
no, p.código 00:31:27
se llamaba, ¿no? 00:31:29
El objeto pedido 00:31:38
tiene de descripción 00:31:41
p.descripción 00:31:49
Vale, pues ya está. 00:31:57
Si ejecutamos esto, 00:31:59
efectivamente este main, 00:32:00
pues le meto el código 00:32:07
veintitrés 00:32:08
descripción 00:32:10
pues se ha creado 00:32:14
el objeto pedido 00:32:15
y efectivamente 00:32:16
se han, 00:32:17
sus propiedades 00:32:18
se han inicializado 00:32:19
con esto 00:32:20
por primera vez 00:32:21
a través del constructor. 00:32:22
Vale, 00:32:24
a través del constructor 00:32:25
ya le he pasado 00:32:26
estos valores, 00:32:27
los ha usado 00:32:28
el constructor 00:32:29
para inicializar 00:32:30
las propiedades 00:32:31
y efectivamente 00:32:33
a partir de este punto 00:32:34
el objeto ya tiene 00:32:35
esas propiedades. 00:32:36
¿Qué daño 00:32:37
se las quiero cambiar 00:32:38
a otras? 00:32:39
Pues hago yo, 00:32:40
yo ahora hago 00:32:41
lo que me dé la gana. 00:32:42
¿Que quiero cambiar 00:32:43
el código 00:32:44
y ponerle ahora dieciséis? 00:32:45
Pues lo que yo quiera. 00:32:46
¿Que quiero modificar 00:32:47
la descripción? 00:32:48
Lo que yo quiera. 00:32:49
¿Vale? 00:32:50
Bueno, 00:32:51
pues esto es 00:32:52
el concepto 00:32:53
de método constructor. 00:32:54
Aparece siempre 00:32:55
cuando uno declara 00:32:56
una clase entidad 00:32:57
las que yo estoy llamando 00:32:58
clases entidad 00:32:59
son las clases 00:33:00
que su significado es 00:33:01
representar 00:33:02
un concepto 00:33:03
de mi aplicación. 00:33:04
Representar pedido, 00:33:05
representar cliente, 00:33:06
representar mueble. 00:33:07
La clase main 00:33:08
no la llamaría 00:33:09
clase entidad 00:33:10
porque esta clase 00:33:11
no representa 00:33:12
ningún objeto 00:33:13
de mi aplicación. 00:33:14
Esta clase 00:33:15
es una clase 00:33:16
que tiene 00:33:17
ese método 00:33:18
especial 00:33:19
que es 00:33:20
el método 00:33:21
constructor 00:33:22
es una clase 00:33:23
que tiene 00:33:24
ese método 00:33:25
especial 00:33:26
que es el punto 00:33:27
de arranque. 00:33:28
A esa no la llamaría 00:33:29
clase entidad 00:33:30
pero es una clase 00:33:31
también. 00:33:32
No tiene propiedades, 00:33:33
no tiene nada 00:33:34
pero es una clase. 00:33:35
Bueno, 00:33:36
vale, 00:33:37
constructores 00:33:38
puede haber 00:33:39
más de uno. 00:33:40
Puede haber 00:33:41
más de uno. 00:33:42
Es decir, 00:33:43
yo puedo hacer 00:33:44
otro constructor 00:33:45
si me da la gana 00:33:46
pero claro, 00:33:47
como todos 00:33:48
se tienen que llamar 00:33:49
igual 00:33:50
porque eso es obligatorio 00:33:51
y todos tienen que devolver 00:33:53
lo mismo 00:33:54
que es 00:33:55
nada, 00:33:56
el vacío 00:33:57
¿Qué me queda a mí 00:33:58
para distinguir 00:33:59
uno de otro? 00:34:00
¿Qué me queda? 00:34:01
La lista de parámetros. 00:34:03
Lo único que me queda a mí 00:34:05
para poder distinguir 00:34:06
uno de otro 00:34:07
es la lista de parámetros 00:34:08
porque el nombre 00:34:09
tiene que ser igual. 00:34:10
Lo que hay delante 00:34:11
tiene que ser igual. 00:34:12
Entonces, 00:34:13
para distinguir 00:34:14
uno de otro 00:34:15
lo único que me falta 00:34:16
esta lista de parámetros. 00:34:18
¿Vale? 00:34:19
Pues, 00:34:21
por ejemplo, 00:34:22
aquí tengo otro ya 00:34:23
otro constructor 00:34:24
que me da a mí la gana 00:34:27
que tenga este código 00:34:28
que es nada. 00:34:29
Pues como veis 00:34:30
admite los dos 00:34:31
que son perfectamente 00:34:33
distinguibles. 00:34:34
Este se llamaría 00:34:35
el constructor 00:34:36
sin parámetros 00:34:37
porque no tiene parámetros. 00:34:38
Este es otro 00:34:39
que es distinto 00:34:40
porque tiene parámetros. 00:34:41
¿Vale? 00:34:43
Las cabeceras son distintas. 00:34:44
Entonces, 00:34:48
a la hora de crear el objeto 00:34:49
¿cómo sabe la máquina virtual 00:34:51
a cuál tiene que ir? 00:34:52
¿A uno o a otro? 00:34:54
Pues depende 00:34:56
de cómo lo llame yo. 00:34:57
Si le llamo 00:34:58
sin parámetros 00:34:59
tendrá que ejecutar 00:35:00
el de arriba. 00:35:01
Si le llamo con parámetros 00:35:03
el de abajo. 00:35:04
Por ejemplo, 00:35:07
en el main este 00:35:08
del primer día 00:35:09
que los estuvimos 00:35:10
creando así. 00:35:11
Pues aquí la máquina virtual 00:35:13
no tiene ningún problema. 00:35:14
Sabe que aparte 00:35:15
de crear el objeto 00:35:16
tiene que llamar 00:35:17
al constructor 00:35:18
que no necesita parámetros 00:35:19
porque no se los estoy pasando 00:35:21
que no necesita. 00:35:22
¿Vale? 00:35:23
Pues lo llama 00:35:24
a este 00:35:25
que lo único que hará 00:35:26
será es mostrar este mensaje. 00:35:27
Sin embargo aquí 00:35:29
aquí yo estoy llamando 00:35:30
al new pedido 00:35:31
de esta otra manera. 00:35:32
Entonces, 00:35:34
además de crear el espacio 00:35:35
sabe que tiene que llamar 00:35:36
al constructor 00:35:37
con tres parámetros. 00:35:38
Pues entonces 00:35:40
tiene que llamar a este. 00:35:41
Luego no hay confusión 00:35:43
cuando hacemos 00:35:44
un new pedido 00:35:45
a cuál de los métodos 00:35:46
tiene que ir. 00:35:47
¿A cuál de los constructores? 00:35:48
Tiene que ir 00:35:49
a aquel 00:35:50
al que le encajen 00:35:51
sus parámetros 00:35:52
con el que yo le echo 00:35:53
en la llamada. 00:35:54
Y así como si le pongo 00:35:57
27 constructores 00:35:58
pero eso sí 00:35:59
se tienen que distinguir 00:36:00
en la lista de parámetros. 00:36:01
No puede ser igual. 00:36:04
Yo no puedo hacer 00:36:05
otro constructor 00:36:06
que reciba un entero 00:36:08
un string 00:36:09
y un array. 00:36:10
No puedo 00:36:11
porque sería igual. 00:36:12
Pero puedo hacer 00:36:13
otro constructor 00:36:14
que reciba a lo mejor 00:36:16
solamente el código 00:36:17
por ejemplo. 00:36:18
Porque me da a mí 00:36:19
la gana hacer 00:36:20
abrir la posibilidad 00:36:21
de crear objetos 00:36:23
sólo con el código 00:36:24
y la descripción 00:36:25
ya la pondré luego. 00:36:26
¿Vale? 00:36:28
Este sería otro constructor 00:36:29
porque resulta 00:36:30
que a mi aplicación 00:36:31
le interesa 00:36:32
poder crear pedidos 00:36:33
pero por ahora 00:36:34
sólo con el código. 00:36:35
La descripción ya vendrá. 00:36:36
Bueno, 00:36:37
pues me hago otro 00:36:38
y no hay ningún problema. 00:36:39
Es perfectamente 00:36:40
distinguirlo del de arriba 00:36:41
porque la lista de parámetros 00:36:42
es distinta. 00:36:43
Luego yo ya 00:36:45
que quiero llamar 00:36:46
a este constructor 00:36:47
bueno, pues lo llamaré 00:36:50
pasándole 00:36:51
que le pongo aquí un 3. 00:36:52
Entonces la máquina virtual dirá 00:36:55
uy, estás llamando 00:36:56
al constructor 00:36:57
que necesita un entero 00:36:58
porque me estás pasando un 3. 00:37:00
Se va aquí y dice 00:37:01
a ver, 00:37:02
¿tengo algún constructor 00:37:03
que necesite un entero? 00:37:04
Sí, tengo uno, este. 00:37:05
Pues llamo a este. 00:37:06
Que yo lo llamo así 00:37:08
sin nada. 00:37:09
Dice, a ver, 00:37:10
estás llamando 00:37:11
al constructor 00:37:12
que no recibe nada. 00:37:13
¿Tengo algún constructor 00:37:14
que no reciba nada? 00:37:15
Sí, este. 00:37:16
Vale, pues llamo a este. 00:37:17
Ahora hago esta llamada. 00:37:18
Uy, estás llamando 00:37:19
a un constructor 00:37:20
que recibe un entero, 00:37:21
un string 00:37:23
y un objeto 00:37:24
porque nulo es un objeto. 00:37:25
¿Tengo yo algún 00:37:26
constructor que reciba eso? 00:37:27
Uy, pues sí. 00:37:29
Tengo este que recibe 00:37:30
un entero, 00:37:31
una cadena 00:37:33
y un array 00:37:34
que es un objeto. 00:37:35
Pues me encaja. 00:37:36
Vale, pues me encaja. 00:37:37
Que yo trato 00:37:39
de crear un objeto 00:37:40
pasándole 00:37:41
por ejemplo 00:37:43
un entero 00:37:44
y una cadena. 00:37:47
Automáticamente 00:37:49
se pone rojo. 00:37:50
Me dice, a ver, 00:37:51
¿tengo yo algún constructor 00:37:52
que necesite 00:37:54
un entero 00:37:56
y un string? 00:37:57
Él se pone a mirar 00:37:59
en la lista y dice no 00:38:00
porque este no recibe nada. 00:38:01
Este un entero, 00:38:05
un string 00:38:06
y una cadena 00:38:07
y este solo un entero. 00:38:08
Luego no hay ninguno 00:38:09
que encaje con esto. 00:38:10
Luego dice, no, 00:38:11
esa llamada no la puedes hacer 00:38:12
porque no hay ningún 00:38:13
método constructor 00:38:14
que me encaje con esto. 00:38:15
Que me da mi la gana 00:38:17
hacerlo 00:38:18
porque yo quiero 00:38:19
un constructor 00:38:20
que reciba solamente 00:38:21
el código 00:38:22
y la descripción. 00:38:24
Que me da mi la gana 00:38:36
hacer un 00:38:37
así, 00:38:39
así, 00:38:40
este. 00:38:41
Ala, 00:38:43
ya tengo otro constructor 00:38:44
que se distingue 00:38:45
de los demás 00:38:46
porque recibe una lista 00:38:47
de parámetros distinta. 00:38:48
Ah, pues entonces 00:38:49
ahora ya sí que se me ha 00:38:50
quitado este error. 00:38:51
Este. 00:38:52
Porque ahora ya 00:38:53
la máquina virtual 00:38:54
ya ha encontrado 00:38:55
que hay un constructor 00:38:56
que espera 00:38:57
un entero y un string. 00:38:58
Ya lo ha encontrado. 00:38:59
Entonces ya me quita 00:39:00
este error. 00:39:01
¿Vale? 00:39:02
Bueno, 00:39:04
pues esto de poner 00:39:06
varios constructores 00:39:07
es lo que se llama 00:39:08
hacer sobrecarga 00:39:09
de constructores 00:39:10
que se puede hacer 00:39:18
en el resto de métodos. 00:39:19
Pero eso ya lo veremos. 00:39:20
Tenemos cuatro constructores 00:39:21
que se distinguen 00:39:26
por 00:39:29
la lista de parámetros. 00:39:30
Y esto es lo que se llama 00:39:35
hacer sobrecarga 00:39:36
de constructores. 00:39:37
¿Vale? 00:39:45
Bueno, pues los constructores 00:39:46
siempre aparecen 00:39:47
de una clase 00:39:48
porque cuando uno 00:39:49
crea un objeto 00:39:50
quiere ya darle valores. 00:39:51
Y es que hay veces 00:39:54
que es que incluso 00:39:55
se los tiene que dar así. 00:39:56
Porque esto que yo he hecho 00:39:57
tan alegremente 00:39:58
de acceder 00:39:59
con 00:40:00
pedido gomas 00:40:01
punto código 00:40:02
pedido gomas 00:40:03
pues no se suele hacer así. 00:40:04
¿Vale? 00:40:05
Porque las propiedades 00:40:06
suelen ser privadas 00:40:07
hay paquetes, etcétera 00:40:08
que ya veremos a la vuelta. 00:40:09
Entonces no se suele hacer así 00:40:11
porque me habrán puesto 00:40:12
un privado y no podré. 00:40:13
Pero eso ya lo 00:40:14
veremos después. 00:40:15
¿Vale? 00:40:16
Vale, pues nada. 00:40:21
¿Alguna duda 00:40:23
sobre constructores 00:40:24
para lo que valen? 00:40:25
Bueno, 00:40:30
pues no nos da tiempo 00:40:31
a nada de 00:40:32
de bueno 00:40:36
a ver 00:40:37
en dos minutos 00:40:39
algo rápido 00:40:40
para que dejarlo ahí 00:40:41
planteado 00:40:42
por si luego podéis 00:40:43
con los ejercicios 00:40:44
practicarlo 00:40:45
y todo eso. 00:40:46
A ver. 00:40:48
Vale, pues 00:40:52
sobre clases 00:40:53
un poquito más 00:40:54
que no digo nada nuevo 00:40:55
simplemente generalizo. 00:40:56
Vale, vamos a imaginar 00:40:59
de esta aplicación 00:41:00
la vamos a ampliar. 00:41:01
Esta aplicación 00:41:03
era para gestionar 00:41:04
pedidos y clientes. 00:41:05
Vamos a ampliarla un poco. 00:41:07
Entonces para ampliarla 00:41:09
lo primero que se nos ocurre es 00:41:11
oye, pues vamos a 00:41:12
trabajar también 00:41:14
con clientes, ¿no? 00:41:15
Pues hombre, le pegaría 00:41:16
tener también 00:41:17
una clase cliente 00:41:18
que tenga las propiedades 00:41:19
de los clientes. 00:41:20
Porque 00:41:22
uno diría 00:41:23
vamos a ver 00:41:24
de mi cliente 00:41:25
me basta con el nombre 00:41:26
porque si me basta 00:41:27
con el nombre 00:41:28
no me hace falta 00:41:29
una clase cliente 00:41:30
porque 00:41:31
string 00:41:32
sirve para guardar un nombre 00:41:33
y entonces 00:41:34
con una propiedad string 00:41:35
me valdría para el cliente, ¿no? 00:41:36
Una propiedad string 00:41:37
me valdría 00:41:38
porque tiene su nombre. 00:41:39
Pero normal 00:41:40
es que los objetos 00:41:41
de mi aplicación 00:41:42
necesiten más cosas 00:41:43
para caracterizarse. 00:41:44
Entonces uno después 00:41:46
de analizar su aplicación 00:41:47
decide 00:41:48
que nombre no 00:41:49
de los clientes 00:41:50
le interesa 00:41:51
su DNI 00:41:52
su dirección 00:41:53
su teléfono 00:41:54
hombre, le interesan 00:41:55
varias cosas. 00:41:56
Pues entonces 00:41:57
tiene que haber una clase. 00:41:58
¿Vale? 00:41:59
Tres minutos 00:42:00
y nos vamos 00:42:01
o nos quedamos 00:42:02
¿Vale? 00:42:03
Entonces 00:42:04
vamos a hacer 00:42:05
una clase cliente. 00:42:06
A ver 00:42:09
lo que he dicho 00:42:10
al principio de la clase 00:42:11
que no me habéis hecho 00:42:12
ni caso 00:42:13
es que yo tengo 00:42:14
lectura de proyectos 00:42:15
ahora hasta las dos y media. 00:42:16
Entonces 00:42:17
os podéis quedar 00:42:18
aquí 00:42:19
haciendo ejercicios 00:42:20
de esto 00:42:21
si os vais a casa 00:42:24
pues no pasa nada. 00:42:25
No vais a casa. 00:42:26
¿Vale? 00:42:27
Espera 00:42:31
déjame que termine esto 00:42:32
¿Vale? 00:42:33
Y seguidme haciendo caso 00:42:34
bueno, si es que me lo 00:42:35
estabais haciendo. 00:42:36
Venga 00:42:38
cinco minutos 00:42:40
A ver 00:42:44
¿De qué te ríes? 00:42:45
Compártelo con nosotros 00:42:46
¿Por qué no? 00:42:48
¿De qué tienes miedo? 00:42:49
Pero igual a mí 00:42:51
sí me interesa. 00:42:52
¿Eh? 00:42:57
Bueno, vale. 00:42:59
Silencio 00:43:02
Bueno, vamos a seguir 00:43:04
ampliando nuestra aplicación. 00:43:05
Si nuestra aplicación 00:43:06
va a trabajar con pedidos 00:43:07
y va a trabajar con clientes 00:43:08
y los clientes 00:43:10
se quieren caracterizar 00:43:11
por diferentes cosas 00:43:12
una clase cliente 00:43:13
va a ser imprescindible. 00:43:14
¿Verdad que sí? 00:43:16
¿Vosotros dos? 00:43:17
Vamos a hacer 00:43:18
una clase cliente más 00:43:19
y la seguimos ampliando. 00:43:20
Venga 00:43:23
clase cliente 00:43:24
Vale 00:43:30
Venga 00:43:32
pues la clase cliente 00:43:33
Ahora 00:43:35
habría que plantearse 00:43:36
¿Por qué queremos 00:43:37
que se caracterice el cliente? 00:43:38
Venga 00:43:39
pues vamos a decirle 00:43:40
que se caracterice 00:43:41
por su DNI 00:43:43
su nombre 00:43:44
y por ejemplo 00:43:46
cada cliente 00:43:48
puede haber hecho 00:43:49
un pedido 00:43:50
y solo uno. 00:43:51
Silencio 00:43:52
¿Vale? 00:43:53
Entonces 00:43:55
después de analizar 00:43:57
nuestra aplicación 00:43:58
porque todo esto 00:43:59
se hace mucho antes 00:44:00
de ponerse a teclear 00:44:01
hemos visto que 00:44:02
vale 00:44:03
cada cliente 00:44:04
puede tener un solo pedido 00:44:05
y cada cliente 00:44:06
se caracteriza 00:44:07
por el pedido 00:44:08
que le ha hecho 00:44:09
solo uno. 00:44:10
Igual que se caracteriza 00:44:11
por su NIF 00:44:12
por su nombre 00:44:13
también se caracteriza 00:44:14
por el pedido 00:44:15
que ha hecho. 00:44:16
Luego la pregunta sería 00:44:17
vale 00:44:18
pues el pedido 00:44:19
que ha hecho 00:44:20
es una propiedad suya 00:44:21
igual que lo es 00:44:22
su NIF 00:44:23
y su nombre 00:44:24
el pedido 00:44:25
que ha hecho 00:44:26
también es una propiedad suya. 00:44:27
Bueno pues nos falta 00:44:28
esa tercera propiedad 00:44:29
¿Eh? 00:44:31
No, es un solo pedido 00:44:35
el que va a tener el cliente. 00:44:36
El cliente se caracteriza 00:44:38
por su NIF 00:44:39
su nombre 00:44:40
y el pedido 00:44:41
que ha hecho. 00:44:42
Recordad que tenemos 00:44:43
una clase pedido 00:44:44
que a su vez 00:44:45
tiene dentro 00:44:46
las propiedades del pedido. 00:44:47
Vale, pues esas tres propiedades 00:44:48
NIF 00:44:49
que es string 00:44:50
nombre que es string 00:44:51
y pedido 00:44:52
llamémosle a pedido 00:44:53
esa otra propiedad 00:44:54
esa otra propiedad 00:44:56
de qué tipo 00:44:58
veis que tendría sentido 00:45:00
que fuera 00:45:01
de tipo 00:45:05
objeto 00:45:07
¿Qué tipo de objeto? 00:45:08
Efectivamente 00:45:10
vale 00:45:11
entonces esta propiedad 00:45:12
sería 00:45:14
de este tipo 00:45:15
porque 00:45:17
recordad 00:45:18
que ahora ya 00:45:19
nuestras variables 00:45:20
pueden ser 00:45:21
de tipo primitivo 00:45:22
o también de tipo objeto 00:45:23
en nuestro main 00:45:25
de antes 00:45:26
en nuestro main 00:45:27
hemos declarado ya 00:45:29
propiedades 00:45:30
que son de tipo objeto 00:45:31
y hemos trabajado 00:45:32
con ellas 00:45:33
¿verdad? 00:45:34
Pues perfectamente 00:45:36
dentro de cliente 00:45:37
puede haber una propiedad 00:45:38
que sea tipo objeto pedido 00:45:39
y dentro de esta propiedad 00:45:42
a su vez 00:45:43
estará el código 00:45:44
etcétera 00:45:45
¿vale? 00:45:47
Entonces por ejemplo 00:45:51
y ya nos vamos 00:45:52
imaginaos que vamos 00:45:55
a hacerle un método 00:45:56
que es 00:45:57
mostrar 00:45:58
descripción 00:45:59
del pedido 00:46:00
del cliente 00:46:01
bueno 00:46:05
devolver descripción 00:46:06
más que mostrar 00:46:07
devolver descripción 00:46:14
del pedido que ha hecho el cliente 00:46:15
primera pregunta 00:46:16
¿qué os hago? 00:46:17
¿Necesita algún parámetro 00:46:18
de entrada 00:46:19
a este método? 00:46:20
Alejandro 00:46:23
de descripción 00:46:28
o sea 00:46:31
devolver descripción 00:46:32
del pedido que ha hecho 00:46:33
y que es una propiedad suya 00:46:34
que está ahí 00:46:35
entonces 00:46:36
¿necesita que yo le pase 00:46:37
alguna información 00:46:38
desde fuera 00:46:39
para acceder 00:46:40
a la información 00:46:41
de su pedido? 00:46:42
bueno ahora mismo 00:46:45
voy a traer el constructor 00:46:46
este objeto tiene 00:46:47
su propiedad pedido 00:46:48
en if y nombre 00:46:49
dentro de 00:46:50
ahora 00:46:51
para 00:46:52
devolverme 00:46:53
hacer un return 00:46:54
mostrarlo 00:46:55
su propiedad 00:46:57
pedido 00:46:58
¿necesita que yo le pase 00:46:59
algo de fuera? 00:47:00
a ver hago la pregunta 00:47:07
otra vez 00:47:08
imagínate que este método 00:47:09
te digo 00:47:10
mostrar 00:47:11
el nif 00:47:12
del cliente 00:47:13
que llama este método 00:47:14
¿qué haría este método? 00:47:15
¿qué pondría yo ahí? 00:47:19
si tuviera que 00:47:21
mostrar la descripción 00:47:22
perdón mostrarle el nif 00:47:23
¿le habríamos pasado 00:47:26
algo desde fuera? 00:47:27
no porque no le hace falta 00:47:28
el nif ya es una propiedad 00:47:29
del objeto 00:47:30
recordad que los métodos 00:47:31
tienen 00:47:32
acceso directamente 00:47:33
a las propiedades 00:47:34
del objeto 00:47:35
es lo que explicamos 00:47:36
ayer a última hora 00:47:37
cuando corregimos 00:47:39
el ejercicio 00:47:40
y lo hicimos todo 00:47:41
bueno lo que volvimos 00:47:42
a explicar otra vez 00:47:43
que un método 00:47:44
accede directamente 00:47:45
a las propiedades 00:47:46
del objeto 00:47:47
que lo llama 00:47:48
y la información 00:47:49
externa 00:47:50
si le hace falta 00:47:51
entonces el objeto cliente 00:47:52
cuando llame a este método 00:47:53
ese objeto cliente 00:47:54
ya tiene su pedido dentro 00:47:56
pero es que está dentro 00:48:03
entonces 00:48:04
imagina 00:48:05
para devolver descripción 00:48:06
de pedido 00:48:07
retún 00:48:09
pedido 00:48:11
punto 00:48:12
descripción 00:48:14
y ya estaría 00:48:20
es decir 00:48:21
pedido es una propiedad 00:48:22
que como es objeto 00:48:23
dentro de ella 00:48:24
tiene código 00:48:25
de descripción 00:48:26
y array de clientes 00:48:27
dentro de ella 00:48:28
todas metidas dentro 00:48:29
dentro las tiene todas 00:48:30
entonces yo puedo 00:48:32
acceder a ella 00:48:33
como se acceden 00:48:34
a las propiedades 00:48:35
de los objetos 00:48:36
con el punto 00:48:37
vale 00:48:38
entonces 00:48:39
no estoy diciendo 00:48:40
nada nuevo 00:48:41
lo que digo 00:48:42
es que las propiedades 00:48:43
objeto 00:48:44
pueden estar dentro 00:48:45
de otros objetos 00:48:46
también 00:48:47
vale 00:48:48
o sea un objeto 00:48:49
puede tener una propiedad 00:48:50
que a su vez es un objeto 00:48:51
y no pasa nada 00:48:52
pues tengo otra propiedad 00:48:53
dentro que a su vez 00:48:54
es un objeto 00:48:55
y yo puedo acceder 00:48:56
a las propiedades 00:48:57
con el punto 00:48:58
sin ningún problema 00:48:59
entonces 00:49:00
este método 00:49:01
devolvería la descripción 00:49:02
del objeto pedido 00:49:03
como haría 00:49:05
un constructor 00:49:06
de este método 00:49:07
por ejemplo 00:49:08
pues vamos a crearlo 00:49:09
automáticamente 00:49:10
pues mira 00:49:15
me ha creado automáticamente 00:49:16
este superloquito 00:49:17
y este publicloquito 00:49:18
que no me interesan 00:49:19
pues mira 00:49:20
le di 00:49:21
le pasa directamente 00:49:22
un if 00:49:23
un nombre 00:49:24
y un objeto enterito 00:49:25
un objeto enterito 00:49:26
y ese objeto 00:49:27
lo usa para inicializar 00:49:28
el objeto pedido 00:49:29
me da igual 00:49:30
que la propiedad 00:49:31
sea objeto 00:49:32
sea primitiva 00:49:33
pueden ser 00:49:36
propiedades 00:49:37
de la clase 00:49:38
perfectamente 00:49:39
con la salvedad 00:49:40
de que yo aquí 00:49:41
de esta variable 00:49:42
accederé a los campos 00:49:43
claro 00:49:44
accederé a lo que 00:49:45
me interese a mí 00:49:46
accederé a lo que 00:49:47
me interese 00:49:48
vale 00:49:49
bueno y ahora sí 00:49:50
para matar 00:49:51
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
5
Fecha:
22 de diciembre de 2023 - 9:28
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
951.16 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid