Saltar navegación

20241202 POO-Clases_5 - 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 Raquel G.

14 visualizaciones

Más información Transcripción

Descargar la transcripción

clases, vale 00:00:00
una clase que es 00:00:02
una clase 00:00:04
ya sabemos que 00:00:05
representa 00:00:08
describe 00:00:10
los elementos, los conceptos 00:00:12
que nuestra aplicación va a gestionar 00:00:15
vale, hasta ahí está bastante claro 00:00:16
lo que son las propiedades 00:00:19
lo que significan y como crear 00:00:21
objetos, propiedades, callaos 00:00:23
los de la segunda fila y todos en general 00:00:25
vale 00:00:27
te voy a cortar el pito, cállate de una pelotera 00:00:28
silencio 00:00:31
no estoy grabando 00:00:34
sí, algo que le duela 00:00:39
es lo primero que se me ha ocurrido 00:00:43
silencio 00:00:44
que se calle de una pelotera 00:00:47
vale, bueno 00:00:49
nuestras aplicaciones hacen cosas 00:00:51
vale, nuestras aplicaciones hacen cosas 00:00:57
nuestras aplicaciones 00:01:00
trabajan con objetos de la realidad 00:01:02
profesores, departamentos 00:01:04
alumnos, ahora mismo la nuestra solo tiene profesores 00:01:06
pero se podría agrandar 00:01:09
con departamentos, alumnos, con relaciones 00:01:10
entre profesores, alumnos, etc 00:01:13
vale, como las del modelo de entidad de relación 00:01:14
y nuestras aplicaciones 00:01:17
trabajan con 00:01:20
elementos, entidades 00:01:21
que hemos descrito mediante clases 00:01:23
y trabajan haciendo cosas 00:01:25
nosotros ya hemos hecho una aplicación 00:01:27
que hace cosas, en este caso 00:01:30
como esta de aquí, que coge 00:01:32
a los 100 profesores, calcula 00:01:34
cuál es el que más gana, le sube 00:01:36
el sueldo al que gane poquito 00:01:38
ya hace cosas, bueno 00:01:40
pues cómo se diseñan las aplicaciones 00:01:41
en lugar de un main 00:01:44
que lo haga ir todo a mogollón 00:01:46
pues decimos, vamos a ver 00:01:48
con los profesores, qué es lo que 00:01:50
nuestra aplicación va a hacer 00:01:52
de forma recurrente cuando el usuario lo pida 00:01:54
pues por ejemplo, a un profesor 00:01:56
concreto, a lo mejor muchas veces 00:01:59
en la aplicación hay que subirle el sueldo 00:02:01
pues según va cogiendo 00:02:03
antigüedad, según va no sé cuánto 00:02:05
según 00:02:07
se le va subiendo el sueldo 00:02:07
vale, pues entonces se dice, ah muy bien 00:02:11
pues el trozo de código 00:02:13
relacionado con subir el sueldo 00:02:14
a un profesor, como lo voy a necesitar 00:02:17
hacer seguramente desde muchos sitios 00:02:19
el trozo de código relacionado con eso 00:02:20
en lugar de ponerlo ahí en mi main 00:02:23
como un chorizo, pues voy a meterlo 00:02:25
en la clase profesor, de tal forma 00:02:27
que en mi clase profesor esté no sólo 00:02:30
las propiedades que describen los profesores 00:02:33
sino también todas las cosas que se pueden hacer 00:02:36
con los profesores, pues eso es el comportamiento 00:02:39
entonces una clase tiene la primera parte 00:02:42
que es la de las propiedades, también llamadas 00:02:45
atributos o variables o campos 00:02:48
y una segunda parte que se llama métodos 00:02:50
que es las cosas 00:02:53
que se pueden hacer con los profesores 00:02:55
que son las que le interesan 00:02:57
a la aplicación, claro 00:02:59
venga, pues entonces 00:03:01
vamos a completar esta clase 00:03:03
metiendo métodos 00:03:05
vale, pues la parte de las propiedades ya está 00:03:06
que es esta 00:03:09
ahora vamos a hacer la segunda parte 00:03:11
de las dos partes 00:03:15
gordas que tiene una clase 00:03:17
y luego aparte tiene otras 00:03:19
cositas 00:03:21
lo que es esta, clases internas, bla bla bla 00:03:22
que eso ya lo dejamos para momentos ya en que estemos 00:03:26
más avanzados. Pero en general 00:03:28
las clases tienen las propiedades 00:03:30
que describen 00:03:32
que incluyen las características 00:03:34
de un objeto 00:03:36
y los métodos. 00:03:37
Vale, pues los métodos ¿qué son? 00:03:41
Los métodos son funciones 00:03:43
tal cual las hemos estudiado. 00:03:45
Funciones que hacen cosas. 00:03:48
¿Y hacen cosas 00:03:51
con qué? Pues, hombre, 00:03:52
yo meteré aquí una función 00:03:54
que haga cosas relacionadas con el profesor. 00:03:56
¿Para qué voy a meter aquí una función 00:03:59
que me calcule su número primo? 00:04:01
¿Qué pinta ahí eso? 00:04:03
Aquí lo que pinta son funciones 00:04:05
que ahora ya sí las llamaremos métodos 00:04:07
a partir de ahora. 00:04:09
Aquí lo que pinta son funciones 00:04:11
que hagan cosas en los trabajos del profesor. 00:04:12
Por ejemplo, en esta aplicación nuestra 00:04:14
pues una cosa que hacíamos era 00:04:17
subir sueldo a profesores. 00:04:19
Pues vamos a hacer un método 00:04:21
que suba el sueldo al profesor. 00:04:23
Entonces, ¿cómo se declara un método? 00:04:26
La cabecera, exactamente igual que una función. 00:04:30
Nombre del método, un nombre lo más explicativo posible. 00:04:34
Si queremos seguir reglas de estilo que deberíamos empezando con minúscula, 00:04:38
pues, por ejemplo, subir sueldo. 00:04:41
Vale. 00:04:44
Este método, en nuestro caso, ¿necesita algún dato de entrada? 00:04:47
venga, pues este método 00:04:54
vamos a hacer que el suel 00:04:55
que le, ¿qué? 00:04:58
hace falta un estático o algo así 00:04:59
calma, no, espera, espera 00:05:01
no te precipites, estamos haciendo la 00:05:03
¿hace falta un bullying? 00:05:05
no hace falta 00:05:08
silencio y atención 00:05:09
vale, entonces, este método en particular 00:05:12
este método en particular, bueno, vamos a hacer antes 00:05:14
de este método, que es mucho más complicado 00:05:17
antes de subir sueldo vamos a hacer uno que, oye 00:05:19
mi aplicación, le interesa 00:05:21
que el profesor salude 00:05:24
diciendo quién es 00:05:25
por ejemplo, vamos a hacer un método 00:05:27
que sea solo para saludar 00:05:30
y sin parámetros 00:05:31
que muestra 00:05:34
algo por consola, con lo cual 00:05:36
este devuelve void 00:05:37
luego esta sería la cabecera 00:05:38
vale, entonces 00:05:40
los métodos 00:05:42
sus cabeceras 00:05:44
también llamadas firma 00:05:47
su firma, también llamadas cabeceras 00:05:48
tienen las mismas reglas que las funciones 00:05:52
nombre del método 00:05:55
empezando con mayúscula 00:05:57
para seguir regla de estilo, que sea lo más 00:05:59
explicadito posible 00:06:00
si necesita alguna información desde fuera 00:06:01
aquí, este primero 00:06:04
no necesita ninguna información 00:06:07
si tiene que devolver algo como valor de retorno 00:06:08
aquí, este primero como va a hacer un 00:06:11
system out aquí dentro 00:06:12
no devuelve nada, vale 00:06:14
entonces, este método 00:06:16
¿qué particularidades tiene? 00:06:18
respecto a las funciones 00:06:20
que hemos hecho nosotros antes? 00:06:22
Bueno, pues que este método 00:06:24
puede usar automáticamente, 00:06:26
sin necesidad de declararlas 00:06:29
ni pasárselas por aquí ni nada, 00:06:30
las propiedades del objeto profesor. 00:06:32
Entonces, en nuestro caso, 00:06:36
¿qué es este método que queremos que haga? 00:06:37
Saludar diciendo 00:06:39
hola, soy Pepito 00:06:40
y gano no sé cuántos. 00:06:42
Pues este método haría 00:06:44
hola, soy 00:06:46
nombre 00:06:54
porque este método 00:06:57
y todos los métodos de la clase 00:07:00
tienen acceso directamente a las propiedades 00:07:02
del objeto, no hay que declararlas 00:07:05
dentro, ni darles valor, ni pasárselas por 00:07:06
parámetro, ni nada 00:07:08
con lo cual yo accedo directamente aquí 00:07:09
hola, soy Pepito 00:07:12
y gano 00:07:13
vale, ya tenemos un método hecho 00:07:19
vale 00:07:24
entonces 00:07:26
tal cual, vale 00:07:28
Entonces, importante, ahora mismo, lo importante que tiene que quedar ahora mismo grabado, pues que este método accede directamente al valor de estas propiedades. No hay que declararlas, pasárselas ni nada. 00:07:31
entonces ahora me preguntaríais 00:07:44
pero es que esto 00:07:46
no estamos diciendo que esto es una plantilla 00:07:48
que esto no tiene nada 00:07:50
claro, si esto no tiene nada 00:07:51
esto solamente dice que cuando haya 00:07:54
profesores, el profesor tendrá 00:07:56
un nombre, cuando haya profesores 00:07:58
el profesor tendrá un NIF, ahora mismo no hay nada 00:08:00
claro, pero es que esto es igual, esto 00:08:01
cuando exista un profesor 00:08:03
ese profesor podrá llamar a saludar 00:08:05
solo podremos 00:08:08
llamar a saludar cuando exista un profesor 00:08:10
y el profesor que llame a saludar 00:08:11
¿qué valor utilizará aquí? 00:08:13
el de su propiedad, su nombre y su sueldo 00:08:16
entonces este método no tiene 00:08:18
sentido que ser 00:08:20
llamado si no hay un profesor 00:08:22
creado antes que lo llame, ahora veremos cómo 00:08:24
entonces, esa es la 00:08:26
diferencia con las funciones que hemos hecho 00:08:28
hasta ahora, las funciones que hemos hecho hasta ahora 00:08:30
tenían un static delante 00:08:32
y eso permitía que no las llamara ningún objeto 00:08:33
ahora mismo olvidaros del static 00:08:36
y de todo eso, olvidaros 00:08:38
¿vale? entonces 00:08:39
Eso ya, cuando veamos los métodos static, 00:08:42
ya nos cuadrará con lo que hemos hecho. 00:08:45
Pero, ahora mismo, olvidaros del static. 00:08:48
Aquí no se pone static. 00:08:50
Entonces, los métodos de una clase, repito, 00:08:52
solo tienen sentido que los llamen un objeto. 00:08:55
¿Vale? 00:08:59
Pues, ahora ya. 00:08:59
Vamos a hacer nuestra aplicación 3, 00:09:00
otra aplicación con otro main, que saluden todos mis 00:09:03
profesores. 00:09:06
Pues, venga. 00:09:08
Ejemplo clase. 00:09:10
profesores, se llamaría este 00:09:11
¿no? sí 00:09:13
vamos a hacer la app 3 00:09:14
para que saluden todos 00:09:17
a mogollón 00:09:19
app profesores 3 con un main 00:09:20
vale, pues venga 00:09:28
vamos a crear un array de profesores 00:09:30
voy a copiar y pegar 00:09:32
este para crear los profesores 00:09:33
de forma aleatoria 00:09:37
bueno, antes del array, lo voy a hacer con un 00:09:39
profesor suelto para que quede bien 00:09:45
vale, vamos a hacer un profesor 00:09:46
ahora ya estamos en tiempo de ejecución, en el main 00:09:48
Aquí es donde aparecen los objetos 00:09:50
Venga, pues mi profesor 1 00:09:52
La dirección de memoria profesor 1 00:09:55
Le asigno 00:09:57
Un espacio en memoria 00:09:59
Vamos a darle valores 00:10:05
Pues NIF, pues cualquiera 00:10:07
Y sueldo cualquiera 00:10:13
Bueno, estamos hoy un poquito 00:10:33
Así que hoy lo dejamos en 1000 00:10:40
Vale, entonces 00:10:42
Ahora, ahora existe un objeto 00:10:44
Pues ahora tiene sentido que ese objeto llame a su método saludar, porque a los métodos de la clase solo lo pueden llamar objetos concretos. O sea, yo no puedo hacer aquí saludar sin más. 00:10:46
Claro, efectivamente 00:11:01
Saludar sin más, no existe 00:11:03
Saludar, pero ¿quién saluda? 00:11:05
Claro, pues solamente 00:11:09
Podemos llamar a este método 00:11:11
Si hay un objeto profesor 00:11:14
Que lo llama, si no, no 00:11:15
¿Y cómo lo llama? 00:11:17
Pues profesor1 00:11:19
Vale, entonces ahora ya sí 00:11:21
Y ahora ya 00:11:23
Queda muy claro, cuando profesor1 00:11:25
Llame a saludar 00:11:28
Hará este código 00:11:29
¿Y qué nombre irá aquí? 00:11:31
El de profesor 1 00:11:33
¿Y qué sueldo irá aquí? El de profesor 1 00:11:34
¿Vale? 00:11:37
Entonces, uno viendo la clase 00:11:41
Diría, oye, pero aquí qué nombre muestro 00:11:43
Si esto es la clase, aquí no hay nada definido 00:11:45
Claro, es que esto no se ejecuta aquí 00:11:47
En este momento 00:11:49
Esto es un main el que lo llama 00:11:49
Aquí solamente estoy declarando 00:11:52
Qué es lo que va a ocurrir cuando alguien llame a saludar 00:11:54
Solamente 00:11:57
¿Y quién va a llamar a saludar? 00:11:57
Obligatoriamente un profesor 00:12:01
Saludar no puede ser llamado de la nada. 00:12:02
¿Estás deseando irte? 00:12:05
¿A que sí? 00:12:06
Porque gestas así súper... 00:12:07
Ah, vale, vale. 00:12:10
Vale, no, es que... 00:12:13
Me piro, me piro. 00:12:14
Dime. 00:12:15
¿Eh? 00:12:21
Porque está asociado a una clase 00:12:27
y lo llama un objeto. 00:12:30
vale, a ver 00:12:31
el mains puede llamar 00:12:35
a métodos estáticos de su propia clase 00:12:38
del estático olvídate, ahora mismo 00:12:40
vale, ahora ya lo incorporaremos 00:12:41
cuando sigamos 00:12:44
viendo porque de la clase nos faltan como 00:12:46
3512 cosas que incorporar 00:12:48
entonces ahora mismo del estático olvídate 00:12:50
pero bueno, si estás inquieto 00:12:52
yo te respondo, el método no es 00:12:53
estático, pero es que es un método asociado a una clase 00:12:56
entonces 00:12:58
asociado a un objeto, claro que puedes 00:12:59
como no puedes llamarlo solo 00:13:01
solo no puedes 00:13:03
pero asociado a un objeto sí 00:13:04
¿vale? pero en cualquier caso lo que te digo es 00:13:06
ahora olvida del tdl static, estamos hablando 00:13:11
de clases, objetos 00:13:13
y yo todavía aquí no he usado el modificador static para nada 00:13:15
con lo cual ahora mismo no tenemos ni idea 00:13:17
de lo que significa ¿vale? 00:13:19
olvídate, ahora mismo no sabemos lo que significa, ya lo sabremos 00:13:21
¿vale? ahora lo que nos importa 00:13:23
es que cuando uno hace un método 00:13:25
en una clase 00:13:27
este método puede acceder 00:13:27
directamente a estas propiedades 00:13:31
pero claro, ¿qué valor van a tener? 00:13:32
para que esto se pueda ejecutar tienen que tener un valor 00:13:35
¿qué valor van a tener? 00:13:37
pues depende, porque este método 00:13:39
lo van a llamar desde un main, lo va a llamar 00:13:41
un profesor1, ah vale, pues tendrá 00:13:43
los valores de profesor1 00:13:44
que hacemos otro profesor2 00:13:46
que ahora este profesor2 00:13:48
tiene como 00:13:54
un if 00:13:56
6666 00:13:57
para el diablo 00:13:59
el diablo es 666 00:14:01
O mucho 6 00:14:03
Y este gana 10.000 00:14:05
Este va a saludar 00:14:07
Más contento 00:14:10
Vale, entonces ejecutamos esto 00:14:11
Y efectivamente 00:14:16
Pepito ha llamado 00:14:20
A su versión de saludar 00:14:22
Ha llamado a saludar con sus propiedades 00:14:23
Que eran Pepito y Mil 00:14:26
Ahora, la segunda llamada 00:14:27
La llamada es la misma 00:14:30
Saludar y saludar 00:14:32
La llamada es la misma 00:14:34
pero, que tontería estoy haciendo 00:14:35
profesor 2, profesor 2 00:14:37
profesor 2, profesor 2 00:14:40
tanto copia y pega 00:14:43
la llamada es la misma 00:14:43
¿qué cambia? el objeto que lo llama 00:14:46
eso es lo que cambia 00:14:48
el objeto que lo llama 00:14:50
entonces, cuando llamemos a saludar 00:14:51
desde el objeto 1 00:14:54
nombre y sueldo 00:14:55
serán los del objeto 1 00:14:57
cuando llamemos a saludar 00:14:59
desde el objeto 2 00:15:02
nombre y sueldo 00:15:03
serán del objeto 2 00:15:05
¿vale? 00:15:06
entonces esto parece una tontería 00:15:09
pero que quede hiper mega claro 00:15:11
porque luego 00:15:13
veo cada cosa 00:15:14
de que de repente aquí pasáis 00:15:16
las propiedades por parámetro 00:15:19
que no sé qué, unas cosas 00:15:21
angustiosas 00:15:23
claro, le puedes pasar lo que quieras 00:15:24
¿vale? entonces queda claro 00:15:27
que cuando uno declara un método 00:15:29
ese método puede acceder a las propiedades 00:15:31
pero claro, ¿qué valor van a tener esas propiedades? 00:15:33
pues depende 00:15:36
si te llama profesor 1, tendrán los valores 00:15:36
de profesor 1, si te llama profesor 2 00:15:39
tendrán los valores de profesor 2, si te llama profesor 27 00:15:41
tendrán los valores de profesor 27 00:15:43
¿vale? 00:15:45
entendido 00:15:48
bueno, y con eso no hace los métodos que le den la gana 00:15:49
por ejemplo, ah vale, aparte de que 00:15:51
los profesores en mi aplicación saluden 00:15:53
también voy a usar lo de subirles el sueldo 00:15:55
un porcentaje, porque es un requisito 00:15:57
de mi aplicación, aplicación para que suba 00:15:59
los sueldos, haga patatín, no sé cuántos. 00:16:01
Venga, vamos a meter aquí un método para subir 00:16:03
el sueldo. Vale, pues entonces 00:16:05
ese método podría ser. 00:16:07
Ahora, este método 00:16:16
sí recibe un parámetro. 00:16:17
Porque es un método 00:16:20
para subir el sueldo un porcentaje 00:16:22
el que uno quiera. 00:16:24
Vale, pues entonces le pasamos el porcentaje por parámetro. 00:16:45
Vale, este método, ¿qué va a hacer? 00:16:53
Cambiar el sueldo 00:16:56
del profesor. 00:16:57
Luego este método no devuelve nada 00:16:58
No tiene que devolver el sueldo 00:17:00
Ni hacer un system out, ni nada 00:17:02
Este método 00:17:04
El propio sueldo del profesor se lo cambia 00:17:06
Luego este método 00:17:09
Pues lo podemos hacer así, ¿no? 00:17:11
Sueldo más igual 00:17:16
Sueldo 00:17:17
Por porcentaje 00:17:19
Entre 100 00:17:22
¿Vale? 00:17:23
Le estoy subiendo el porcentaje 00:17:25
vale, pues este método tiene un efecto 00:17:28
que se queda registrado 00:17:33
ya en la propiedad del objeto 00:17:35
como ya se queda registrado, ni lo tengo que 00:17:36
devolver por parámetro, no tengo que hacer nada 00:17:39
ya se queda registrado 00:17:40
en la propiedad del propio objeto que lo llame 00:17:43
ahí ya se queda registrado 00:17:45
subimos este parámetro y ya está 00:17:46
vale, entonces el método 00:17:49
usa, recopilando 00:17:51
propiedades del objeto si las necesita 00:17:53
por supuesto 00:17:54
parámetros que uno necesite 00:17:55
Que le tiene que pasar desde fuera 00:17:59
Como en las funciones 00:18:00
Y podría tener que devolver algo 00:18:02
Depende de lo que hagamos 00:18:05
En este caso no tiene que devolver nada 00:18:06
Porque el efecto es 00:18:08
Se queda en la propia variable 00:18:09
Ya se queda ahí, que se queda modificada 00:18:11
No tiene que devolver nada 00:18:13
Entonces aquí, en esta 00:18:14
Si hacemos ahora ya un array de profesores 00:18:16
Para esta misma aplicación 00:18:19
Vamos a hacer un array de profesores 00:18:22
Y subir el sueldo, pero con este método 00:18:23
Vale, pues entonces 00:18:25
Hemos hecho un array de 10 profesores 00:18:38
Lo rellenamos 00:18:40
Y ahora vamos a subirles el sueldo a todos 00:18:42
Vale 00:18:44
Pues entonces podemos hacer esto 00:18:46
Para cada profesor 00:18:48
Prof 00:18:51
Punto 00:19:00
Subir sueldo 00:19:02
¿Qué le vamos a subir a todos? Pues un 30% 00:19:04
Por ejemplo 00:19:12
Vamos a hacer un sistema para ver si realmente lo ha subido 00:19:13
Vamos a mostrarlos antes y después 00:19:19
Antes 00:19:21
Y después poniendo 00:19:24
un salto de línea entre medias 00:19:37
vale, entonces veis aquí 00:19:39
no hay valor de retorno 00:19:43
pero es que no hace falta porque el propio profesor 00:19:44
que ha llamado al método 00:19:47
ya se ha quedado su propiedad modificada 00:19:48
cada profesor del array que ha llamado 00:19:51
al método aquí, ha visto 00:19:53
que su propiedad se ha quedado modificada 00:19:55
pues ya está, ese es el efecto de llamar 00:19:57
al método, haber modificado 00:19:59
entonces si 00:20:01
ejecutamos 00:20:05
A ver, el método está claro, ¿no? 00:20:05
Vale. 00:20:23
El método está claro. 00:20:24
Y ahora vamos a llamarlo 00:20:25
para todos y cada uno 00:20:26
de los profesores de un array. 00:20:28
Entonces, rellenamos el array. 00:20:30
Mostramos sus valores. 00:20:33
Aquí. 00:20:35
Y ahora queremos 00:20:36
que todos los profesores del array, 00:20:37
todos, 00:20:39
llamen al método 00:20:40
subir sueldo 00:20:41
para subirles el sueldo. 00:20:42
Pues entonces, por eso, 00:20:43
estamos recorriendo el array 00:20:44
y para todos y cada uno de ellos 00:20:45
estamos llamando a subir sueldo. 00:20:47
30, por ejemplo. 00:20:49
Entonces, cuando luego mostremos el array, 00:20:51
veremos cómo cada profesor 00:20:53
efectivamente su sueldo se ha modificado. 00:20:55
Porque el efecto de subir sueldo 00:20:57
para cada profe 00:20:59
es el que dice aquí. 00:21:00
El sueldo de cada profe 00:21:03
se ha visto modificado. 00:21:05
¿Vale? 00:21:08
Entonces da la sensación 00:21:09
uy, pero si no está devolviendo nada, 00:21:11
no está guardando el valor, 00:21:12
es que no hace falta. El profesor que llama 00:21:13
el sueldo en sus propiedades dentro y recibe 00:21:15
en esas propiedades las modificaciones. 00:21:17
Entonces, si ejecutamos esto, pues 00:21:21
si parece que se les ha subido el sueldo 00:21:23
a todos, ¿no? 00:21:25
Un 30%. 00:21:27
¿Verdad que sí? 00:21:29
No. 00:21:33
Vale. 00:21:40
¿Qué otro método podríamos poner? 00:21:41
Por ejemplo, en la aplicación anterior 00:21:47
hemos necesitado el sueldo... 00:21:50
No, aquí pone el sueldo mismo anterior. 00:21:51
¿Qué otra cosa podría ser interesante hacer 00:21:54
con un profesor en concreto? 00:21:56
Pues cambiarle el nombre. 00:21:58
Podríamos hacer aquí un método para cambiarle el nombre. 00:22:00
Ver si gana más de no sé qué 00:22:03
y si gana más de no sé qué, decir eres muy rico. 00:22:05
bueno, pues cualquier cosa 00:22:08
que la aplicación le interese hacer 00:22:10
con las propiedades de los profesores 00:22:12
pues lo mete aquí en un método 00:22:14
y ya está 00:22:15
¿vale? 00:22:17
claro 00:22:19
pues efectivamente 00:22:20
entonces 00:22:22
aquí por ejemplo 00:22:25
que hay 00:22:29
he puesto en el aula virtual 00:22:30
que no la tenía puesta 00:22:35
os la dije a principio de curso 00:22:36
pero luego no la puse aquí 00:22:37
El enlace 00:22:39
Ya a las grabaciones 00:22:43
De las clases de Estefan 00:22:45
Es la misma contraseña 00:22:47
Por si necesitáis todavía más grabaciones 00:22:48
Más clases, más cosas, pues están aquí 00:22:51
¿Vale? 00:22:53
Sí, y vamos más o menos 00:22:55
En paralelo, con lo cual, ¿no te has enterado? 00:22:57
Pues te ponen las suyas 00:22:59
Bueno, ¿no lo sabes? 00:23:00
Vale 00:23:08
Bueno, pues aquí tenéis 00:23:08
Un listado así a mogollón 00:23:12
Y algunas son chorradas 00:23:14
Otras son cosas más no sé qué 00:23:20
Por ejemplo, ¿qué podríamos hacer? 00:23:22
Venga, aparece 00:23:29
Ah, joder, lo que ha tardado en aparecer 00:23:41
Vale 00:23:43
Vale, a ver, este primer ejercicio 00:23:44
Háganme caso 00:23:50
Este primer ejercicio 00:23:54
Que ya son un montón de apartaditos chorras 00:23:56
Que acaba aquí 00:23:58
¿Vale? 00:24:01
Relax 00:24:04
A ver, los 10 primeros 00:24:05
son chorradinas 00:24:09
unas ligadas unas con otras 00:24:11
para acabar de entender bien 00:24:13
qué es esto de un objeto, de una referencia 00:24:15
de no sé qué, ¿vale? 00:24:17
Eso es lo primero 00:24:19
que estaría bien 00:24:20
que hicierais para acabar de entender exactamente 00:24:23
qué es un objeto, una referencia, todo eso 00:24:25
que lo hicierais y lo iniciarais bien 00:24:26
¿vale? Y luego ya a partir de aquí 00:24:29
pues ejercicio, normales y corrientes 00:24:31
¿qué podéis empezar a hacer? 00:24:33
El 11 y el 12 00:24:37
y el 13 00:24:39
sin ningún clase de problema 00:24:40
¿vale? 00:24:43
ahora mismo solo el 11, el 12 y el 13 00:24:45
¿vale? 00:24:47
a ver, en realidad ya con esto se puede hacer todo 00:24:51
pero bueno, como se va incorporando cierta complejidad 00:24:53
ahora mismo 11, 12 y 13 00:24:55
y punto pelota 00:24:57
porque luego este de aquí 00:24:58
ya es una clase dentro de otra y bueno 00:25:01
conviene que lo veamos con algún otro ejemplo 00:25:03
¿pero qué? 00:25:04
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
14
Fecha:
2 de diciembre de 2024 - 19:49
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
25′ 09″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
108.12 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid