Saltar navegación

20241210 POO-Clases-Paquetes_2 - 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.

14 visualizaciones

Más información Transcripción

Descargar la transcripción

Ha quedado más o menos claro, ¿no? 00:00:00
Que cuando las clases se distribuyen en varios paquetes, 00:00:02
tenemos el problema de que tenemos ya que dar permiso. 00:00:05
Entonces, lo que me ha preguntado Pablo al final, 00:00:09
pues sí, claro, uno puede, el import, 00:00:14
si ponéis un paquete, un paquete cualquiera, el que sea, 00:00:18
y ponéis asterisco, ponéis asterisco, 00:00:21
eso es como decir 00:00:27
puedes usar sin el nombre largo 00:00:29
todas las clases del paquete 00:00:32
es como importarlas de golpe todas 00:00:34
entonces si secretaría 00:00:36
además de secretario tuviera 20 más 00:00:38
puede usarlas todas con su nombre corto 00:00:40
pero cuidado 00:00:43
porque eso es peligroso 00:00:45
es una práctica de programación muy horrible 00:00:46
poner el asterisco 00:00:48
porque estás haciendo visibles 00:00:49
desde aquí 00:00:52
a un montón de clases de las que a lo mejor no eres consciente 00:00:52
porque tú no tienes por qué saber 00:00:56
todas las clases que hay en este paquete 00:00:58
que has cogido de Pepito Pérez 00:01:00
que a lo mejor tiene seguramente 2.000 00:01:02
entonces si pones el asterisco 00:01:04
estás haciendo visibles las 2.000 00:01:06
y puede 00:01:08
que alguna de esas 2.000 00:01:10
se llame igual que otra 00:01:12
de otro paquete del cual también estás haciendo import 00:01:14
con lo cual ahí va a coger 00:01:16
la del primer import siempre 00:01:18
entonces puede haber 00:01:20
efectos secundarios en la aplicación 00:01:22
hacéis dos import punto asterisco 00:01:24
dos clases se llaman igual 00:01:27
coge siempre 00:01:29
si tú la pones sin el nombre largo abajo 00:01:31
coge siempre la del primero 00:01:33
eso es lo que quieres que ocurra, vale, es ya como 00:01:34
tener demasiadas cosas bajo control 00:01:37
se va a escapar de tu control 00:01:39
entonces, a menos que los import 00:01:40
te queden de más de 100 líneas 00:01:43
que los hay 00:01:45
100 líneas de import, las hay, no pasa nada 00:01:45
pues a menos que ya estés 00:01:49
harto, pon un asterisco 00:01:51
pero bueno, si se puede evitar 00:01:53
pues evita, si se puede evitar sin un coste 00:01:55
demasiado 00:01:57
pero bueno, si tengo un paquete que yo sé que esas clases 00:01:57
claro, si lo tienes todo bajo control 00:02:01
sí, ¿vale? 00:02:03
pues a ver en la uni no, pero sí 00:02:08
hice 00:02:10
vale, pues más o menos 00:02:11
se ha quedado claro, pero yo he mencionado 00:02:16
ahí que hay más modificadores aparte 00:02:18
del public, pues para que pintan esos modificadores 00:02:20
vale, pues a ver 00:02:22
¿qué ocurre cuando 00:02:23
en general 00:02:25
lo que está dentro de una clase 00:02:28
tanto propiedades 00:02:30
como métodos 00:02:31
se llaman miembros de la clase. 00:02:33
Entonces los miembros de la clase son 00:02:36
propiedades y métodos. Lo digo para 00:02:37
hablar en forma general de ambos. 00:02:39
Pues ¿qué ocurre cuando yo 00:02:42
a un miembro de la clase, me da igual 00:02:44
que sea una propiedad o un método, no le pongo 00:02:46
ningún modificador delante. Ninguno. 00:02:47
Vale. 00:02:51
Pues es como si le hubiera puesto 00:02:52
el modificador por defecto. 00:02:53
que es este, que ya no te lo coge, pues porque ya, no sé, 00:02:55
antiguamente sí que te permitía cogerlo. 00:03:00
Entonces, el modificador por defecto significa que es accesible ese miembro 00:03:03
desde todas las clases del mismo paquete, ¿vale? 00:03:11
O sea, si no ponemos nada, desde todas las clases del mismo paquete es accesible. 00:03:14
Con lo cual, si yo aquí al constructor le quito el public, 00:03:19
desde cualquier otra clase 00:03:22
pero en el mismo paquete 00:03:26
podría hacer new profesor 00:03:27
desde cualquier otra clase 00:03:29
pero que esté en el mismo 00:03:31
desde esta main no podría 00:03:32
porque esta main está en otro 00:03:34
pero desde esta sí 00:03:35
entonces 00:03:37
ese es el modificador por defecto 00:03:40
que es el no haber nada 00:03:43
y luego hay uno que es 00:03:44
el que más muy usado 00:03:46
que es este 00:03:49
¿y este qué significa? 00:03:50
este dice 00:03:55
solo puedes acceder a este miembro 00:03:56
desde la misma clase 00:03:58
desde la misma 00:04:00
ni siquiera desde clases del mismo paquete 00:04:02
solo desde la misma 00:04:05
ya está 00:04:07
entonces 00:04:08
no, a no ser desde la misma, otra cosa es que luego tú 00:04:10
te inventes un, claro 00:04:12
entonces diríais, anda 00:04:14
¿y para qué existe 00:04:16
este modificador? 00:04:19
cuando uno hace una clase 00:04:20
la hace para que otras clases 00:04:21
instancien objetos, accedan a las propiedades 00:04:23
accedan a los métodos, hagan cosas 00:04:26
si yo a este método mostrar nombre 00:04:28
le pongo el private este delante 00:04:30
pues el main este no lo puede usar 00:04:33
por supuesto, porque es privado 00:04:36
pero es que ni desde la misma clase podría 00:04:38
aunque yo dentro del mismo paquete 00:04:41
este entidades 00:04:44
claro, imaginaos que dentro de entidades 00:04:45
Me hago una clase cualquiera 00:04:48
Voy a hacerme una clase prueba cualquiera 00:04:50
Con un método main 00:04:53
Y desde esta misma clase prueba mía 00:04:59
Voy a intentar 00:05:02
Bueno, un profesor podría hacer 00:05:04
Vale, estoy aquí en prueba 00:05:07
Profesor 00:05:18
Profesor nombre 00:05:19
Vamos a ponerle aquí 00:05:22
Vale, a ver, estoy 00:05:23
Esta clase mía prueba 00:05:28
está en el mismo paquete que profesor 00:05:30
en el mismo 00:05:32
luego puedo instanciar 00:05:33
no hace falta que ponga el nombre largo 00:05:36
no hace falta ni el import ni nada 00:05:38
no hace falta porque estoy en la misma 00:05:40
podría poner el nombre largo 00:05:41
pero no me hace ninguna falta 00:05:44
podría, porque estoy en el mismo paquete 00:05:46
vale 00:05:49
a profesor he podido acceder 00:05:49
al constructor 00:05:53
porque este tiene el modificador 00:05:53
por public, pero es que aunque tuviera 00:05:56
el modificador por defecto 00:05:58
aunque tuviera el por defecto 00:06:00
podría igualmente 00:06:02
desde prueba 00:06:06
tanto declarar la propiedad 00:06:06
como instanciar el objeto 00:06:09
podría llamar al constructor igual 00:06:11
porque tiene el modificador por defecto 00:06:12
que es desde este mismo paquete puedes 00:06:15
¿vale? 00:06:17
pero ¿qué pasa con la propiedad nombre? 00:06:20
la propiedad nombre es privada 00:06:22
entonces si yo desde esta clase 00:06:24
que está dentro 00:06:26
intento acceder a la propiedad nombre 00:06:27
p.nombre 00:06:30
para dar un valor 00:06:31
y cambiarle de nombre 00:06:33
pues me dice 00:06:35
lo siento pero nombre no es visible 00:06:37
esta está en la misma clase 00:06:39
perdón, esta clase está en el mismo paquete 00:06:41
pero nombre no es visible 00:06:42
porque tiene el modificador privado 00:06:44
si no lo tuviera 00:06:46
claro que podría 00:06:49
porque está en la misma clase 00:06:50
y tiene el por defecto 00:06:52
pero como tiene el privado 00:06:54
pues no puedo 00:06:56
¿vale? hasta ahí lo que significa 00:06:57
ahora, ¿qué sentido tiene? 00:07:00
tiene que tener un sentido 00:07:03
todo tiene un sentido 00:07:04
en la vida, bueno, o nada, pero esto sí que lo tiene 00:07:05
¿qué sentido tiene? 00:07:09
vale, cuando tú haces una clase 00:07:12
tú puedes hacer primero 00:07:14
cosas auxiliares, por ejemplo 00:07:16
este método, a lo mejor 00:07:18
quiere servirse de un método auxiliar 00:07:20
para hacer algo 00:07:22
y este método auxiliar lo has hecho aquí 00:07:23
para llamarlo solo desde aquí 00:07:26
pero no quieres que lo usen desde fuera 00:07:27
porque es un método 00:07:29
cuyo único uso 00:07:30
es ofrecerlo desde aquí 00:07:31
vale 00:07:32
entonces 00:07:33
a ese método 00:07:34
tendría sentido 00:07:35
ponerle private 00:07:35
por ejemplo 00:07:36
pues auxiliar 00:07:36
pero en lo que 00:07:37
las propiedades 00:07:38
respecta 00:07:40
¿qué sentido tiene? 00:07:40
si tú 00:07:42
a una propiedad 00:07:43
le quitas el privado 00:07:43
esa propiedad 00:07:45
automáticamente 00:07:48
es accesible 00:07:49
desde aquí 00:07:49
tanto para 00:07:50
recibir valor 00:07:52
como para 00:07:52
devolverlo 00:07:54
como por ejemplo 00:07:54
para mostrarlo 00:07:55
con lo cual 00:07:56
tú no puedes 00:07:59
distinguir 00:08:00
el permiso de lectura 00:08:01
del de escritura. No puedes distinguirlo. 00:08:03
Si yo aquí le quito 00:08:06
el privado, automáticamente esta 00:08:07
propiedad se hace accesible 00:08:09
para clases del mismo paquete, 00:08:11
tanto para leer como para escribir. 00:08:13
Van en pack los dos permisos. 00:08:15
Yo aquí, esto 00:08:17
sería escribir en la propiedad 00:08:19
nombre, escribir, y esto 00:08:21
sería mostrar la propiedad 00:08:23
nombre, o sea, leer de la propiedad. 00:08:25
Bueno, pues hay situaciones 00:08:27
en las cuales yo tengo una entidad 00:08:29
y las propiedades que hay dentro 00:08:30
a lo mejor quiero que sean visibles 00:08:32
para ver lo que tienen 00:08:34
pero no quiero que sean modificables 00:08:35
no quiero que sean modificables 00:08:37
por ejemplo 00:08:38
entonces necesito algo alternativo 00:08:39
porque si yo quito el privado 00:08:42
van a ser accesibles 00:08:45
tanto para ser modificadas 00:08:47
como para ser leídas 00:08:48
entonces si queremos ese efecto 00:08:50
lograr ese efecto 00:08:53
que siempre lo queremos 00:08:54
en situaciones más reales 00:08:56
De que una propiedad poder decidir yo si desde fuera permito solo leerla o además de leerla permito escribirla o qué, pues ¿qué mecanismo sacamos? Pues entonces, a esa propiedad, y esto sí que es el uso habitual como se hace siempre, le pongo privada, vale, privada, con lo cual al ponerla privada no puedo acceder ni para leer ni para escribir, está claro, no puedo acceder ni para leer ni para escribir, vale, la pongo privada. 00:08:58
Y ahora, me hago dos métodos, uno que sirva para escribir en la propiedad 00:09:27
y otro que sirva para devolver el valor de la propiedad. 00:09:34
Y a esos dos métodos ya les pongo public si quiero, 00:09:38
o le pongo public solo a uno y al otro no, lo que quiera. 00:09:41
Y esos métodos son los famosos métodos get y set. 00:09:44
Vale, vamos a hacerlos justo aquí abajo. 00:09:48
Vamos a hacer un método, la estructura del método set. 00:09:51
el método set es 00:09:56
un método que 00:09:58
no devuelve nada, tiene void 00:10:01
que nombre nos ponemos todos 00:10:02
de acuerdo, no es que sea obligatorio 00:10:05
pero nos ponemos todos de acuerdo como programadores 00:10:06
en el mundo, los 8000 millones 00:10:09
de programadores que haya, de cual nos hemos 00:10:11
puesto todos de acuerdo para que se 00:10:13
llame ese método, nos hemos puesto todos de acuerdo 00:10:14
que ese método se llame 00:10:17
set y luego el nombre 00:10:18
de la propiedad empezando 00:10:21
en mayúscula 00:10:23
Y luego le paso como parámetro 00:10:24
El valor con el que quiero 00:10:30
Actualizar esa propiedad 00:10:32
Y ahora, ese método 00:10:33
Tiene esto dentro 00:10:38
No, perdón, dis.nombre 00:10:39
Esto es muy 00:10:42
Muy importante, los get y los set 00:10:46
No es difícil 00:10:48
Esto sí que es una cuestión de estudiarlo y memorizarlo 00:10:49
No es difícil 00:10:52
Sí, sí, sí, pero eso luego 00:10:53
eso después, como con los constructores 00:10:57
primero vemos lo que es y luego ya vemos la forma rápida 00:11:00
vale, entonces 00:11:04
este es el método que se llama 00:11:05
el método set, que es un método 00:11:09
que sirve para lo que estamos viendo 00:11:12
le pasamos un valor desde fuera 00:11:16
y coge ese valor y actualiza con él la propiedad 00:11:18
luego entonces, gracias a este método 00:11:21
esta propiedad puede ser privada perfectamente 00:11:24
puede ser privada 00:11:27
y si yo quiero darle un nuevo valor 00:11:27
pues ahora ya desde mi prueba 00:11:30
puedo hacer esto 00:11:32
p.llamo al método 00:11:35
setNombre 00:11:37
y le doy el valor que quiera 00:11:38
perfecto, y si ahora muestro la propiedad 00:11:40
ahora la muestro 00:11:48
que no puedo mostrarla porque no le es privada 00:11:49
entonces no puedo mostrarla 00:11:52
no puedo mostrarla 00:11:54
porque es privada, pero si la mostrara 00:11:55
la veremos como, pues vería que se ha cambiado el nombre 00:11:57
Entonces, es a través del método set 00:12:00
a través del cual yo actualizo 00:12:02
el valor de una propiedad de este objeto. 00:12:05
No es que sea obligatorio programar así, 00:12:08
pero es el consenso que todos seguimos. 00:12:11
¿Y por qué es importantísimo seguir este consenso? 00:12:14
Porque en una aplicación normal real 00:12:18
no lo hemos hecho todos nosotros. 00:12:20
Si todo lo que hay en nuestra aplicación 00:12:23
lo hemos hecho nosotros, genial. 00:12:25
Hacemos lo que nos dé la gana, 00:12:27
llamemos a los métodos como queramos. 00:12:28
Ponemos los private public que nos dé la gana, 00:12:29
lo que queramos, 00:12:31
porque todo lo que está en esa aplicación 00:12:32
lo hemos hecho nosotros. 00:12:34
Pero normal es que una aplicación real 00:12:35
tire de clases que han hecho otros. 00:12:37
Y esas clases asumen 00:12:40
que cuando vayan a actualizar una propiedad tuya 00:12:42
lo van a hacer a través del set, 00:12:45
con lo cual van a llamar a un set. 00:12:46
Si tú no tienes el set hecho con el convenio, 00:12:48
te va a fallar la interacción con esas clases. 00:12:51
Entonces, hay que seguir estos convenios 00:12:54
porque si tú interaccionas con clases que han hecho otros, 00:12:56
esos otros van a esperar que tú tengas 00:12:58
tus métodos set perfectamente puestos 00:13:00
con su nombre siguiendo 00:13:03
esta regla, set 00:13:05
nombre de la propiedad empezando en mayúscula 00:13:06
de ahí la utilidad 00:13:09
de que las propiedades, como ya dijimos 00:13:10
empiecen en minúscula 00:13:12
para que no haya confusión con los set 00:13:13
¿vale? 00:13:16
vale, pues entonces 00:13:18
¿y qué ocurre? con este 00:13:20
método estamos dando permiso de escritura 00:13:22
pero solo hemos dado permiso de escritura 00:13:24
si yo desde aquí quiero leer la variable 00:13:26
no puedo, mi programa 00:13:28
quiere ahora leer la variable para ver si 00:13:30
realmente ha cambiado 00:13:32
el nombre del 00:13:34
profesor, no puedo 00:13:36
he dado permiso 00:13:38
de escritura con el set pero de lectura no lo he dado 00:13:40
vale, pues lo puedo dar 00:13:42
a través del otro método, que es el get 00:13:44
el método get 00:13:46
de nuevo sigue un convenio que tenemos que seguir 00:13:48
¿qué devuelve el get? como el get 00:13:50
es para recuperar el valor 00:13:55
devuelve el tipo de dato 00:13:57
de la variable que quiero yo recuperar. 00:13:59
Pues el método get me va a devolver 00:14:01
en este caso para el nombre un string. 00:14:02
Vale. ¿Qué 00:14:06
convenio sigue el nombre del método 00:14:06
get? Lo mismo, pero 00:14:09
ahora get el nombre de la 00:14:11
variable mayúscula. 00:14:13
Y no recibe nada porque no le hace ninguna falta. 00:14:14
Y ahora, ¿qué 00:14:18
hace este método? Devolver la 00:14:18
variable. Ya está. 00:14:20
Devuelve la variable. 00:14:23
Vale. Pues la variable es 00:14:28
privada. Luego, yo nunca voy a hacer 00:14:29
un p.nombre. No lo puedo 00:14:31
hacer porque es privada. 00:14:33
Pero tengo la posibilidad de actualizarla 00:14:35
con el set y la 00:14:37
posibilidad de recuperarla con el get. 00:14:39
Luego, este system out no haría p.nombre 00:14:41
porque es imposible, sino que 00:14:43
haría p.getNombre. 00:14:45
Dígame. 00:14:48
¿Vale? Pues esta 00:14:55
es la manera habitual de programar 00:14:57
las entidades. A todas 00:14:59
las propiedades se las suele poner 00:15:01
privadas. Y luego ya se 00:15:03
hace un par de get y set 00:15:05
para cada una de ellas. 00:15:06
Que en una aplicación en concreto 00:15:09
uno quiere que una propiedad 00:15:11
sea visible para leer 00:15:13
pero no para modificarla. 00:15:14
Pues quitas esto. 00:15:18
Quitas esto y ahora 00:15:19
ya tienes tu propiedad nombre que cualquiera 00:15:21
puede acceder para leerla 00:15:23
pero tienes la garantía de que nadie te la va a modificar. 00:15:24
¿vale? sin estos métodos 00:15:27
get y set, la alternativa que tendrías 00:15:30
es quitar esto y automáticamente das 00:15:32
permiso simultáneo de leer y de escribir 00:15:34
pero con esto 00:15:36
de los get y los set 00:15:38
pues tú ya 00:15:39
y estos get y set se hacen public 00:15:41
claro, se hacen public porque se supone que son 00:15:44
para dar acceso a clases de fuera del paquete 00:15:46
estos get y set 00:15:48
ya se hacen public 00:15:50
¿vale? 00:15:51
pues el nombre, como se llama un método 00:15:53
el nombre del objeto, punto 00:16:08
el nombre del método, y esto que me va 00:16:10
a devolver, me va a devolver el valor 00:16:12
de la variable nombre del objeto p 00:16:14
vale 00:16:16
aquí estoy en el mismo paquete 00:16:17
pero desde fuera del paquete que es el main 00:16:19
como son public, pues lo mismo 00:16:22
aquí no haría prof.nombre 00:16:24
aquí lo mismo, haría 00:16:26
prof.set 00:16:27
nombre, ahora aquí 00:16:29
sí que me deja y estoy fuera 00:16:36
del paquete, estoy fuera, pero 00:16:38
me deja, ¿vale? 00:16:39
Efectivamente. 00:16:45
Bueno, pues esto de los get y set 00:16:50
básico. Entonces, normalmente 00:16:52
una entidad cualquiera tiene tropecientas 00:16:54
variables. Uno no hace 00:16:56
el par de get y set a mano, normalmente. 00:16:58
Si tiene un entorno 00:17:01
de desarrollo, pues tiene la suerte que se los 00:17:02
genera solos, ¿vale? 00:17:04
Entonces, por ejemplo, 00:17:06
en la clase secretario 00:17:08
este nombre. Aquí nos 00:17:11
faltan los get y set. Esta clase secretario 00:17:13
si la hiciéramos bien, 00:17:15
pues esta clase secretario tendría su 00:17:17
propiedad privada y 00:17:19
ahora haríamos los get y set 00:17:21
para que el resto de clases puedan 00:17:22
actualizar la propiedad o 00:17:25
recuperarla como Dios manda. 00:17:27
¿Los escribimos a mano? 00:17:29
Pues deberíais, para que se os quede en la cabeza 00:17:31
cómo funcionan las cosas. 00:17:33
Que sois unos jodidos vagos, 00:17:34
pues hacéis... 00:17:37
Aquí es 40 propiedades por cada... 00:17:38
Claro, cuando tienes muchas propiedades 00:17:40
siempre las generas así. 00:17:42
Pues como hacíamos el constructor. 00:17:44
Botón derecho. 00:17:46
Source. 00:17:47
Generar getter y setters. 00:17:48
Generar getter y setter. 00:17:52
¿De qué propiedad quieres hacer getter y setter? 00:17:53
De esta. 00:17:56
¿Quieres hacer los dos o solo una? 00:17:56
¿Qué quieres? 00:17:59
¿El get o el set? 00:17:59
Venga, los dos. 00:18:00
Ala, generados. 00:18:02
Pues ya está. 00:18:04
Te los generas así tan bonitos. 00:18:04
¿Vale? 00:18:08
Es lo mismo que habríamos escrito. 00:18:09
Bueno, pues todo el mundo sabe entonces lo que significa el modificador public, qué implicaciones tiene. Entonces, una clase no admite private, ¿no? No lo admite. Una clase o es public o no tiene nada. 00:18:10
claro, es que una clase privada 00:18:33
significa solo me puedo usar desde mi misma 00:18:36
eso no tiene ningún sentido 00:18:38
entonces cuando una clase 00:18:39
tiene public 00:18:43
repito, eso no significa que todo lo que está dentro 00:18:43
es public, luego ya cada uno de los miembros 00:18:46
de dentro ya se elige 00:18:48
ya se elige 00:18:49
pero desde el momento en que haya alguno solo 00:18:51
que es public, solo con que haya uno 00:18:54
ya en la clase se pone un public delante 00:18:56
con que haya solo uno public 00:18:58
y eso ya da acceso 00:19:00
desde fuera del paquete, con los import correspondientes, 00:19:02
con el nombre largo, etc. 00:19:05
¿Vale? Y cada miembro se va distinguiendo. 00:19:06
Vale. 00:19:10
Hay un cuarto modificador 00:19:11
que es el protected, 00:19:12
que lo vamos a dejar por ahora porque el protected 00:19:14
es igual que el private, 00:19:16
pero como deja usar 00:19:18
además de sí misma 00:19:20
a las clases herederas. 00:19:22
Pero como las herederas no las conocemos todavía, pero tenemos herencia. 00:19:24
Claro, el private es un 00:19:27
protected, pero que incluye 00:19:28
en la posibilidad de acceder a las herederas 00:19:30
si pones private puedes acceder desde 00:19:33
si pones private no 00:19:34
solo desde la misma 00:19:36
protected amplía a las herederas 00:19:37
vale, ya el por defecto 00:19:40
amplía a las del mismo paquete 00:19:43
un poco menos restrictivo 00:19:44
permite a las herederas usarlo 00:19:46
vale 00:19:49
al final imagino que se usará el private como 00:19:50
bueno, se usa el protected mucho 00:19:52
también, porque casi todas las aplicaciones 00:19:56
tienen una jerarquía de herencia 00:19:58
Sí 00:20:00
Bueno, va también 00:20:02
Depende también de la situación 00:20:06
Claro 00:20:08
Pero bueno, está todo clarísimo 00:20:10
¿No? Vale, pues lo tenéis 00:20:13
Que revisar 00:20:18
Hombre 00:20:18
Vale, ya por último 00:20:21
Para que veáis lo de los hard 00:20:24
Ya para que veáis lo de los hard 00:20:25
Vamos a hacer esta aplicación 00:20:28
Que funcione, vamos a hacer un main que funcione 00:20:29
Para comprimirla en un JAR 00:20:32
Ver que realmente ha metido todo eso en el JAR 00:20:33
Etcétera, y decirle a la máquina virtual 00:20:36
Ejecuta este JAR 00:20:37
Vamos a hacer eso 00:20:38
Pues justo lo que he dicho vamos a hacer 00:20:40
Vale, entonces 00:20:45
Pero voy a hacer un main 00:20:47
Una aplicación, vamos a cambiar esto para que funcione 00:20:49
Porque si no 00:20:52
Vale, pues este ejemplo de clase paquetes 00:20:52
Tiene mi clase profesor 00:20:56
Que la dejamos así con sus getty set 00:20:59
y su método mostrar nombre, le quito el private 00:21:01
porque luego lo vamos a... 00:21:03
El código ya no es legible, ¿verdad? 00:21:05
Depende si lo has exportado con los fuentes o no. 00:21:08
Lo normal es que lo exportes sin los fuentes. 00:21:10
Claro. 00:21:13
Tienes opción de que en el hard vaya también el código fuente. 00:21:14
Pero no es lo normal. 00:21:17
Que me traiga el código fuente. 00:21:19
Entonces tenemos la clase profesor con nombre, 00:21:20
get, set, constructor y el único método 00:21:23
mostrar nombre. 00:21:25
Podemos llamar al get y ya está, pero bueno, 00:21:26
por hacer algo. 00:21:29
Tenemos secretario con sus get y set. 00:21:30
Y su método también mostrar nombre que no sirve para nada, pero bueno. 00:21:33
Prueba queda para ver del mismo paquete. 00:21:40
Y main, que es la que se va a ejecutar. 00:21:42
Seguro que hay programas que le sacan el código. 00:21:44
Claro, online. 00:21:47
O sea, tropecientos. 00:21:49
Tú buscas de compilador online. 00:21:50
Te dice, súbeme el fichero. 00:21:52
Y ya está. 00:21:53
Y funcionan bien. 00:21:54
Claro, sí, sí, sí. 00:21:55
Tiene que ser muy fácil porque te van a intentar. 00:21:56
Claro, cada vez que te dan un código hard de algo. 00:21:57
Yo, de hecho, cuando llegué al ministerio la primera vez, 00:22:00
pero como la administración funciona tan mal desgraciadamente, 00:22:02
Me dieron un montón de aplicaciones que estaban por mantener. 00:22:04
Me dijeron, alguien se ha ido y esto hay que mantenerlo. 00:22:07
Pues ese alguien que se había ido no había dejado el código fuente. 00:22:11
Claro, entonces, pues como los descompiladores existen, 00:22:14
pues lo pude descompilar. 00:22:18
Si no, imposible, claro. 00:22:19
Vale, pues vamos a cambiar esto para que funcione. 00:22:21
New Entidades Profesor. 00:22:24
Es que el constructor de profesor la había quitado al public, ¿verdad? 00:22:25
¿Dónde está el constructor? 00:22:30
Sí, la había quitado al public. 00:22:31
Vale, entonces el main ya... 00:22:35
Este main, ¿qué va a hacer? 00:22:37
Va a mostrar el nombre del profesor, 00:22:39
luego va a cambiar 00:22:42
el profesor a Juanito 00:22:43
y va a decir el nuevo nombre es... 00:22:45
Esto va a hacer este main. 00:22:48
Para luego cuando lo ejecutemos desde el JAR 00:22:49
para que... 00:22:51
Sé que este lo quito 00:22:55
porque no hace nada. 00:22:57
Secretario, nada, no vale para nada. 00:23:00
Bueno, es cuando probamos la otra clase. 00:23:03
El nuevo nombre 00:23:05
y ponemos aquí 00:23:06
prof.mostrarnombre 00:23:08
a la nuestra aplicación 00:23:11
nada, va a hacer esto 00:23:12
mostrar el primer nombre 00:23:14
que es pepito y luego cambiarse y mostrar el nuevo 00:23:17
vale, pues esta es nuestra 00:23:19
aplicación súper sofisticada 00:23:21
al get mostrarnombre 00:23:23
¿cómo? 00:23:25
en vez de get nombre la llamamos mostrarnombre 00:23:27
bueno, es que como ya tenía ese método 00:23:29
mostrarnombre, que es lo que hemos hecho al principio 00:23:31
para, pues lo uso aquí 00:23:33
vale, pero no, no lo llama 00:23:34
esa parte del get 00:23:37
pero hace lo mismo, no, bueno, hace lo mismo 00:23:38
porque este lo muestra por consola, el otro lo devuelve 00:23:41
vale, entonces, esta es nuestra 00:23:43
aplicación que la queremos ya distribuir 00:23:47
para que alguien la use, pues 00:23:49
ahora ya, esta estructura de aquí 00:23:51
el eclipse, el proyecto, esto ya pierde su sentido 00:23:53
ya no vale para nada, no entregamos 00:23:55
el proyecto a un tío para que ese tío 00:23:57
se instale un eclipse, se abra su eclipse 00:23:59
y se lo abre el eclipse, eso es absurdo 00:24:01
¿qué hacemos? lo empaquetamos 00:24:03
en un JAR y ya le damos el JAR y la máquina 00:24:05
virtual lee el JAR directamente 00:24:07
eso sí, el usuario tiene que tener una máquina 00:24:09
virtual en su ordenador, simplemente 00:24:11
vale, pues JAR es un comando de 00:24:12
compresión que podemos irnos a la consola 00:24:15
uno se puede ir a la consola 00:24:17
y ejecutar este comando 00:24:23
con sus opciones y luego 00:24:24
darle la carpeta raíz donde está todo 00:24:26
pero gracias a que tenemos 00:24:28
un entorno de desarrollo 00:24:30
no nos hace falta comprimir desde la consola 00:24:32
entonces, pues nos 00:24:34
vamos aquí a el proyecto 00:24:36
que Eclipse nos hace muchas cosas 00:24:38
por nosotros 00:24:40
vale, entonces, a ver 00:24:41
proyecto 00:24:44
botón derecho 00:24:47
export 00:24:50
quiero exportar esto, ¿cómo lo quiero exportar? 00:24:51
como un fichero hard 00:24:55
vale 00:24:56
entonces, pero tengo 00:24:58
dos opciones, estos son clases 00:25:00
sin más, como si fueran clases de librería 00:25:02
para que uno de estos proyectos los importe 00:25:05
haga un import, que eso también lo haremos 00:25:07
con las static 00:25:08
o es una aplicación 00:25:11
con un main que se va a ejecutar 00:25:13
esto es una aplicación con un main 00:25:15
entonces las aplicaciones que tienen un main 00:25:17
además de las clases comprimidas 00:25:19
tienen que incorporar un pequeño 00:25:21
ficherito de texto que le dice 00:25:23
a la máquina virtual cuál es la que tiene el main 00:25:25
entonces la máquina virtual mira el fichero de texto 00:25:27
y dice ah la que tiene el main es esta 00:25:29
vale, pues entonces le decimos no, que es de esas, es de las que tiene un main 00:25:30
es de las que se van a ejecutar 00:25:33
no son clases sin más, una tiene un main 00:25:35
Entonces seleccionamos el runable 00:25:37
Y ahora ya 00:25:39
Next 00:25:42
Y nos dice, venga 00:25:43
¿Y cuál va a ser tu clase main? 00:25:45
Pues, buh, ¿dónde estará mi clase main? 00:25:48
Esto se llamaba 00:25:53
Ejemplo paquetes o algo así 00:25:54
¿No se llamaba ejemplo paquetes? 00:25:56
Ah, ejemplo clases paquetes 00:26:06
Entonces está 00:26:08
¿Por qué no me aparece aquí? 00:26:09
Ah, vale, aquí 00:26:12
Ah, es que me pone primero las clases 00:26:20
Vale, entonces 00:26:22
Ejemplo 00:26:23
Buff 00:26:25
Sería más fácil ponerlo a mano 00:26:28
Hay que encontrar 00:26:31
Sí, pero 00:26:33
Tienes que poner bien la 00:26:35
La cadena 00:26:38
A ver, se llama main 00:26:39
Entonces tiene que estar por aquí 00:26:43
Ejemplo 00:26:45
Clases paquetes se llama 00:26:49
Entonces tiene que haber por aquí 00:26:51
Una clase main de ejemplo clases paquetes 00:26:53
Pues es que yo no la veo 00:26:56
A ver, voy a seleccionar uno cualquiera 00:27:03
Y luego se lo cambio 00:27:12
No, es que no 00:27:13
No, es que no me deja cambiar la mano 00:27:19
Pero Jolines, es que tiene que estar ahí 00:27:23
A ver, vamos a 00:27:25
Espera 00:27:27
Está guardado 00:27:30
Abajo del todo sale 00:27:34
¿Y me lo decís ahora? 00:27:37
Vamos a ver 00:27:39
Yo la veo tu opinión esa 00:27:40
Vamos a ver 00:27:45
Export 00:27:47
Empezamos otra vez 00:27:49
Runable 00:27:51
Next 00:27:52
Y ahora 00:27:56
O sea que esto del orden alfabético no lo practica 00:27:59
claro 00:28:01
pues es donde he estado ya mirando 00:28:09
y no me sale 00:28:12
¿a vosotros ya os sale? 00:28:13
no me lo puedo creer 00:28:34
a ver que 00:28:36
a ver 00:28:36
entidades 00:28:41
main 00:28:42
a ver, es que si hubiera cambiado el nombre del método 00:28:43
estuviera mal, pero es que está 00:28:46
todo bien 00:28:48
vale, a ver 00:28:50
voy a ponerlo 00:28:59
en el paquete main 00:29:00
vamos a ver 00:29:03
a ver, voy a hacer el fichero a mano y ya está 00:29:04
vale, si esto es 00:29:34
meter en el manifest el nombre de la clase 00:29:37
entonces lo puedo hacer a mano 00:29:39
a ver 00:29:40
voy a, no, no hace falta 00:29:44
voy a ponerle que no sea runable 00:29:48
la diferencia es la misma 00:29:50
a ver, ponerlo vosotros runable 00:29:51
si a vosotros os aparece, pues estupendo 00:29:54
entonces 00:29:56
¿lo estáis haciendo? 00:29:57
vale 00:30:00
sí, pero que es que a mí no me aparece en la clase 00:30:00
entonces 00:30:07
yo le voy a poner normal y corriente 00:30:08
vale 00:30:11
Bueno, o se lo añado a mano 00:30:12
O se lo añado a mano en el fichero 00:30:16
Venga, no es que me obligue a poner alguna 00:30:18
Pues luego se la cambio yo 00:30:20
Se la voy a cambiar con un par 00:30:21
Venga, ala, puedo cualquier otra y se la cambio 00:30:22
Venga, export 00:30:25
Ala, runable hard file 00:30:26
Next, vale 00:30:29
¿Dónde? 00:30:31
Pues 00:30:34
Lo voy a poner en el escritorio 00:30:34
Pues yo en el escritorio 00:30:37
Por encontrarlo rápido 00:30:39
Aprofe 00:30:41
el fichero lo llaméis como os dé la gana 00:30:44
punto hard, vale 00:30:46
guardar y ahora 00:30:47
¿cuál es tu clase principal? 00:30:49
voy a poner 00:30:53
si no me aparece, pongo cualquiera 00:30:53
claro, es que ejemplo clase paquetes 00:30:55
no aparece en ningún sitio 00:31:01
si, vosotros seleccionadla 00:31:03
como queráis 00:31:09
¿Qué más da? 00:31:12
Es el nombre del punto de vuestra aplicación 00:31:13
Como queráis, llamadla como queráis 00:31:15
Vale, pues 00:31:18
Yo qué sé, voy a solucionar esto mismo 00:31:20
Y luego se la cambio, ya está 00:31:22
A ver si, venga 00:31:25
Vale, ya está 00:31:27
Piti, piti 00:31:40
Ala 00:31:41
Ah, claro 00:31:43
Es que voy a tener que descomprimirlo 00:31:46
Vale, este es el hat, ¿vale? 00:31:47
Entonces, este hard de aquí 00:31:49
Tiene dentro 00:31:52
Toda esa estructura de carpetas 00:31:54
Más un ficherito que informa de cuál es la clase main 00:31:55
Vale, el hard 00:31:58
Se puede ver lo que hay dentro 00:32:00
Con el Winzip, se puede 00:32:02
Entonces, vamos a mirarlo por curiosidad 00:32:04
Vale, entonces 00:32:05
Aquí voy a cambiar la extensión 00:32:08
O sea, voy a cambiar solo 00:32:10
Para que me deje abrirlo con zip 00:32:11
No, porque es que 00:32:13
Mi portátil no lo 00:32:15
No, porque 00:32:16
me tengo que buscarla 00:32:18
en el sistema de archivos y es que no tengo idea 00:32:21
de dónde está, así que 00:32:23
entonces es casi mejor que le cambio la extensión 00:32:25
y luego se vuelva a poner y ya está 00:32:28
vale 00:32:29
vale, se la he cambiado 00:32:35
solo para que me permita abrirla con el 00:32:38
WinZip para ver lo que tiene dentro 00:32:40
vale 00:32:41
extra 00:32:42
lo extraigo todo, vale 00:32:45
vale, fijaos 00:32:47
lo que tiene dentro 00:32:50
Ah, claro, es que 00:32:51
Es que como le he dado otra main 00:32:54
Pues me ha tirado 00:32:56
Me ha exportado la otra 00:32:57
Es que yo no sé por qué a mí no me aparece 00:32:58
¿Vosotros habéis podido encontrar la main? 00:33:00
Y al entrar dentro habréis visto 00:33:04
Una carpeta entidades 00:33:06
Otra carpeta main 00:33:08
Dentro de entidades la carpeta secretaría 00:33:10
Y habréis visto también 00:33:12
Un fichero que se llama manifest.mf 00:33:13
¿O no? 00:33:16
Abridmanifest.mf 00:33:18
es un fichero de texto 00:33:19
lo podéis abrir con el blog de notas 00:33:21
veréis que ese fichero 00:33:27
manifest punto 00:33:36
no, dentro de meta inf 00:33:37
pues si lo abrís con el blog de notas 00:33:42
veréis que tiene dentro el nombre de la clase 00:33:46
¿verdad? 00:33:48
no tiene dentro main punto main 00:33:49
pues ese fichero 00:33:51
el manifest punto mf dentro de la clase meta inf 00:33:53
es el que usa la máquina virtual 00:33:56
para saber 00:33:58
que ese es el arranque. Entonces, si vosotros ahora en la consola 00:34:00
hacéis esto, 00:34:02
que es 00:34:05
vamos a llamar a la máquina virtual 00:34:06
Java, 00:34:10
le vamos a dar un hard, 00:34:12
le vamos a dar un hard, 00:34:16
con lo cual ponéis la opción esto para decirle 00:34:17
vamos a dar un hard, y ahora ponéis aquí 00:34:19
vuestro fichero, el que sea, como lo hayáis 00:34:21
llamado, punto hard. 00:34:23
Bueno, os tendréis que ir al escritorio, os tendréis 00:34:25
que ir a donde estéis. 00:34:27
pues veréis que se ejecuta la aplicación 00:34:28
o sea, la máquina virtual entra dentro 00:34:30
del hard, entra dentro 00:34:33
del manifest, busca el main y ejecuta 00:34:35
la aplicación 00:34:37
¿vale? lo podréis comprobar 00:34:37
que eso funciona así, gran misterio 00:34:48
mío, ¿por qué 00:34:50
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
14
Fecha:
10 de diciembre de 2024 - 18:32
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
34′ 53″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
160.79 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid