Saltar navegación

20251209 POO_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 9 de diciembre de 2025 por Raquel G.

3 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, a ver, pues el otro día, a partir de esta aplicación que corregimos, de esta de cuenta, ¿verdad?, de esta de aquí, bueno, pues aunque parecía una chorrada, pues sacamos varias cosas. 00:00:00
Entre ellas incorporamos el concepto de método constructor, ¿verdad?, que es un método especial. 00:00:16
No funciona como el resto de métodos que siguen todos la misma regla. El nombre que ahí me dé la gana, lo más explicativo posible y con minúscula esto por cuestión de estilo, no por obligación. 00:00:27
parámetros que usa el método 00:00:40
que es toda esa información 00:00:43
que el método necesita para trabajar 00:00:44
que no está dentro 00:00:47
del objeto que lo llama 00:00:48
porque lo que está dentro del objeto que lo llama 00:00:50
está ahí y puede acceder 00:00:52
directamente 00:00:54
y luego ya el método 00:00:55
opera, hace lo que le da la gana 00:00:58
con esos parámetros que ha recibido de fuera 00:01:00
que tendrán la información adicional de fuera 00:01:02
y con 00:01:04
las propiedades del objeto que lo llama 00:01:06
opera, hace lo que sea 00:01:08
y eso puede ser 00:01:09
mostrar por consola, conectarse a una base de datos 00:01:11
cualquier cosa y puede ser que 00:01:13
además 00:01:15
entregue, mande 00:01:16
al exterior, lance al exterior 00:01:19
un único valor 00:01:21
si eso ocurre tendrá que haber un retune 00:01:22
con ese valor que lanza al exterior 00:01:25
y aquí el tipo de dato 00:01:27
del valor lanzado 00:01:29
si no lanza nada al exterior 00:01:31
un void 00:01:33
y luego ya como llamamos a ese método 00:01:33
Pues ya lo sabemos, ¿cómo llevamos a ese método? Pues con su nombre y pasándole tantos parámetros ya concretos, valores concretos, en este caso el valor concreto leído por consola, pasándole tantos parámetros como necesite. 00:01:37
y luego el valor de retorno 00:01:53
si lo tuviera 00:01:55
lo uso yo para lo que quiera 00:01:56
para asignarle una variable 00:01:58
en este caso igual de para asignarle una variable 00:02:00
lo uso para concatenar 00:02:03
para lo que quiera ese valor de retorno 00:02:04
si lo quiero usar lo uso para lo que quiera 00:02:06
y si no lo quiero usar 00:02:09
llamo al método sin más y lo tiro a la basura 00:02:10
no pasa nada 00:02:13
entonces el constructor 00:02:13
era un método especial porque 00:02:18
su nombre es obligatoriamente 00:02:20
el de la clase 00:02:23
mayúscula incluida 00:02:24
no devuelve nada 00:02:27
pero ni siquiera se especifica con void 00:02:30
no devuelve nada 00:02:32
recibe los parámetros que uno quiera 00:02:33
y puede tener varias versiones 00:02:36
esta versión sin parámetros 00:02:37
esta que tiene dos 00:02:39
puede tener todas las versiones que quiera 00:02:41
cuando se llama este método 00:02:45
se le llama en un momento concreto 00:02:47
y solo en ese, no se le puede llamar 00:02:49
cuando uno quiera en cualquier otro momento, no solo en ese 00:02:51
se le llama automáticamente 00:02:53
la máquina virtual lo llama 00:02:56
cuando se crea el objeto con el new 00:02:57
ahí se le llama 00:03:00
¿y qué parámetros recibe el método? 00:03:01
los que vayan en los paréntesis 00:03:04
entonces 00:03:05
si yo estoy llamando a este 00:03:07
como este recibe un string 00:03:09
y un double 00:03:11
pues la máquina virtual no tiene duda 00:03:13
de que al que se está llamando 00:03:15
es al que recibe un string y un double 00:03:16
no tiene duda 00:03:18
pero si estoy llamando a este 00:03:19
que no recibe nada, entonces no tiene duda 00:03:22
del que tiene que invocar es este 00:03:25
porque no recibe nada 00:03:26
que yo llamo 00:03:28
a uno 00:03:31
aquí 00:03:31
llamo a uno con otro parámetro 00:03:33
además, con el número 7 00:03:36
el compilador me dirá, oye 00:03:38
no hay ningún constructor 00:03:40
preparado para recibir 00:03:42
un string, un double 00:03:44
y un int, no lo hay 00:03:46
no lo hay, entonces me da error 00:03:48
y efectivamente no lo hay 00:03:50
yo solo tengo constructores preparados 00:03:51
para recibir 00:03:54
nada 00:03:54
o para recibir un string 00:03:56
o un double, solo tengo constructores preparados para eso 00:04:00
entonces solamente 00:04:02
puedo instanciar objetos 00:04:03
o con esta variante o con esta otra 00:04:05
no con otras 00:04:08
¿vale? 00:04:09
bueno 00:04:12
¿está claro? ¿hasta ahí? 00:04:13
sí 00:04:16
muy bien, bueno pues ya llega el momento 00:04:16
podemos ya posponerlo más 00:04:20
vamos a tener ya 00:04:21
que enfrentarnos a los public 00:04:24
estos que siempre 00:04:26
quitamos, ponemos, que no sabemos ni por qué 00:04:28
se ponen, ya tenemos 00:04:30
que enfrentarnos ya cuando ya tenemos 00:04:32
varias clases, que es nuestro caso, ahora ya 00:04:34
nuestros ejercicios tienen varias clases 00:04:36
no solo una, ahora ya 00:04:38
sí que sí, lo del public, private 00:04:40
etcétera, podemos jugar con ello 00:04:42
ahora ya sí, cuando tenemos varias 00:04:44
vale, pues vamos a ver 00:04:46
un poquito qué significa eso 00:04:48
y luego cómo lo 00:04:50
lo usamos 00:04:52
vale 00:04:54
pues 00:04:59
esto 00:04:59
¿dónde está el roto? 00:05:02
bueno, pues ahora ya sí 00:05:18
que sabemos que una aplicación 00:05:18
¿verdad? 00:05:20
una aplicación en Java, ¿qué es? 00:05:22
es un montón de clases 00:05:25
un conjunto de clases, ¿verdad? 00:05:26
la aplicación que hemos hecho en el ejercicio 00:05:37
11, tiene 00:05:38
la clase cuenta 00:05:40
que representa el concepto 00:05:41
cuenta con las cosas que puede 00:05:44
hacer, ¿vale? 00:05:46
Representa el concepto cuenta como su 00:05:48
cantidad 00:05:50
y titular 00:05:52
y además tiene las cosas 00:05:53
que puede hacer como recibir dinero 00:05:56
en un ingreso, soltar dinero 00:05:58
en una retirada, pues tiene la clase 00:06:00
cuenta y luego además tiene la clase 00:06:02
main, la clase que llamamos la clase principal 00:06:04
porque de este conjunto de clases 00:06:06
si la aplicación es de escritorio y queremos ejecutarla en un ordenador 00:06:09
una será la principal 00:06:12
es decir, la que tiene el método main 00:06:16
la que tiene el main 00:06:19
y ahora cuando lanzamos esa aplicación 00:06:22
la máquina virtual 00:06:26
se va a buscar ese main 00:06:28
y empieza a ejecutar desde ese main 00:06:31
y ahora ya ese main 00:06:37
pues crea objetos de las clases que sea 00:06:38
¿vale? eso es como hemos trabajado hasta ahora 00:06:41
crea objetos de las clases que sea 00:06:43
en el ejercicio 11 00:06:45
este main creaba 00:06:46
un objeto cuenta y con ese objeto cuenta 00:06:49
hacía retiradas, ingresos 00:06:51
¿vale? conclusión 00:06:53
una aplicación son muchas clases 00:06:54
¿vale? 00:06:57
pueden ser 2, 3 o 100.000 00:06:59
entonces si son 100.000 00:07:01
vamos a meter 00:07:03
un poquito de organización 00:07:05
porque si son 100.000 y me dicen 00:07:06
oye, retoca la clase usuario 00:07:08
porque al usuario ahora le hemos metido 00:07:10
su dirección 00:07:13
de correo electrónico. 00:07:15
Madre de Dios, tienes todavía mil clases 00:07:16
hasta que encuentras a tu usuario. 00:07:18
Cuando ya tenemos muchas, vamos a 00:07:20
organizarlas un poquito para que 00:07:22
a la hora de retocar la aplicación me sea más fácil 00:07:24
encontrar la clase que estoy 00:07:26
buscando. 00:07:28
Bueno, pues ¿cómo 00:07:30
organizamos las clases? 00:07:32
Las organizamos en paquetes, ¿verdad? 00:07:34
Entonces, una aplicación normal son varias clases 00:07:50
Si son poquitas, podría tenerlas todas en el mismo paquete 00:07:54
Pero si son muchas clases, lo normal es que las tengan paquetes separados 00:07:59
¿Vale? Entonces, cada paquete es una carpeta de clases 00:08:03
¿Vale? Cada paquete es una carpeta con clases 00:08:08
Vale, bueno pues mi aplicación, mi aplicación de gestión de facturas, mi aplicación de gestión de matrículas, mi aplicación de usuarios, la que sea, mi aplicación de inventario, pues mi aplicación tendrá varios paquetes o lo que es lo mismo, varias carpetas y cada carpeta tendrá unas cuantas clases y todas ellas serán la aplicación. 00:08:12
y de todas ellas, una y solo una 00:08:45
debería tener 00:08:48
este método 00:08:50
de tal manera que cuando la aplicación se arranque 00:08:51
el punto de arranque 00:08:54
es este 00:08:56
y a partir de ahí ya 00:08:57
se empiezan a crear objetos de otras clases 00:08:59
que llaman a métodos, babababa 00:09:02
todo lo que sea 00:09:04
bueno, está ahí claro, ¿no? 00:09:05
o sea, cada paquete tiene que tener un main 00:09:07
no, la aplicación 00:09:09
tiene un único main, que estará en uno 00:09:11
de los paquetes en el que sea 00:09:13
Un main por aplicación 00:09:14
Porque la aplicación tiene que arrancar en un punto 00:09:18
Y va a arrancar en ese main 00:09:21
En ese único main 00:09:22
O sea, ahora lo que estamos haciendo nosotros no sería 00:09:24
Sería un proyecto con un main 00:09:26
Sí, a ver, lo que pasa es que 00:09:29
Como estamos haciendo 00:09:30
Para no tener miles de proyectos 00:09:31
Para cada ejercicio 00:09:34
Pues estamos metiendo en un único proyecto 00:09:35
Varios ejercicios 00:09:38
Y entonces por eso hay varios main 00:09:40
Pero es que cada main es una aplicación distinta 00:09:41
cada mail es un ejercicio distinto 00:09:44
lo que es una aplicación distinta 00:09:47
entonces asociamos mail a aplicación 00:09:48
entonces ya no solo estará el mail 00:09:50
sino el resto de clases 00:09:52
que se empiezan a instanciar 00:09:54
desde el mail 00:09:57
bueno, pues entonces 00:09:58
ahora yo tengo una aplicación cualquiera 00:10:02
pues imaginaos que tengo 00:10:03
una aplicación, pues yo que sé 00:10:05
de gestión de usuarios 00:10:07
por poner algo, da lo mismo 00:10:09
vale, pues esta aplicación 00:10:11
después de analizarla, tiene, ¿con qué entidades trabaja? 00:10:18
Pues trabaja con la entidad usuario, que tiene sus datos DNI, 00:10:22
pues entonces habla una clase usuario. 00:10:26
Vale, pues aquí tengo mi clase usuario. 00:10:29
A lo mejor me interesa también una clase que es la clase, 00:10:33
por ejemplo, el usuario se caracteriza por su documento, 00:10:39
pero el documento tiene varias cosas. 00:10:42
la ubicación donde está la foto 00:10:44
un string, pues a lo mejor 00:10:47
tengo mi clase documento 00:10:49
vale 00:10:54
ahora tengo 00:10:56
dentro de la clase usuario 00:10:58
entonces habrá una propiedad que será de tipo documento 00:11:00
da igual, a lo mejor tengo 00:11:02
también ahora una clase de utilidades 00:11:04
que es 00:11:06
la clase que tiene 00:11:08
los métodos 00:11:10
pues yo que sé, utilidades 00:11:13
de entrada y salida, por ejemplo 00:11:18
para 00:11:20
hacer la entrada y salida de datos 00:11:21
pues lo meto en esa clase 00:11:24
luego tengo la clase 00:11:25
que tiene el método main 00:11:29
pues por ejemplo esa podría ser la clase main 00:11:31
y así podría tener muchas 00:11:33
así podría tener muchas 00:11:38
en una única aplicación, muchas 00:11:39
bueno, pues entonces vamos a dividirlas 00:11:41
en diferentes paquetes 00:11:45
pues por ejemplo, normalmente la división que se hace 00:11:46
es conceptual 00:11:49
cada paquete tiene clases 00:11:50
que se refieren 00:11:53
que tienen un significado común 00:11:55
de alguna manera 00:11:58
bueno, pues estas dos de aquí 00:11:58
¿vale? 00:12:01
pues estas 00:12:03
dos de aquí 00:12:04
por ejemplo, las puedo meter 00:12:07
en el paquete modelo 00:12:11
porque es el modelo de mi aplicación 00:12:13
¿vale? 00:12:17
a lo mejor 00:12:19
esta clase de aquí 00:12:21
la voy a meter en un paquete 00:12:22
que se llame utilidades 00:12:25
¿vale? 00:12:27
estos serían los paquetes 00:12:33
¿vale? esta clase de aquí como significa 00:12:40
otra cosa que es la clase principal 00:12:42
pues por ejemplo la voy a meter en el 00:12:44
paquete main 00:12:46
¿vale? tengo tres paquetes 00:12:47
bueno pues cada paquete es una carpeta 00:12:51
cada paquete es una carpetita 00:12:54
con el mismo nombre 00:12:58
¿vale? entonces lo que es mi aplicación 00:12:59
tendrá que tener físicamente 00:13:07
mi aplicación, una carpeta 00:13:09
que se llama modelo y aquí están 00:13:11
estas clases, otra 00:13:13
carpeta que se llama utilidades y ahí está 00:13:15
esa clase, otra carpeta 00:13:17
que se llama main y ahí está esa clase 00:13:19
luego cada paquete lo que 00:13:21
es físicamente es 00:13:23
una carpeta del sistema de archivos 00:13:25
con ese nombre 00:13:27
luego mi aplicación 00:13:28
es diferentes clases 00:13:30
distribuidas en 00:13:32
diferentes carpetas 00:13:34
vale, es necesario que sean todas carpetas 00:13:36
al mismo nivel? No, puedo tener 00:13:42
un árbol de carpetas 00:13:44
por ejemplo, a lo mejor yo tengo 00:13:45
dos clases de utilidades 00:13:48
y unas son específicas 00:13:50
de entrada y salida por consola, por ejemplo 00:13:52
entonces yo quiero una organización 00:13:54
en la que aquí me hago 00:13:56
una subcarpeta 00:13:58
que se llame 00:14:00
consola 00:14:02
entonces, ¿vale? esta carpeta 00:14:03
se llamaría utilidades 00:14:06
y dentro de utilidades me hago una 00:14:07
subcarpeta, una subcarpeta 00:14:11
que se llame, por ejemplo, 00:14:14
consola. Esta carpeta 00:14:16
está dentro de esta. 00:14:18
Tiene sentido esta organización 00:14:20
porque me hace un mapa real 00:14:21
de lo que significa cada cosa. 00:14:23
Estas serían las utilidades, bueno, 00:14:26
utilidades de entrada y salida. 00:14:27
Estas serían las utilidades de entrada y salida, 00:14:29
pero solo 00:14:32
las que van por consola. 00:14:33
Entonces, la meto yo, esas clases 00:14:36
en una carpetita ahí dentro. 00:14:38
¿Vale? Entonces, 00:14:40
Entonces, ¿aquí qué tendría? 00:14:41
Aquí tendría cuatro paquetes. 00:14:42
Tendría cuatro. 00:14:44
Este, un paquete. 00:14:46
Este, utilidades, otro. 00:14:48
Este, otro. 00:14:50
Y este, consola, otro. 00:14:52
Luego, tengo tantos paquetes como carpetas con clases. 00:14:55
Me da igual que unas estén dentro de otras. 00:15:01
Me da lo mismo. 00:15:03
Aquí tengo cuatro paquetes. 00:15:05
Este, este, este y este. 00:15:07
Porque tengo cuatro carpetas. 00:15:09
Aunque una esté dentro de otra. 00:15:11
Y todas ellas pueden tener clases. 00:15:12
Directamente en utilidades puedo tener yo clases dentro. 00:15:15
Pero dentro de la subcarpeta consola también puedo tener clases. 00:15:19
¿Vale? 00:15:24
Bueno, pues, ¿cómo sería el nombre de cada paquete? 00:15:26
Hemos dicho que el nombre de cada paquete es el nombre de la carpeta. 00:15:29
Pero, ¿qué pasa cuando es una subcarpeta? 00:15:32
Pues que el nombre del paquete va con prefijo. 00:15:34
El de estas modelos y más. 00:15:38
El de estas utilidades entrada y salida sin más. 00:15:41
El de estas main sin más. 00:15:46
Pero el nombre de este paquete. 00:15:48
Consola barra utilidades. 00:15:50
Utilidades punto consola. 00:15:53
Entonces el nombre de este paquete sería, si lo saco por aquí, 00:15:56
el nombre de este sería toda la ruta, pero con puntos en vez de con barra. 00:16:03
utilidades 00:16:09
entrada y salida 00:16:11
punto consola 00:16:14
con el punto 00:16:15
luego 00:16:18
lo que tengo físicamente 00:16:20
son carpetas y subcarpetas 00:16:21
pero eso para Java son paquetes 00:16:24
y para Java 00:16:28
el nombre que recibe 00:16:29
es el nombre de la carpeta 00:16:31
y si es subcarpeta 00:16:33
es decir, está una dentro de otra 00:16:35
pues toda la ruta 00:16:38
con el separador punto 00:16:39
si dentro de consola 00:16:41
a su vez me da a mí la gana 00:16:43
crear otro paquete 00:16:45
ahí dentro, otra carpeta con 00:16:47
clases que se llama de otra manera 00:16:49
llamémosle x 00:16:51
pues me ha aparecido un quinto paquete 00:16:52
y ese quinto paquete como se llamaría 00:16:54
utilidades.es 00:16:57
consola.x 00:16:59
luego tendría 5 00:17:00
tendría el paquete modelo, el paquete utilidades 00:17:02
el paquete main 00:17:05
el paquete utilidades.consola 00:17:06
y el paquete utilidades.consola.x 00:17:09
cinco paquetes 00:17:12
están organizados como carpetas unas dentro de otras 00:17:15
pero para Java le da igual 00:17:18
para Java son cinco paquetes de la misma categoría todos 00:17:20
cada uno con su nombre 00:17:24
algunos tendrán nombre largo porque está en subcarpetas 00:17:26
y otros nombre corto porque está en el raíz del proyecto 00:17:30
directamente, está en el raíz 00:17:33
en el raíz de la aplicación, lo que se llama el raíz 00:17:35
de la aplicación 00:17:38
pero que tenga el nombre largo o nombre corto 00:17:39
o lo que es lo mismo, que sean subcarpetas 00:17:42
o no, a Java le da 00:17:44
lo mismo, todos son 00:17:46
paquetes con clases dentro 00:17:48
de la misma categoría 00:17:50
y del mismo nivel, es decir 00:17:51
no es que un paquete esté dentro del otro 00:17:53
una carpeta sí está dentro de la otra 00:17:55
pero los paquetes no están 00:17:58
dentro del otro 00:18:00
para Java no está uno dentro del otro 00:18:00
son paquetes con clases 00:18:04
conceptualmente 00:18:05
cada una de las que sea 00:18:07
bueno pues ahora esto que implicación tiene 00:18:08
pues la implicación 00:18:13
que tiene es que 00:18:15
las clases 00:18:16
que están en cada paquete 00:18:18
ahora ya 00:18:20
tienen acceso 00:18:22
para instanciar objetos 00:18:25
o para lo que sea 00:18:27
a clases de otro paquete 00:18:28
en función de esos 00:18:30
modificadores que yo les ponga. 00:18:32
Public, private, no sé qué. 00:18:35
Entonces, esto ahora 00:18:37
vamos a verlo 00:18:38
con código 00:18:39
que es más fácil 00:18:41
de ver. 00:18:44
Vale, pues 00:18:51
en un proyectito aparte, aunque van a ser 00:18:53
cuatro chorradas, vamos a hacerlo en un proyectito aparte 00:19:02
para que se vea claro. 00:19:04
Y luego ya la misma idea la aplicaremos ahora ya 00:19:06
así en el resto de ejercicios. 00:19:08
Entonces, 00:19:11
Voy a hacerme yo un proyecto aparte para subirlo a la aula virtual como ejemplo. 00:19:12
Lo voy a llamar paquetes ejemplo. 00:19:24
Y aquí irán todo lo que tenemos que saber de modificadores de acceso, paquetes y demás. 00:19:31
Vale, pues entonces, esta es mi carpeta raíz. 00:19:40
Ahora vamos a ver realmente la estructura del sistema de archivos en que se mapea. 00:19:43
Yo aquí puedo meter clases sin más 00:19:47
Entonces las estaría metiendo todas en la raíz 00:19:51
Eso no se hace desde la versión Java de no sé qué 00:19:53
Porque la máquina virtual se va a liar 00:19:56
Para ti nada, eso ya nos olvidamos 00:19:58
Entonces las clases las vamos a meter siempre en paquetes 00:19:59
Pues por ejemplo, me voy a hacer un paquete modelo 00:20:02
Un primer paquete 00:20:05
Modelo 00:20:06
Que es el modelo general 00:20:11
Y aquí pues a lo mejor tengo yo mi clase alumno 00:20:14
Porque mi aplicación va a trabajar con alumnos 00:20:16
luego su modelo tiene un alumno 00:20:22
vale 00:20:24
le voy a 00:20:27
como todavía esto no sabemos lo que significa 00:20:29
no lo hemos mencionado, esto lo quito 00:20:32
vale, y el alumno va a tener 00:20:33
su nombre 00:20:35
como vamos a ver solamente el problema de los accesos 00:20:38
una propiedad y se acabó 00:20:41
su nombre 00:20:43
vale, no es obligatorio 00:20:43
poner constructores 00:20:47
porque de hecho hemos hecho los primeros ejercicios 00:20:48
sin hacer constructores 00:20:51
y luego nosotros podíamos crear 00:20:52
alumnos con new alumno. 00:20:54
¿Vale? Porque no hacer ningún 00:20:57
constructor equivale 00:20:58
para Java hacer 00:21:00
esto, como hacer uno por 00:21:02
defecto vacío. 00:21:04
Si yo no hago ningún constructor, 00:21:06
no lo escribo, se supone 00:21:08
que hay este por defecto. 00:21:10
Por eso podemos hacer el new alumno. 00:21:12
Lo hemos podido hacer sin hacer constructores 00:21:14
nosotros. Porque si no 00:21:16
escribimos ninguno, se supone que está este por 00:21:18
defecto. ¿Vale? 00:21:20
entonces ni lo escribo 00:21:22
vale, alumno 00:21:24
ahora 00:21:25
me voy a hacer pues otro paquete 00:21:27
este pues venga 00:21:29
utilidades 00:21:34
un paquete de utilidades 00:21:35
pues este paquete de utilidades de aquí 00:21:40
que tiene una clase 00:21:43
de utilidades para hacer cosas 00:21:46
un paquete de utilidades 00:21:47
para hacer cosas 00:21:57
vale 00:21:58
por ejemplo, pues que utilidad puede hacer 00:21:59
yo que sé, una utilidad que a lo mejor 00:22:03
me interesa, no sé por qué. 00:22:05
¿Vale? 00:22:09
Ver 00:22:12
si el nombre, le voy a quitar el public, 00:22:12
ver si 00:22:18
le paso un alumno 00:22:19
y me va a decir si su nombre empieza 00:22:21
por mayúscula. Por ejemplo, una utilidad 00:22:23
que mi aplicación necesita. 00:22:25
Pues vamos a hacer. 00:22:27
¿Esta aplicación no tiene propiedades? 00:22:29
Bueno, venga, para que tenga 00:22:36
propiedades sí, por ejemplo, 00:22:37
la aplicación se caracteriza 00:22:39
por su propiedad, una propiedad 00:22:41
para poner una propiedad por un char 00:22:43
vale, y 00:22:45
la utilidad que tiene esta aplicación es 00:22:52
ver si un alumno 00:22:54
que yo paso como parámetro, su inicial 00:22:56
es igual que este carácter 00:22:59
por alguna razón 00:23:00
le interesa a la aplicación esto 00:23:02
saber cosas de iniciales 00:23:04
pues nada, entonces este método como sería 00:23:06
me devuelvo un boolean 00:23:08
porque me tiene que devolver sí o no 00:23:09
el método es 00:23:12
empieza por 00:23:14
que hay que pasarle como parámetro 00:23:15
a este método para comparar 00:23:20
si su nombre empieza por este carácter. 00:23:21
El alumno. 00:23:25
El objeto enterito, no pasa nada. 00:23:29
Yo le paso... 00:23:32
Es decir, alumno 00:23:35
es un tipo de datos más 00:23:39
que me acabo de crear. Es un tipo de dato. 00:23:41
Entonces yo le puedo pasar 00:23:44
una variable de tipo alumno. 00:23:45
¿Y ahora qué tendría que hacer este método? Pues este método tendría que hacer retun o.nombre igual a carácter, ¿verdad? O.nombre charAt, perdón, o.nombre charAt cero. 00:23:47
pues si la inicial 00:24:07
del nombre del alumno 00:24:11
o punto nombres stream 00:24:13
la inicial del nombre del alumno 00:24:14
es igual al carácter 00:24:17
de mi clase utilidades 00:24:19
me va a devolver true y si no false 00:24:21
vale 00:24:23
pues esta clase 00:24:24
necesita usar a la otra 00:24:26
necesita usar a esta 00:24:28
pues aquí nos viene ya el primer problema 00:24:30
me da un error de compilación que no sé de dónde sale 00:24:32
vamos a ver de dónde sale 00:24:35
me dice, uy, lo siento, pero alumno 00:24:37
no lo veo, no lo encuentro por ninguna parte 00:24:41
decimos, pero bueno, pero si alumno, ¿cómo no lo vas a encontrar? 00:24:45
pero si yo lo he hecho, claro, pero es que 00:24:50
alumno está en otro paquete 00:24:54
entonces, está en otro distinto, pues para que 00:24:57
clases de otro paquete diferente al mío puedan 00:25:02
accederme a mí, tengo que poner el public, vale, primer paso, entonces vamos a ponerlo 00:25:06
aquí, vamos a subir ese proyecto, modificador public para la clase, vale, permite que clases 00:25:16
fuera del paquete 00:25:35
del paquete donde esté 00:25:36
clases fuera del paquete 00:25:38
puedan hacer referencia 00:25:40
a esa clase 00:25:43
a esa clase 00:25:44
si no se pone 00:25:47
el public, solamente 00:25:49
pueden hacer referencia a la clase 00:25:51
alumno, clases del mismo 00:25:53
paquete, ¿vale? 00:25:55
es decir, si yo aquí no le pongo 00:26:13
el public 00:26:17
no le pongo el public 00:26:18
¿vale? pero utilidades 00:26:20
está aquí, fijaos 00:26:24
aquí utilidades 00:26:32
en el mismo paquete, le acabo de subir al paquete 00:26:33
modelo, aquí no ha habido ningún 00:26:36
problema, porque está en el 00:26:38
mismo paquete, está en modelo 00:26:40
con lo cual, aunque alumno no tiene public 00:26:41
cualquier clase 00:26:44
de ese paquete puede hacer referencia a ella 00:26:46
pero en mi caso 00:26:48
anterior, que utilidades estaba en un 00:26:50
paquete aparte, porque a mi me interesa 00:26:52
yo quiero que esté en un paquete aparte 00:26:54
porque se organiza 00:26:55
pues me dice, perdona 00:26:58
Pero alumno, es que no sé ni quién es 00:27:00
Este import, no lo quiero 00:27:02
Me lo ha metido el suelo 00:27:05
Vale, este no lo quiero 00:27:07
O sea, perdón, este alumno, lo siento, no lo veo 00:27:09
Vale, pues primer paso 00:27:12
Ah, claro, ¿cómo lo vas a ver? 00:27:14
Primera cosa imprescindible 00:27:15
Public delante del class 00:27:17
Ahora ya 00:27:20
Hacemos el primer paso, y solo el primero 00:27:22
Para poder 00:27:24
Hacer referencia a esta clase 00:27:26
Vale 00:27:27
poniendo el public se me ha quitado el error 00:27:29
no, me sigue diciendo 00:27:32
alumno no lo conozco 00:27:34
¿por qué no lo conozco? 00:27:36
porque ahora ya sí que os digo la verdad 00:27:38
entera, que os hemos mentido 00:27:40
hasta ahora, alumno 00:27:42
no es el nombre de esta clase 00:27:44
en realidad 00:27:46
el nombre de esta clase tiene que llevar 00:27:46
como prefijo su package 00:27:50
entonces esta clase en realidad 00:27:52
se llama modelo 00:27:54
punto alumno 00:27:56
es como se llama de verdad 00:27:57
con lo cual 00:27:59
si yo pongo su nombre real 00:28:00
ahora ya se calla 00:28:02
ahora ya sí que lo encuentra 00:28:04
este error de aquí ya lo veremos luego 00:28:07
modelo.alumno 00:28:08
ningún problema 00:28:10
¿vale? 00:28:11
porque el nombre verdadero de la clase 00:28:14
es el del package 00:28:17
punto su clase 00:28:18
independientemente de cómo sea el package 00:28:20
imaginaos que yo me voy a hacer 00:28:25
tengo algunas entidades especiales 00:28:27
que quiero yo 00:28:30
que estén guardadas físicamente 00:28:32
en una subcarpeta de modelo 00:28:34
pues vamos a hacernos unas entidades especiales 00:28:35
y las vamos a meter 00:28:38
en un paquete, new package 00:28:40
modelo 00:28:42
punto especiales 00:28:43
vale, pues como veis 00:28:46
modelo especiales 00:28:51
es otra 00:28:52
es otra 00:28:53
es otro paquete 00:28:56
que está al mismo nivel 00:29:00
está exactamente al mismo nivel 00:29:01
que modelo y que utilidades, modelo especiales 00:29:06
exactamente al mismo 00:29:08
otro paquete con sus clases 00:29:10
lo que pasa es que 00:29:12
al llamarse modelo.especiales 00:29:14
físicamente 00:29:16
está guardada una subcarpeta de este 00:29:18
pero esa java le da igual 00:29:20
¿vale? 00:29:22
pero a nosotros, pues mira, nos gusta así porque visualmente 00:29:24
nos lo vemos mejor 00:29:26
si yo veo aquí modelo.especiales 00:29:28
veo que aquí van a ir 00:29:30
las clases especiales del modelo 00:29:32
es una cuestión 00:29:35
de claridad 00:29:36
mucho mejor 00:29:37
hacer modelo.especiales 00:29:40
que un paquete especiales y más 00:29:42
porque especiales, especiales de qué 00:29:43
sin embargo si veo modelo.especiales 00:29:45
son entidades especiales 00:29:48
es por una cuestión de claridad 00:29:49
del diseño 00:29:52
bueno pues ahora 00:29:52
efectivamente 00:29:54
si yo entrara 00:29:56
en la estructura de carpetas 00:29:58
de mi proyecto, si yo entrara 00:30:00
que podemos entrar con el show in 00:30:02
system explorer 00:30:04
entramos en la estructura de carpetas de mi 00:30:06
proyecto, que está aquí 00:30:08
efectivamente, ¿qué tengo? 00:30:10
tengo 00:30:13
modelo, carpeta modelo 00:30:14
carpeta utilidades 00:30:16
utilidades tienen 00:30:17
su clase 00:30:20
modelo tiene su clase 00:30:21
y además tiene la subcarpeta 00:30:24
especiales 00:30:26
que tendrá la clase que voy a hacer ahora 00:30:27
¿vale? 00:30:30
luego tengo tres paquetes con la peculiaridad 00:30:32
que da exactamente igual 00:30:34
de que una carpeta está dentro de la otra 00:30:35
y eso afecta al nombre 00:30:38
del paquete, ya está, al nombre 00:30:40
y le da claridad, nada más 00:30:42
bueno, pues imaginaos que modelo especial 00:30:43
vamos a meter ahora una clase 00:30:46
que sea 00:30:48
pues alumno 00:30:49
ciego, por ejemplo 00:30:52
Necesita adaptación visual. Pues el alumno ciego tendrá, como todos los alumnos, su nombre e imaginaos que tiene un grado, yo que sé, de discapacidad visual, pues su propiedad grado. 00:30:56
Vale, pues fijaos dónde está esta clase alumno ciego. Esta clase alumno ciego está en el paquete modelo.especiales. 00:31:16
¿qué significa eso? 00:31:23
que el verdadero nombre de la clase 00:31:25
el verdadero nombre 00:31:27
es modelo.especiales.alumnociego 00:31:28
por ejemplo 00:31:32
si en mi clase utilidades 00:31:35
yo ahora 00:31:37
quisiera hacer algo con los alumnos ciegos 00:31:39
en mi clase utilidades 00:31:42
por ejemplo 00:31:43
he ver grado 00:31:44
perdón 00:31:46
devolver grado del 00:31:52
pues le tendría que pasar un alumno ciego 00:31:58
si le paso alumno ciego 00:32:01
sin más 00:32:04
el compilador 00:32:08
como nos podemos imaginar 00:32:12
me dice a mi sentencia 00:32:13
que debería ser 00:32:15
retun a punto grado 00:32:16
¿no? 00:32:19
a mi sentencia de retun a punto grado 00:32:22
bueno, aquí el método me dice 00:32:25
eh, alumno ciego no lo conozco 00:32:26
pero a ver, si es public 00:32:28
¿cómo no vas a poder hacer referencia? 00:32:30
él es public, ya, pero es que su nombre no es este 00:32:32
su nombre es 00:32:35
modelo.especiales.alumnociego 00:32:36
ahora ya sí que lo ve perfectamente 00:32:43
¿vale? 00:32:46
entonces el verdadero nombre de la clase para Java 00:32:49
no es el nombre que ponemos aquí arriba 00:32:52
es el con todo su paquete 00:32:54
¿por qué? 00:32:57
porque así la máquina virtual va a poder navegar fácilmente 00:32:58
por el sistema de archivos hasta que lo encuentra 00:33:01
si no, hasta ahí estamos 00:33:03
vale, pero claro 00:33:09
normalmente si una aplicación está bien diseñada 00:33:13
y yo tengo las cosas unas metidas dentro de otras 00:33:17
por claridad, puedo tener a lo mejor paquetes 00:33:20
que sean un montón de subcarpetas 00:33:23
modelo, punto especiales, punto no sé qué, punto no sé cuánto 00:33:25
porque así tengo más claridad a la vista 00:33:29
para ver qué significa cada cosa 00:33:32
entonces podría llegar un momento en que mi código fuera un rollo 00:33:33
que te mueres 00:33:38
porque tuviera aquí punto no sé qué 00:33:39
punto no sé cuánto, punto no sé cuánto 00:33:41
entonces para salvarme de eso 00:33:43
para salvarme y no tener que arrastrar todo eso 00:33:44
aquí es donde 00:33:47
entra el import 00:33:49
imagínate que tenemos que usar 00:33:50
alumno ciego en mil sitios 00:33:53
de mi clase aquí, utilidades 00:33:55
alumno ciego en mil sitios 00:33:57
jolín, qué rollo escribir esto todo el rato 00:33:59
que es una línea larguísima 00:34:01
me quedan líneas de código enormes 00:34:02
vale, pues puedo hacer una trampa 00:34:05
que es 00:34:07
pones import 00:34:08
y el nombre de la clase 00:34:10
que quieres acortar 00:34:12
quiero acortar esta clase 00:34:14
vale, pues a partir de ahí 00:34:16
la puedes llamar 00:34:21
siempre como alumno ciego 00:34:23
no hace falsa que pongas su prefijo 00:34:24
si has puesto el import 00:34:26
vale 00:34:28
entonces como hemos puesto el import 00:34:29
de toda esa clase con todo su nombre 00:34:32
ahora ya 00:34:34
puedo usarla con su nombre corto 00:34:36
corto. 00:34:38
Luego, el nombre real es el largo. 00:34:40
El nombre corto lo puedo 00:34:44
usar si me echo un import 00:34:46
antes con el nombre largo. Si no me echo 00:34:48
un import con el nombre largo, pues no. 00:34:50
¿Y ahora tenemos un objeto 00:34:54
de esta clase? Bueno, eso ya 00:34:56
cuando hagamos la principal. No estamos en ello todavía. 00:34:58
¿Vale? Ahora mismo estamos en un método que 00:35:00
recibirá cuando haya una aplicación 00:35:02
ejecutándose. Sí, habrá que crear un objeto de 00:35:04
esos y pasárselo. ¿Vale? 00:35:06
Entonces, puedo usar el nombre 00:35:11
recorto aquí 00:35:13
sin paquete 00:35:14
porque he puesto 00:35:16
import 00:35:21
pero cuidado, un segundín y ahora me preguntas 00:35:23
pero cuidado con los import 00:35:29
¿vale? que tienen su truco también 00:35:31
porque imaginaos que yo tengo 00:35:34
dentro de utilidades 00:35:37
tengo una clase que se llama alumno ciego 00:35:40
no hay ningún problema 00:35:43
yo podría hacerme aquí en utilidades 00:35:45
una clase alumno ciego 00:35:47
no sé por qué querría hacerlo 00:35:48
pero como poder podría 00:35:55
imaginaos que me hago una clase aquí alumno ciego 00:35:57
dentro de utilidades 00:35:59
tengo dos clases que se llaman igual 00:36:00
no pasa nada 00:36:03
porque están en paquetes distintos 00:36:05
su nombre real, el de esta es 00:36:06
modelo.especiales.alumnociego 00:36:09
y el de esta es utilidades.alumnociego 00:36:12
son dos clases distintas 00:36:14
con nombres distintos 00:36:16
Java no tiene ningún problema con eso 00:36:17
¿cuándo puede llegar el problema? 00:36:19
cuando aquí en esta utilidades hacemos este import 00:36:21
porque ahora 00:36:24
cuando pongamos alumno ciego 00:36:26
¿a qué alumno ciego te refieres? 00:36:28
al que está en tu propio 00:36:31
paquete 00:36:32
o al del import 00:36:33
pues por defecto él asume que te refieres 00:36:35
al de tu propio paquete 00:36:38
con lo cual 00:36:40
desde aquí tenemos 00:36:42
se nos ha limitado el acceso 00:36:44
a clases alumno ciego de otros 00:36:46
con el import 00:36:48
entonces en esta situación 00:36:49
yo nunca usaría el import 00:36:51
las distinguiría por su nombre real 00:36:53
y pondría aquí 00:36:55
su nombre real 00:36:57
modelo.especiales 00:36:58
.alumnociego 00:37:04
y aquí no hay duda, me refiero a la del otro 00:37:07
me refiero a la del otro, porque he puesto el nombre 00:37:08
completo, me refiero a la del otro 00:37:11
pero si yo 00:37:13
por ahorrarme 00:37:15
escribir líneas, digo 00:37:16
no pasa nada 00:37:18
me voy ahí de chulo 00:37:19
y hago el import 00:37:22
digo, no pasa nada, me echo el import 00:37:24
como me echo el import, puedo usar alumno ciego 00:37:26
sin más 00:37:28
uso alumno ciego sin más, pues la hemos liado 00:37:29
porque ahora, alumno ciego 00:37:32
él sobreentiende que te refieres 00:37:34
a la del propio paquete 00:37:36
que se llama así 00:37:38
¿vale? 00:37:39
luego, cuidado con los import cuando hay 00:37:42
clases que se llaman igual en diferentes 00:37:44
paquetes, ¿vale? esa situación 00:37:46
hay que resolverla bien 00:37:48
lo que importa es que entendáis 00:37:50
la situación a la que me refiero 00:37:52
en esta 00:37:53
como tengo dentro de mi clase utilidades 00:37:55
un alumno ciego 00:37:58
si yo no pongo prefijo 00:37:59
es la del propio paquete 00:38:02
no es la del import 00:38:03
luego puede estar haciendo algo 00:38:05
que no es lo que yo quiero 00:38:07
vale, pero claro, esta situación 00:38:09
pues no la queremos 00:38:12
me voy a quitar esta clase de aquí 00:38:14
delete, me la quito 00:38:16
y aquí ya no hay problema con el import 00:38:17
no hay problema 00:38:20
me refiero a esta 00:38:22
vale, pues entonces 00:38:23
ya esto nos ha dejado 00:38:27
bien con nombre corto o largo 00:38:30
me da igual 00:38:33
aquí hemos usado el nombre largo para modelo alumno 00:38:34
aquí hemos usado el nombre corto 00:38:36
para alumno ciego porque teníamos el import 00:38:39
no pasa nada 00:38:41
vale 00:38:41
pues ahora ya nos ha dejado 00:38:43
sin error de compilación 00:38:47
acceder 00:38:48
¿por qué? porque alumno 00:38:49
tiene public 00:38:52
y alumno ciego tiene public 00:38:53
también, si no tiene public 00:38:56
me da igual import, me da igual lo que sea 00:38:58
que no puedo 00:39:00
vale, hasta ahí está 00:39:00
¿no? bueno, pero sigue 00:39:04
habiendo algo aquí que parece ser que está sin resolver 00:39:08
¿qué me dice? o.nombre 00:39:10
nombre no está visible 00:39:13
y aquí me dice lo mismo 00:39:16
me dice grado no está visible 00:39:17
vamos a ver 00:39:19
claro, es que 00:39:21
poner el public delante de la clase 00:39:23
solamente te sirve 00:39:26
para poder hacer referencia 00:39:28
a esa clase 00:39:30
pero luego, todo lo que hay dentro 00:39:30
propiedades y métodos 00:39:34
tú ya les tienes que hacer a cada uno 00:39:35
de ellos public o no 00:39:38
a cada uno de ellos por separado 00:39:39
la clase alumno es public 00:39:41
con lo cual yo he podido hacer referencia a ella 00:39:44
aquí 00:39:46
pero luego cuando he intentado acceder 00:39:47
meterme dentro y acceder a nombre 00:39:50
perdona pero nombre 00:39:52
nombre no es public 00:39:54
con lo cual a nombre no te dejo 00:39:56
puede ser que haya otro parámetro que sí 00:39:58
pero a public a este no 00:40:02
pues que tenemos que hacer para que además 00:40:03
de poder hacer referencia alumno 00:40:06
además me deje entrar en nombre 00:40:07
pues ponerle aquí el public 00:40:10
luego los modificadores public 00:40:13
afectan tanto a clases 00:40:16
como a propiedades 00:40:18
para la clase es imprescindible 00:40:21
es el primer paso 00:40:24
porque es para poder hacer referencia a ella 00:40:25
pero ahora ya 00:40:28
si yo me quiero meter dentro de las cosas 00:40:30
además 00:40:33
además 00:40:34
esas cosas tienen que tener public 00:40:35
¿vale? 00:40:37
no, porque a lo mejor tú quieres 00:40:45
dar acceso a unos sí y a otros no. 00:40:47
Entonces, desde el momento en que 00:40:50
quieres dar acceso solo a uno, 00:40:51
el public tiene que estar. 00:40:54
Porque el public tiene que estar 00:40:55
ya solamente para poder poner tu identificador, 00:40:57
para poder hacer el constructor, new. 00:40:59
Es decir, ya solamente 00:41:02
para poder yo aquí escribir modelo alumno 00:41:03
ya tiene que estar el public. 00:41:05
Ahora hay otra cosa que yo me meta dentro, 00:41:06
como me he metido aquí. 00:41:09
¿Vale? Entonces, 00:41:12
esto es para yo hacer referencia 00:41:14
a la clase. Y ahora, 00:41:15
si además quiero dar 00:41:17
acceso a 00:41:19
propiedades 00:41:21
tengo que 00:41:22
marcarlas como public 00:41:25
por ejemplo 00:41:27
es que yo puedo querer 00:41:30
dar acceso al nombre, pero a lo mejor tiene un identificador 00:41:32
interno 00:41:34
hombre, por seguridad, efectivamente 00:41:35
porque tú quieres proteger, encapsular 00:41:45
tú ofreces al exterior 00:41:47
solo lo imprescindible 00:41:49
porque si ofreces más parámetros 00:41:51
el otro se puede meter por error 00:41:53
y poner punto id y meterse en el id 00:41:54
y a lo mejor tú no quieres que se pueda meter en el id 00:41:57
¿vale? entonces un segundito 00:41:59
ahora, por ejemplo aquí 00:42:01
el public aquí tiene que estar 00:42:03
pero dentro de que está este public 00:42:05
a este le doy acceso 00:42:07
y a este no 00:42:09
con lo cual 00:42:10
desde utilidades 00:42:13
ahora ya sí que me 00:42:14
deja hacer el opunto nombre 00:42:17
pero si yo hubiera querido por lo que fuera 00:42:18
mostrar el id 00:42:21
pues al id me dice 00:42:22
no, id no es visible 00:42:25
a id no te dejo que entres 00:42:27
porque id no tiene 00:42:29
el public 00:42:31
a nombre sí que te dejo 00:42:32
y de hecho a nombre nos ha dejado 00:42:34
para comparar el carácter 00:42:37
pero a id no 00:42:38
solo nos deja 00:42:40
acceder a las 00:42:45
propiedades marcadas 00:42:51
marcadas como public 00:42:53
es decir 00:43:00
A esta no nos deja 00:43:02
A esta no nos dejaría 00:43:04
A esta 00:43:06
Pues no nos deja 00:43:09
¿Vale? 00:43:10
¿Vale? 00:43:13
Julín 00:43:15
El asterisco 00:43:16
¿Dónde está? 00:43:20
Aquí ¿Vale? 00:43:22
A esta primera de aquí 00:43:23
No nos está dejando 00:43:26
A esta otra sí 00:43:28
Vale, aquí lo mismo 00:43:29
para yo poder devolver 00:43:34
el grado de mi alumno ciego 00:43:37
yo no puedo acceder a la propiedad 00:43:39
grado de alumno ciego 00:43:41
si no la he puesto pública, pues aquí igual 00:43:43
a.grado me dice 00:43:45
lo siento pero no es visible 00:43:46
claro, es que si me voy a alumno ciego 00:43:48
la clase está como pública, luego puedo hacer referencia 00:43:50
pero el grado no 00:43:53
luego tendría que poner un public 00:43:54
así estaría haciendo public 00:43:56
los dos, si quiero uno sí y otro no 00:43:59
pues en líneas separadas, como fuera 00:44:00
ahora ya al ser public 00:44:02
este ya 00:44:04
sí que me deja acceder al 00:44:06
grado, ¿vale? 00:44:08
Jesús, ¿qué vas a preguntar? 00:44:10
Justo, efectivamente 00:44:16
los que tú quieras que sean llamados 00:44:18
desde fuera de la clase 00:44:22
¿vale? 00:44:24
vale, pues entonces 00:44:26
hasta aquí está claro, y ahora vamos a parar un momento 00:44:32
cosas que tienen que estar 00:44:34
claras, que 00:44:36
la aplicación reparte las clases 00:44:38
en paquetes 00:44:40
lo normal es que una de esos paquetes 00:44:41
sea la que tenga el método main 00:44:44
que hace ya las cosas 00:44:46
¿vale? 00:44:47
ahora, clase en un paquete 00:44:49
su nombre real 00:44:51
se convierte en su nombre cortito 00:44:53
el de aquí, con todo el prefijo 00:44:56
del paquete delante 00:44:58
y ese es su nombre real 00:44:59
para yo instanciarla, para lo que quiera 00:45:01
¿que me quiero ahorrar el nombre largo? 00:45:03
donde yo quiera hacer referencia 00:45:06
a ella, como aquí, donde quiera hacer 00:45:09
referencia, pues hago 00:45:11
el import con su nombre largo 00:45:13
y ya está 00:45:15
cada vez que quiera acceder a ella, pongo el corto y se acabó 00:45:15
¿vale? esto cuidado con el 00:45:19
matiz de si tengo clases que se llaman igual 00:45:21
que ahí se genera 00:45:23
la ambigüedad, eso por un lado 00:45:25
y ahora por otro 00:45:27
¿cómo 00:45:28
puedo hacer yo referencia y acceder 00:45:31
a propiedades de una clase 00:45:33
desde otro paquete, desde una clase desde otro 00:45:35
pues tengo que poner este 00:45:37
modificador en la clase 00:45:39
solo para hacer referencia a la clase 00:45:40
y ahora ya cada propiedad 00:45:43
identificar las que quiero y las que no 00:45:45
si no ponemos el public 00:45:47
esas propiedades 00:45:49
solo se pueden acceder desde la 00:45:50
propia clase 00:45:53
perdón, desde el propio paquete 00:45:54
¿vale? 00:45:57
si no se pone solo desde el mismo 00:45:59
paquete, por ejemplo, si yo me hago 00:46:01
un main o me hago lo que sea 00:46:03
dentro de mi clase modelo 00:46:04
esa clase modelo puede acceder 00:46:06
al ID sin problema, porque es una clase 00:46:09
que está en el mismo paquete 00:46:10
en el mismo, vale 00:46:12
dime 00:46:13
yo lo que hacía para acceder a una variable 00:46:15
o cualquier cosa que tenía en otra clase 00:46:18
era que llamaba el objeto y llamaba esa variable 00:46:19
creaba un objeto de esa clase 00:46:22
y le llamaba, pero con el public 00:46:25
pues no funciona tan bien en la otra 00:46:26
la demás clase que tengamos en este paquete 00:46:28
no funciona tan bien en la otra 00:46:30
tiene que tener el public para tú poder llamar 00:46:31
esa propiedad desde otra clase 00:46:34
eso es otra cosa 00:46:35
que hayamos dos clases iguales 00:46:41
si están en diferentes paquetes no da ningún error 00:46:43
es lo que acabamos de explicar 00:46:45
el problema es cuando tú haces un import 00:46:47
porque entonces 00:46:50
estás haciendo un alias 00:46:52
y a esta clase le estás dando como alias 00:46:53
un nombre que ya existe en tu paquete 00:46:56
entonces ahora ya tienes 00:46:58
la confusión servida 00:47:00
tienes una clase en tu paquete 00:47:02
que se llama Pepito 00:47:04
Una clase en otro paquete 00:47:05
Que se llama Pepito 00:47:07
Hago un alias de esa otra con Pepito 00:47:08
Pues dos iguales, no puede ser 00:47:11
Venga, vamos a 00:47:12
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:
3
Fecha:
9 de diciembre de 2025 - 14:06
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
47′ 15″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
941.92 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid