Saltar navegación

20241210 POO-Clases-Paquetes_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 10 de diciembre de 2024 por Raquel G.

13 visualizaciones

Más información Transcripción

Descargar la transcripción

Public static void. 00:00:00
Vale, pues el void ya sabemos lo que es. 00:00:01
El static ahora dentro de un rato. 00:00:04
De comer, no paráis de comer, por favor. 00:00:07
Ya está. 00:00:10
No se come todo el rato. 00:00:11
Joder, tenéis que saber parar. 00:00:13
Hay que crecer, pero es que es la bola. 00:00:15
Es pecado la bola. 00:00:17
Pues vaya pecado. 00:00:19
Tan malo. 00:00:20
Bueno. 00:00:21
Vale, entonces void ya sabéis lo que es. 00:00:24
Cuando el método no devuelve nada. 00:00:26
Public. 00:00:29
Hemos visto que se ponía delante de una clase, pero también lo hemos visto que lo ponía delante del método constructor, siempre lo hemos borrado, pero no teníamos ni idea de lo que significaba. Se puede poner tanto delante de clases como de propiedades, como de métodos, significando esto que vayamos a ver ahora. 00:00:30
Bueno, pues esto tiene que ver los modificadores de acceso, esto que vamos a contar ahora en la versión live, que son estos, el public, el package, que es como no haber nada, cuando no se pone nada es esto, el protected, este protege mucho, y el private. 00:00:48
estos modificadores de acceso 00:01:23
que son los que vamos a entender ahora 00:01:25
que significan 00:01:27
estos tienen que ver 00:01:28
con el concepto de paquete 00:01:30
¿vale? 00:01:33
pues entonces, nosotros ahora ya sabemos 00:01:34
que una aplicación en Java 00:01:37
una aplicación 00:01:40
son 00:01:42
un montón de clases distintas 00:01:43
¿vale? nosotros a lo mejor hemos hecho 00:01:46
pues una aplicación con tres clases 00:01:48
profesor 00:01:50
Departamento y la mail 00:01:51
Bueno, pues ya esa tenía tres clases 00:01:54
Pero una aplicación puede tener 00:01:56
Pues muchas, cientos, miles 00:01:57
¿Vale? 00:01:59
Esa es una aplicación, ya lo sabemos 00:02:00
Que es un montón de clases distintas 00:02:03
De esas clases 00:02:05
Muchas de ellas 00:02:07
Serán entidades 00:02:09
El profesor, el departamento, el aula, el no sé qué 00:02:10
Y al menos una 00:02:13
Al menos una 00:02:15
Será la clase que tiene el famoso método mail 00:02:17
Al menos una 00:02:19
¿Verdad? Y la máquina virtual, cuando le decimos, oye tú, arranca esta aplicación, cuando le decimos eso, lo que hace la máquina virtual es buscar la que tiene el método main, ahora ya veremos cómo la encuentra, porque buscar ahí en un montón de 200.000 clases no sería fácil. 00:02:21
ahora ya después veremos cómo la encuentra 00:02:40
pues lo que hace la máquina virtual es 00:02:42
buscar la que tiene el main 00:02:44
y arrancar a partir de ahí 00:02:45
y ya todas las sentencias del main 00:02:47
se van ejecutando 00:02:50
muchas de ellas serán precisamente 00:02:51
instanciar objetos 00:02:54
de estas clases, lo que sea 00:02:56
vale, pues es una aplicación JAO, un montón de clases 00:02:58
pero si tenemos 100, 200 00:03:00
300, 1000, 400, 1000 clases 00:03:02
todas ahí en la misma 00:03:04
carpeta, pues es 00:03:06
un poco desorganizado y farragoso. 00:03:08
Entonces, ¿cómo se organiza una aplicación Java? 00:03:11
Se organiza metiendo las clases en diferentes paquetes. 00:03:14
A lo mejor estas clases se pueden meter en un paquete. 00:03:19
Estas dos de aquí en otro. 00:03:26
Es decir, ¿qué son paquetes? 00:03:31
Los paquetes son única y exclusivamente 00:03:32
carpetas del sistema de archivos. 00:03:35
Carpetas del sistema de archivos 00:03:38
que tienen clases. 00:03:40
ya está 00:03:43
no se supone que tienen que estar todas en la misma carpeta 00:03:44
para poderse llamar entre sí 00:03:47
o están todas dentro de lo mismo 00:03:48
o sea, porque estén en un proyecto ya se pueden llamar así 00:03:51
incluso aunque no estén en el mismo proyecto 00:03:55
lo que pasa es que Eclipse 00:03:57
edita una organización, pero Eclipse es Eclipse 00:04:01
que es el entorno de desarrollo 00:04:03
en el que trabajamos cuando estamos desarrollando 00:04:04
y tenemos nuestra organización 00:04:07
luego cuando ya la aplicación está hecha, otra cosa es esa aplicación 00:04:08
como ya se distribuye 00:04:11
y se va a distribuir en un montón de carpetas 00:04:13
con clases dentro, ya está 00:04:16
no hay más, para Java no hay más que eso 00:04:17
un montón de carpetas con clases dentro 00:04:19
ahora lo vemos un poquito más 00:04:21
la organización que vemos en el Eclipse 00:04:23
esa no es de Java 00:04:25
esa es del Eclipse 00:04:26
lo organiza pues con esas carpetitas, la SRC 00:04:28
para que nosotros lo veamos 00:04:31
y podamos desarrollar cómodamente 00:04:33
pero no es una organización que entienda esta 00:04:35
a esta hay que darle 00:04:37
un montón de carpetas 00:04:39
con clases dentro, se acabó 00:04:40
Nada más. No hay más organización que esa. Vale. Bueno, pues entonces, lo habitual es que cuando a la máquina virtual le damos una aplicación, no le damos las carpetas así a su vez en una carpeta todas, no. 00:04:42
Lo que le damos es todas esas carpetas comprimidas en un único archivo con extensión .jar. Es decir, jar es una herramienta para comprimir archivos, como puede ser el zip, exactamente igual. 00:05:01
Pero esta herramienta de comprimir archivos, esta la entiende la máquina virtual. 00:05:19
Entonces, si a la máquina virtual le damos un fichero .jar que lleva dentro comprimidas un montón de carpetas con clases, 00:05:24
pues la máquina virtual sabe descomprimir el .jar y ya tiene ahí las carpetitas con clases dentro. 00:05:33
Y repito, cada una de esas carpetas es un paquete. 00:05:41
Es decir, un paquete, una carpeta. 00:05:45
Una carpeta, un paquete. 00:05:48
Hay una correspondencia 00:05:49
miunívoca entre 00:05:50
carpeta y paquete. Pues un montón 00:05:52
de esas carpetas, 00:05:54
llamémoslas paquetes, un montón 00:05:56
de esos, comprimidos 00:05:58
en un fichero .hard 00:06:00
es la 00:06:02
aplicación. Eso se 00:06:04
le da a la máquina virtual, la máquina virtual 00:06:06
recibe el .hard, ahora lo veremos, 00:06:08
lo descomprime, 00:06:11
encuentra la que tiene 00:06:13
la main dentro de todo ese caos de 00:06:14
carpetas, habrá que ver cómo lo encuentra, 00:06:16
dentro de todo ese caos se encuentra la que tiene el método main 00:06:18
una solo 00:06:20
y ahí arranca la aplicación 00:06:21
y repito, ya hemos visto que esta aplicación 00:06:23
que tendrá aquí dentro 00:06:26
pues ya irá llamando al resto 00:06:27
creando objetos profesor 00:06:30
llamando a los métodos de profesor 00:06:32
creando objetos departamento, llamando a métodos 00:06:34
ya desde aquí se van instanciando 00:06:36
objetos de las demás, llamando a los métodos 00:06:38
lo que sea, ¿vale? eso es una aplicación Java 00:06:40
de escritorio 00:06:42
una aplicación Java pues que se ejecuta en tu ordenador 00:06:44
hay otras arquitecturas, claro, una aplicación web 00:06:46
que se ejecuta en un servidor web 00:06:49
pero otra arquitectura 00:06:51
pues ya lo veremos el año que viene 00:06:52
pero la aplicación Java de escritorio es esto 00:06:55
un montón de paquetes o carpetas 00:06:57
todas esas comprimidas 00:06:59
en un archivo .jar que la máquina virtual 00:07:00
es capaz de descomprimir 00:07:03
buscar la main y ejecutarla 00:07:05
bueno, pues entonces 00:07:07
los paquetes 00:07:10
que son diferentes carpetas 00:07:12
y contienen clases, ya nos plantean 00:07:14
el problema de, oye, 00:07:17
pero ¿cómo 00:07:19
desde esta main que está en este paquete 00:07:20
¿cómo podemos 00:07:23
llamar, hacer referencia 00:07:25
a una clase que está en otro? 00:07:27
Porque hasta ahora eso nunca lo hemos hecho. 00:07:29
Con lo cual nos hemos despreocupado. 00:07:31
Hasta ahora, todas las clases 00:07:33
de una aplicación nuestra, todas 00:07:35
estaban en la misma carpetita 00:07:37
o en el mismo paquete. 00:07:39
Hemos hecho un paquete ahí, ejercicio 1. 00:07:41
Ejercicio 1. Y lo hemos metido 00:07:43
todo dentro. Con lo cual, 00:07:45
como hemos hecho las aplicaciones siempre todas en el mismo paquete, 00:07:47
¿qué era el ejercicio 2? 00:07:50
Ejercicio 2, todas dentro. 00:07:51
Pues nos hemos despreocupado de eso. 00:07:53
Nos hemos despreocupado porque ahí no hacía falta buscar nada. 00:07:56
Pero ¿qué pasa si tenemos una aplicación 00:07:59
que tiene diferentes paquetes, la misma aplicación, 00:08:00
diferentes carpetas? 00:08:05
Pues ahí ya no es tan sencillo. 00:08:06
Ahí ya, para que unas clases puedan usar otras, 00:08:08
ya sí que interviene esto. 00:08:12
Ya sí que hay que manejar esto. 00:08:13
Perdón. 00:08:15
¿Es como la música de fondo? 00:08:16
Vale, pues entonces, antes de verlo, para simplificar, antes de verlo así en el ordenador, 00:08:21
algunas cositas que hay que tener claras. 00:08:28
Vamos a ver. 00:08:31
Cada, el nombre del paquete, es decir, las carpetas, no tienen que ser carpetas al mismo nivel todas y ya. 00:08:34
los paquetes pueden involucrar 00:08:44
sus carpetas, es decir, una aplicación 00:08:47
puede tener, a lo mejor 00:08:49
una aplicación mía, pues puede 00:08:50
tener una carpeta que sea 00:08:53
entidades 00:08:54
y esto es una carpetilla 00:08:55
¿esto qué significa? 00:08:59
Tenías dibujado la carpetita 00:09:05
Yo lo hubiera tenido que pensar mucho más 00:09:06
Es que estoy nojando 00:09:08
mucho mis habilidades artísticas 00:09:11
Si le haces un triangulito más 00:09:13
ya parece que es como si hubiese una escoba adentro 00:09:15
¿Un triangulito más como así? 00:09:17
No, ahí ya lo he estropeado 00:09:20
Hay que dibujar el papel dentro de la carpeta 00:09:22
No voy a dibujar nada 00:09:26
Silencio, vale 00:09:28
Entonces, en esta carpeta 00:09:30
Que se llama entidades 00:09:32
Aquí ya puede haber 00:09:34
Unas cuantas clases 00:09:36
Por ejemplo, a lo mejor yo aquí he metido 00:09:37
La clase profesor y la clase alumna 00:09:40
Por ejemplo 00:09:42
Vale 00:09:43
A lo mejor tengo en mi aplicación otra carpetita, ¿vale? Otra carpetita para meter las clases relacionadas con utilidades que me interesan. Esta aplicación va a hacer cosas matemáticas y tengo yo aquí algunas clases con utilidades matemáticas de números primos de patatín patatán que la voy a meter en una carpetita, esa carpetita utilidades, ¿vale? 00:09:45
Y aquí a lo mejor pues tengo unas cuantas clases como por ejemplo pues una clase primos donde tengo yo ahí métodos para hacer cosas con números primos o lo que sea, ¿vale? Entonces a lo mejor tengo también clases relacionadas con hacer lecturas de teclado. 00:10:16
Bueno, pues entonces 00:10:35
Esa clase la voy a meter 00:10:38
Por cuestión de organización en otra carpetita 00:10:39
Y ahí a lo mejor 00:10:42
Tengo una clase que se llama teclado 00:10:44
Pues para tener 00:10:46
Ahí recogiditos, los meto 00:10:48
Hacia abajo en el teclado 00:10:49
Entonces, primera pauta 00:10:50
Cuando una aplicación tiene un montón de clases 00:10:53
La idea es separarlas 00:10:55
Por de qué van estas clases 00:10:58
A qué se refieren 00:10:59
Siempre va a haber un conjunto de clases 00:11:00
Que son las entidades, siempre 00:11:03
de lo que se ocupa la aplicación. 00:11:04
Pues esas irán en un paquete aparte. 00:11:06
Un paquete aparte. 00:11:09
¿Vale? 00:11:10
O lo que es lo mismo, 00:11:12
una carpeta aparte. 00:11:13
Luego a lo mejor hay clases relacionadas 00:11:14
con la entrada y salida de datos. 00:11:16
Pues esas clases relacionadas 00:11:18
con la entrada y salida 00:11:19
irán en una carpetita, 00:11:20
paquete, 00:11:21
interfaz, 00:11:22
o como uno lo quiera llamar. 00:11:23
¿Vale? 00:11:24
Y así uno organiza su aplicación. 00:11:29
¿Vale? 00:11:31
Entonces de organización de aplicación, 00:11:31
del modelo en capas, 00:11:33
de todo eso, 00:11:34
pues hay muchos rollos 00:11:35
y muchas historias, 00:11:37
pero no es el momento de meternos ahora. 00:11:37
Bueno, pues entonces, esta aplicación tendría 00:11:39
tres paquetes. Entidades, utilidades, 00:11:41
entrada y salida. Tres paquetes. Vale. 00:11:43
Pero 00:11:47
si yo quiero más 00:11:47
paquetes, ¿es obligatorio que estén 00:11:49
todos al mismo nivel de anidamiento? 00:11:51
No. Estas carpetas 00:11:53
físicas pueden 00:11:55
tener subcarpetas. 00:11:57
Pueden tener subcarpetas. Por ejemplo, 00:11:59
dentro de las entidades, a lo mejor hay 00:12:01
algunas entidades que solo 00:12:03
se usan para una cosa específica, 00:12:05
Y quiero yo meterlas, porque queda más organizado, en una subcarpeta dentro de entidades. 00:12:07
Bueno, pues a lo mejor entidades puede tener una subcarpeta que se llame, pues yo qué sé, solamente para las clases relacionadas con la secretaría. 00:12:15
Y aquí a lo mejor pues tengo una clase que es la clase secretaria. 00:12:34
secretario. Entonces, por la razón 00:12:37
que sea, a mí me interesa 00:12:40
esta clase ponerla en una 00:12:42
subcarpeta de entidades, no en una 00:12:44
carpeta aparte, porque 00:12:46
me parece que una carpeta aparte no 00:12:48
refleja tan bien 00:12:50
la realidad de la 00:12:51
situación. El secretario 00:12:54
es una entidad también, la quiero 00:12:57
poner aquí, pero no es una entidad 00:12:59
del mismo estilo que profesor y alumno, 00:13:00
pues me hago una subcarpeta. 00:13:03
Entonces, las carpetas pueden tener subcarpetas. 00:13:05
¿eso qué significa? que aquí tengo 00:13:07
cuatro paquetes 00:13:09
tengo tantos paquetes como carpetas 00:13:10
me da igual que unas carpetas estén metidas dentro de otras 00:13:13
me da lo mismo 00:13:15
tengo tantos paquetes 00:13:17
como carpetas, aquí tendría cuatro 00:13:20
¿vale? me da igual 00:13:21
que estén metidos uno dentro de otros 00:13:23
para Java eso es lo de menos 00:13:24
a Java le da igual que estén metidas dentro de otros 00:13:26
tiene cuatro paquetes completamente distintos 00:13:29
distintos 00:13:31
y este y este no están relacionados 00:13:32
aquí no existe 00:13:35
lo de tengo un paquete dentro del otro 00:13:37
no, lo que pasa es que 00:13:39
físicamente, si está 00:13:42
uno en una carpeta, que está dentro 00:13:44
de la otra, pero son paquetes 00:13:45
independientes, me da igual 00:13:48
que físicamente una carpeta esté dentro de la otra 00:13:49
pero a nivel de código no incluye 00:13:52
para Java 00:13:52
este paquete y este tienen la misma relación entre ellos 00:13:55
que este y este, la misma, para Java 00:13:58
para Java hay un portal 00:13:59
justo 00:14:01
entonces 00:14:02
Entonces, ¿qué nombre tienen que recibir los paquetes? 00:14:04
Pues, para que Java, porque claro, luego esto, 00:14:09
si se distribuye ya la aplicación, 00:14:13
todo esto es lo que va metido en un hard, 00:14:15
todo esto va metido en un hard. 00:14:19
Entonces, la máquina virtual lo descomprime, 00:14:22
la máquina virtual lo descomprime, 00:14:24
y ¿qué nombre reciben, tienen que recibir los paquetes 00:14:26
a la hora de llamarlos, ya veremos cómo, dentro del código? 00:14:30
Pues para que Java se aclare 00:14:32
Porque si no es capaz de encontrar en las carpetas 00:14:34
Lo que nosotros le vamos a pedir por código 00:14:38
Cuando se lo pidamos 00:14:41
Para que Java se aclare 00:14:42
El nombre del paquete 00:14:43
Tiene que ser exactamente igual 00:14:45
Que el nombre de la carpeta 00:14:46
Si hablamos de una subcarpeta 00:14:48
Tiene que acompañar también 00:14:51
Con el punto 00:14:53
Con toda la ruta 00:14:54
Por ejemplo, aquí tendríamos cuatro paquetes 00:14:56
Paquete 1 00:14:59
Entidades 00:15:00
Ahí tendríamos un paquete, entidades. 00:15:01
Otro paquete, utilidades. 00:15:08
Otro paquete, entrada-salida. 00:15:16
Y tendríamos un cuarto paquete, que es el correspondiente a esta carpeta. 00:15:21
¿Cuál sería el nombre de este? 00:15:25
Toda la ruta, donde el separador ahora sería un puntito. 00:15:27
Sería entidades.secretaría. 00:15:33
Secretaría. Claro, cuatro 00:15:38
paquetes completamente independientes 00:15:43
para Java, cada uno con sus 00:15:45
clases. Lo que pasa es que Java 00:15:47
cuando nosotros, desde el 00:15:49
código, le digamos algo relacionado 00:15:51
con este paquete, al decirle 00:15:53
entidades.secretaría, él va a decir 00:15:55
ah, voy a buscar las clases 00:15:57
de este paquete en la carpeta 00:15:59
entidades y dentro de él en la carpeta 00:16:01
secretaría. Es decir, 00:16:03
el nombre del paquete 00:16:05
le sirve a Java para cuando le 00:16:07
Digamos, la clase que está en este paquete, Java entonces dice, ah, vale, me voy a la estructura de carpetas y me voy a la carpeta con ese nombre. 00:16:09
¿Qué tiene puntitos dentro? Pues sigo toda la ruta. 00:16:16
Entonces Java necesita que el nombre del paquete sea igual que el de la carpeta y si está en subcarpeta, añadido con la ruta, 00:16:20
porque luego le vamos a decir nosotros dentro, coge clases de este paquete, coge clases de este otro, 00:16:28
y él va a tener que saber 00:16:33
¿y dónde me voy a buscarlas? 00:16:35
Pues lo saca de aquí, tanto la ruta 00:16:36
como el nombrecito, ¿vale? 00:16:38
Bueno, pues... 00:16:41
Ahora de importar es más fácil, ¿no? 00:16:42
Porque puedes importar entidades asterisco 00:16:44
y importas todos los que estén dentro, ¿no es cierto? 00:16:46
No, importas todas las... 00:16:48
Eso lo haces solo con la clase, no todos los paquetes que estén dentro. 00:16:50
O sea, yo puedes hacer... 00:16:53
Bueno, ahora lo vemos, ¿vale? 00:16:55
El asterisco es para importar todas las clases 00:16:56
dentro de un paquete, no todos los subpaquetes. 00:16:58
Pero no todas las clases de los subpaquetes tampoco. 00:17:00
no, no, no, no, eso 00:17:02
vale, pues 00:17:04
esto está claro, ¿no? porque a veces 00:17:06
induce mucho error y os hacéis un lío 00:17:08
bueno, pues entonces 00:17:10
ahora ya, ¿qué ocurre con 00:17:14
nuestras aplicaciones cuando tenemos 00:17:16
clases que están en diferentes 00:17:18
paquetes? vamos a suponer que aquí 00:17:20
tenemos, yo tengo un paquete main 00:17:22
por aquí, este paquete 00:17:24
que es el paquete main 00:17:29
tendría aquí un quinto 00:17:31
paquete que es el paquete main 00:17:33
no comáis 00:17:35
por favor 00:17:37
tenéis que ser capaces de parar de comer 00:17:39
alguna vez 00:17:42
vale 00:17:43
además es que venís del recreo, venís comidos 00:17:47
y bebidos y fumados y de todo 00:17:49
vale 00:17:52
pues a ver 00:17:53
bueno, venís metidos 00:17:54
lo que sea 00:17:58
bastante que venís 00:17:59
bueno, vale 00:18:01
Pues ahora tenemos nuestra aplicación 00:18:03
Con clases en diferentes paquetes 00:18:05
Por ejemplo, ahora tenemos la main 00:18:07
Tengo mi clase main que está en el paquete main 00:18:09
Entonces nosotros tendríamos aquí nuestra 00:18:11
Clase main 00:18:13
Con el método main, por ejemplo 00:18:14
Y vamos a imaginarnos que la clase main 00:18:18
Lo que quiere hacer es 00:18:21
Instanciar un objeto profesor 00:18:22
¿Nosotros qué hemos hecho hasta ahora? 00:18:24
Pues hemos hecho aquí 00:18:27
Profesor 00:18:28
Igual a bla bla bla 00:18:32
Vale, pues si nosotros seguimos haciendo eso, en una situación en la que las clases están en paquetes distintos, el compilador me va a decir, ¿eh? ¿Quién es profesor? No tengo ni idea de quién es profesor, porque el compilador va a mirar solo en la carpetita donde está esta. 00:18:34
Eso es la carpetita. 00:18:53
Entonces, ¿qué tenemos que hacer? 00:18:55
Pues va a hacer falta dos cosas. 00:18:57
Una, decirle a esta clase dónde está esta. 00:19:00
Esa es la primera cosa que va a hacer falta, pero no es suficiente. 00:19:05
Luego, además, la clase profesor tiene que dar permiso para ser utilizada fuera del paquete. 00:19:08
¿Y cómo da permiso la clase profesor para ser utilizada fuera del paquete? 00:19:14
Pues da permiso poniéndose el public delante 00:19:19
Entonces, cuando uno pone un public 00:19:23
Delante de una clase, dice 00:19:26
Oye, doy permiso 00:19:28
Al resto de las clases de otros paquetes 00:19:29
A que me usen 00:19:33
¿Vale? A que me usen 00:19:34
Porque si no se pone el public, no 00:19:36
Nosotros hasta ahora, como todas las clases 00:19:38
Las teníamos siempre en el mismo 00:19:40
Nos olvidamos del public 00:19:42
Porque no hay que dar ese permiso explícito 00:19:44
¿Vale? Pero ahora sí 00:19:46
y no solo hay que dar permiso 00:19:48
sino que además en esta 00:19:50
hay que decir, oye, profesor está en este paquete 00:19:51
¿y cómo lo podemos decir? 00:19:54
de dos maneras 00:19:57
o bien dando el nombre 00:19:58
completo de la clase, que os he mentido 00:20:00
como tantas veces que os miento 00:20:02
profesor no es el nombre 00:20:03
aunque yo ya he hecho una clase 00:20:07
profesor 00:20:08
la clase no se llama profesor 00:20:09
la clase se llama profesor 00:20:12
y con todo el paquete 00:20:14
en el que está adelante. Esta clase profesor 00:20:16
al estar dentro de entidades 00:20:19
su nombre verdadero 00:20:20
entidades.profesor 00:20:23
Lo que pasa es que cuando yo no pongo 00:20:26
esto, cuando yo no pongo esto 00:20:28
la máquina virtual asume que está en este 00:20:30
paquete. Entonces no hay problema. 00:20:32
Como nosotros hasta ahora todas las clases estaban 00:20:34
en el mismo, no poníamos esto. 00:20:36
Porque entonces el compilador 00:20:39
lo busca en la misma carpeta y lo encuentra. 00:20:40
Pero si profesor está en otro 00:20:42
hay que poner 00:20:44
el nombre real de la clase 00:20:46
y el nombre real de la clase es 00:20:48
el que acompaña al class 00:20:50
y delante el nombre del paquete 00:20:52
entidades o entidades 00:20:54
punto secretaría, el que sea 00:20:56
lo que pasa es que eso a veces se hace 00:20:58
pesado, el tener nombres de clases tan largos 00:21:00
pues podemos hacer un apañito 00:21:02
un apañito poniendo un import 00:21:04
arriba, ¿vale? 00:21:06
esa es la idea, ahora viéndolo en código 00:21:08
va a quedar más claro que aquí en el lío de la pizarra 00:21:10
pero la idea en general está 00:21:12
¿no? 00:21:14
puntos de la idea 00:21:14
las clases 00:21:17
están en diferentes paquetes 00:21:19
y la aplicación es 00:21:20
un ficherito .jar que comprime 00:21:22
todas estas carpetas con los paquetes 00:21:25
vale, cada 00:21:27
carpeta, me da igual que esté dentro 00:21:30
una de la otra, es un paquete distinto 00:21:32
que tiene que recibir obligatoriamente 00:21:34
tiene que recibir el nombre 00:21:36
de la carpeta en la que está 00:21:38
si es subcarpeta 00:21:40
pues tiramos hasta arriba hacia toda la ruta 00:21:42
pero el separador un poco 00:21:45
y ahora ya, cuando una clase de un paquete 00:21:46
quiere usar clases 00:21:50
de otro para instanciarlas 00:21:52
para hacer el nido, para lo que sea 00:21:53
esa otra clase tiene que haber dado 00:21:55
permiso con el public delante, que de eso es 00:21:57
de lo que haremos los detalles 00:21:59
y además la otra clase tiene que 00:22:00
especificar dónde está, porque si no 00:22:03
lo especifica, el compilador 00:22:05
a asumir que está en el mismo paquete 00:22:09
con lo cual no la va a encontrar nunca 00:22:11
¿Vale? Esas son las ideas 00:22:13
Y ahora ya 00:22:15
Lo vemos en concreto 00:22:16
En el código que se ve más limpio 00:22:19
Pues venga 00:22:20
A ver 00:22:26
A ver 00:22:28
Ejemplito, paquetitos 00:22:52
Bueno, pues 00:22:55
Todo, todo lo que vemos aquí es 00:23:05
Importante, ¿eh? 00:23:07
No está todo seleccionado para que sea imprescindible 00:23:09
Así que todo 00:23:12
Lo tenéis que saber, todo 00:23:13
Vale, no 00:23:15
Contamos ni una mamonada, ni una 00:23:15
Todo imprescindible 00:23:18
Luego ya vosotros tenéis espacio para ampliar 00:23:20
Todo lo que queráis 00:23:23
Vale, pues venga, vamos a hacernos un proyecto 00:23:24
De ejemplo que subiremos para ver esto 00:23:29
De los modificadores de acceso 00:23:31
Pues vamos a 00:23:32
Llamarlo 00:23:35
A ver, ya se, tapo tanto 00:23:38
Un nuevo proyecto 00:23:41
Ejemplo 00:23:47
Clase 00:23:51
Modificadores 00:23:52
Bueno, paquetes para que no sea un nombre tan largo 00:23:55
Ejemplo clase, paquetes 00:23:58
Pues venga 00:24:00
Vamos a hacernos ahora ya una aplicación 00:24:07
Con 00:24:09
Tres paquetes distintos 00:24:10
Uno de ellos metido dentro de 00:24:12
En una carpeta metida dentro de la otra 00:24:14
Vale, pues venga 00:24:16
Aunque no tenga mucho sentido, vamos a hacer algo parecido a eso 00:24:18
Vamos a hacernos un primer paquete 00:24:20
Entonces 00:24:23
Un primer paquete, entidades 00:24:26
vale, este primer paquete 00:24:28
de entidades pues va a tener una clase 00:24:40
profesor 00:24:42
vamos a ponerle 00:24:43
una propiedad y un método 00:24:49
le voy a quitar el public por ahora 00:24:52
le vamos a poner como hemos hecho hasta ahora 00:24:54
una propiedad 00:24:58
y un método para luego ver como 00:25:00
funcionan los modificadores de acceso 00:25:02
tanto en las propiedades como en métodos 00:25:04
este profesor tiene su nombre 00:25:05
vamos a ponerle 00:25:10
un constructor 00:25:12
Al que le vamos a quitar lo que le hemos quitado hasta ahora 00:25:13
Siempre 00:25:20
El public y esto 00:25:21
Es una clase como la que hemos hecho hasta ahora 00:25:22
Sin public y sin nada, ignorándolo todo 00:25:26
Y vamos a poner un método cualquiera 00:25:28
Para mostrar el nombre 00:25:32
Sin más 00:25:34
Este método es un método de la clase profesor 00:25:35
Que cuando un profesor lo llame 00:25:47
Mostrará por consola el nombre del profesor 00:25:49
Pues ya está, nada más 00:25:51
Sin parámetros de entrada y sin nada 00:25:52
Que suba 00:25:55
Un paquete entidades cualquiera 00:26:03
¿Vale? 00:26:11
Una clase mínima porque vamos a 00:26:17
Lo que vamos a ver aquí solo son 00:26:19
Cómo funciona lo de los diferentes paquetes 00:26:20
Y los modificadores 00:26:23
¿Vale? 00:26:23
Vamos a hacernos 00:26:29
Otro paquete, el paquete main 00:26:31
Que va a tener la clase main 00:26:34
Pues nos hacemos un paquete 00:26:35
Main 00:26:38
y vamos a hacer aquí la clase main 00:26:42
para hacer cosas con este de aquí. 00:26:47
Vale, todavía no hacemos nada en el main. 00:26:58
Tengo el main, todavía no hace nada la aplicación. 00:27:02
¿Vale? 00:27:07
Vale. 00:27:14
Ahora vamos a hacernos un paquete 00:27:15
para tener al secretario del instituto 00:27:18
que por la razón que sea, 00:27:22
a mí ese paquete me interesa que esté dentro de entidades 00:27:24
porque me parece mejor organizado. 00:27:27
Pues entonces 00:27:29
En el mismo SRC 00:27:31
Digo 00:27:34
Voy a crearme un paquete 00:27:34
Y a este paquete le llamo 00:27:37
Entidades.secretaria 00:27:41
Por ejemplo 00:27:45
¿Veis? Y tengo tres paquetes completamente distintos 00:27:46
Este paquete me lo he creado yo desde aquí 00:27:57
SRC, nuevo paquete 00:28:00
Y le he dado yo el nombre 00:28:01
Entidades.secretaria 00:28:02
Entonces tengo tres paquetes distintos 00:28:04
entidades, entidades secretaría y el main 00:28:07
en entidades secretaría 00:28:10
vamos a hacernos una clase también 00:28:14
la del secretario 00:28:15
nos hacemos 00:28:18
una nueva clase 00:28:20
también le quitamos el public porque todavía 00:28:21
no sabemos ni para qué 00:28:29
y le vamos a poner también al secretario 00:28:30
pues una 00:28:33
una propiedad, un constructor 00:28:34
que también le quitamos 00:28:39
esto y esto 00:28:43
y un método cualquiera 00:28:47
un método cualquiera también 00:28:49
para mostrar el nombre del secretario 00:28:51
vale 00:28:53
bueno, pues ya está 00:28:57
entonces ya tenemos 00:29:04
tres paquetes distintos 00:29:07
efectivamente 00:29:08
si vemos la estructura de carpetas 00:29:10
que se ha hecho por dentro 00:29:12
pues Eclipse 00:29:15
ha creado una subcarpeta 00:29:17
secretaria dentro de entidades 00:29:19
de hecho vámonos a la estructura de carpetas 00:29:20
que la forma sencilla de iros 00:29:23
que siempre os lo digo en el examen, pues si dais aquí en el botón derecho, 00:29:25
decir muéstrame el proyecto en el sistema de archivos, muéstramelo. 00:29:28
Pues este es el proyecto en el sistema de archivos. 00:29:34
Si miramos nuestro proyecto en el sistema de archivos, 00:29:41
aquí en SRC efectivamente tiene carpeta main con la clase main, 00:29:45
carpeta entidades con la clase profesor y dentro secretaría con la clase secretario. 00:29:52
Y aunque secretaría sea una subcarpeta de esta, aunque sea una subcarpeta, son dos paquetes independientes, dos paquetes independientes. Y de hecho aquí en el eclipse pues lo veo que son, ¿dónde está esto? 00:29:58
lo veo que son tres paquetes independientes 00:30:14
lo que es obligatorio 00:30:19
eso sí es que el nombre de este arrastre 00:30:20
toda la ruta de carpetas 00:30:22
desde la raíz del proyecto, con el puntito 00:30:24
y podría haber siete subcarpetas 00:30:26
anidadas, el nombre del proyecto sería 00:30:30
del paquete sería larguísimo 00:30:32
papá, punto, papá, punto 00:30:35
papá, papá, vale, pero no pasa nada 00:30:37
es que en un proyecto real 00:30:38
es así, si uno 00:30:40
redespliega 00:30:43
no os acordaréis, claro, el proyecto 00:30:44
que desplegó Iván el otro día, que tenía un montón de paquetes 00:30:46
algunos paquetes, tenía un nombre enorme 00:30:48
porque 00:30:51
estaban separados por un montón de puntos, porque eran muchas 00:30:52
sus carpetas, ¿vale? 00:30:54
vale, pues entonces 00:30:57
ya tenemos esta organización de paquetes 00:30:58
porque hemos querido hacerla así 00:31:00
ahora 00:31:02
¿qué implicaciones tiene si yo desde mi 00:31:03
main quiero hacer profesores? 00:31:06
pues nos vamos al main 00:31:08
esta aplicación, lo primero 00:31:09
lo que quiere hacer es crear un objeto profesor. 00:31:12
Venga, vamos a crear un objeto 00:31:15
profesor. 00:31:16
Y nosotros hasta ahora 00:31:19
hemos actuado de esta manera. 00:31:20
¿No os has engañado? 00:31:23
No os he engañado. Lo que pasa es que 00:31:25
no os he dado toda la información. 00:31:26
Bueno, entonces... 00:31:28
A ver, en realidad no os he... 00:31:30
Gracias. 00:31:32
En realidad no os he engañado. Lo que pasa es que 00:31:34
trabajamos en un único paquete, pues para no tener 00:31:36
estos problemas. 00:31:38
Bueno. 00:31:40
Efectivamente, me dice 00:31:42
¿Qué error me dice? Me dice 00:31:44
Uy, profesor no tengo 00:31:46
Ni puñetera idea de a qué te refieres 00:31:48
Con profesor, porque lo que 00:31:50
Hace él es ir dentro del paquete 00:31:52
En el que está, que es el main 00:31:54
Y ahí en ese paquete main no ve a nadie que se llame profesor 00:31:55
No ve a nadie 00:31:58
Le decimos, tranquilo 00:32:00
No te preocupes, es que yo 00:32:02
Te he dado el nombre corto 00:32:03
Dice 00:32:05
Te he dado el nombre corto 00:32:07
Y el nombre corto de la clase 00:32:09
es válido solo cuando 00:32:11
está en el mismo paquete. 00:32:14
Como no está en el mismo paquete, dice, te voy a dar 00:32:16
el nombre largo. ¿Y el nombre largo 00:32:18
cuál es? Este es el nombre 00:32:20
largo. ¿Vale? 00:32:22
Entidades, uy. 00:32:24
Punto 00:32:27
profesor. ¿Vale? 00:32:28
Este es el nombre largo. 00:32:30
Vale. Pero me sigue 00:32:34
diciendo. Ahora 00:32:36
ya no me 00:32:38
dice, no tengo ni idea de a quién te 00:32:40
refieres. Ahora me dice 00:32:42
otro mensaje. Ahora me dice, 00:32:45
ya sé a quién te refieres, porque me has dado el nombre largo. 00:32:47
Y el nombre largo es 00:32:49
absolutamente unívoco. Ahora me dice, 00:32:50
ojo, es que no es visible. 00:32:53
No es visible. 00:32:56
Vale. Pues venga, vámonos 00:32:57
a profesor. ¿Qué es lo que 00:32:59
tenemos que hacer? Lo primero 00:33:01
y no último que tenemos que hacer. 00:33:03
Poner el public. 00:33:06
Vale. 00:33:08
Hemos arreglado todos nuestros problemas. 00:33:10
no, hemos arreglado este 00:33:11
pero poner aquí 00:33:14
el public, lo único que significa 00:33:16
es que yo permito 00:33:18
voy a permitir 00:33:20
que esta clase sea usada 00:33:21
pero que voy a permitir que sea usado 00:33:23
lo que además especifique 00:33:26
aquí uno por uno, es decir 00:33:28
public no significa poner aquí public arriba 00:33:30
que yo pueda usar todo lo que 00:33:32
hay dentro según me dé la gana 00:33:34
por ejemplo, aquí estoy usando 00:33:35
el constructor 00:33:38
el constructor tiene un public 00:33:38
delante, no 00:33:42
con lo cual no puedo usarlo 00:33:43
entonces 00:33:45
poner public delante de la clase 00:33:47
es el primer paso 00:33:49
pero luego yo ya adentro 00:33:52
decido de todo lo que hay dentro 00:33:53
que hago publico y que no, puedo decidir que solo 00:33:55
sea publico el constructor y lo demás no 00:33:57
puedo decidir lo que yo quiera 00:33:59
hombre, pues si quiero instanciar un objeto 00:34:01
el constructor va a tener que ser publico, no hay otra 00:34:03
pues entonces ahora ya sí 00:34:05
le ponemos un public 00:34:07
vale 00:34:08
entonces ahora ya el main se cayó 00:34:10
porque ha encontrado tanto la referencia 00:34:12
a la clase, ya la ha encontrado porque le hemos dado 00:34:14
el nombre largo y ha encontrado 00:34:16
que el constructor es público 00:34:18
magnífico, pero claro 00:34:20
¿qué pasaría si nosotros 00:34:22
quisiéramos ahora llamar al 00:34:24
método de profesor 00:34:26
mostrar nombre 00:34:28
o como se llama el método 00:34:30
es que no me lo ofrece 00:34:32
porque no es público, claro, mostrar nombre 00:34:35
¿Qué pasa si yo quiero ahora 00:34:36
Llamar a este método? 00:34:39
Que es un método que tiene esa clase hecho ahí estupendo 00:34:40
Para mostrar el nombre 00:34:42
¿Se puede? 00:34:43
Pues que de nuevo 00:34:46
De nuevo me dice el compilador 00:34:47
¡Ojo! 00:34:50
Mostrar nombre no está visible 00:34:51
Lo siento, pero mostrar nombre no está visible 00:34:53
Entonces 00:34:56
¿Queremos 00:34:57
¿Queremos dar permiso 00:34:59
A usar este método desde fuera? 00:35:02
Sí, queremos dar permiso 00:35:04
pues entonces le pongo un public 00:35:06
entonces 00:35:08
lo ultimito por recopilación solo 00:35:09
recordad 00:35:13
el public aquí delante de la clase 00:35:14
significa que la referencia 00:35:16
ahora he declarado una clase, a declararla la va a encontrar 00:35:19
pero luego tú ya 00:35:21
lo que puedas usar o no 00:35:23
de métodos, de propiedades, dependerá del public 00:35:25
por ejemplo, ¿qué pasa si yo 00:35:27
quiero acceder directamente 00:35:29
a la propiedad nombre? 00:35:30
como hemos hecho hasta ahora 00:35:32
yo quiero acceder directamente a la propiedad nombre 00:35:36
directamente 00:35:39
me dice, no, nombre no está visible 00:35:39
¿por qué? 00:35:43
porque no tiene el public delante 00:35:44
¿quiero yo acceder desde el main 00:35:46
directamente a la propiedad nombre? 00:35:48
hombre, pues en este caso, en este ejemplo 00:35:51
en concreto sería una tontería 00:35:52
porque ya tengo un método que me muestra el nombre 00:35:54
a lo mejor 00:35:56
me interesa acceder para darle un valor 00:35:58
por ejemplo, yo quiero 00:36:00
acceder a la propiedad 00:36:02
nombre para cambiárselo. 00:36:05
Pues no podría. Tal y como está 00:36:08
en la aplicación, no puedo. Porque la 00:36:10
propiedad nombre no tiene el public delante. 00:36:12
No es visible. 00:36:15
Vale. Yo quiero acceder a la propiedad 00:36:16
nombre. Pues 00:36:19
le pongo el public. 00:36:21
Ahora ya sí me deja. 00:36:23
¿Vale? 00:36:25
Pedro, ¿qué ibas a preguntar? 00:36:26
Nada. ¿He perdido 00:36:28
la oportunidad? 00:36:31
Pues nada. Es tu opinión. 00:36:32
Vale, entonces 00:36:35
¿Necesitáis descansar? 00:36:39
Vale, pues antes de descansar 00:36:42
Ya lo último 00:36:43
Y así os vais con el cuerpo más tranquilo 00:36:45
Realmente 00:36:47
Arrastrar el nombre largo de la clase 00:36:49
Todo el rato es un rollo 00:36:51
Porque imaginaos que ahora quiero yo hacer un secretario 00:36:52
Me queda un pedazo de nombre 00:36:55
Muy largo 00:36:57
Entidades 00:36:59
Punto secretaría 00:37:00
Punto secretario 00:37:03
secretario. Voy a ponerle public para que me deje. Vale, entonces, ¿que yo quiero declarar 00:37:05
un secretario? Pues un nombre largo es que es muy largo, es larguísimo. ¿Y qué ocurre 00:37:18
si tengo un paquete así de largo con 200.000 nombres separados por puntitos? ¿Qué ocurre? 00:37:23
Pues que me queda ahí solamente para declararle el objeto, me queda una línea gigante. No 00:37:31
pasa nada, lo puedo hacer, pero queda un poco 00:37:37
feo. Entonces, la máquina 00:37:39
virtual me dice, o Java 00:37:41
en general, me dice, venga, te dejo 00:37:43
un truquito, para no tener que estar 00:37:45
arrastrando el nombre largo todo el rato, 00:37:47
que es bastante recomendable, para no tener 00:37:49
lo que está arrastrando, te dejo 00:37:51
que hagas un import arriba. 00:37:53
¿Un import? 00:37:55
Entonces, yo digo, a ver, 00:37:57
yo quiero decir a la clase main, oye, clase 00:37:59
main, cada vez que uses 00:38:01
la palabra secretario, 00:38:03
cada vez que use la palabra secretario 00:38:05
me refiero al secretario 00:38:10
de entidad de secretaría 00:38:13
entonces, para no tener que verlo todo el rato 00:38:14
no, dis no, le pones esto aquí 00:38:17
delante, después del package 00:38:19
que por otro no hemos dicho 00:38:21
que siempre tiene que haber una línea package 00:38:21
al principio del paquete, ponme aquí delante 00:38:24
el nombre de la clase 00:38:27
entidades.secretaria.secretario 00:38:28
entonces poniendo este import 00:38:33
ahora ya, cada vez que pongas 00:38:39
secretario aquí 00:38:41
él ya sabe que te refieres a este 00:38:42
entonces poniendo 00:38:45
esta línea no tienes que arrastrar todo el rato 00:38:47
entidades.secretaria.secretario 00:38:49
y también que no queremos arrastrar 00:38:51
la entidad de profesor todo el rato 00:38:55
que quiero yo trabajar con profesor solo 00:38:57
pues podría hacer otro import 00:38:59
e import hago los que me den la gana 00:39:01
normalmente una clase normal pues tiene 00:39:03
57 import, porque estás importando 00:39:05
muchos paquetes de muchos sitios 00:39:08
vale, si yo pongo el import 00:39:09
pues entonces ya no me hace falta 00:39:15
lo puedo poner, no sobra 00:39:17
pero ya no me hace falta el nombre largo 00:39:18
ya no me hace falta, pero porque he puesto 00:39:20
el import, vale 00:39:23
está claro, si yo no pongo el import 00:39:24
tengo que poner 00:39:29
el nombre largo 00:39:30
que es el nombre con todo su prefijo 00:39:31
del paquete, vale 00:39:35
cuidado con los import 00:39:43
porque imaginaos 00:39:48
que en la clase main 00:39:50
tengo una clase que se llama profesor 00:39:52
y tengo otra 00:39:54
que se llama profesor otro paquete 00:39:56
no hay ningún problema, yo puedo tener perfectamente 00:39:57
clases con el mismo nombre 00:40:01
en la misma aplicación, con que estén en diferentes 00:40:02
paquetes, porque como ya sabemos 00:40:04
que el nombre real de la clase le acompaña 00:40:06
el nombre de su paquete, los nombres van a ser 00:40:08
distintos, puedo tener una clase profesor 00:40:10
en este paquete y otra clase profesor 00:40:12
en ese otro, perfectamente, y cada una tendrá 00:40:14
su nombre largo distinto 00:40:16
pues ¿qué ocurre si en esta clase main 00:40:17
tengo yo una clase que se llama 00:40:20
en este paquete, perdón, tengo una que se llama 00:40:22
profesor 00:40:24
justo, si yo no pongo el apellido este 00:40:24
pongo profesor 00:40:28
él va a asumir que te refieres 00:40:30
a la que está en el paquete y no va a mirar el import 00:40:32
no va a mirar el import 00:40:34
y a lo mejor tú te crees porque has puesto 00:40:36
el import 00:40:38
te crees que se está refiriendo 00:40:38
al profesor de este paquete 00:40:41
y no, se refiere al profesor 00:40:43
que está en el paquete en el que estás tú. 00:40:46
Es la primera que mira. 00:40:48
La primera que mira. 00:40:50
Entonces, cuidado con si hay clases 00:40:51
que se llaman igual. 00:40:54
Cuidado, ¿vale? 00:40:56
Entonces, si tienes clases 00:41:04
que se llaman igual, 00:41:06
llámalas a todas, 00:41:07
dándole el nombre. 00:41:09
Entonces, 00:41:10
si yo pongo aquí entidades profesor, 00:41:11
no hay ninguna confusión. 00:41:14
Si pongo entidades profesor, 00:41:16
sé que se va a referir a esa. Entonces, a veces 00:41:17
el nombre largo es imprescindible 00:41:19
porque es la única forma de decirle exactamente 00:41:21
es que quiero esta. No quiero la 00:41:23
que está en el mismo paquete tuyo. Quiero 00:41:25
esa. Pues no es el importe 00:41:27
en ese caso la manera, sino exponiendo 00:41:29
su nombre real. Bueno, hasta aquí 00:41:31
que es la pequeña introducción 00:41:35
más o menos. Pues entonces 00:41:37
paramos, vale. Lo de levantar la 00:41:39
mano era el descansito. Un segundísimo. 00:41:41
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:
13
Fecha:
10 de diciembre de 2024 - 18:36
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
41′ 43″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
825.70 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid