Saltar navegación

20241202 - 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 2 de diciembre de 2024 por Stefano C.

15 visualizaciones

Más información Transcripción

Descargar la transcripción

Entonces, vamos a grabar la siguiente parte, si habláis o preguntáis algo me dais la autorización a grabaros, ¿vale? 00:00:00
Entonces, nosotros hasta la última vez hemos estado viendo un poquito la diferencia entre objeto y clase, hemos estado viendo los constructores, cómo se crea un objeto, etc. 00:00:09
Hemos llegado hasta esto, donde hemos visto que sustancialmente podemos crear constructores con distintos números o distintos orden de parámetros y por lo tanto lo que se puede hacer es sobrecargar un constructor. 00:00:22
También los métodos se pueden sobrecargar 00:00:41
La sobrecarga de métodos es que en la misma clase pueden haber varios métodos que se llaman con el mismo nombre 00:00:45
Se llaman iguales, pero difieren en el número o en el tipo de parámetros que reciben 00:00:52
Nunca puede haber métodos que tengan el mismo nombre con la misma secuencia de tipos de parámetros 00:00:59
Eso no se puede hacer, se enfada 00:01:09
¿Qué queréis? Hacemos un ejemplo 00:01:11
Por ejemplo, yo puedo crear el método escribe que recibe un string 00:01:13
Y lo que hace es escribir un string 00:01:18
El método escribe que recibe un num 00:01:20
Y lo que hace es escribir un num 00:01:23
Y el método escribe que recibe un string, una i 00:01:24
Y hace esta combinación de aquí, por ejemplo 00:01:29
El método es siempre el método escribe 00:01:31
Pero el programa sabe en cualquier momento 00:01:34
Cuál de los tres tiene que utilizar 00:01:38
En base al tipo de datos que se le pasa 00:01:40
Si yo llamo escribe de 5 00:01:44
Estará llamando este método de aquí 00:01:46
Y me imprimirá 5 en pantalla 00:01:47
Si yo llamo escribe de gato,7 00:01:49
Pues me escribirá gato un espacio 7 00:01:53
¿Vale? 00:01:57
Tened en cuenta también que normalmente 00:01:59
Si se llaman iguales 00:02:02
Los métodos hacen lo mismo 00:02:04
cuando vosotros habéis visto 00:02:07
el mismo método 00:02:10
println 00:02:13
si lo vamos a ver está sobrecargado 00:02:15
puede escribir un número 00:02:19
puede escribir un string 00:02:20
puede escribir un boolean 00:02:22
puede escribir un float 00:02:23
nosotros lo buscamos 00:02:24
ap java 00:02:28
esto es println 00:02:31
es un 00:02:34
printreader 00:02:35
Si vamos al objeto printWriter 00:02:38
Que es el que me permite escribir 00:02:41
Y vamos a buscar println 00:02:43
Veis que println 00:02:46
Hay un println a secas 00:02:48
Un println para booleano 00:02:51
Un println para char 00:02:52
Un println para redachar 00:02:54
Un println para double 00:02:55
Un println para long 00:02:57
Hacen todo lo mismo 00:02:58
Pero 00:03:02
Pillan un parámetro distinto 00:03:04
Entonces el método println dentro de la clase printwriter que es esta de aquí 00:03:07
Está sobrecargado 00:03:13
¿Entiendes? 00:03:15
¿Dudas? 00:03:17
Vale 00:03:19
Al llamar el método escribe dependiendo de cuantos parámetros uso 00:03:19
Y el tipo de los parámetros que tengo pues aplicaré una implementación u otra 00:03:26
Es decir que será la Jartel Machine o quien por él o el compilador o lo que sea 00:03:30
que cuando tú llamas Escribe con un determinado parámetro, sabrá cuál de estos tres es el que de verdad estás llamando. 00:03:37
Y si ahora llamo Escribe entre paréntesis y pongo True, ¿qué pasa? 00:03:46
Se enfada. Me lo marca el ojo diciendo, no existe un método Escribe que pille un Boolean como parámetro. 00:03:56
Por lo tanto, no sé qué tengo que hacer. No existe este método. 00:04:05
Debería crear un nuevo 00:04:08
Escribe boolean b 00:04:10
Que lo que haga es system.8.2.1.n 00:04:11
De b 00:04:14
Ya está 00:04:14
Vale 00:04:15
Otro tema muy importante 00:04:19
Muy muy importante 00:04:22
Es el concepto de these 00:04:23
Vale 00:04:26
Vamos a pillar un ejemplo 00:04:27
¿Se acuerdan si este era el coche 00:04:29
Que hemos utilizado el otro día? 00:04:32
Ahora, yo aquí dentro 00:04:34
Estoy utilizando 00:04:36
Un constructor 00:04:37
Estoy utilizando varios métodos 00:04:39
Y cosas por el estilo 00:04:42
Esto es una clase 00:04:43
Hay un objeto aquí 00:04:46
En el método main, sí 00:04:48
Pero cuando yo defino la clase 00:04:55
O se quito el método main 00:04:57
Hay un objeto 00:04:58
Hay una definición de un objeto 00:04:59
Hay un molde para objetos 00:05:04
Pero un objeto como tal no existe 00:05:06
No existirá hasta que en un main 00:05:08
Yo haga un new 00:05:12
¿Queda claro? 00:05:13
O sea, existe el objeto como descripción en general, como clase, pero no existe una instancia de esa clase hasta que no cree la instancia de esa clase. 00:05:14
Y si yo aquí dentro, por alguna razón, quisiera hacer referencia al objeto construido. 00:05:26
O sea, yo aquí quiero hacer algo para decir, oye, mira, a este punto pilla el objeto que eres tú, 00:05:36
Porque este cambiamatricula lo han llamado sobre un objeto 00:05:41
Y si yo quiero hacer referencia desde aquí dentro a este objeto sobre el que le han llamado 00:05:47
Aquí llamaban sobre C1 00:05:52
Aquí dice C1.descríbete 00:05:55
Si yo ahora dentro de escribete aquí en este código de aquí 00:05:57
Quisiera hacer referencia a este objeto C1 00:06:01
¿Cómo podría hacerlo? 00:06:05
Pero no existe 00:06:07
Porque yo esto lo quito ahora 00:06:14
¿Esto? Vale 00:06:16
Ahora, yo sé que alguno me llamará 00:06:20
¿Sí? 00:06:23
Pero ¿cómo puedo saber yo? 00:06:26
¿Cómo puedo hacer referencia a mí mismo? 00:06:28
¿Al objeto? 00:06:31
Porque descríbete será llamado sobre un objeto en un cierto momento 00:06:33
Entonces, si yo llegara allí 00:06:36
Este objeto existe, porque si no, no podría ser llamado descríbete 00:06:37
¿Cómo hago referencia al objeto sobre el que se ha llamado desde dentro de la clase? 00:06:40
Donde estoy pensando de forma genérica 00:06:45
Todavía no lo he creado 00:06:48
No puedo poner C1 aquí 00:06:49
C1 no existe 00:06:51
¿Entendéis cuál es el problema? 00:06:52
Pero esa es la clase, no es un objeto 00:06:57
Entonces todos se llaman igual 00:06:58
Con la palabra mágica 00:07:00
This 00:07:06
Cuando tú usas this 00:07:06
Estás diciendo este objeto 00:07:10
¿Cuál? 00:07:12
El objeto sobre el que la has llamado 00:07:14
Si yo 00:07:16
Llamaré C1 00:07:18
descríbete y aquí dentro uso this, será el c1. Si yo ahora uso c2.descríbete, this 00:07:23
se referirá a este c2, al objeto sobre el que se ha llamado. ¿Para qué sirve esto? 00:07:32
Mira, el primer uso sirve, ¿vale? Os daréis cuenta en el futuro. Pero el primer uso básico 00:07:42
que se hace, es que tú tienes 00:07:49
aquí string matrícula 00:07:51
string modelo, string velocidad 00:07:54
máxima, ¿os acordáis? y el 00:07:55
constructor, nosotros habíamos 00:07:57
utilizado ma, mo, vean 00:07:59
¿si? porque ma es la matrícula 00:08:01
mo es el modelo, ahora cuando tú 00:08:05
vas a ver el código 00:08:07
¿vale? vas a ver la 00:08:09
la ayuda 00:08:11
de este 00:08:13
magnífica clase coche que has hecho 00:08:14
y te dicen, oye mira 00:08:17
Para construir un coche tienes que dar 00:08:18
MAMOVEAN 00:08:20
¿Tú sabes qué es MAMOVEAN? 00:08:21
Imagínate que 00:08:26
Sacamos sólo esto 00:08:27
Y te dicen, oye mira, para crear un coche 00:08:31
Esto es como tienes que hacer 00:08:44
Tienes que hacer un new 00:08:46
Y luego le pones MAMOVEAN 00:08:47
¿Está claro? 00:08:49
¿De qué se está pidiendo? 00:08:53
No, sería mucho más claro 00:08:54
Si esto 00:08:56
Fose matrícula 00:08:58
matrícula, esto fuese modelo, esto fuese velocidad máxima y esto fuera año fabricación. 00:09:00
¿A qué hora? Ya es más fácil. 00:09:13
Pero ¿cuál es el problema? 00:09:18
Que si yo he usado matrícula aquí y ahora le pongo matrícula aquí, 00:09:19
él se lía, porque para él dentro de este bloque matrícula es esta. 00:09:28
Entonces, le tengo que decir, oye, matrícula esta, o modelo, o velocidad máxima, o año de fabricación 00:09:33
No es este de aquí, pero yo quiero que este, que sería este, esto es correcto, lo quiero poner aquí dentro 00:09:56
¿Queda claro? ¿Queda claro esto? ¿Cuál es el problema? 00:10:05
Entonces, ¿cómo puedo diferenciar esta matrícula de esta matrícula? 00:10:13
Pon esta matrícula y ponla dentro de este objeto su atributo matrícula. 00:10:27
¿Se entiende? 00:10:40
Esto es sutil. 00:10:42
Pero será siempre este objeto, el objeto sobre el que tú lo llamas. 00:10:51
Aquí en un cierto sentido lo estás construyendo. 00:10:56
Entonces tú tienes unos parámetros que te han dado desde fuera 00:10:59
Y un objeto que estás construyendo 00:11:02
Y tú dices, pilla la variable matrícula 00:11:04
Que me has dado como parámetro 00:11:08
Y lo guardas en accede a este objeto 00:11:09
Al objeto que estoy creando 00:11:12
En su campo matrícula 00:11:13
Y allí dentro es donde pones el valor 00:11:16
Entonces para hacer esto 00:11:18
Dis.model es igual a modelo 00:11:21
Si velocidad máxima esta de aquí es mayor o igual a cero 00:11:24
Pues entonces guarda this.velocidadMáxima es igual a velocidadMáxima 00:11:30
this.velocidadMáxima es igual a 1 si no 00:11:35
Y this.añoFabricación es igual a año 00:11:38
¿Sí? 00:11:44
Cuando no hay ambigüedad 00:11:47
Porque aquí no hay ambigüedad 00:11:49
Si yo uso modelo, él mirará directamente este de aquí 00:11:51
Pero en realidad esto no sería modelo 00:11:56
Esto sería 00:12:00
Dis.model 00:12:01
Es implícito 00:12:02
Y cuando no hay problemas de 00:12:07
Choque de variables 00:12:10
Que se llaman de la misma forma 00:12:13
Pues esto, él lo entiende directamente 00:12:15
¿Veis que me lo pone en azul? 00:12:17
Está entendiendo que es este 00:12:19
Azul 00:12:20
Pero si yo aquí, por alguna razón 00:12:21
Pusiera string 00:12:25
Modelo 00:12:27
Pues entonces ahora ya él se lía 00:12:28
Él dice, vale, si tú me has dado modelo este aquí 00:12:31
Pues este de aquí tiene que ser este 00:12:33
Y si yo quiero hacer referencia 00:12:35
Al de este objeto 00:12:37
¿Sí? 00:12:39
Ahora, esto del dis 00:12:46
Esta es la forma más básica que se puede utilizar 00:12:47
Dis, ¿vale? 00:12:50
En realidad luego se puede hacer 00:12:51
Cosas interesantes, ¿vale? 00:12:54
Imaginados un método que al final 00:12:56
Tengo public 00:12:58
Método 00:13:00
Mi método, que se yo, no se que hace 00:13:02
Y yo quiero que al final 00:13:04
De lo que haga aquí 00:13:06
No sé qué hace 00:13:08
Yo quiero devolver 00:13:10
Este objeto 00:13:12
Que el resultado de esto 00:13:15
Es devolver el objeto mismo 00:13:17
El objeto sobre el que he sido llamado 00:13:19
Pues devolvería un coche 00:13:20
Y sería un 00:13:24
Return this 00:13:27
Entonces este es un concepto que ya empieza 00:13:29
A dar un saltito más en adelante 00:13:39
En el 00:13:41
mundo de la 00:13:42
orientación a objetos 00:13:44
es un poquito retorcido 00:13:46
y hay que trabajar 00:13:48
un poquito sobre ello para entenderlo 00:13:50
¿vale? ahora que habéis visto la primera vez 00:13:53
aparecerá alguna vez 00:13:54
en esta vida, habrá algunos momentos 00:13:57
de vuestra vida en que diréis, oye mira yo tengo 00:13:59
que programar algo aquí, tengo que hacer referencia 00:14:01
a este objeto 00:14:03
pero no sé cómo llamarlo este objeto 00:14:04
no sé cómo hacerlo 00:14:07
pues entonces, this 00:14:08
¿sí? 00:14:10
Diga, a este objeto. 00:14:12
Cuando tú estás dentro de este método, ¿sobre qué objeto lo estás llamando? 00:14:22
Aquí, yo estoy aquí. 00:14:28
¿Sobre qué objeto lo estoy llamando? 00:14:31
No, frenar no es un objeto, es un método. 00:14:34
Sobre un objeto abstracto de tipo coche, porque todos los coches del mundo pueden frenar, según tu definición, 00:14:40
pero aquí no tienes un objeto 00:14:49
porque el objeto se creará en fase de main 00:14:52
donde tú crearás un objeto 00:14:56
y llamarás frenar sobre ese objeto 00:14:58
c1.frenar 00:15:00
entonces ahora el objeto sobre el que lo estás llamando es c1 00:15:02
pero desde aquí, desde fuera 00:15:06
desde donde estás llamando 00:15:08
desde donde estás utilizando 00:15:10
tú sabes que frenar lo has llamado sobre c1 00:15:11
pero cuando estás aquí dentro 00:15:14
No tienes una referencia a C1 00:15:17
Entonces tienes un puntero a ti mismo 00:15:19
No es un objeto 00:15:23
Es una referencia al objeto en el que estás 00:15:29
Si frenar lo llamas sobre C1 00:15:33
Este dice se referirá a C1 00:15:35
Si lo llamas sobre C2 00:15:37
Se referirá a C2 00:15:39
Y si lo llamas sobre gato 00:15:41
Pues estará refiriendo al gato 00:15:42
Es un comodín para decir el propio 00:15:44
Es que aquí tienes otro tipo de problema 00:15:48
Tienes una variable local 00:16:02
Que se llama modelo 00:16:05
Y otra variable que se llama modelo 00:16:06
Que pero es una parte 00:16:09
De la estructura de tu coche 00:16:10
Todos los coches tienen un modelo 00:16:13
Y tienes que poder diferenciar 00:16:14
Esta de esta 00:16:16
Si tú aquí dentro usas solo modelo 00:16:18
Él hace referencia 00:16:21
A este modelo de aquí 00:16:23
¿Vale? 00:16:24
Si tú quieres hacer referencia a esto 00:16:26
Es como si desde aquí 00:16:28
Tú accedieras 00:16:30
A c1.modelo 00:16:32
Porque aquí tú tienes 00:16:36
Y esto lo pones en string 00:16:40
String s 00:16:42
Es igual 00:16:44
Porque tú aquí tienes una referencia c1 00:16:45
Entonces la puedes utilizar 00:16:48
Y decir quiero el modelo 00:16:50
Pero de que objeto 00:16:51
Del objeto c1 00:16:53
Pero cuando tú estás dentro 00:16:54
de la propia definición de los métodos 00:16:56
tú no tienes 00:17:00
o puede poner C1 00:17:01
porque C1 no es nada 00:17:03
entonces necesitas 00:17:05
una palabra comodín 00:17:07
que te diga, oye, sea cual sea 00:17:09
este objeto, tú vete a 00:17:11
este objeto a su parte modelo 00:17:13
este objeto 00:17:15
¿cuál objeto? el objeto sobre el que 00:17:19
se ha llamado este constructor 00:17:21
el objeto que se está construyendo en este caso 00:17:22
o en este caso aquí, si yo pongo 00:17:25
esto 00:17:27
está diciendo, el modelo 00:17:27
sobre el que, el coche 00:17:31
sobre el que se ha llamado frenar 00:17:33
pues esta es una 00:17:35
referencia a ese objeto 00:17:37
si tú lo llamas sobre C1, esto se referirá 00:17:38
a C1, si tú lo llamas sobre C7 00:17:41
se referirá a Cristiano Ronaldo 00:17:43
porque 00:17:45
cuando, esto para 00:18:06
no entiendo tu pregunta 00:18:07
en general que es un constructor, me estás preguntando 00:18:09
para crear 00:18:11
un objeto, se puede crear 00:18:14
pero está vacío 00:18:17
si yo tengo un coche 00:18:18
vamos a eliminar 00:18:23
esto, vamos a hacer una copia 00:18:28
están objetos 00:18:30
vamos a copiar esto 00:18:36
creamos coche 2 00:18:40
y vamos a trabajar sobre coche 2 00:18:43
¿vale? entonces 00:18:45
imaginémonos que yo 00:18:51
me cargo este 00:18:54
constructor de aquí, ¿vale? fuera 00:18:55
ahora tengo un problema 00:18:58
Porque aquí yo creaba coches 00:18:59
Pero ahora no lo puedo crear 00:19:02
El coche 00:19:05
La única cosa que puedo hacer es crear 00:19:06
Un coche 00:19:08
Un coche 2 00:19:10
Pero este coche 2 00:19:12
No tiene nada 00:19:14
Si ahora yo lanzo 00:19:17
¿Lo que hace? 00:19:19
Explota 00:19:24
Vamos a ver porque tengo otro 00:19:24
Tengo otro por aquí 00:19:27
¿Dónde está? 00:19:30
Aquí 00:19:31
le quito todo esto 00:19:32
ya está, he creado un coche 00:19:34
sí, un coche de tipo coche 2 00:19:37
sí, lo he creado 00:19:39
¿vale? aquí lo que he hecho 00:19:41
para que no estaba, es simplemente 00:19:43
he quitado el constructor 00:19:45
ahora no hay constructor en esta clase 00:19:46
¿vale? entonces yo 00:19:49
si no hay constructores 00:19:51
puedo crear un constructor vacío 00:19:52
pero ahora lo lanzo 00:19:55
a feria internacional 00:19:58
del null 00:20:02
Porque todo está 00:20:02
¿Cómo se dice? 00:20:07
Inicializado 00:20:12
A su valor por defecto 00:20:12
Porque en ningún momento 00:20:15
Ha habido un constructor 00:20:17
Que ha metido lo que tenía que meter 00:20:18
En la cosa, puedo crear coches 00:20:20
De modelo nul 00:20:22
¿Cómo es eso? 00:20:24
De matrícula nul, modelo nul 00:20:26
Velocidad máxima cero y año de fabricación cero 00:20:28
De hecho, todos los estoy construyendo así 00:20:30
Y luego debería 00:20:33
Aquí 00:20:35
Acceder a cada campo 00:20:37
C1.matricula 00:20:40
Es igual a mat01 00:20:45
C1. 00:20:49
¿Qué es esto? 00:20:55
Modelo 00:20:57
No lo sé 00:20:58
Me sale solo me can 00:21:02
Y ahora, cuando lo lanzo, cuando escribe el C1, sí que es un megane y sigue teniendo su matrícula. 00:21:06
Pero es mucho más incómodo. 00:21:19
Es más, yo podría querer que estos datos de aquí no sean accesibles. 00:21:22
Porque si yo permito a estos datos de ser accesibles, la gente puede hacer lo que le da la gana con esto de aquí. 00:21:31
Puede mañana llegar y decir ahora mi matrícula es otra 00:21:37
Ahora mi modelo cambia 00:21:41
Ahora mi velocidad máxima ha cambiado 00:21:43
Y si yo los protejo, pues entonces ya esto no lo puedes hacer 00:21:45
Entonces, lo que se hace es decir, vale 00:21:50
Voy a crearme métodos especiales que me construyen coches 00:21:55
En base a los parámetros que le paso 00:22:01
Y entonces 00:22:03
Hacemos esto 00:22:06
Este aquí te dice 00:22:09
Este es un método para construir coches 00:22:12
Que requiere cuatro parámetros 00:22:14
Y una vez que me dan los parámetros 00:22:17
Yo los guardo 00:22:20
De golpe 00:22:21
En sus propios atributos 00:22:22
Y cuidado 00:22:24
Yo puedo hacer también 00:22:25
Algún tipo de 00:22:27
Control 00:22:28
Yo puedo decir que si 00:22:29
La velocidad máxima que me has puesto aquí 00:22:30
No es 00:22:32
No me gusta 00:22:33
Pues entonces pongo una velocidad máxima por defecto 00:22:34
O algo por el estilo 00:22:38
Pero puedes hacer control sobre lo que te da aquí 00:22:39
La matrícula no puede ser la que te da la gana 00:22:41
La matrícula tiene que ser con un determinado código, algoritmo 00:22:43
Que te da la matrícula para decir si es buena o no 00:22:47
Pues yo puedo hacer que cuando tú me pasas una matrícula 00:22:49
Aquí haga las comprobaciones necesarias 00:22:51
Para ver si es una matrícula efectivamente buena 00:22:53
Si es buena, creo el objeto 00:22:56
Si no es buena, no creo el objeto 00:22:58
¿Se entiende? 00:23:00
Más o menos 00:23:04
¿Dudas? 00:23:04
Vale 00:23:10
Nota, ya que estamos en esto 00:23:11
Yo aquí tengo 00:23:15
Un constructor 00:23:18
Vacío 00:23:20
¿Sí? 00:23:23
Esto se llama constructor por defecto 00:23:26
Cualquier clase que vosotros creáis 00:23:29
Por defecto 00:23:32
Tiene un constructor sin parámetros 00:23:34
que os permite crear 00:23:37
un objeto de esa clase 00:23:39
es el constructor por defecto 00:23:40
ahora 00:23:44
si yo creo un cualquier otro 00:23:46
constructor 00:23:48
public coche2 00:23:49
string 00:23:53
matricula 00:23:55
que lo que hace es 00:23:56
this.matricula 00:23:59
es igual a matricula 00:24:02
this.modelo 00:24:03
10.modelo es igual a, no sé, 10.velocidad máxima es igual a 0 y 10.añofabricación es igual a 0. 00:24:07
Este es un constructor que me permite dar solo la matrícula 00:24:27
Y lo que hace es poner la matrícula dentro 00:24:31
Y a todos los otros parámetros le da un parámetro básico 00:24:34
Un valor por defecto 00:24:39
En el momento en que creo un constructor 00:24:42
Pierdo el constructor por defecto 00:24:46
Ya no lo tengo 00:24:50
El constructor por defecto existe solo 00:24:51
Si no existen otros constructores 00:24:57
Queda claro hasta aquí 00:25:01
Si yo vuelvo a quitar esto 00:25:03
No hay constructores 00:25:08
Y por lo tanto él dice 00:25:12
Ah, muy bien, me vale 00:25:13
Usaré el constructor por defecto 00:25:15
Si yo pongo un constructor 00:25:18
Es porque le estoy diciendo 00:25:21
Oye, mira, no me crees objetos tú 00:25:23
Te estoy diciendo yo cómo se crean objetos 00:25:26
Se crean así 00:25:29
esta es la forma correcta de crear estos 00:25:30
objetos, por lo tanto él dice 00:25:32
ah vale, si te encargas tú 00:25:34
de decirme cómo se crean estos objetos 00:25:35
ya te quito 00:25:38
la forma por defecto que había 00:25:39
creado yo, ya no se puede hacer por 00:25:42
defecto, se hace como dices tú 00:25:44
porque tú sabrás que controles 00:25:45
o que cosas has hecho 00:25:48
aquí dentro y seguramente estás haciendo 00:25:50
un trabajo más concreto 00:25:52
y mejor con respecto al 00:25:54
mío que era general de 00:25:56
Tú no has hecho ningún constructor, te hago construir un objeto 00:25:57
Pero es un objeto vacío 00:26:00
Se entiende la diferencia 00:26:01
Porque imagínate que tú al momento 00:26:03
De crear un objeto 00:26:16
Sea cual sea 00:26:19
Todavía no sabes 00:26:19
Las características de ese objeto 00:26:21
Tú creas un coche 00:26:23
Pero tu 00:26:25
Sistema 00:26:29
Es de una planta de construcción de coches 00:26:31
Vale, ¿qué le pones al color del coche 00:26:34
cuando al principio es solo un trozo de hierro, tiene solo el chasis? 00:26:36
¿Qué color le pones? 00:26:41
Entonces a lo mejor tú puedes crear un coche, ya tienes tu coche, es este coche de aquí. 00:26:44
Y a lo mejor sí que el número de telar lo tienes, o todavía no, lo tendrás, no sé si es el número de telar. 00:26:48
Lo que sea que tú te creas un molde vacío, en un cierto sentido, que tendrá esta estructura de aquí, 00:26:53
pero todavía con todos los parámetros no formalizados, 00:27:00
y los irás construyendo tú en las varias fases de proceso. 00:27:04
Llamarás el método de pinta coche 00:27:08
Que lo pintará con un valor 00:27:10
Que te ha pasado por parámetro verde 00:27:12
Y entonces pondrá que el coche 00:27:15
Es color verde 00:27:16
Y te lo irá rellenando 00:27:17
Es para tener 00:27:19
Al fin y al cabo flexibilidad 00:27:22
En algunos casos lo puede tener 00:27:23
Ahora, vale, perfecto 00:27:25
Pero yo también tengo 00:27:27
Este de aquí 00:27:29
Puedo crear dos constructores 00:27:31
Sí 00:27:37
Este de aquí 00:27:39
Construye un coche 00:27:43
A partir solo de la matrícula 00:27:46
Y todo el resto 00:27:48
No se que es 00:27:49
Lo pongo valores normales 00:27:50
Y este de aquí 00:27:53
Tiene cuatro parámetros 00:27:54
Y pondrá los parámetros correctos 00:27:56
En cada uno de ellos 00:27:59
Ahora yo puedo hacer 00:28:00
Un new 00:28:02
Coche2 00:28:06
0010B 00:28:09
Esto me crea un objeto 00:28:12
Y también podría hacer 00:28:19
Bueno, lo pongo arriba 00:28:22
Este es un constructor válido 00:28:23
Y también este es un constructor válido 00:28:28
Algo 00:28:31
9, 9 00:28:39
Coma 00:28:40
Que gane 00:28:42
Coma 00:28:43
33, 2 00:28:45
Este también es válido 00:28:47
¿Sí? 00:28:51
String, string, int, int 00:28:53
O solo string 00:28:54
Pero aquí sigue dándome error 00:28:56
Entonces, ¿cómo puedo hacer yo 00:28:59
A que esto no me dé error? 00:29:05
Ah, pero yo esto 00:29:15
Imaginamos que yo no tengo acceso a esto 00:29:17
Esto lo está haciendo otro grupo 00:29:19
Yo quiero que aquí no le explote a ellos 00:29:21
¿Cómo puedo hacer mi clase para que pueda hacer esto? 00:29:24
Porque hemos dicho, una opción es borro todo 00:29:28
¿Vale? 00:29:30
Si borro todos los dos constructores 00:29:33
Pues ya está, esto funcionaría 00:29:37
Y si tengo que coche 1 00:29:39
Está definido así 00:29:43
Y coche 2 00:29:45
C2 está definido así 00:29:49
Ahora como lo hago, porque no puedo borrar todo 00:29:51
Creo otro constructor 00:29:53
Que no tenga nada 00:29:58
Public 00:30:00
Coche 2 00:30:02
De nada 00:30:04
Lo que hará es algo parecido a esto 00:30:05
Con los valores que tú quieres 00:30:11
Por ejemplo aquí le podría poner null 00:30:15
Ahora tengo tres constructores 00:30:17
Uno que es un constructor sin parámetros 00:30:22
Entonces me vale esto 00:30:24
New 00:30:26
Coche2 00:30:27
Me vale 00:30:30
Simplemente no tengo parámetros 00:30:32
Y por lo tanto pondré parámetros por defecto 00:30:37
O pondré parámetros míos 00:30:39
O cosas por el estilo 00:30:41
Tened en cuenta que el constructor por defecto que no hemos visto, en realidad es esto. 00:30:42
Este es el constructor por defecto. 00:30:53
Entonces, si yo no pongo ningún constructor, automáticamente tengo un constructor por defecto 00:31:04
que me hace él por defecto, sin problemas. 00:31:09
Si yo creo un constructor, pierdo ese constructor por defecto, 00:31:14
Pero nadie me impide 00:31:19
De volver a crearlo yo 00:31:21
¿Se entiende? 00:31:23
¿Dudas? 00:31:29
Y esto más o menos es lo que dice 00:31:34
Aquí, aquí 00:31:36
Y el coso por el estilo 00:31:38
Entonces, volviendo a lo del dis 00:31:39
Veamos si aquí dice algo que se me ha olvidado 00:31:41
Para invocar la ejecución de un método 00:31:44
De un objeto es imprescindible conocer su dirección 00:31:46
Almacenada a la variable de tipo referencia 00:31:48
¿Vale? O sea, necesito tener una referencia 00:31:50
A un objeto para poder llamar su método 00:31:52
¿Vale? Esta dirección 00:31:54
la ha de guardar en primera instancia 00:31:55
que el código en el que se haga 00:31:57
el new, ¿vale? o sea cuando 00:31:59
hago c1 es igual a new 00:32:01
coche, pues ahí ese c1 00:32:03
es la referencia a mi objeto 00:32:06
y ahora puedo hacer c1.frenar 00:32:07
c1.acelerar 00:32:10
y todas esas cosas, ¿vale? 00:32:11
hay una excepción para esta regla ya que 00:32:13
si un objeto quiere ejecutar un método 00:32:15
propio, lo cual es bastante habitual 00:32:17
necesita conocer su propia dirección 00:32:19
¿sí? 00:32:22
Si yo desde dentro 00:32:23
La misma declaración de los métodos 00:32:25
Quiero acceder a otro método 00:32:28
Tendré que llamarlo sobre este objeto 00:32:30
Para hacerlo, uso el dis 00:32:32
Luego en realidad 00:32:36
Dentro del mismo objeto 00:32:44
Se puede no usar el dis, pero 00:32:46
Es más claro 00:32:48
Veremos en futuro 00:32:49
Vendrán momentos en que el dis 00:32:53
Queda claro 00:32:55
Entonces la última cosa 00:32:57
y que nos queda para ver es el concepto del método estático vale ahora hemos entendido los 00:32:59
métodos para objetos los métodos estáticos son esos objetos que si llamados sobre objetos 00:33:05
distintos proporcionen la misma el mismo resultado o sea que no cambia el resultado si lo llevamos a 00:33:11
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
15
Fecha:
2 de diciembre de 2024 - 14:24
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
33′ 22″
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:
134.03 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid