Saltar navegación

20241216 POO-Clases-STATIC-JAR - 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 enero de 2025 por Raquel G.

9 visualizaciones

Más información Transcripción

Bueno, pues si uno ha hecho, Adrián Alonso, cállate. Vale, pues si uno, es Adrián Alonso, pues eso, si uno ha hecho estas funciones tan estupendas que le han llevado tantísimo tiempo, es para que la gente las use, para distribuirlas en internet o para usarlas nosotros mismos en nuestros proyectos. 00:00:00
pero bueno, realmente 00:00:26
a ver, esto nadie 00:00:27
nos lo va a comprar y nosotros mismos no lo vamos 00:00:30
a usar, vamos a hacer 00:00:32
una clase con métodos estáticos 00:00:33
que si nos sea útil 00:00:35
a lo mejor y que si 00:00:37
podamos usar 00:00:40
pues 00:00:40
estamos todo el rato leyendo el teclado 00:00:43
y es un rollo patatero 00:00:46
porque tenemos que hacer la clase scanner 00:00:47
quitar los next lines 00:00:49
si he leído un número y luego no sé qué 00:00:51
pues mira, vamos a hacernos ya que estamos 00:00:53
una clase con métodos estáticos 00:00:55
para leer entero, leer decimal, leer cadena 00:00:58
y ya está 00:01:01
y esa clase la importamos 00:01:02
desde cualquier proyecto que estemos haciendo 00:01:05
eso que implicará que ya nos olvidamos 00:01:07
del escáner, nos olvidamos de la madre que lo trajo 00:01:09
ya, pero no tienes que escribir escáner todo el rato 00:01:11
tú llamas a un método y punto, pelota 00:01:15
te olvidas del escáner 00:01:17
te olvidas de 00:01:19
a ver, vamos a hacer 00:01:20
un método, vamos a hacer 00:01:25
una clase con métodos 00:01:27
estáticos útiles 00:01:29
para cualquier otro proyecto 00:01:31
de los míos y ahora 00:01:33
vamos a ver cómo lo puedo yo exportar 00:01:35
e importar desde cualquier otro proyecto para usarlo 00:01:37
porque en el ejemplo que hemos visto 00:01:40
antes, como estábamos 00:01:41
en el mismo proyecto, aquí no había 00:01:43
ningún problema, yo desde mi main 00:01:45
aunque estaba en otro paquete 00:01:47
aunque estaba en otro paquete 00:01:48
yo usaba la clase sin más 00:01:50
con el nombre del paquete 00:01:53
pero si estuviera en otro proyecto 00:01:54
esto no podría hacerlo 00:01:56
esto solo podría hacerlo 00:01:57
desde paquetes de la misma clase 00:01:59
de la misma proyecto 00:02:03
pues venga, vamos a hacernos aquí 00:02:04
otro paquete 00:02:06
venga, dentro de matemáticas 00:02:10
vamos a hacernos un paquete 00:02:15
que se llame pues 00:02:16
consola, por ejemplo 00:02:19
porque van a ser utilidades de consola 00:02:20
un paquete 00:02:23
consola y ahora vamos 00:02:25
a hacer una clase con esos 00:02:27
métodos, esa clase 00:02:29
por ejemplo que se llame 00:02:33
leer 00:02:34
por ejemplo 00:02:36
porque es una clase con métodos 00:02:39
para leer por consola 00:02:41
pues venga, vamos a hacer 00:02:43
como haríamos un método 00:02:45
le vamos a poner ya al public porque ya hemos avanzado 00:02:46
que la idea es usarlo desde, por supuesto 00:02:49
fuera de ese paquete 00:02:51
un método 00:02:52
que me lea del teclado una cadena 00:02:54
y me la devuelva como 00:02:56
valor de retorno 00:02:58
bueno pues este método 00:03:00
sería, nos hacemos nuestro 00:03:02
escáner, aquí como mi 00:03:04
variable local 00:03:06
y ahora, pues ahora ya 00:03:07
puedo hacerme esto 00:03:18
¿verdad? 00:03:20
o sea este método me lee 00:03:34
una cadena del teclado 00:03:36
Y de hecho hasta 00:03:38
Podría no tener que arrastrar 00:03:41
Los system out 00:03:44
Pues yo que sé, podríamos hacer 00:03:45
Vamos a probar 00:03:47
Introduzca 00:03:50
Cadena de texto 00:03:53
Cadena de texto 00:03:55
Ala 00:04:01
Pues este método 00:04:02
Me dice introduzca cadena de texto 00:04:04
Se queda esperando a que yo meta una cadena de texto 00:04:06
Y cuando yo la he metido me la devuelve 00:04:09
Como valor de retorno 00:04:11
Aquí ya veis que ya empezamos a entender 00:04:12
Lo que estamos haciendo 00:04:19
Scan es un objeto de la clase Scanner 00:04:20
Al que efectivamente he instanciado con el constructor 00:04:25
Ya entendemos las cosas que hacíamos 00:04:29
El constructor de Scanner necesita el qué 00:04:31
El sitio al que se va a enganchar el Scanner 00:04:35
Sistening que es la consola 00:04:37
next line ¿qué es? 00:04:40
next line es un método de la clase 00:04:42
escáner, no estático por supuesto 00:04:44
porque lo llamo asociado a un objeto scan 00:04:46
next line es un método, ¿qué es lo que hace ese 00:04:48
método? pues si no se mete a ver cómo está programado 00:04:50
por dentro, pues se quedará esperando 00:04:52
y cuando tú le metes algo te lo devuelve 00:04:54
entonces ya las cosas que hemos 00:04:56
escrito toda la vida ya cobran sentido 00:04:58
vale, vamos a hacer ahora un método 00:05:00
para leer un entero, por ejemplo 00:05:02
entero 00:05:04
y este me va a devolver un int 00:05:11
y ahora cambiamos el mensaje 00:05:13
introduzca 00:05:15
número 00:05:17
entero 00:05:20
y ahora en lugar de con next line 00:05:22
pues lo leemos con next int 00:05:26
claro, y vamos a hacernos un método 00:05:27
para un decimal 00:05:32
que son las tres cosas que leemos habitualmente 00:05:34
o dabble 00:05:37
dabble para que tenga más 00:05:42
precisión 00:05:44
No sé, a mí me 00:05:45
Me cae mal 00:05:49
Vale, introduzca número decimal 00:05:51
Y ahora scan next double 00:05:54
Vale, pues si yo pudiera 00:05:58
Usar estos métodos desde cualquier sitio 00:06:03
Cuando tengo que leer una cadena 00:06:05
Pondría leer punto cadena 00:06:07
Y me olvidaría de hacer el escáner en mi proyecto 00:06:08
Me olvidaría de todo 00:06:11
Cuando tengo que leer un entero, pondría 00:06:12
Leer punto entero 00:06:14
¿Verdad? 00:06:16
Sí. No, súper mentira, porque no he puesto 00:06:19
un static, con lo cual nunca podría hacerlo así. 00:06:21
Si quiero hacerlo así, tendría 00:06:23
que poner un static. Nos han mentido, profesor. 00:06:25
No, es que se me ha olvidado poner static. 00:06:26
Vale, ahora ya sí. Estos métodos 00:06:31
son static y pueden serlo, no tienen ningún 00:06:33
problema, porque no dependen de ninguna propiedad 00:06:35
de la clase. Porque de hecho la clase 00:06:37
no tiene propiedades. Eso es. 00:06:39
Vale, pues yo ahora 00:06:42
desde cualquier... 00:06:43
Ahora a mí 00:06:47
me encantaría, cada vez que quiera leer 00:06:47
algo de esto, poner leer.cadena 00:06:51
y ya está, y me olvido de hacer el escáner 00:06:52
leer.entero y ya está, me olvido de hacer el escáner 00:06:55
vale, entonces desde otras 00:06:57
clases de mi mismo proyecto 00:06:59
está claro, no tengo ningún 00:07:01
problema, por ejemplo, pues yo que sé 00:07:03
me voy a hacer aquí en app 00:07:05
de mates, esta 00:07:06
aplicación main, por ejemplo 00:07:08
aquí yo he hecho, en esta aplicación 00:07:10
main que hemos hecho antes para 00:07:13
probar las utilidades matemáticas 00:07:14
cuando tenía que leer el número 00:07:16
me he tenido que hacer un escáner, he hecho el next 00:07:18
in, pues si yo 00:07:20
ahora ya 00:07:22
con esto, podría cambiar esto 00:07:24
me olvido 00:07:26
de tener que hacer el escáner al principio 00:07:28
de todo, me olvido de todo esto 00:07:30
y aquí por ejemplo 00:07:32
no, pero 00:07:35
aquí por ejemplo, ¿qué puedo hacer? 00:07:38
venga, char 00:07:41
op igual a 00:07:42
leer punto 00:07:45
cadena 00:07:46
Y me da la cadena leída 00:07:49
Que luego yo me quedo con el carácter en la primera posición 00:07:50
Pues me quedo, eso ya es problema mío 00:07:54
Vale 00:07:56
He llamado a leer cadena 00:07:57
Eso me va a leer una cadena 00:07:59
Y no tengo que poder escanear ni nada 00:08:01
Ya el método me lo hace todo dentro 00:08:02
Y aquí igual cuando he leído el número 00:08:04
Pues yo podría hacer así 00:08:07
Int num igual a 00:08:09
Leer punto entero 00:08:11
Y ya está 00:08:14
Y aquí lo mismo 00:08:16
Cuando he leído el número 00:08:19
pues me olvido del scan y de todo 00:08:20
¿vale? 00:08:23
entonces yo tengo estos métodos que los uso 00:08:32
cada vez que quiero un entero, cada vez que quiero una cadena 00:08:34
y me despreocupo de escáneres 00:08:36
y de cosas, completamente 00:08:38
y no solo de eso, sino que como podemos comprobar 00:08:39
me despreocupo del salto de línea 00:08:41
que se ha quedado de tener que eliminarlo 00:08:44
porque el escáner es una variable local que aparece 00:08:46
y desaparece, luego se le elimina 00:08:48
todo lo que tenga en el buffer 00:08:50
no es como aquí 00:08:51
que tengo un escáner compartido por todos 00:08:54
vale, pues igual que es útil 00:08:56
para clases de mi mismo proyecto 00:08:59
utilísimo si lo puedo usar ya 00:09:00
en cualquier otro proyecto que yo tenga 00:09:03
que yo empiece de nuevas, lo uso 00:09:04
y ya me olvido del escáner y de todo 00:09:07
pregunta 00:09:08
¿por qué esto que es más cómodo 00:09:08
no es lo que te dejan importar? 00:09:13
¿por qué la clase escáner no hace esto directamente? 00:09:17
bueno, la clase escáner lo hace con Slime 00:09:21
pero que tenga un método exacto para esto 00:09:23
que te abre tercero el escáner 00:09:25
bueno, a ver, te ofrece 00:09:26
Scanner y tú lo usas como quieras 00:09:30
pero no puede cerrarse a sí mismo tampoco 00:09:32
claro, pero hay que estar pendiente de cerrarlo 00:09:33
y esto no, porque esto lo usas y 00:09:36
automáticamente desaparece 00:09:37
ya, pero a ver 00:09:40
o sea, me refieres, ¿por qué no hay una 00:09:42
utilidad añadida que 00:09:44
es más cómodo 00:09:45
al final y es igual 00:09:48
bueno, a ver, tú tienes varias 00:09:49
clases de entrada y salida 00:09:52
no, a ver, es 00:09:53
escáner se acopla al teclado 00:09:57
y te lee cosas, y luego tú lo usas como quieras 00:10:01
pues que lo quieres meter en 00:10:03
bueno, pues entonces 00:10:04
vale, pues entonces nosotros, esta clase 00:10:07
nos encantaría usarla desde cualquier otro proyecto 00:10:11
para ya cada vez que tengamos que leer del teclado 00:10:13
usarla sin más, pero efectivamente 00:10:15
si yo ahora me hago un proyecto nuevo 00:10:17
vamos a hacer un proyecto nuevo 00:10:19
pues para hacer cualquier cosita 00:10:22
Proyecto prueba 00:10:24
Porque este no es solamente para hacer la prueba 00:10:29
Y lo voy a subir ni nada 00:10:31
Pues haga 00:10:32
Me hago este proyecto de prueba por aquí 00:10:34
Y me voy a hacer 00:10:37
Pues una aplicación 00:10:40
Aquí en mi paquete main 00:10:41
Me voy a hacer 00:10:45
Una clase main 00:10:47
Y ahora pues resulta que yo aquí 00:10:48
Pues quiero hacer cosas y entre ellas me interesa 00:10:55
Pues leer un número entero por ejemplo 00:10:57
Entonces claro 00:10:58
A mi me encantaría pues poder llamar 00:11:00
A el paquete que se llamaba 00:11:03
Consola 00:11:05
Punto, pues leer 00:11:05
Y ahora punto, pues entero 00:11:08
Por ejemplo, y esto me 00:11:10
Leería un numerito entero 00:11:12
¿Vale? 00:11:15
Pero esta ruta, para este proyecto 00:11:19
No pinta nada, no es nadie 00:11:21
Porque el paquete consola 00:11:23
Está en otro sitio 00:11:25
Está 00:11:27
No, no, no 00:11:28
¿Vale? 00:11:34
Está aquí, está en nuestro proyecto. 00:11:36
Está aquí. 00:11:40
Consola está aquí. 00:11:42
Consola es un paquete. 00:11:44
Consola es un paquete que está aquí, 00:11:52
que tiene leer. 00:11:54
Entonces, consola.leer 00:11:55
tiene sentido aquí dentro 00:11:57
de este proyecto matemáticas. 00:11:59
Aquí dentro tiene sentido consola.leer. 00:12:01
Pero aquí en otro proyecto, 00:12:04
que es otro proyecto distinto, 00:12:05
claro, pero te tienen que haber dado el código fuente 00:12:07
es que yo no te voy a dar el código fuente 00:12:14
claro, no vaya a ser que te dé el código fuente 00:12:16
y me piratees el código 00:12:22
y te haga rico a mi costa 00:12:23
vale, entonces está claro 00:12:26
que desde este proyecto, que no tiene nada que ver con este 00:12:29
aquí, consola.leer 00:12:32
no es nadie 00:12:34
consola.leer es alguien aquí en este 00:12:35
consola.leer es alguien aquí 00:12:39
pero aquí no es nadie 00:12:41
vale, pues entonces ¿qué hacemos? 00:12:42
pero yo aún así quiero que usen mi código 00:12:45
y quiero distribuirlo 00:12:46
por eso me lo voy a decir a la gente, oye, copia y pega 00:12:47
eso es muy cutre, me lo voy a decir eso 00:12:50
entonces ¿qué hago? 00:12:52
voy a exportar este paquetillo 00:12:54
lo voy a exportar a un hard 00:12:56
porque un hard es la manera en la que se distribuyen 00:12:58
las aplicaciones java 00:13:01
me da igual que sean clases de librería 00:13:03
clases con método main como ya hicimos 00:13:04
el otro día, es la manera en la que se distribuyen 00:13:07
las clases, pues venga 00:13:09
hacemos aquí en matemáticas, que es donde estaba 00:13:11
ese paquete, export 00:13:13
en hard, ahora nada 00:13:14
de runable, porque lo que 00:13:17
yo voy a exportar no son clases con método 00:13:19
main, no son aplicaciones para ejecutarse 00:13:21
con main, lo que yo voy a 00:13:23
exportar 00:13:26
son clases sin más 00:13:27
clases sin más, pues entonces 00:13:29
marco hard, esto no es una 00:13:31
aplicación ejecutable 00:13:33
vale, pues hard, y ahora que me dice 00:13:34
vale, sí, pero 00:13:37
si fuera capaz de verlo, me dice 00:13:38
pero que quieres exportar realmente 00:13:41
pues marco aquí todo 00:13:43
no, yo quiero el paquete solo este, es que aquí está 00:13:45
tan mínimo que no lo veo 00:13:47
marco consola solo, vale 00:13:48
quiero exportar solo consola 00:13:51
es que eso yo quiero 00:13:52
solo quiero mi clase de leer que está en consola 00:13:55
solo quiero esa, ah, bueno 00:13:57
vale 00:14:03
en consola, que quiero exportar, todo, solo dejas 00:14:03
hay todo, ¿vale? 00:14:06
Vale, entonces aquí te dice 00:14:08
¿quieres exportar también el código 00:14:10
fuente? Hombre, si eres muy 00:14:12
generoso, pero no lo vamos a exportar. 00:14:14
No, que se joda. 00:14:16
Vamos a exportar el código fuente. 00:14:18
Y ahora, ¿a qué 00:14:21
jar lo quieres exportar? 00:14:22
Bueno, al que nos dé la gana. Venga, 00:14:24
llamadlo como queráis, ¿vale? 00:14:26
Yo lo tengo ahí llamado en el escritorio 00:14:28
para encontrarlo rápido. 00:14:30
¿Vale? 00:14:32
Yo lo tengo aquí para 00:14:36
encontrarlo rapidito, lo tengo en el escritorio 00:14:37
teclado.jar 00:14:39
vale, exportame eso 00:14:40
el paquete este de aquí 00:14:43
consola, que no sé muy bien lo que estoy 00:14:45
exportando porque no lo veo, pero vamos 00:14:47
estará exportando todo bien, lo que hay dentro 00:14:49
teclado, ala, next 00:14:51
todo esto lo dejamos por 00:14:53
defecto 00:14:55
y next, todo por 00:14:56
defecto 00:15:03
y finish, vale 00:15:04
ala 00:15:07
pues mi 00:15:10
jar está aquí. 00:15:13
Esto no es una cosa que se puede ejecutar. 00:15:16
No tiene un método main. No es una clase que 00:15:18
tenga un método main. Esto tiene una clase 00:15:20
con métodos estáticos. No es 00:15:22
algo para ejecutar. 00:15:24
Claro, ¿para qué me sirve a mí este teclado 00:15:26
.jar? Pues yo ahora estoy en 00:15:28
cualquier proyecto y digo, oye, me 00:15:30
interesan las clases que hay en este jar. Me interesan. 00:15:32
Pues voy a 00:15:35
importarlas. Entonces 00:15:36
alguien me tiene que haber dado físicamente 00:15:38
este jar con sus clases. O 00:15:40
Yo lo he descargado de internet o de donde sea. 00:15:42
O lo he cogido de un repositorio. 00:15:44
Pero una vez que ya lo tengo, 00:15:46
ahora ya yo me voy a mi proyecto. 00:15:48
¿En qué proyecto estaba yo 00:15:51
en el que quería usar estas clases? 00:15:52
Pues estaba en mi proyecto, proyecto prueba. 00:15:54
Pues ahora me voy al 00:15:57
botón derecho. 00:15:58
Eso, muy bien. 00:16:01
Me voy 00:16:05
al botón derecho. 00:16:06
Y de import, nada. 00:16:07
Que eso es muy listo. Me voy a 00:16:09
build path. 00:16:11
Y me voy a 00:16:13
Configure BillPath 00:16:15
A ver, puedo ir por muchos camiones al mismo sitio 00:16:16
Pero es el que más entendemos 00:16:19
No hay una carpeta física en el explorador 00:16:20
Donde se pueda meter ese hack 00:16:22
Que la detecte quién 00:16:23
Pero eso tendrás que decirle 00:16:26
Él no detecta todos los hacks que hay en el mundo 00:16:30
Lo tendrás que decir 00:16:32
Pero tendrás que decírselo 00:16:33
Que es lo que estamos haciendo 00:16:36
¿Cómo que si no tiene un pad? 00:16:37
Hombre, Java tendrá un pad por defecto 00:16:40
Donde tendrá todas las clases guardadas 00:16:42
Java no, los proyectos de Java 00:16:43
Eclipse tendrá un 00:16:46
path de donde buscará 00:16:48
para los proyectos, para las claves que usas 00:16:49
No, tiene uno para cada 00:16:52
proyecto, y tú en cada proyecto lo fijas 00:16:54
y lo estamos fijando con esto 00:16:56
Claro, es lo que vamos a hacer ahora 00:16:57
Pero pensaba que tenía uno común 00:16:59
No, no, no, no, no, no, cada aplicación 00:17:01
Java lleva su propio path 00:17:03
Cada vez que construyes un proyecto te crea 00:17:05
un directorio con todas las 00:17:07
con un montón de librerías 00:17:09
que se pueden utilizar como 00:17:11
a ver, si tú 00:17:13
a ver, las librerías 00:17:15
que están dentro de la JRE 00:17:17
esas sí están en un 00:17:19
claro, pero tú tendrías que meter 00:17:21
teclado.jar dentro de las del JRE 00:17:22
si lo metes dentro, sí 00:17:25
pero lo que no puedes es 00:17:27
meterlo en otra carpeta y decir esto es por defecto para todas 00:17:29
porque cada proyecto tiene que conseguir 00:17:31
el suyo propio 00:17:33
a ver, si tú la metes, el teclado.jar 00:17:33
lo metes dentro de la JRE 00:17:39
pero tienes que irte al directorio JRE 00:17:40
comprimirlo en la manera que el JR 00:17:43
y meterlo ahí, entonces sí 00:17:45
pero claro, no es lo que hacemos, la JR nunca la tocamos 00:17:46
de esa manera, nunca se toca la JR 00:17:49
vale, entonces ahora 00:17:51
venga, pues a ver 00:17:53
nosotros vamos, botón derecho del proyecto 00:17:55
configure buildpad 00:17:57
¿qué hacemos cuando entramos en 00:17:59
configure buildpad? 00:18:01
pues le estamos diciendo 00:18:03
¿dónde puede él encontrar 00:18:05
clases? normalmente 00:18:07
él puede encontrar clases 00:18:09
en el raíz del proyecto y en 00:18:10
todos los paquetes que te da por debajo. 00:18:13
Entonces, cada vez que hacemos un paquete, 00:18:15
añadimos a esa RU, a ese ClassPad, 00:18:17
llamémoslo, aunque no quiero meterme en esos líos, 00:18:20
al proyecto, a Java, le estamos diciendo, 00:18:22
oye, ojo, que este proyecto puede tener clases en el raíz 00:18:24
y en todas estas carpetas que cuelgan de ti, ¿vale? 00:18:27
Pero teclado.jar no cuelga de ninguna carpeta 00:18:32
dentro del proyecto, no cuelga ninguna dentro. 00:18:35
Entonces, hay que añadir esa ruta al proyecto. 00:18:38
Pues, para eso entramos aquí en Configure Buildpad, ¿vale? 00:18:42
Pues, aquí os metéis en la pestaña esta de librerías, ¿vale? 00:18:47
Y veis, aquí hay una cosita que tiene esa palabra clave que yo 00:18:52
he mencionado sin querer meterme mucho, que es Classpath. 00:18:57
Entonces, ¿qué es el Classpath? 00:19:00
Cada proyecto tiene su Classpath, que repito, 00:19:02
es una variable, una variable de entorno, 00:19:05
que guarda todas las rutas 00:19:07
donde esa aplicación 00:19:10
puede tener clases accesibles. 00:19:12
El Clash Path ahora mismo 00:19:15
al estar vacío 00:19:16
significa que es la ruta por defecto 00:19:17
que es la del propio proyecto 00:19:21
y todos los paquetes que cuelgan de él. 00:19:22
Que eso no hay que meterlo, 00:19:24
es la suya propia. 00:19:26
Y luego aparte tenemos aquí esto 00:19:27
porque esta es común para todos 00:19:29
y las clases que están aquí 00:19:31
son accesibles para todo el mundo. 00:19:32
Pero tendrías que irte aquí dentro. 00:19:35
Creo que decía yo. 00:19:37
Claro, vale. 00:19:38
Sí, pero jamás. 00:19:39
Nunca toques una JRE 00:19:42
porque la máquina virtual 00:19:43
se usa para millones de aplicaciones 00:19:44
de tu ordenador. 00:19:46
Entonces, cualquier modificación 00:19:47
que hagas en ella 00:19:48
tiene mucho peligro. 00:19:49
Curiosidad, 00:19:50
tiene una cosa igual, 00:19:50
un nombre igual. 00:19:51
Claro, no la toques nunca 00:19:52
sobre todo porque 00:19:53
hay una forma más fácil 00:19:54
que es meter ese hard. 00:19:55
Entonces, ¿qué tenemos que hacer ahora? 00:19:58
Decirle al Clashpad, 00:19:59
oye, tú, Clashpad, 00:20:00
que aparte de las clases 00:20:02
que cuelgan de tu propio proyecto, 00:20:04
dime. 00:20:06
Sí, el ClassPass es una variable que tiene cada proyecto, la suya propia, y es una variable que te informa del conjunto de rutas dentro de las cuales puede haber clases que use esa aplicación. 00:20:06
¿Quieres que te lo diga? 00:20:23
El ClassPath es una variable que guarda todas las rutas 00:20:31
en las cuales hay clases 00:20:35
que la aplicación puede usar. 00:20:39
¿Vale? 00:20:46
Vale, pues entonces, 00:20:51
hay una por proyecto. 00:20:52
Cada aplicación Java tiene su propio ClassPath. 00:20:55
y lo podemos editar 00:20:57
por supuesto desde la consola 00:20:59
pero si tenemos un entorno de desarrollo 00:21:01
nos es más fácil editarlo a partir de aquí 00:21:03
properties, configure build path 00:21:05
y entramos aquí en libraries 00:21:07
vale, ahora mismo no tiene nada, que no tenga nada 00:21:08
significa que las únicas 00:21:11
rutas en las que hay clases que la aplicación 00:21:13
puede usar son las propias del proyecto 00:21:15
las suyas propias 00:21:17
el raíz y los paquetes que cuelguen 00:21:19
pero resulta que queremos añadirle 00:21:21
el hard que está fuera del proyecto 00:21:24
de hecho está en el escritorio 00:21:26
se lo queremos añadir y decirle, ojo 00:21:27
que en este jar hay clases que también quiero que uses 00:21:29
ojo, pues entonces 00:21:31
¿qué hacemos? 00:21:33
nos vamos aquí en 00:21:37
le voy a quitar la esta 00:21:39
vale 00:21:42
y ahora veis 00:21:45
vale, pues ahora pincháis classpad 00:21:46
y veis que aquí se abre 00:21:49
un montón de botones 00:21:51
y uno de ellos es, añade un jar 00:21:53
externo, es justo lo que queremos 00:21:55
un JAR que está fuera en el escritorio 00:21:58
que está fuera del proyecto 00:22:00
quiero añadirlo, no significa que lo meta 00:22:01
dentro del proyecto, lo que significa es que 00:22:04
su ruta la agrego al classpath 00:22:05
pero el JAR no lo muevo 00:22:08
el JAR se queda en el escritorio 00:22:10
añado la ruta al classpath 00:22:11
pero o sea que si tú el JAR 00:22:13
por ejemplo lo eliminas, ya quedó grabado aquí 00:22:16
no, no, no, como el JAR lo eliminas 00:22:18
ya quedó grabado, porque lo único que es configurado 00:22:20
en el classpath es la ruta 00:22:22
Entonces, cuando el proyecto no es de usar esa clase, 00:22:23
va a ir a través de la ruta al JAR. 00:22:27
Si el JAR no ha escrito en el escritorio, está jodido. 00:22:29
¿Vale? 00:22:32
Bueno, pues entonces, vamos a añadir un JAR externo. 00:22:33
Le damos a ADE externo al JAR. 00:22:37
Y nos dice, pues dime dónde está A, alma de cántaro. 00:22:39
Pues tú te vas al escritorio, aquí, teclado.jar. 00:22:42
Abrir. 00:22:47
¿Veis? 00:22:48
Ha aparecido aquí debajo. 00:22:48
entonces como veis 00:22:49
lo que hemos añadido es solo la ruta 00:22:52
hemos dicho, oye que este proyecto 00:22:54
tiene derecho a usar 00:22:55
a partir de ahora 00:22:58
a partir de ahora tiene derecho a usar 00:22:59
aparte de la JRE 00:23:01
aparte de las propias clases suyas 00:23:03
a ver, te decides 00:23:05
te vas o te quedas 00:23:08
vale 00:23:08
vale 00:23:11
pues con esto es lo que estamos diciendo 00:23:13
ojo, que este proyecto a partir de ahora 00:23:15
tiene derecho a usar, tres cosas 00:23:17
las clases de la máquina virtual como siempre 00:23:19
por supuesto, System.out, Scanner 00:23:22
String, todas esas que están en la máquina virtual 00:23:24
las suyas propias 00:23:26
que ha hecho él, lógicamente faltaría más 00:23:28
las que ha hecho él dentro de su proyecto 00:23:30
y además las que estén aquí 00:23:31
¿vale? 00:23:34
pues ya está, ya hemos hecho esto, ya le damos 00:23:36
Apply, Close 00:23:38
y se me ha 00:23:39
quitado el rojo, ¿veis que automáticamente 00:23:42
se me ha quitado el rojo? ahora ya 00:23:44
esto es accesible 00:23:46
si miramos lo que ha pasado en mi proyecto 00:23:47
lupa 00:23:51
efectivamente 00:23:54
aparte de JRE 00:23:56
me ha aparecido aquí esto 00:23:58
que me dice 00:23:59
ah mira, tienes acceso a teclado.jar 00:24:02
que está aquí 00:24:05
y si lo despliegas dentro 00:24:05
hasta te informa de las clases que hay dentro 00:24:07
te informa de ellas 00:24:09
pero eso sí, solo tienes el compilado 00:24:10
el fuente no tienes 00:24:14
entonces el tío te ha distribuido su jar 00:24:15
pero tú no sabes cómo ha hecho el código 00:24:17
Pero es que no te hace ninguna falta 00:24:19
¿Vale? 00:24:21
Si yo pincho aquí, de hecho me dice 00:24:23
Uh, lo siento pero 00:24:24
Me dice 00:24:27
No sé 00:24:29
No sé qué es eso 00:24:30
Porque está solo el compilado, o sea, yo no tengo acceso a su código 00:24:32
Pero no lo necesito 00:24:35
Lo único que quiero es usarlo 00:24:36
¿Vale? Y ahora ya 00:24:38
Como ya lo tengo aquí, pues este 00:24:40
Paquete consola me ha aparecido 00:24:42
No es que físicamente esté ahí dentro 00:24:44
Lo que hay es una referencia 00:24:46
a donde está en el 00:24:48
escritorio, ¿vale? 00:24:50
Y ahora yo ya puedo usar esto perfectamente 00:24:52
para leer un entero. 00:24:54
Por ejemplo, vamos a leer una cadena. 00:24:56
Vamos a ver si hemos solucionado 00:24:58
lo del, al ser variable, un segundito, al ser 00:25:00
variable local, vamos a ver 00:25:02
si hemos solucionado lo del salto de 00:25:04
línea. Recordad que el salto de línea nos 00:25:06
ocurría cuando después de leer un número 00:25:08
leíamos una cadena, ¿verdad? 00:25:10
Pues voy a leer un número y voy a leer 00:25:12
ahora una cadena con mi 00:25:14
super librería. 00:25:16
leer.cadena 00:25:17
vale, como veis 00:25:25
mi código es más cómodo 00:25:31
que si tuviera que haber hecho el escáner, luego el 00:25:33
scan next line, pues esto es 00:25:35
más cómodo, que quiero leer un número 00:25:37
leer entero, le quiero una cadena 00:25:38
leer cadena, ya está 00:25:41
vamos a ejecutarlo 00:25:42
venga, primero un numerito entero 00:25:44
¿veis? 00:25:51
y se queda esperando la cadena 00:25:53
no tengo el problema ese de que 00:25:54
el salto de línea después del número 00:25:57
alimenta al otro next 00:25:59
y no porque son independientes 00:26:00
son dos objetos escáner que han desaparecido 00:26:02
vale, entonces 00:26:04
hemos ganado con esto 00:26:06
dos ventajas 00:26:10
dejar de arrastrar el escáner 00:26:11
lo del salto de línea famoso 00:26:15
ahora ya 00:26:17
si hacéis eso del build path 00:26:19
con cualquier proyecto 00:26:22
que hagáis, pues podéis usar esta clase para leer 00:26:24
y no tenéis 00:26:26
que acordaros del escáner todo el rato 00:26:28
vale, esto es un ejemplo 00:26:30
en realidad era un ejemplo 00:26:34
de utilidad de los métodos 00:26:35
estáticos, son métodos de librería 00:26:38
métodos que no dependen de propiedades de la clase 00:26:39
los llamo 00:26:42
con el nombre de la clase, con lo cual 00:26:43
es comodísimo, no tengo que crear ningún objeto 00:26:46
lo llamo con el nombre 00:26:47
que los quiero usar en otro proyecto, los exporto con un 00:26:48
jar y luego los importo 00:26:52
ah, sí, dime 00:26:53
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:
9
Fecha:
10 de enero de 2025 - 17:45
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
26′ 59″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
113.58 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid