Saltar navegación

20241129 POO-Clases_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 1 de diciembre de 2024 por Raquel G.

36 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, vamos a seguir avanzando sobre lo que ya conocemos. 00:00:00
Lo que hemos visto hasta ahora es la programación estructurada, que es construir programas que son una secuencia de sentencias una tras otra, 00:00:19
Donde esas sentencias involucran declaración y asignación de datos a variables, bien sea desde el teclado o bien sea directamente a Capone o bien sea porque va a la otra expresión. 00:00:30
Y luego, sentencias de decisión, como los I, los switch case, y sentencias de iteración, como los for, los while. 00:00:41
bueno, pues un programa 00:00:49
que es una secuencia una tras otra 00:00:51
de sentencias de ese tipo 00:00:53
que elaboran 00:00:54
construyen un algoritmo 00:00:57
para realizar algo, es un programa 00:00:59
estructurado, ¿vale? y esa es la programación 00:01:01
estructurada, ya está, no hay más 00:01:03
entonces la programación estructurada 00:01:05
es la base 00:01:07
de cualquier aplicación 00:01:09
de cualquier aplicación, como la que 00:01:11
os enseñó este chico ayer, pues que tienen 00:01:13
programación estructurada, ya está, no hay más 00:01:15
¿vale? 00:01:17
Lo que pasa es que efectivamente las aplicaciones son enormes, son muy largas, cada una gestiona un montón de cosas, entonces no podemos construir aplicaciones basadas en una secuencia de sentencias una tras otra. Es imposible, es implanteable. 00:01:19
los programas que nos quedarían 00:01:36
no podríamos ni depurarlos 00:01:37
porque cualquier error 00:01:39
donde encuentre un error 00:01:40
dentro de cien mil líneas 00:01:41
es como imposible 00:01:42
bueno, pues entonces 00:01:43
aquí entra por tanto 00:01:45
es que no quiero borrar esto todavía 00:01:47
porque me ha gustado 00:01:48
aquí entra por tanto 00:01:49
la programación orientada a objetos 00:01:50
¿vale? 00:01:53
que no es otra cosa 00:01:54
no es otra cosa 00:01:56
diferente a la programación estructurada 00:01:57
es una forma de diseñar 00:01:58
nuestras aplicaciones 00:02:02
una forma de diseñarla 00:02:04
que facilita reutilizar 00:02:05
código, ampliar código 00:02:07
depurar código 00:02:10
facilita todo eso, sobre todo la 00:02:11
reutilización 00:02:13
¿vale? claro, como si fuera una 00:02:14
programación modular de toda la vida 00:02:17
claro, como las funciones, pero es algo 00:02:18
orientado ya a aplicaciones más grandes 00:02:21
claro, vale 00:02:23
pero luego, esa aplicación 00:02:25
lo que tienen sus pequeños ladrillitos 00:02:27
es programación estructurada, ya está, no tiene más 00:02:29
que eso, lo que hemos hecho nosotros 00:02:31
que haremos una y otra vez 00:02:33
por eso en nuestras aplicaciones 00:02:34
a partir de ahora y todo el rato 00:02:36
vamos a estar utilizando 00:02:38
y reutilizando todo lo que hemos visto 00:02:41
entonces todo lo que hemos visto lo vais a seguir 00:02:42
practicando, no hay ningún problema 00:02:44
pero ahora ya con aplicaciones 00:02:46
con otras estructuras 00:02:48
¿vale? 00:02:49
Jesús te estás durmiendo 00:02:51
bueno, entonces, vale, pues vamos a ver 00:02:53
más o menos cuáles son las bases 00:02:56
de la planeación orientada a objetos, de dónde sale esto 00:02:58
pues la idea sale 00:03:00
para que nos pongamos en contexto 00:03:02
una aplicación normalmente gestiona 00:03:06
cosas de la vida 00:03:08
para eso la utilizamos 00:03:09
pues como esto por ejemplo 00:03:11
aquí hay un problema 00:03:14
le damos una aplicación que gestione 00:03:16
los profesores 00:03:18
que hay en un departamento 00:03:20
los departamentos están 00:03:22
en las facultades 00:03:24
a su vez las facultades tienen cátedras 00:03:26
y esas cátedras 00:03:28
las tienen propiedad profesores 00:03:30
bueno, pues tenemos un problema 00:03:32
ahí, este mismo 00:03:34
que gestionar, entonces nos han pedido 00:03:35
una aplicación que 00:03:38
gestione, pues eso, dar de alta 00:03:40
cátedras de un profesor que ha sacado la cátedra 00:03:42
mover a un profesor de departamento 00:03:44
está asignado en un sitio 00:03:46
moverlo a otro, pues eso es una 00:03:48
aplicación normal que alguien te ha podido 00:03:49
pedir que le desarrolles 00:03:52
entonces 00:03:54
esa aplicación va a trabajar con cosas 00:03:56
esas cosas 00:03:58
esas cosas, las llamamos tanto 00:03:59
en el contexto de la base de datos 00:04:01
como en el contexto de la programación 00:04:02
las llamamos entidades 00:04:04
¿vale? va a trabajar con entidades 00:04:06
y entidades son conceptos de la vida real 00:04:12
entonces un problema 00:04:15
un primer 00:04:17
problema a abordar 00:04:19
un primer problema es la 00:04:20
identificación de las entidades 00:04:22
que importan 00:04:25
para mi aplicación 00:04:27
¿vale? y esa es una tarea de analistas 00:04:28
¿vale? 00:04:31
Entonces, esa identificación de las entidades, pues en este caso nos podría llevar, vale, mi aplicación va a gestionar profesores, pues seguro que una entidad profesor voy a necesitar esta, mi aplicación va a gestionar departamentos también, porque me importan los departamentos, pero los profesores que trabajan en departamentos, pues aquí, entonces uno va identificando su aplicación en función de las funcionalidades que tiene que hacer, 00:04:32
dar de alta a un profe 00:04:56
asignar una cátedra a un profesor 00:04:58
según las funcionalidades que le han pedido 00:05:00
porque claro, el cliente ha llegado 00:05:02
y te ha dicho una aplicación que haga 00:05:03
esto, esto y esto 00:05:05
te pide algo que tiene que hacer 00:05:07
y en función de eso que tiene 00:05:10
que hacer, tú ya sacas 00:05:12
esas entidades que te importan 00:05:14
entonces si ves que una de las cosas que tiene 00:05:17
que hacer es asignar profesor 00:05:18
a un departamento, ya pa, se te abre 00:05:20
la luz, ah vale, pues entonces mi aplicación 00:05:22
seguramente tendrá que tener una entidad 00:05:24
profesor y una entidad de departamento. 00:05:26
¿Vale? Y esto que yo estoy 00:05:29
haciendo, lo estoy haciendo en el mundo de 00:05:30
la programación de Java, identificar 00:05:32
las entidades. Pero en el 00:05:34
mundo de bases de datos y de los datos 00:05:36
es el mismo proceso. 00:05:38
Es el mismo proceso porque van en paralelo. 00:05:40
Las aplicaciones tienen 00:05:43
los datos en bases de datos. 00:05:44
Entonces van completamente en paralelo. 00:05:46
Y las entidades que uno haya 00:05:48
identificado en su 00:05:50
modelo, en su modelo entidad 00:05:52
relación, esas entidades 00:05:54
tendrán una correspondencia en 00:05:56
una entidad, ahora veremos cómo, que se llama clase, 00:05:58
de nuestra aplicación. 00:06:01
Tendrá una correspondencia y esa aplicación 00:06:02
trabajará con esas entidades. 00:06:04
Entonces, estas, 00:06:07
repito, es trabajo de los analistas, 00:06:08
identificar cuáles importan. 00:06:10
Claro, a ver, ¿importa traje 00:06:12
del profesor? Pues no. Esta 00:06:14
aplicación, en ningún momento me han dicho cambiar 00:06:16
de traje al profesor, pues no va a haber una entidad 00:06:18
traje, porque no 00:06:20
no trabaja con eso, pero 00:06:21
trabaja con, esto es que no sé 00:06:24
qué narices es, interfacultativo, no sé 00:06:25
qué significa, eh, pues varias facultades 00:06:28
básicamente 00:06:30
que un departamento esté distribuido 00:06:30
en varias facultades, vale, vale 00:06:34
bueno, pues 00:06:35
uno que va identificando las entidades 00:06:37
que realmente su aplicación 00:06:40
va a gestionar, vale 00:06:42
bueno, pues esto tiene el nombre general 00:06:43
de entidad 00:06:45
en la programación 00:06:46
orientada a objetos 00:06:49
Esto lo asociamos 00:06:50
Esto lo asociamos 00:06:53
A esto, clase 00:06:55
¿Vale? 00:06:57
Entonces, ¿qué es una clase? 00:07:00
Una clase es, ahora ya sí 00:07:02
Un código, que ahora veremos cómo escribimos 00:07:05
Un código que escribimos en Java 00:07:09
Que ahora veremos cómo 00:07:11
Que describe cómo es una entidad por dentro 00:07:12
Eso es una clase 00:07:16
Describe cómo es una entidad por dentro 00:07:17
O sea, todo lo que guarda la identidad de la tabla. 00:07:19
Lo que tiene, lo que se llaman sus propiedades. 00:07:20
Sí. 00:07:23
Que en las bases de datos equivaldría a los campos. 00:07:24
Claro, si hemos identificado un profesor, 00:07:27
un profesor tendrá nombre, DNI, etcétera, etcétera. 00:07:30
Podido de profesor. 00:07:35
Claro, y eso en la base de datos se corresponderá 00:07:36
a que habrá una tablita, profesor, 00:07:39
que tendrá un montón de campos. 00:07:42
Nombre del profesor, no sé cuántos, no sé cuántos. 00:07:43
Eso en el mundo de las bases de datos. 00:07:45
pues su equivalente en la aplicación 00:07:47
que lo gestione será 00:07:49
que habrá una clase escrita en Java 00:07:51
ahora veremos cómo se escribe 00:07:53
que esa clase te describirá 00:07:55
el profesor tiene nombre 00:07:58
tiene DNI, tiene no sé cuántos y no sé qué 00:07:59
claro, entonces 00:08:01
luego habrá un problema 00:08:03
a resolver 00:08:05
que ya será mapear 00:08:06
todo lo que está en la base de datos 00:08:09
todos los datos que están ahí 00:08:11
mapearlos para que los tenga 00:08:13
ya mi aplicación 00:08:15
ahí dentro. Esa es mi asignatura 00:08:17
del año que viene. 00:08:19
Así que os genero 00:08:21
las ganas 00:08:22
ya de que la veáis el año que viene. 00:08:25
Qué guay, estáis disfrutando. 00:08:27
Estáis muertos de ganas. 00:08:29
Pues debería ir. 00:08:30
No debería ser solo con eso. 00:08:33
Yo tengo curiosidad. 00:08:35
Pues eso el año que viene. 00:08:37
Entonces, 00:08:39
más o menos nos hemos situado sobre qué es 00:08:41
una clase. Una clase 00:08:43
identificamos la necesidad 00:08:45
de programarla, ahora veremos 00:08:47
cómo se programa, cuando ya hemos 00:08:49
identificado que mi aplicación 00:08:50
va a trabajar con ese concepto 00:08:52
de la vida real, esa entidad. 00:08:55
Y ya os digo como añadido, 00:08:57
aunque luego nosotros no vamos a usar 00:08:59
la base de datos, que eso en la vida real 00:09:01
siempre va a tener una base de datos asociada 00:09:03
donde cada tabla 00:09:05
será una clase. 00:09:06
Tabla de profesores 00:09:09
pues tendrá una clase asociada 00:09:11
clase profesor que describe 00:09:13
cómo es un profesor. Bueno, 00:09:15
esa es más o menos la motivación, ¿vale? 00:09:17
Luego, 00:09:21
para hacer el análisis de todo, pero ese 00:09:22
no es nuestro problema, ni 00:09:23
seguramente trabajéis en eso en el futuro, 00:09:25
pues hay un montón de tips. 00:09:27
Pues, ¿qué es entidad y qué no? 00:09:29
El tip básico es, ¿qué es 00:09:32
entidad? Algo 00:09:33
que tiene muchas propiedades distintas. 00:09:35
Porque, claro, un nombre. 00:09:37
Mi aplicación trabaja con nombres, por ejemplo. 00:09:39
los nombres no son entidades 00:09:41
porque un nombre se puede guardar en una variable string 00:09:43
pues ya está, los nombres 00:09:45
los guardo en variables, no tengo que hacer ninguna clase 00:09:47
o una aplicación que trabaja 00:09:49
con números, hasta ahora 00:09:51
nuestras aplicaciones solamente trabajaban 00:09:53
o con números o con cadenas 00:09:55
no hemos necesitado clases en ningún 00:09:56
momento, porque un numerito 00:09:59
se guarda en una variable y un nombre 00:10:01
se guarda en una variable de tipo string 00:10:03
entonces hay ni clases ni nada 00:10:05
pero si nuestra aplicación trabaja con profesores 00:10:07
un profesor ya es un concepto complejo 00:10:09
que tiene nombre, tiene DNI, tiene no sé qué 00:10:12
entonces un profesor no se puede guardar 00:10:14
en una variable de las que conocemos 00:10:15
entonces tenemos que hacer 00:10:17
este añadido, este de la clase 00:10:19
¿qué hacemos ahora? 00:10:21
con variables separadas, claro 00:10:22
y por supuesto que se podría programar 00:10:25
cualquier aplicación sin nada de esto 00:10:27
pero sería horrible, porque para gestionar un profesor 00:10:29
tengo que tener un montón de variables 00:10:32
solo para él, y gestionar todas esas variables 00:10:34
en paralelo, sin mezclarlas 00:10:35
con las variables del otro. O sea, un montón de 00:10:38
arrays donde este array los nombres, 00:10:39
este array los DNIs, este array 00:10:42
sería una locura. Claro que 00:10:43
podríamos hacerlo, pero ¿para qué? Vamos a organizar 00:10:45
la aplicación con este invento 00:10:48
para que sea mucho más sencillo. 00:10:49
Porque de la otra manera, 00:10:52
esa aplicación, uno si consigue 00:10:54
hacerla, no va a haber nadie más 00:10:55
en la vida que lo entienda. Lo entienda jamás. 00:10:57
Contratado para siempre. 00:10:59
Efectivamente, has cogido a la empresa por los 00:11:01
cataprines, porque no te pueden 00:11:04
echar. Pero 00:11:05
Y como existe esto, con mala suerte 00:11:07
Vale, pues está claro lo que es una clase, más o menos 00:11:10
Vamos a ver cómo se programa una clase en Java 00:11:14
Bueno, pues yo he identificado que mi aplicación va a trabajar, por ejemplo 00:11:19
Con profesores y departamentos 00:11:39
Es una aplicación sencillita 00:11:42
Que lo que va a hacer va a ser asignar profesores a departamentos 00:11:43
ver cuántos profesores trabaja en un departamento 00:11:49
quitar un profesor de un departamento 00:11:53
este tipo de funcionalidades 00:11:55
entonces una vez que yo he leído lo que me pide el cliente 00:11:56
asignar profesor 00:11:58
ver profesores de un departamento 00:12:00
ver qué departamento tiene más profesores 00:12:01
ver no sé qué 00:12:03
una vez que yo he visto las funcionalidades 00:12:04
ya después de analizar he visto 00:12:06
pues dos entidades 00:12:07
profesor con sus datos 00:12:08
y departamento con sus datos 00:12:10
bueno pues 00:12:12
entonces eso hace que automáticamente digamos 00:12:14
vale pues una clase profesor 00:12:16
y una clase, departamento. 00:12:17
Bueno, vamos a empezar con la clase profesor. 00:12:21
¿Cómo se declara una clase? 00:12:27
Pues empezamos obligatoriamente 00:12:29
con esta palabrita que ya os suena. 00:12:32
Clase. 00:12:37
Así empezaban nuestros programas de toda la vida. 00:12:38
¿Por qué? 00:12:41
Porque en Java y en cualquier lenguaje de programación, 00:12:41
bueno, en cualquiera no, pero vamos. 00:12:43
en java todos los todo cualquier aplicación tiene que ser un montón de clases cualquiera entonces 00:12:45
las nuestras eran sólo una clase pero una tiene que haber al menos era sólo una por eso empezamos 00:12:54
class lo que fuera y aquí poníamos algo dentro que es lo que se llama método que es todo eso es 00:13:01
lo que vamos a entender y ver ahora que era el código que se ejecutaba ahora mismo olvidados 00:13:07
de ese main y de todo 00:13:14
olvidaros del main 00:13:15
y de todos sus, vale 00:13:18
yo he identificado una entidad profesor que necesito 00:13:19
empiezo con class 00:13:22
en su ficherito, aparte 00:13:24
vale, a ver, puedo hacer 00:13:26
pero bueno, estos matices los iremos incorporando 00:13:28
van a hacer mucho barullo 00:13:30
poco a poco, ahora mismo poneros en el chip 00:13:31
de que cada clase 00:13:34
es un fichero de texto distinto 00:13:35
vale, es un fichero de texto diferente 00:13:37
vale, pues en un fichero 00:13:40
de texto nuevo, en un código 00:13:42
fuente.java, claro, yo empiezo 00:13:44
ya a declarar mi clase profesor. 00:13:46
Pues empiezo con 00:13:49
la palabra reservada obligatoria 00:13:50
clase. Y ahora 00:13:52
le doy el nombre a la clase que me dé la 00:13:54
gana. Hombre, normal es darle 00:13:56
un nombre que se relacione 00:13:58
con la entidad. Entonces, lo más bonito 00:14:00
sería profesor, efectivamente. 00:14:02
¿Clase no lo pones dentro de una public 00:14:04
class? O sea, es ya... No, no, no, 00:14:06
a ver, lo que puedo es poner public delante, 00:14:08
pero como no sabemos lo que significa todavía, no lo pongo. 00:14:10
Pero como automáticamente nos estamos generando 00:14:12
estamos haciendo los ejercicios dentro de clases públicas 00:14:14
claro, porque cuando 00:14:16
lo hacíamos, él nos ponía el public 00:14:18
automáticamente, ¿lo podéis poner o no? 00:14:20
ahora mismo no tiene ninguna trascendencia 00:14:22
la clase en sí es eso 00:14:23
sí, sí, sí, esto no lo metas dentro de otra 00:14:25
a ver, puede haber clases internas 00:14:27
pero esto de nuevo lo dejamos para más adelante 00:14:29
ahora, ¿vale? 00:14:31
entonces, una clase profesor 00:14:33
empieza con class, punto pelota 00:14:35
que si ponéis el public delante no pasa nada 00:14:37
pero como no entendemos lo que significa, ¿para qué ponerlo? 00:14:39
class, vale, nombre de la clase 00:14:41
el que a uno le dé la gana 00:14:43
sin restricciones más allá que los mismos 00:14:44
de los nombres de variables 00:14:46
pues que no tengan caracteres raros 00:14:47
letras y números 00:14:49
ni siquiera estoy 00:14:52
porque en las variables 00:14:54
el carácter de subrayado si lo admite 00:14:55
pero nombres de clases ni lo sé 00:14:58
pero es que jamás he visto una clase que tenga 00:15:00
un subrayado 00:15:02
no lo pongáis 00:15:03
sí que hay 00:15:05
una pauta de estilo que no es 00:15:08
obligatoria pero es recomendable 00:15:10
y es que los nombres de clase 00:15:12
empiecen siempre con mayúscula 00:15:14
entonces, eso 00:15:17
en nuestro caso 00:15:18
al profesor 00:15:19
le llamaríamos, la clase profesor 00:15:22
la pondríamos profesor 00:15:25
que no pasa nada, puede ser con minúscula 00:15:26
pero ¿por qué 00:15:29
se sigue esa regla de estilo? 00:15:30
pues para distinguir 00:15:32
claro, string es una clase 00:15:34
efectivamente 00:15:36
¿para qué se sigue esta regla de estilo? 00:15:37
Pues para que sea más fácil distinguir qué es una clase y qué es una variable primitiva. 00:15:40
Recordad cuando os dije las variables primitivas, recomendable que empiecen con minúscula, no obligatorio, pero recomendable. 00:15:46
Son pautas de estilo que clarifican luego el código. 00:15:54
Sí, pero los primitivos también los queríamos. 00:15:56
Sí, con minúscula, claro, porque es una variable. 00:16:00
Pero el tipo de dato es tiene la mayúscula porque es una clase. 00:16:03
Ahora lo vamos a ir viendo todo eso. 00:16:06
Vale, pues profesor 00:16:08
Y ahora se abren las llaves y se cierra 00:16:10
Y ahí ya va dentro la descripción del profesor 00:16:12
Bueno, pues la descripción del profesor 00:16:17
¿En qué consiste? 00:16:22
En aquellas propiedades que lo caracterizan 00:16:25
Nada más 00:16:28
No consiste en nada más 00:16:28
Entonces hay que identificar 00:16:31
Qué propiedades le importan a la aplicación 00:16:32
Las que le importen 00:16:35
El color de ojo no le importa a la aplicación 00:16:37
pues jamás pondría una propiedad color de ojos 00:16:39
¿qué le importa? 00:16:42
pues a lo mejor en esta aplicación le importa 00:16:43
el nombre 00:16:46
el DNI 00:16:47
y el sueldo, yo que sé, por ejemplo 00:16:49
le importan esas tres cosas a la aplicación 00:16:51
porque es con lo que hace gestiones y cosas 00:16:53
le importan esas tres cosas 00:16:55
vale, pues eso es lo que se llaman 00:16:56
propiedades de la clase 00:16:59
propiedades que 00:17:02
también admiten 00:17:03
campos de la clase, atributos 00:17:05
o incluso variables 00:17:08
Más o menos los cuatro nombres suelen usarse como equivalentes 00:17:09
Propiedades, atributos, variables o campos 00:17:15
Variables o campos es más terminología del eclipse por traducción del inglés 00:17:17
Propiedades y atributos, pues la terminología más nuestra 00:17:22
Bueno, pues entonces, lo primero que se mete aquí dentro de la clase 00:17:27
Son las propiedades, ya digo, o atributos o campos 00:17:32
Vale, pues ¿cómo se ponen las propiedades? Pues se declaran variables, como hemos declarado toda la vida, una variable por cada propiedad. Hemos dicho nosotros que a nosotros nos van a importar nombre, DNI y sueldo. 00:17:37
hemos dicho, vale, propiedad 00:17:59
nombre, ¿qué tipo de dato? 00:18:01
string 00:18:04
pues ya está, declaro aquí 00:18:04
esta propiedad string 00:18:06
exactamente igual que declararía 00:18:09
cualquier otra variable 00:18:11
cualquier otra variable 00:18:13
string nombre, ahí declarada 00:18:14
¿qué más 00:18:17
hemos dicho que nos importa? el need 00:18:19
vamos a ponerlo en string también 00:18:21
bueno, pues hombre, lo puedo poner aquí abajo 00:18:23
string nombre, o bueno 00:18:25
como es del mismo tipo, podría ponerlo 00:18:27
aquí. 00:18:29
Siempre lo hago en bucle. 00:18:33
Además es ateo. 00:18:35
¿Tanto Jesús? ¿O no lo habéis dicho Jesús? 00:18:38
Ah, vale. 00:18:41
Lo de Jesús era en mis tiempos. 00:18:42
No, también lo he dicho Jesús. 00:18:43
Ah, vale, vale. 00:18:44
Jesús lo he dicho. 00:18:46
Ah, bueno, pero en su caso se le perdona. 00:18:48
Pues sí, se lo sale. 00:18:50
Eso, yo mismo. 00:18:51
vale, dos propiedades 00:18:53
como si declaramos las dos variables 00:18:57
la otra que hemos dicho, sueldo 00:18:59
asumimos que es double 00:19:01
pues venga 00:19:02
los nombres de las propiedades 00:19:04
la misma idea que los nombres cuando declaramos 00:19:09
variables en un programa de los que hemos hecho hasta ahora 00:19:12
decíamos, nombres que sean 00:19:14
lo más explicativo posible 00:19:16
pues sí, lo más explicativo porque 00:19:17
define qué propiedad tiene 00:19:20
empezando con minúscula 00:19:22
no es obligatorio 00:19:24
Pero si seguimos estas reglas de estilo 00:19:25
Los programas van a ser más claros 00:19:27
¿Vale? Pues estas son las propiedades 00:19:29
Ya las tenemos aquí 00:19:31
Delante puede haber cosas 00:19:32
El private está aquí para ti 00:19:36
Pero es que todo eso todavía no sabemos 00:19:37
En qué momento habría que ponerlo, ni por qué, ni nada 00:19:39
Entonces ya lo incorporaremos 00:19:41
Poco a poco 00:19:43
Lo digo porque si os ponéis a ver por ahí cosas 00:19:44
¿Cómo se ha quedado una clase? 00:19:46
Pues a lo mejor veis un montón de cosas 00:19:47
Y esto no ha salido, pero es que hay que ir progresivamente 00:19:49
Usarlo y que te diga 00:19:52
Claro, pero bueno 00:19:55
Yo voy incorporando progresivamente 00:19:57
¿Vale? Entonces, las propiedades 00:19:58
¿Vale? Aquí no tiene sentido 00:20:01
Asignar ningún valor 00:20:03
¿Por qué? Porque esto es 00:20:04
Como una especie de plantilla 00:20:07
Esto dice, los profesores 00:20:08
Cuando los haya, cuando existan ya 00:20:10
Los profesores en la aplicación, ahora veremos 00:20:13
Qué significa eso de que existan, cuando existan 00:20:14
Tendrán un nombre, un if y un sueldo 00:20:17
Esto es una descripción 00:20:19
De las propiedades 00:20:21
que caracterizan al profesor. 00:20:23
¿Cuáles son? 00:20:24
Pero esto no es un ejemplo 00:20:25
concreto de profesor. 00:20:27
Eso es una plantilla. 00:20:28
¿Vale? 00:20:29
Es una plantilla. 00:20:29
Luego dentro del profesor 00:20:31
crearé a cada profesor individual. 00:20:32
Claro, luego dentro de la aplicación. 00:20:34
Luego ya la aplicación, 00:20:35
ahora veremos cómo, 00:20:37
ya podrá crear 20 de estos. 00:20:38
20 profesores. 00:20:41
Y cada uno de esos 20 00:20:42
tendrá su propio nombre. 00:20:44
Es decir, su propio valor aquí. 00:20:47
Su propio NIF. 00:20:48
Su propio valor aquí. 00:20:49
Su propio sueldo. 00:20:51
Su propio valor aquí. 00:20:51
Pero eso ya será cuando ya hagamos una aplicación 00:20:52
Que tenga ya profesores reales 00:20:55
Y haga cosas con ellos 00:20:57
Si le llamo al profesor 00:20:57
Pero al nombre, me va a salir su nombre 00:21:00
Si le llamo al profesor, pero a mí me va a salir su nombre 00:21:03
Claro, claro, ya de estos 00:21:04
Usa el profesor para todo 00:21:07
De estos puede haber 200.000 copias 00:21:08
Ya reales en la aplicación 00:21:11
Pero es que aquí todavía no existe ninguna aplicación 00:21:13
Aquí tenemos una plantilla 00:21:15
Una plantilla 00:21:17
Pero no hay ninguna aplicación ejecutándose ni hay nada 00:21:18
esto es, cuando haya una aplicación 00:21:20
que gestione profesores 00:21:22
esos profesores responden 00:21:23
a esta plantilla, es decir, tienen estas tres 00:21:26
propiedades 00:21:28
nosotros, el concepto de persona 00:21:29
es único 00:21:32
salvo matices filosóficos 00:21:33
es un concepto de persona 00:21:36
pero luego aquí, pues tenemos 00:21:38
deberíamos ser 00:21:39
30, pero tenemos, pues yo que sé, 20 00:21:42
o por ahí, ¿vale? 00:21:44
personas hay muchísimas, pero la idea, el concepto es uno 00:21:45
pues esto es lo mismo 00:21:48
hay una plantilla de profesor 00:21:50
este es el concepto, el profesor tendrá 00:21:51
nombre, nif y sueldo, pero todavía no existe 00:21:53
eso existirá cuando hagamos la aplicación 00:21:55
que no la hemos hecho 00:21:57
vale, entonces 00:21:58
dentro de una clase puede haber más cosas 00:22:01
que vamos a tener que incorporar ya mismo 00:22:03
una de ellas 00:22:05
y la que incorpora 00:22:06
el concepto más importante 00:22:09
es, una vez que tenemos las propiedades 00:22:11
ahora en la clase 00:22:14
vendrá una cosa que se llaman los 00:22:15
métodos 00:22:17
los métodos 00:22:18
ahora todavía no vamos a ponerlos 00:22:21
porque vamos a hacer una aplicación que haga profesores 00:22:24
para ver como, vale 00:22:26
¿qué son los métodos? 00:22:28
pues los métodos son 00:22:30
funciones 00:22:32
funciones tal cual las hemos estudiado 00:22:33
funciones 00:22:36
una o mil 00:22:37
entonces, las funciones 00:22:39
que se meten aquí 00:22:42
la idea es que sean funciones 00:22:43
que hacen cosas relacionadas 00:22:46
con los profesores. 00:22:48
Entonces, 00:22:50
ahí ya tengo una forma 00:22:51
de organizar mi aplicación. 00:22:52
Mi aplicación 00:22:53
era cosa con los profes. 00:22:54
Ahora cosa con los profesores 00:22:55
porque por eso 00:22:56
la he identificado 00:22:57
como entidad. 00:22:58
Ahora profes, 00:22:59
subir el sueldo, 00:22:59
cambiarle de departamento, 00:23:01
aunque no hemos metido 00:23:02
aquí departamento todavía, 00:23:02
ya lo meteremos. 00:23:03
Cambiarle de nombre 00:23:06
porque ha cambiado de género. 00:23:06
Alterar el enigma 00:23:08
porque había un error. 00:23:09
La aplicación 00:23:10
era cosas. 00:23:10
Vale, 00:23:12
pues esas cosas 00:23:12
las podemos meter 00:23:13
en funciones 00:23:14
como hemos visto ya. 00:23:15
Y esas funciones 00:23:17
su sitio de ubicarlas 00:23:18
irían aquí, las que hacen cosas 00:23:19
relacionadas con el profesor, vale 00:23:22
ahora ya veremos como 00:23:24
hacer esos métodos 00:23:26
y luego como ejecutarlos 00:23:27
como ejecutarlos, porque aquí no hay ningún main 00:23:29
nosotros hasta ahora hemos ejecutado 00:23:32
las cosas, las funciones 00:23:34
eran, teníamos una única clase 00:23:36
con un main y las funciones abajo 00:23:38
y de ahí no hemos salido 00:23:39
ahora ya abrimos 00:23:41
ese contexto a uno más amplio 00:23:43
vale, bueno pues 00:23:46
ahora mismo, antes de ver un ejemplo de cómo funcionan 00:23:48
los profesores ya en un main. 00:23:49
Queremos no. Queremos nos 00:23:51
con que los métodos serían 00:23:53
un conjunto de funciones 00:23:55
que hacen 00:23:59
cosas relacionadas con el profesor. 00:24:03
Porque si no, a cuento 00:24:06
de qué pintan ahí esas funciones. 00:24:07
Una función ahí que me haga así un número de primo, ¿no? 00:24:09
¿Para qué la voy a meter aquí en un profesor? 00:24:11
Vale, pues esto que yo he escrito ahí 00:24:25
ya es una clase válida. 00:24:26
Sencillita. 00:24:29
Pero ya es una clase válida. 00:24:31
Entonces, yo ya podría hacer una aplicación que cree 20 profesores y les dé datos a cada uno de ellos para luego hacer cosas con ellos. ¿Qué cosas? Pues no sé, ya lo meteremos aquí, qué hacer con ellos, ¿vale? Vamos a ver cómo sería SME. 00:24:32
Bueno, pues entonces, repito 00:24:48
Esto no es nada que se esté ejecutando 00:24:56
Esto es una plantilla 00:24:58
No es nada que se esté ejecutando 00:25:00
¿Vale? ¿Qué es lo que sí que se ejecuta 00:25:01
Ya en una aplicación Java? 00:25:04
Lo que se ejecuta en una aplicación Java 00:25:06
Ya lo hemos dicho desde el principio 00:25:08
Es lo que hay en el método main 00:25:09
Y ya está, eso es lo único que se ejecuta 00:25:11
En una aplicación Java, de escritorio 00:25:14
No una aplicación web ni nada de eso 00:25:15
Luego, si yo quiero hacer una aplicación Java 00:25:17
Que gestione profesores 00:25:19
Ese modelo lo tengo que seguir haciendo 00:25:21
Como hemos hecho hasta ahora 00:25:23
Una clase 00:25:25
Pues a ver si luego 00:25:26
Me dan otro recambio 00:25:29
Una clase y aquí un main 00:25:30
Vale 00:25:34
Pues ahora ya tengo una aplicación 00:25:45
Con dos clases 00:25:46
Dos ficheros distintos fuente 00:25:47
Dos punto java 00:25:50
Mi aplicación tiene dos clases 00:25:51
Esta que es la plantilla del profesor 00:25:53
Y esta main donde vamos a hacer cosas 00:25:55
Ahora ya lo hago ahí en la pantalla 00:25:58
Que se va a ver mejor 00:26:00
Vale 00:26:00
Esta también es una clase 00:26:03
Porque empieza por class 00:26:06
Pero esta la podemos ver como una clase sin propiedades 00:26:07
No tiene propiedades 00:26:10
No tiene propiedades 00:26:12
Porque esa clase no define ninguna entidad 00:26:14
No define una entidad 00:26:16
Es la clase ejecutable, entre comillas 00:26:17
¿Vale? 00:26:20
Lo que sí que tiene dentro es un método 00:26:22
Porque esto es una función, en realidad 00:26:23
Tiene su nombre 00:26:26
Un void porque no devuelve nada 00:26:26
Y estas dos cosas que todavía no entendemos 00:26:29
Pero bueno, en breve las entenderemos 00:26:30
Pues lo que sí que tiene es una función. 00:26:32
Entonces, como ya hemos dicho a veces, 00:26:34
cuando arranca una aplicación Java, 00:26:37
que normalmente son muchas clases, 00:26:39
la máquina virtual se pone a buscar entre todas ellas, 00:26:41
y ya veremos cómo consigue encontrarla, 00:26:44
se pone a buscar entre todas ellas 00:26:46
cuál es la que tiene este método dentro. 00:26:48
A partir de ahora ya voy a dejar de usar la palabra función 00:26:50
para usar la palabra método, ¿vale? 00:26:52
Porque es el nombre de programación de entradas de objetos. 00:26:56
Lo que vaya aquí serán métodos, 00:26:59
aunque su sintaxis era como de las funciones que hemos visto. 00:27:00
Y esto es un método, o lo que hemos llamado función hasta ahora, 00:27:03
con su nombre, no devuelve nada, recibe unos parámetros 00:27:07
que todavía no hemos visto para qué usarlos, y hace cosas. 00:27:10
Vale, pues cuando una aplicación, que es un montón de clases, 00:27:13
arranca, la máquina virtual se pone ahí toda loca 00:27:16
hasta que encuentra de todas las clases que tiene, 00:27:19
cuál tiene el método main dentro, exactamente con su cabecera. 00:27:23
Y en cuanto lo encuentra, empieza a hacer lo que hay aquí. 00:27:27
Y ya está. Y cuando ya lo ha hecho todo y ha terminado, la aplicación se acabó, ¿vale? Bueno, pues por ejemplo, ¿qué vamos a hacer en esta aplicación ahora? Vamos a crear un array de 20 profesores y los vamos a rellenar a cada uno con sus datos y luego vamos a mostrar el profesor que más gana. 00:27:30
por ejemplo, esa aplicación ya la podemos hacer 00:27:50
20 profesores 00:27:52
¿cuál es el que más gana? 00:27:54
os vamos a mostrar cuál es el que más gana 00:27:57
de los 20 que hemos hecho 00:27:59
pues venga, lo vamos a hacerlo ya aquí 00:28:00
que ahí no se ve nada 00:28:03
¿te puse de aquí para que no te dieran mal? 00:28:11
es verdad 00:28:13
vale 00:28:14
pues entonces 00:28:24
vamos a ver 00:28:28
Pues venga, voy a hacer un proyectillo 00:28:29
Nuevo 00:29:23
Vamos a ver 00:29:37
Si, pero aparte 00:29:38
Cajamos 00:29:40
Vale, pues venga 00:29:42
ejemplo clase profesores 00:29:48
pues las clases que hace uno 00:29:50
las primeras que hace son las entidades 00:29:52
que ha identificado, porque si no luego 00:29:54
no puede hacer un main que trabaje con ellas 00:29:56
bueno, pues vamos a hacer primero nuestra clase 00:29:58
profesor 00:30:00
no puedo crear varias clases 00:30:01
dentro del mismo 00:30:09
fichero, sí, pero 00:30:10
puedes, lo que pasa es que 00:30:13
no pueden tener el public delante 00:30:16
no, porque 00:30:20
una clase public es obligatorio 00:30:23
que el nombre de la clase sea igual que el del fichero 00:30:26
entonces si tuvieras varias public 00:30:28
delante tendrías un problema 00:30:30
entonces puedes declarar varias 00:30:31
en un fichero y que public sea solo una 00:30:34
y esa sí puede llamar a las otras 00:30:36
de dentro del mismo fichero 00:30:38
sí, pero tú puedes llamar a cualquiera 00:30:40
aunque no esté en el mismo fichero 00:30:42
incluso las que no son public 00:30:43
claro, si está en el mismo paquete 00:30:45
vale, todo esto ya lo vamos incorporando 00:30:48
De todas formas, como pauta, lo deseable es una clase en cada fichero, ¿vale? 00:30:50
Porque luego va a quedar mucho más organizado. 00:30:55
Cuando tú abres un proyecto de alguien, ver todas las clases en diferentes... 00:30:57
Porque es que si no, vas a verlo aquí en el explorador de proyectos, 00:31:01
vas a ver el ficherito.java, que dentro tiene muchas clases. 00:31:04
Entonces, lo ideal es tener una clase por fichero y así lo ves. 00:31:08
Claro, siempre se hace así, ¿vale? 00:31:12
Venga, pues entonces. 00:31:13
Pues ahora, la clase profesor. 00:31:16
de hecho como el public, no lo he puesto ahí 00:31:18
el public ni lo quiero, lo quito 00:31:22
porque no sabemos lo que significa 00:31:24
vale, hemos dicho que 00:31:25
tres propiedades, dos de ellas 00:31:28
string 00:31:30
y una de ellas 00:31:31
double 00:31:36
pues sale, esta clase 00:31:38
está hecha, muy simple 00:31:41
porque no tiene 00:31:43
métodos, cosas que se puedan hacer con los 00:31:44
profesores, bueno ya iremos incorporando 00:31:47
vale, pues entonces ahora ya vamos a hacer una aplicación 00:31:48
que trabaja con esto 00:31:51
Pues ahora ya 00:31:52
No es mi clase 00:31:55
Sí, lo estoy metiendo todo en el mismo paquete 00:31:56
Todo en el mismo 00:32:04
De hecho, como estoy quitando los public 00:32:06
Tienen que estar todos en el mismo 00:32:07
La cosa azul esta 00:32:08
Sí 00:32:15
Te estará avisando 00:32:16
Supongo que no es public 00:32:20
Pero vamos, ya veremos la implicación de todo eso 00:32:21
Vale 00:32:23
Pues venga, nuestra aplicación de profesores 00:32:25
Ay, no he marcado que pusiera el main 00:32:30
Si pones main contra espacio 00:32:31
También te lo rellena 00:32:37
Ay, que listos sois, a ver 00:32:38
Mira, muy bien, esto me va a ahorrar mucho trabajo 00:32:41
En el futuro 00:32:45
Vale, pues entonces 00:32:46
Esto 00:32:48
Que te sientes mal 00:32:49
Ah, durante 00:32:52
Oye, cada uno tiene sus 00:32:55
¿Habrá cosas en las que tú seas un crack? 00:32:58
Claro 00:33:00
Bueno 00:33:01
Venga 00:33:04
Somos todos muy listos 00:33:09
A ver 00:33:12
Venga 00:33:13
Esto ya sí es una aplicación 00:33:16
Que se va a ejecutar 00:33:20
Esto si uno ve esto 00:33:21
Y aunque haya métodos aquí dentro 00:33:22
Con código, cuando ya lo sabamos 00:33:24
Esto no es nada que se esté ejecutando 00:33:25
esto es una plantilla, una descripción 00:33:27
y ahora ya esto sí 00:33:30
es algo que se va a ejecutar 00:33:32
entonces aquí ya hay profesores reales 00:33:33
aquí no hay profesores 00:33:36
aquí no hay nada, aquí sí va a haber 00:33:38
un profesor real, vale 00:33:40
pues ¿qué es un profesor real? 00:33:41
un profesor real es 00:33:44
un ejemplo 00:33:46
concreto de profesor, un ejemplo 00:33:48
concreto, vale 00:33:50
eso en programación de entrada 00:33:52
a objetos se llama 00:33:55
objeto o se llama instancia 00:33:56
que son sinónimos 00:33:59
vale, pues entonces ya tenemos 00:34:00
dos, varias palabras clave 00:34:03
por la ciencia de objetos, clase 00:34:05
¿qué es una clase? 00:34:07
una clase es una descripción 00:34:08
de las propiedades 00:34:11
de una entidad 00:34:13
y también de su comportamiento 00:34:14
pero eso, como todavía no tenemos los métodos 00:34:17
puestos, pero también lo será 00:34:19
eso es una clase, una clase es 00:34:21
una plantilla 00:34:23
puesta en un fichero Java 00:34:23
que describe cómo es una entidad 00:34:26
y qué cosas puede hacer aquí 00:34:29
a través de sus métodos. 00:34:31
¿Qué es una instancia o un objeto 00:34:33
que son sinónimos? 00:34:35
Es un ejemplo concreto de estos. 00:34:37
Un ejemplo concreto. 00:34:39
La instancia o el objeto 00:34:41
solo existe en un programa en ejecución. 00:34:43
Solo existe. 00:34:47
Cuando uno está desarrollando 00:34:49
y tiene los ficheritos ahí, 00:34:50
lo único que tiene son clases. 00:34:52
¿vale? Cuando ya llama la máquina 00:34:53
virtual para que 00:34:55
el main arranque 00:34:57
y empiece a hacer cosas desde aquí, 00:34:59
ahora ya tiene un programa en ejecución. 00:35:02
Cuando ya hemos 00:35:04
llamado a la máquina virtual, se ha venido 00:35:05
aquí y ha empezado a ejecutar. Ahí ya 00:35:07
sí tenemos un programa en ejecución. Bueno, pues 00:35:09
cuando ya hay un programa en ejecución, 00:35:11
ahí es donde tiene sentido 00:35:13
que existan ya los objetos o 00:35:15
las instancias, porque ahí ya tengo los 00:35:17
profesores reales de mi aplicación. 00:35:19
¿Vale? Antes 00:35:23
Yo no tengo nada. Vale, pues entonces vamos a crear una instancia, objeto, como lo queráis llamar, un ejemplo concreto de profesor. Vamos a ver cómo se crea. Uno solo. Luego ya haremos 20 para hacer este pequeño programita de ver cuál es el que más gana. 00:35:23
creamos un profesor 00:35:40
concreto 00:35:43
por ejemplo 00:35:45
si te gusta Paco 00:35:49
esto es lo que se llama 00:35:50
instancia 00:35:52
o objeto 00:35:54
un profesor ya concreto 00:35:56
en tiempo de ejecución 00:35:59
en tiempo de ejecución es cuando el programa 00:36:01
ya se está ejecutando 00:36:03
tiempo de compilación es cuando 00:36:04
estamos desarrollando 00:36:07
tenemos tiempo de compilación 00:36:08
es cuando un tío 00:36:11
está aquí desarrollando 00:36:11
tiempo de ejecución 00:36:12
cuando ya 00:36:13
he llamado yo 00:36:14
a la máquina virtual 00:36:15
para que se ejecuten las cosas 00:36:15
vale 00:36:17
pues una instancia 00:36:18
un objeto 00:36:19
un profesor concreto 00:36:19
aparece en tiempo de ejecución 00:36:20
cuando ya este mail 00:36:22
se esté ejecutando 00:36:23
bueno 00:36:24
pues como hago aparecer 00:36:25
un profesor 00:36:26
pues resulta 00:36:27
que una instancia 00:36:28
o un objeto concreto 00:36:29
es también una variable 00:36:30
lo que pasa 00:36:32
es que en lugar de ser 00:36:33
una variable entera 00:36:34
una variable string 00:36:35
es una variable 00:36:36
profesor 00:36:37
vale 00:36:38
eso es 00:36:39
es un dato 00:36:40
Un profesor concreto es un dato 00:36:40
Es un dato donde se guardan variables de toda la vida 00:36:42
Lo que pasa es que es un dato complejo 00:36:45
No es un int, no es un float 00:36:47
Pero es un dato 00:36:49
¿Y de qué tipo es ese dato? 00:36:50
De tipo profesor 00:36:53
Luego acabo de crear, haciendo la clase 00:36:54
Lo que acabo de crear 00:36:57
Es un nuevo tipo de datos 00:36:59
¿Vale? 00:37:00
Aparte de los que ya conozco 00:37:03
He creado un tipo nuevo 00:37:05
Y yo ahora ya de aquí declaro 00:37:06
Las variables que me den la gana 00:37:08
Por ejemplo, vamos a crear un primer profesor. 00:37:10
Vale, pues con esto he declarado una variable 00:37:15
con el nombre que a mí me ha dado la gana. 00:37:18
Y esta variable, siempre que declaramos una variable en Java, 00:37:21
sabemos que hay que poner el tipo al que pertenece. 00:37:24
Pues ¿a qué tipo pertenece esta variable? 00:37:27
A este. 00:37:29
¿Eso qué significa? 00:37:31
Que esto es un tipo complejo, porque tiene cosas dentro. 00:37:32
¿Vale? 00:37:37
Luego ahora ya tenemos dos tipos de datos. 00:37:37
Y solo dos. 00:37:40
Bueno, no. 00:37:41
tres, pero bueno, eso ya más adelante, los enumerados 00:37:41
seríamos 00:37:43
los que podríamos llamar a través de... justo 00:37:45
vale, entonces 00:37:47
tenemos tipos primitivos 00:37:48
los que hemos visto, byte, short, int, long 00:37:51
double, float, boolean y char, tipos primitivos 00:37:53
y tipos objeto 00:37:55
de los tipos objeto hemos visto 00:37:57
ya string y acabamos de crear 00:37:59
uno, pues hemos creado un tipo objeto 00:38:01
profesor y podríamos crear 00:38:03
200.000, entonces 00:38:05
de ese tipo que hemos creado 00:38:07
yo declaro las variables que yo quiera 00:38:09
como si quiero declarar dos variables 00:38:11
profesor, ala, he declarado 00:38:13
dos variables profesor, y estos van a ser 00:38:15
dos ejemplos concretos de profesores 00:38:17
como variables 00:38:19
string, tú de variables string puedes crear todas las variables 00:38:21
que quieras, pero todas son del tipo string 00:38:23
pues de profesores puedes crear 00:38:25
todos los que quieras, claro, entonces 00:38:27
ahora este profesor es un tipo que 00:38:29
tiene dentro cosas, pues habrá que ver cómo 00:38:31
me meto en sus cosas 00:38:33
al final coge las cosas de las otras que hay 00:38:34
claro, claro, claro 00:38:37
es como ponerle una carcasa 00:38:39
Justo, un tipo objeto es un montón de tipos primitivos envueltos en una carcasa. 00:38:40
Pero como a ti te interesa esa combinación concreta, 00:38:47
como a ti te interesa esa combinación, 00:38:50
pues coges esa combinación de tipos primitivos y a una carcasa, ¿vale? 00:38:53
Venga. 00:38:56
Vale, entonces, a ver, esta es mi variable. 00:39:01
Yo aquí ya voy a meter ejemplos concretos de profesores. 00:39:07
ejemplos concretos, esta es una variable 00:39:09
vale, los tipos objeto tienen una peculiaridad 00:39:12
respecto a los tipos primitivos, que ya le hemos dicho algunas veces 00:39:17
y es que en realidad esta variable es una dirección de memoria 00:39:21
que está apuntando a la zona 00:39:26
donde están ya todos esos primitivos, todos esos datos 00:39:29
vale, entonces cuando hemos hecho esta declaración 00:39:33
con esta declaración de profesor1 00:39:36
lo único que hemos hecho es 00:39:39
declarar esta variable 00:39:41
que se llama 00:39:42
profesor1 00:39:45
que es Paco. 00:39:47
Joder con Paco, ¿eh? 00:39:50
¿Qué te habrá hecho Paco? 00:39:51
Y esto es una dirección de memoria 00:39:53
y es una dirección de memoria 00:39:55
pero yo aquí en la dirección no puedo meter los datos 00:39:57
no puedo meter el nombre, el IND 00:39:59
es una dirección. 00:40:01
¿Esta dirección de memoria a dónde está apuntando? 00:40:02
Claro, ahora mismo 00:40:04
Todavía a nada 00:40:08
Ahora mismo es null, está apuntando a la nada 00:40:09
Está apuntando a la nada 00:40:12
Con esas dos líneas que yo he hecho 00:40:15
He hecho esto en memoria 00:40:16
Con lo cual 00:40:19
A ver, espera, pero tendré que crear el espacio 00:40:21
En memoria, esto es como el array 00:40:27
Cuando declaramos un array 00:40:28
Sin más, sin poner 00:40:30
Todavía el new int, no sé qué 00:40:32
Decíamos, he creado una dirección 00:40:34
Que va a la nada 00:40:36
Los de atrás, que se callen 00:40:37
Si yo ya quiero que la array exista 00:40:40
Para meter datos 00:40:43
Tenemos que hacer el new bla bla bla 00:40:44
Eso era porque la array era un objeto 00:40:46
Pues esto igual 00:40:48
Con esto que yo he hecho aquí, profesor1 00:40:50
He creado esto 00:40:52
Una dirección de memoria 00:40:54
Llamada profesor1 que va a la nada 00:40:56
Pero a eso no me vale 00:40:58
Quiero el espacio para guardar ya el string 00:40:59
el nombre, el in, todo, quiero el espacio 00:41:02
pues me falta hacer algo 00:41:05
me falta hacer algo, y ese algo 00:41:06
de crear el espacio, ¿cómo se hace? 00:41:08
pues como 00:41:11
eso, pues muy parecido a como 00:41:11
hacíamos con el array, así 00:41:14
punto pelota 00:41:16
ya está, no, el Paco todavía no, Paco 00:41:17
tiene que esperar 00:41:20
si me ha quedado claro que se había dado más Paco 00:41:21
si tú por eso no sufres 00:41:24
claro, entonces, ahora ya 00:41:25
después de haber hecho el new 00:41:30
nombre de la clase 00:41:32
nombre de la clase 00:41:34
y paréntesis vacíos 00:41:35
que podrían no ser vacíos 00:41:37
pero esto lo iremos añadiendo, etcétera, etcétera 00:41:40
ahora ya 00:41:41
con esto ya sí que he conseguido 00:41:43
que ese null desaparezca 00:41:45
y ahora ya tengo ahí 00:41:47
un espacio 00:41:49
precioso 00:41:53
y ese espacio ¿para quién es? 00:41:54
para tantas variables como propiedades 00:41:57
en este caso para tres 00:41:59
para el nombre, para el nif 00:42:01
y para el s, ahora ya sí que habré 00:42:03
creado aquí espacio para el nombre 00:42:05
habré creado 00:42:07
aquí espacio 00:42:09
para el nif 00:42:10
y habré creado 00:42:12
aquí espacio 00:42:15
para el suelo 00:42:16
ahora ya sí, después de haber hecho el new 00:42:18
he quedado un espacio con sus 00:42:21
tres casillitas, y cada casillita tiene 00:42:23
su nombre 00:42:25
el que yo haya puesto en la clase 00:42:26
como esto se llamaba 00:42:28
en la clase a esta propiedad le ha llamado nombre? 00:42:31
Pues esta casillita, 00:42:34
ahora veremos cómo acceder, se llamará nombre. 00:42:35
¿Cómo a esta propiedad le ha llamado 00:42:38
NIF? Pues esta casillita, ahora veremos 00:42:39
cómo acceder, se llama NIF. ¿Y cómo a esta 00:42:41
propiedad le ha llamado sueldo? Pues a esta 00:42:43
casillita, ahora veremos cómo acceder, se llama sueldo. 00:42:45
Ahora ya sí, ya tenemos ahí un ejemplo 00:42:47
concreto, ¿vale? 00:42:49
Un espacio de memoria. Y de estos 00:42:51
puedo hacer mil. Y cada uno 00:42:53
será una dirección apuntando a su zona. 00:42:55
Una dirección apuntando a su zona. Puedo hacer 00:42:57
mil, tantos profesores como 00:42:59
mi aplicación necesite 00:43:01
¿vale? 00:43:02
entonces, todo esto 00:43:05
es lo que 00:43:07
tenéis que ir memorizando 00:43:09
claro, ya 00:43:11
desde ya, o desde dentro de cinco 00:43:13
minutos, ya no puede ser 00:43:15
que alguien no sepa que crear 00:43:17
un objeto se hace con el new 00:43:19
el nombre de la clase 00:43:21
y los paréntesis, porque eso ya es 00:43:23
cuestión de memorizarlo, nada más 00:43:25
¿vale? 00:43:26
Entonces ahora ya tengo mi profesor ahí, pero mi profesor está al pobre sin datos, no tiene nada. Estas casillitas están vacías, este profesor no tiene nada. Vale, pues ¿cómo accedemos a sus casillitas? ¿Cómo accedemos a sus celditas, a sus casillitas? Pues accedemos con el puntito. 00:43:28
Yo ahora pongo ya mi nombre de variable, profesor1, punto, nombre. 00:43:46
Esta es, casillita nombre del objeto profesor1. 00:43:53
Pues a la casillita nombre del objeto profesor1 le llamamos Paco. 00:43:59
Y ya nos hemos quedado satisfechos para todo el día. 00:44:04
Vale. 00:44:07
Era Fernando, don Francisco. 00:44:08
Al siguiente le llamamos Fernando. 00:44:11
A ver, también se pueden llamar Juanita, Pepita o Eva. 00:44:13
Que no solo hay hombres en el mundo 00:44:16
Tienes toda razón 00:44:19
Me has pillado 00:44:21
Me has pillado 00:44:22
No, pero como te has dicho 00:44:23
Que era una clase de profesor 00:44:24
Y una clase de profesor 00:44:25
No, no, no 00:44:26
Profesor 00:44:27
Profesor, sí 00:44:30
Vale 00:44:32
Que quiero además ponerle 00:44:34
Un NIF 00:44:37
Pues le pongo un NIF 00:44:38
Que quiero además ponerle un sueldo 00:44:41
Poco a poco, poco a poco 00:44:45
No te precipites 00:44:52
Todo va a acabar encajando 00:44:54
Perfectamente 00:44:56
Y al final vais a saberlo todo 00:44:57
Todo 00:45:00
Claro, o sea, está fenomenal 00:45:01
Que lo veáis adelantando 00:45:06
Pero yo lo que os digo es que 00:45:07
Poco a poco 00:45:09
Y en el orden correcto 00:45:10
Vamos a ir incorporando 00:45:12
Todo para que al final lo sepáis 00:45:15
todo lo dejaba 00:45:16
del mundo 00:45:18
vale, pues este profesor ya está 00:45:20
y este es un ejemplo concreto, esto es lo que se llama 00:45:23
una instancia, mi instancia profesor 1 00:45:25
que en memoria es esto y tiene aquí su dato 00:45:27
6.600 pavos 00:45:29
como cobra pavo 00:45:30
a ver, que son 00:45:31
pesos mexicanos 00:45:35
no son euros 00:45:36
pues no sé 00:45:39
como no sea un profesor del master 00:45:42
de... 00:45:45
Claro. 00:45:46
Sí, si es de un 00:45:49
chiringuito de estos... 00:45:51
Bueno, pues 00:45:52
ya está, como son y 15, 00:45:56
ya sé que seguiríais mucho más 00:45:59
tiempo, pero vamos a parar. 00:46:01
Vale, pues esto es un ejemplo concreto, una instancia 00:46:03
de profesor. Entonces, 00:46:05
clase, hay una, 00:46:06
y luego yo hago aquí tantos profesores como quieran. 00:46:08
Y a cada uno accedo 00:46:11
a sus casillitas con 00:46:13
el nombre de la variable 00:46:15
punto la casillita, ¿vale? 00:46:16
Venga, pues luego continuamos. 00:46:19
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:
36
Fecha:
1 de diciembre de 2024 - 19:32
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
46′ 22″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
1.30

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid