Saltar navegación

20241216 POO-Clases-STATIC - 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.

8 visualizaciones

Más información Transcripción

Descargar la transcripción

Ve, hagamos de una cosa muy bonita, que sí, que os va a gustar mucho. Vale, pues entonces, en el ejercicio este 21 que habíamos visto el otro día las clases empleado, departamento y el main, pues no llegamos a mirarlo, habíamos dicho, claro, ahora ya nuestra clase tiene dos tipos de propiedades, propiedades como estas que no tienen static y esta que sí que lo tiene. 00:00:00
Entonces ya sabemos lo que significa esto, que estas propiedades de aquí implican que cada objeto departamento, cada objeto tiene su propio nombre, su propio director y su propio array de empleados. 00:00:29
Cada objeto departamento tiene el suyo propio 00:00:42
Pero al aparecer esta propiedad aquí 00:00:44
Y tener el static delante 00:00:48
Significa que todos los objetos departamento 00:00:51
Todos acceden a la misma propiedad 00:00:55
Dirección empresa 00:01:00
Porque es compartida por todos 00:01:00
¿Vale? 00:01:02
No, no es que sea el par, es una propiedad compartida 00:01:06
Sin embargo, nombre, ¿tiene cada uno su nombre? 00:01:09
cada uno su director 00:01:11
y cada uno sus empleados 00:01:13
y sin embargo 00:01:15
dirección empresa es una variable que está ahí 00:01:17
compartida por todos los objetos 00:01:19
entonces por eso en este 00:01:22
main de pruebas que hicimos 00:01:23
pues me da igual hacer 00:01:25
de uno punto dir empresa 00:01:27
que hacer de dos punto 00:01:29
dir empresa me da igual porque dir empresa 00:01:31
es la misma variable para todos 00:01:33
compartida 00:01:35
entonces como daba igual el objeto que la llamara 00:01:36
daba igual, pues la forma habitual de llamar 00:01:39
las variables estáticas es con el nombre de la clase 00:01:41
porque me da igual el objeto que la llame 00:01:43
que yo la llamo con de 1 00:01:45
me da igual, estoy accediendo al mismo sitio 00:01:47
me da exactamente igual 00:01:49
como si la llamo con otro objeto departamento 00:01:51
de 2 que he hecho por aquí 00:01:53
me da lo mismo decir de 1.empresa 00:01:55
que de 2.empresa me da igual 00:02:01
porque esta es la variable compartida por todos 00:02:03
entonces como me da igual 00:02:04
la puedo llamar así 00:02:06
y de hecho 00:02:08
lo que habíamos dicho es que podemos incluso 00:02:10
llamar a esta variable, aunque no 00:02:13
existan 00:02:15
objetos departamento, aunque no 00:02:15
exista ninguno. 00:02:18
Desde el momento en que 00:02:20
llamamos a la variable dirEmpresa 00:02:22
con el nombre de la clase, esa variable 00:02:24
aparece ahí. Y es una variable 00:02:26
fuera de cualquier objeto, 00:02:28
completamente fuera de cualquier objeto. 00:02:30
¿Vale? Es una variable global. 00:02:33
No pertenece a ningún objeto 00:02:35
y a la vez pertenece a todos, porque todos 00:02:36
lo comparten. 00:02:38
¿Vale? Entonces 00:02:40
¿Por qué la hemos ubicado aquí? 00:02:42
Dentro, bueno 00:02:46
Porque es una información relativa a los departamentos 00:02:46
Entonces los temas de diseño no se nos tienen que olvidar 00:02:49
Y los temas de diseño 00:02:51
Significan qué propiedades les doy a las clases 00:02:53
Qué clases hago 00:02:55
Todo lo que estáis trabajando en 00:02:56
Bases de datos, pues aquí igual 00:02:59
Pues hombre, dirección empresa 00:03:00
Tiene que ver con dónde están los departamentos 00:03:02
Pues dónde pongo esa variable 00:03:05
No la puedo poner fuera de todas las clases 00:03:07
Porque ahí no se puede poner nada en Java 00:03:08
pues la pongo dentro de la clase departamento 00:03:09
pero me acuerdo del static 00:03:12
porque no está asociada a ningún objeto 00:03:14
no está asociada 00:03:16
va por libre 00:03:17
y accedo a ella a través del nombre de la clase 00:03:18
¿vale? 00:03:21
entonces precisamente como no va asociada a ningún objeto 00:03:23
pues dijimos que a las propiedades 00:03:26
estáticas 00:03:28
no es convenio de programación 00:03:29
que se acceda a ellas con getty set 00:03:32
se las pone public 00:03:34
y punto pelota 00:03:35
no hay get y set, entonces accedemos 00:03:37
directamente con el nombre de la clase 00:03:39
punto la propiedad 00:03:41
o de uno punto propiedad o de dos 00:03:42
punto propiedad, me da igual 00:03:45
si es que de uno y de dos existen 00:03:47
vale 00:03:49
entonces, si hay 00:03:49
propiedades estáticas 00:03:57
inicializada, te refieres 00:03:59
bueno, si en ese momento 00:04:06
si tiene un valor inicial por defecto, si 00:04:08
aquí no lo hemos inicializado 00:04:10
depende de la aplicación, depende 00:04:11
Podríamos, podríamos aquí inicializarla, darle un valor y ya está, ¿vale? Depende de los requisitos de la aplicación. Vale, entonces, el modificador estático aplicaba tanto a propiedades como a métodos. Por ejemplo, aquí habíamos hecho un método, este de aquí, que lo hicimos, un método para devolver el país en el que estaba la empresa según la ubicación. 00:04:13
Entonces, este método 00:04:41
Para devolver el país al que pertenece la empresa 00:04:44
Según la ubicación 00:04:47
De la 00:04:49
De la empresa 00:04:50
La única propiedad a la que necesita acceder 00:04:52
Es a esta 00:04:55
La única, ¿vale? 00:04:56
Luego este método 00:04:59
No depende para nada del objeto 00:05:01
Que lo llame 00:05:03
Lo puede llamar cualquier objeto 00:05:04
No depende para nada del objeto que lo llame 00:05:06
Lo puede llamar cualquiera 00:05:07
lo puede llamar 00:05:08
de uno punto get país 00:05:10
o lo podría llamar 00:05:12
de dos punto get país 00:05:14
nos da igual el que lo llame 00:05:16
porque el objeto que lo llame va a hacer lo mismo 00:05:17
que es mirar 00:05:20
la variable común estática 00:05:22
y devolver el país 00:05:24
entonces como nos da igual 00:05:25
los métodos estáticos 00:05:26
no se llaman con un objeto 00:05:29
se pueden llamar pero 00:05:32
es mucho más claro para el código 00:05:33
si los llevamos directamente con el nombre de la clase 00:05:36
entonces a los métodos 00:05:38
estáticos se les llama 00:05:40
muchas veces métodos de librería 00:05:43
porque son métodos para hacer utilidades 00:05:44
independientes de cualquier objeto 00:05:46
son utilidades independientes de cualquier 00:05:48
objeto porque son 00:05:50
funciones, métodos 00:05:51
que no trabajan con 00:05:54
propiedades concretas de un objeto 00:05:56
no trabajan con propiedades concretas de un objeto 00:05:58
luego son como métodos para hacer 00:06:00
funciones auxiliares, utilidades 00:06:02
por ejemplo 00:06:04
Por ejemplo, vamos a hacer aquí un proyecto, para no liar tanto, un proyecto pues matemáticas, porque resulta que nos vendría bien, por ejemplo, nosotros hicimos en su momento el código para ver si un número es primo o no es primo, el código para ver si un número es triangular o no es triangular, 00:06:05
para calcular el factorial de un número 00:06:34
hicimos ciertos 00:06:38
algoritmos para calcular 00:06:39
funciones matemáticas 00:06:41
entonces si resulta que nosotros queremos hacer 00:06:43
esas cosas varias veces 00:06:45
pues vamos a meterlos en unos métodos 00:06:47
de estos y los llevamos cada vez que queramos 00:06:49
por ejemplo 00:06:51
vamos a hacernos una clase 00:06:53
utilidades matemáticas 00:06:55
Matemáticas 00:06:57
A ver, no tengo por qué crear el paquete 00:06:58
Pero bueno, voy a crear un paquete, no es obligatorio 00:07:05
Pero bueno 00:07:07
No tiene por qué haber siempre un paquete 00:07:08
Puedes trabajar en 00:07:11
Vale, pues vamos a hacernos un paquete que sea 00:07:12
Utilidades 00:07:15
Y dentro del paquete utilidades 00:07:16
Vamos a hacernos 00:07:20
Una clase 00:07:25
Que sea 00:07:26
Matemáticas, para ser utilidades 00:07:27
matemáticas 00:07:30
vale, venga pues por ejemplo 00:07:31
a mi resulta que me va a 00:07:36
interesar en un montón de sitios 00:07:38
de mi proyecto, de mis aplicaciones 00:07:40
que estoy haciendo por ahí, que estoy haciendo en mis aplicaciones 00:07:42
distintas, me va a interesar muy 00:07:44
a menudo saber si un número es primo o no 00:07:46
porque estoy haciendo aplicaciones de 00:07:48
criptografía, de lo que sea y necesito saber 00:07:50
si un número es primo o no 00:07:52
pues vamos a hacernos una función 00:07:53
un método, ahora ya no uso la palabra 00:07:55
función, un método que 00:07:58
me diga 00:08:00
sí o no en función de si un número 00:08:02
que yo le paso por 00:08:04
teclado es primo o no es primo 00:08:06
vale, esto ya 00:08:08
esta función 00:08:10
este código lo he hecho un montón de veces 00:08:12
entonces bueno 00:08:14
podemos hacerla 00:08:15
hacerla así 00:08:18
rápidamente otra vez 00:08:20
asumo que de partida 00:08:22
es primo, pero si encuentro 00:08:24
un divisor 00:08:26
si encuentro 00:08:27
un divisor 00:08:30
entre 2 y n-1 que lo divida, pues exprimo será falso. 00:08:31
If n dividido entre i es igual a 0, 00:08:50
entonces exprimo igual a falso. 00:08:58
Y ahora, return exprimo. 00:09:04
Vale, pues ahora ya un algoritmo de estos 00:09:09
os tiene que salir de corrido y bien hecho 00:09:11
y prácticamente sin pensarlo, porque esto ya lo hemos 00:09:16
hecho, ya hemos explicado 00:09:17
programación estructurada 00:09:20
hemos explicado 00:09:21
algoritmia relacionada con sumas 00:09:22
con contar, con ver si algo ocurre o no ocurre 00:09:25
todo eso lo tenemos hiper mega explicado, entonces bueno 00:09:27
este código debería salirnos de corrido 00:09:29
y si no, pues tenemos que estudiar 00:09:31
desde el principio y ponernos 00:09:33
ponernos otra vez 00:09:36
las pilas, vale 00:09:37
bueno, pues ya está, hemos hecho una función 00:09:39
un método maravilloso 00:09:41
un método maravilloso al que yo le paso un número 00:09:43
y me devuelve true, si es primo, y false, si no. 00:09:45
¿Vale? 00:09:51
Ahora, yo este método lo quiero usar 00:09:54
desde cualquier sitio del mundo mundial. 00:09:56
Desde cualquier sitio del mundo mundial. 00:10:00
Entonces voy y pienso, anda, 00:10:02
¿qué particularidad tiene este método? 00:10:04
Que no está usando ninguna propiedad de la clase. 00:10:07
De hecho, no podría aunque quisiera, 00:10:11
porque la clase no tiene propiedades. 00:10:12
pero no está usando ninguna propiedad de la clase 00:10:14
ninguna, con lo cual este método no depende para nada 00:10:18
de un objeto matemáticas concreto 00:10:21
no depende para nada 00:10:24
entonces cuando yo me doy cuenta 00:10:25
cuando escribo un método 00:10:28
de que ese método no depende para nada de propiedades de la clase 00:10:32
pues digo, anda, es estático 00:10:36
voy y se lo pongo 00:10:38
es estático 00:10:41
y que he ganado 00:10:42
poniendo static 00:10:45
que ahora ya voy a poder llamar a ese método 00:10:46
tranquilamente con el nombre 00:10:48
de la clase matemáticas.exprimo 00:10:51
como si fuera una función de librería 00:10:53
para hacer lo que yo quiera 00:10:54
¿vale? por ejemplo yo ya tengo aquí 00:10:55
esto, vamos a meter otra función más 00:11:00
para que sea una clase 00:11:02
con métodos de librería 00:11:04
por ejemplo 00:11:06
pues vamos a hacer el factorial de un número 00:11:07
aunque esté en otro proyecto 00:11:10
ahora lo vemos, si está en otro proyecto 00:11:12
también, pero habría que ver 00:11:14
cómo, ahora lo vemos, ¿vale? 00:11:16
y n, venga, vamos a hacernos el 00:11:22
factorial de un numerito n 00:11:24
esto es el factorial de una multiplicación acumulativa 00:11:25
pues si era una 00:11:28
multiplicación acumulativa, pues la multiplicación 00:11:30
acumulativa se inicializa en 1 00:11:32
y ahora ya, pues podemos 00:11:33
hacer, while n 00:11:36
sea mayor o igual que 1 00:11:38
pues hacemos 00:11:40
mul por igual 00:11:42
n y a n lo dejamos decrementado 00:11:44
y ahora ya devolvemos 00:11:47
como no está pedro, no voy a poner 00:11:50
ni una sola llave si es que no hace falta 00:11:52
devolvemos mult 00:11:53
vale 00:11:56
algoritmo parece el factorial 00:11:58
multiplicamos 00:11:59
el número primero 00:12:01
por n 00:12:04
luego por n-1, por n-2, por n-3 00:12:05
así mientras n sea mayor o igual que 1 00:12:08
si me dan el 0 00:12:10
pues me va a devolver 00:12:16
uno, que es el factorial de cero. Estupendo. 00:12:18
Claro. O sea, ese caso 00:12:20
peculiar 00:12:22
tenemos la suerte de que lo satisfacemos. 00:12:23
El factorial de cero es uno. 00:12:25
Vale. Pues... 00:12:31
Pues ya está. Ahora estas dos funciones 00:12:33
es primo y es factorial. 00:12:40
Punto importantísimo. Nos hemos dado cuenta 00:12:42
de que no dependen de ninguna propiedad 00:12:44
de la clase. Luego son independientes 00:12:46
de que exista 00:12:49
un objeto matemática. Son independientes. 00:12:50
no dependen de ninguna propiedad, porque repito 00:12:52
la clase no tiene ni propiedades, ¿cómo puede depender? 00:12:54
te aburro mucho, ¿verdad? 00:12:56
me lo dicen mucho 00:12:58
entonces, como me he dado cuenta de eso 00:12:59
pongo el static delante 00:13:02
¿vale? 00:13:04
y ahora ya, poniendo el static 00:13:06
delante, ¿qué puedo hacer? 00:13:08
pues ahora yo estoy haciendo mis clases matemáticas 00:13:09
por ahora aquí dentro 00:13:12
yo tengo aquí ahora ya un programita que hace cosas 00:13:13
¿dime? 00:13:16
¿hará falta el public? 00:13:19
cuando lo use fuera de la clase, ahora mismo 00:13:20
Yo me voy a hacer mi main aquí mismo 00:13:22
En utilidades, ¿vale? 00:13:24
Entonces, primer paso 00:13:26
Venga, pues me voy a hacer aquí una clase main 00:13:28
Que haga cosas con matemáticas 00:13:30
Por ejemplo 00:13:32
Pues yo ahora le digo a este 00:13:35
Pues nada, bueno, para que quede un programa 00:13:37
Con un poco de sentido 00:13:52
Pues le podemos decir 00:13:54
¿Qué quieres hacer? 00:13:55
Y le digo, oye, dime 00:14:07
Uno si quieres hacerlo de número primo 00:14:09
Y dos 00:14:12
Si quieres hacerlo del factorial 00:14:16
Por ejemplo 00:14:17
Venga que quieres hacer 00:14:18
Primo o factorial 00:14:21
Elige 00:14:22
Pues entonces ahora ya leo la opción 00:14:24
Eee 00:14:27
El scan punto 00:14:31
Next line 00:14:34
Punto char 00:14:39
Cero 00:14:43
Y ahora ya, pues ahora ya en función de lo que me haya dicho 00:14:44
Pues ya está 00:14:47
Dime 00:14:48
A ver, porque me estoy quedando 00:14:56
Él se supone que le ha metido uno o dos 00:14:59
Pues yo me quedo con el primer carácter 00:15:02
De lo que ha metido 00:15:03
Ah, vale, vale, sí, bueno 00:15:04
Podría luego comparar con el número entero 00:15:07
Que codifica el uno y el dos 00:15:09
Pero tendría que mirar la tabla ASCII 00:15:11
Entonces, vale, bien apuntado 00:15:12
Más cómodo si lo pongo en charas y comparo 00:15:14
Bueno, aunque ponga linda igual 00:15:16
Podría comparar con la cadena 00:15:19
Yo se lo pongo un int y pido que sea un int 00:15:20
Bueno, da igual 00:15:23
Vamos, pero 00:15:25
Y luego lo arreglo 00:15:25
Pues con un int 00:15:28
Sí, cada uno, pues como se apañe mejor 00:15:29
Bueno 00:15:32
En el caso de que me hayan dicho uno 00:15:33
Pues ahora le diré 00:15:37
Oye, dame el número 00:15:38
Dame el número 00:15:42
Y ahora leemos el número 00:15:47
Leemos el número 00:15:49
Y ahora es cuando con este número 00:15:58
tenemos que decir si es primo 00:15:59
o no es primo 00:16:02
¿qué ocurre? que tenemos aquí en la clase 00:16:02
matemáticas 00:16:06
un método 00:16:07
al que si yo le paso un número entero 00:16:09
me devuelve true o false el número es primo 00:16:12
¿no? que es justo lo que quiero 00:16:14
y además como ese método es static 00:16:15
lo puedo llamar con el nombre de la clase 00:16:17
pues perfecto 00:16:20
ala, me hago esto 00:16:22
matemáticas 00:16:24
punto 00:16:26
es primo, y le paso el numerito 00:16:29
esto me devolverá true o false 00:16:32
bueno, pues ya está, lo meto en un if 00:16:35
ala, pues ya está 00:16:37
he llamado 00:17:05
de la manera estática 00:17:07
que es la que le tengo que llamar 00:17:09
al método es primo 00:17:10
y no me he tenido que crear ningún objeto matemáticas 00:17:13
en ningún momento, no ha hecho falta 00:17:15
no me lo he tenido que crear 00:17:16
porque este método es estático, no necesita 00:17:17
que exista un objeto para ser llamado 00:17:21
no lo necesita, entonces yo puedo 00:17:22
llamar a exprimo con el nombre de la clase 00:17:25
y magnífico 00:17:26
le paso el numerito y sé que me va a 00:17:29
devolver un true o un false en lugar 00:17:31
de ese exprimo, no exprimo 00:17:32
luego de alguna manera lo que hacemos con 00:17:34
métodos estáticos es que tenemos la 00:17:36
opción de hacer como métodos 00:17:39
que hacen utilidades 00:17:41
métodos tipo librería que no 00:17:42
hacen cosas con un objeto en concreto 00:17:44
sino como utilidades genéricas 00:17:46
es una de sus utilidades, claro 00:17:48
vale porque 00:17:50
Os veo copiar ahí muy copistas, pero no sé si lo estáis enterando. 00:17:54
Vale. 00:18:03
Entonces, bueno, pues el caso 2 sería lo mismo. 00:18:04
En el caso 2, en este caso, dame el número. 00:18:17
Ya tengo declarada la variable y ahora 00:18:20
ya vamos a mostrar el factorial directamente. 00:18:21
Gracias a que tenemos un método estático en la clase matemáticas 00:18:26
que me calcula el factorial de un número 00:18:30
pues yo lo llamo 00:18:33
tranquilamente 00:18:34
una duda, aquí en el caso de switch case 00:18:36
que tú tienes inicializado la variable num 00:18:38
en el caso 1 00:18:40
si nunca se ejecuta el caso 1 00:18:41
sigue inicializado, ¿vale? igualmente 00:18:44
sí, porque 00:18:45
a ver, porque 00:18:46
hay un único bloque 00:18:51
el switch se abre aquí en un único bloque 00:18:52
otra cosa es que tú abrías otro dentro 00:18:55
pero si no abres ninguno dentro 00:18:56
dentro del case no hay un bloque 00:18:58
que hay un único bloque. 00:19:00
Entonces, el compilador, o sea, cuando genera el .class, 00:19:01
efectivamente, ya genera espacio 00:19:06
para todas las que estén declaradas en ese bloque. 00:19:08
Claro, en cuanto la máquina virtual 00:19:19
tiene que ejecutar una sentencia que está en un bloque, 00:19:21
todas las variables declaradas en ese bloque 00:19:25
habrá creado espacio para ellas, 00:19:27
aunque no haya pasado por su ejecución. 00:19:29
Aunque no haya pasado por su ejecución. 00:19:31
Entonces, vale. 00:19:34
Y aquí después de los next in 00:19:40
Como luego hay un 00:19:43
Ah no, porque no hay bucle, da igual 00:19:43
Solo lo deja hacer una vez 00:19:45
Pues ya está, entonces nosotros aquí tan apañados 00:19:46
Venga, dame el número 00:19:52
Este es primo 00:20:00
Pues sí, es primo 00:20:01
Vamos a 00:20:03
Venga, dame el factorial de 54 00:20:08
Buf, me he pasado, me he pasado 00:20:11
No va a tener 00:20:13
Ah, es que no lo he puesto en un siso 00:20:14
Pero ha terminado 00:20:17
Ah no, es que le he dado 54 00:20:18
Estoy gilipichis 00:20:20
A ver, 2 00:20:21
Dame el número 00:20:23
Sí que he hecho bien la función 00:20:25
El factorial de 65 00:20:29
Es 0 00:20:31
Vamos a ver 00:20:32
Función factorial 00:20:35
Vale, multiplicando 00:20:39
Lo va multiplicando por n 00:20:50
y luego lo deja decrementado para la siguiente 00:20:51
entonces multiplica 00:20:53
está bien, ¿no? 00:20:54
factorial de num 00:21:17
dame el número 00:21:18
2, dame el número 4 00:21:19
pues será que es muy alto 00:21:25
pero no, es mucha casualidad 00:21:27
ya, pero entonces lo que debería 00:21:29
es desbordar y no dar 00:21:34
un cero, sin más 00:21:36
debería desbordar el int y ya está 00:21:37
es que ha sido mucha casualidad atinar con el que desborde 00:21:39
y se queda en cero 00:21:46
por ejemplo, había puesto 64 antes 00:21:46
voy a poner 64 00:21:50
a partir de cierto ya da cero siempre 00:21:52
No, porque me da mucha manía 00:21:55
Lo de buggeáis vosotros 00:22:07
Odio el de buggear, ¿eh? 00:22:08
Que no, que no, que sé ejecutar en modo de bug 00:22:10
Y sé ver las variables 00:22:13
Sé poner puntos de ruptura, todo eso lo sé hacer 00:22:14
Pero me da una pereza 00:22:16
¿Qué paso? 00:22:18
Con 50 sigue siendo 0 00:22:22
A ver, 2 00:22:24
vale, aquí ya ha desbordado 00:22:26
entonces, a partir de cierto 00:22:29
número 00:22:31
vale, es que el desbordamiento a partir de cierto número 00:22:32
como se queda con la parte menos significativa 00:22:37
el resto no son ceros, pero esa parte 00:22:39
sí, entonces empieza 00:22:41
a dar, pero llegará un momento, si no lo pone uno 00:22:43
muy grandote, que vuelva a dejar 00:22:45
de ser cero 00:22:47
ah, pues sí, porque ha 00:22:48
desbordado el int 00:22:51
o sea, las multiplicaciones, y se ha salido de los 00:22:53
32, entonces 00:22:55
el significado que te muestra ya ha perdido su sentido 00:22:57
necesitaríamos 64 bits 00:22:59
para mostrarlo 00:23:01
entonces a partir de cierto desbordamiento 00:23:02
uy no, no, no 00:23:06
dame el número, ah no, es que me he pasado de largo 00:23:10
es que no cabe en un entero, claro 00:23:18
bueno, se podría 00:23:20
pero bueno, a ver, no es lo que nos interesa ahora 00:23:25
si queréis jugar con esto, jugáis vosotros 00:23:28
¿vale? pero vamos 00:23:30
lo que está claro es que el único problema 00:23:32
es que si el factorial es mayor de lo que 00:23:34
cabe en 32, el resultado no es válido, ya está 00:23:36
desbordado y no es válido 00:23:38
entonces 00:23:40
si el factorial es mayor que el int 00:23:40
más value, pues 00:23:44
no va a dar un valor 00:23:45
un valor consentido, claro 00:23:48
no, no, no, no, porque 00:23:53
no, a ver 00:24:00
es que tendrías tú que hacer tú tus cuentas 00:24:03
para saber cuál es el número 00:24:05
que te llega al 00:24:07
integer max value 00:24:09
y cuando lo supieras 00:24:11
decirle si el número es mayor 00:24:13
igual que este, pues no hagas el factorial 00:24:15
porque te has pasado, que podríamos 00:24:17
llegar a encontrar cuál es ese número 00:24:19
haciendo pruebas viendo cuando empieza 00:24:20
a ser negativo, claro 00:24:23
o se hace un for 00:24:25
y la primera vez que le sale negativo 00:24:27
o más que 00:24:29
negativo, que le sale menor que el anterior 00:24:31
pues ahí es donde ha desbordado 00:24:33
vale, bueno, pues entonces 00:24:34
lo que nos interesa a nosotros 00:24:37
vale, pues ya está 00:24:40
nos hemos hecho aquí unas funciones de librería 00:24:41
ahora, nosotros las hemos 00:24:43
usado desde un main 00:24:45
que está en el mismo paquete 00:24:47
por eso, no me he 00:24:49
preocupado yo por el public 00:24:51
pero claro, si nosotros queremos 00:24:53
usar estos métodos 00:24:55
desde clases que están fuera del paquete 00:24:57
pues ya sabemos que entonces tendríamos que añadir 00:24:59
el public, ¿verdad? 00:25:01
Es decir, ahora ya como he añadido el public, si yo quiero usar estas utilidades desde otro paquete, por ejemplo, voy a hacerme otro paquete distinto, pues app mates, yo que sé, otro paquete distinto y aquí ya voy a hacer el main. 00:25:03
copio este main 00:25:26
y lo pego aquí 00:25:31
vale 00:25:35
vale, entonces ahora ya estoy 00:25:36
en otro paquete, vale 00:25:45
estoy en otro 00:25:46
en el paquete main que está en este otro de aquí 00:25:48
vale, aquí 00:25:51
entonces si yo 00:25:52
desde este main que está en otro paquete 00:25:55
diferente al que está mi clase de matemáticas 00:25:56
quiero usarlo 00:25:59
pues efectivamente 00:26:00
matemáticas así a palo seco no me dice 00:26:02
nada. ¿Qué tendría que poner ahí? 00:26:05
Para que se me quitara esa línea roja, 00:26:09
¿qué tengo que poner en esa línea? 00:26:11
Estoy en un main 00:26:14
que está fuera del paquete donde 00:26:15
está la clase de matemáticas. 00:26:17
Mi pregunta es, 00:26:21
¿qué tecleo hay aquí? 00:26:23
No en otro sitio. Ahí, ¿dónde tengo yo 00:26:25
el cursor para que se me quite la línea roja? 00:26:27
Pregunta de prueba técnica 00:26:28
de Java. 00:26:32
No quiero generalidades. 00:26:34
La pregunta es, 00:26:35
¿Qué tengo que teclear yo aquí, en este punto que tengo al cursor, para que se me quite esa línea roja? 00:26:37
Muy bien, efectivamente. 00:26:47
Tengo que teclear esto. 00:26:51
Y ya se me ha quitado. 00:26:54
¿Por qué? 00:26:55
Porque matemáticas es una clase que está en otro paquete. 00:26:56
Luego, desde otro paquete, o uso su nombre largo, o pongo el import arriba. 00:27:00
Pero como yo os he dicho que tengo que teclear ahí, ahí no puedo poner import, obviamente. 00:27:06
Si no quiero poner utilidades ahí, pues pongo arriba import utilidades.matemáticas 00:27:10
y ahora ya aquí podríamos quitar esto si quisiéramos. 00:27:28
Esto ya también lo hemos visto. 00:27:32
Y claro, todo esto funciona y encaja porque los métodos son públicos, lógicamente. 00:27:39
si yo este public 00:27:45
no lo hubiera puesto, 00:27:47
si yo este public 00:27:48
no lo hubiera puesto, 00:27:51
por mucho import, 00:27:53
mucho nombre largo, 00:27:55
mucho lo que fuera, 00:27:57
me diría, uy, 00:28:00
este método no es visible, 00:28:01
¿verdad? Porque no tiene el public delante. 00:28:03
Me da igual nombre largo 00:28:06
import. Si el método no es public, 00:28:07
aquí me va a decir, lo siento, 00:28:10
no tienes acceso a ese 00:28:11
método de la clase matemáticas, 00:28:13
porque no es public y tú estás fuera del paquete 00:28:15
entonces pues, ah, vale 00:28:17
pues le ponemos public 00:28:21
y listo 00:28:22
que es la idea si yo quiero usar esto desde cualquier lado 00:28:24
vale, siguiente paso 00:28:27
si yo he hecho esta 00:28:30
siguiente paso y paramos unos minutos 00:28:32
si yo he hecho este paso 00:28:34
si yo he hecho esta clase librería con unos 00:28:37
métodos impresionantes 00:28:39
para que use la gente 00:28:41
pues hombre, la gente lo usará 00:28:42
desde sus propios proyectos 00:28:44
¿no? 00:28:45
no es mi proyecto, lo usa desde sus propios proyectos 00:28:47
entonces 00:28:50
¿cómo hago yo? ¿cómo distribuyo yo esto? 00:28:51
¿qué hago yo con esta clase? 00:28:55
para que los demás la puedan usar 00:28:56
la meto en un jar 00:28:57
con lo cual la gente de sus proyectos 00:28:59
la tendrá que importar 00:29:02
ahora veremos cómo, ¿vale? vamos a parar un ratinino 00:29:03
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:
8
Fecha:
10 de enero de 2025 - 17:43
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
29′ 07″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
123.43 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid