Saltar navegación

Objetos y 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 17 de diciembre de 2025 por Stefano C.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

¿Qué relación? Vale, voy a grabar esta clase, por lo tanto, si habláis, me autorizáis a grabar vuestra voz, ¿vale? 00:00:00
Entonces, vamos a ver un poquito, unos cuantos temas, algunos no lo hemos visto antes, algunos sí, ¿vale? 00:00:08
Siempre sobre el concepto de programación orientada a objetos, desarrollo de clases, objetos y clases, estática y no estática y cosas por eso. 00:00:16
¿Vale? Entonces, primer tema que vamos a ver es el método main. 00:00:24
Nosotros estamos utilizando el método main desde el principio, 00:00:35
desde el primer día, digamos, que hemos tocado programación. 00:00:40
Pero hemos ido diciendo, ah, si escriben así, esto es así, 00:00:44
que son estas cosas, no lo sé, lo vamos entendiendo con el tiempo. 00:00:49
Ahora estamos a un nivel en el que más o menos podemos descifrar todo del método main, ¿vale? 00:00:53
El domain es público, es decir, que se puede acceder desde fuera de esta clase. 00:01:03
Alguien accederá a este método para empezar mi programa, ¿vale? 00:01:07
La virtual machine se arrancará, empezará haciendo sus cosas y cuando ya está lista, 00:01:12
ha creado el entorno para funcionar, llamará desde no sé dónde este método. 00:01:18
para que desde aquí empiece mi programa. 00:01:23
Estático. 00:01:29
Eso quiere decir que no depende de un objeto. 00:01:30
No tengo que crear un objeto 00:01:32
y luego llamar el método main sobre este objeto. 00:01:33
Es la clase que tiene el método main. 00:01:36
El punto de acceso no necesita la creación 00:01:38
de una instancia de esa clase 00:01:40
para poder ser ejecutado. 00:01:41
Eso porque cuando empiezo el programa 00:01:44
todavía no tengo objetos. 00:01:46
Si no, la Java Vector Machine 00:01:48
debería haber creado un objeto anterior 00:01:49
para poder luego llamar mi main 00:01:52
sobre ese objeto. Pero, ¿qué objeto es? 00:01:54
Pues no lo sé. 00:01:56
Entonces lo pones estático y ya 00:01:57
no dependes de objetos. 00:02:00
Void. El método main no devuelve nada. 00:02:02
No me espero que el método main 00:02:04
devuelva un entero, un objeto, 00:02:06
un string o lo que sea. 00:02:08
Se llama main 00:02:11
y pilla como parámetro 00:02:12
un array de string 00:02:14
llamado args. 00:02:16
args está por 00:02:18
argumentos. 00:02:20
¿Vale? 00:02:23
Estos son unos parámetros 00:02:24
que yo puedo pasar a mi programa 00:02:26
antes de ejecutar 00:02:28
el programa. Nosotros estamos acostumbrados 00:02:31
a que yo lanzo el programa y me aparece 00:02:32
un... ¿Enserta el número? 00:02:34
Pues sí, inserto el número. ¿Vale? 00:02:36
Pero si habéis usado alguna vez 00:02:38
algún programa de informática, 00:02:39
muchas veces los programas o los comandos 00:02:42
que lanzáis, en el momento en que lanzáis 00:02:44
el mismo comando, le pasáis 00:02:47
unos parámetros, unos argumentos. 00:02:48
Habéis hecho un ping en vuestra vida. 00:02:51
Cuando vosotros hacéis ping, 00:02:55
el comando es ping. 00:02:56
Pero ahora le pasáis un parámetro. 00:02:58
Le pasáis a quién hacéis el ping. 00:02:59
¿Sí? Y así con muchas 00:03:02
otras cosas. Habéis copiado un archivo 00:03:04
desde el Necesto, no sé qué. 00:03:06
Habéis hecho algo en Linux o 00:03:07
en... 00:03:09
en sistemas. 00:03:11
¿Habéis visto algo? Muchos comandos 00:03:14
son el comando y luego tiene una 00:03:16
serie de parámetros que le hacen funcionar 00:03:17
el comando. Pues esos parámetros serían 00:03:19
argumentos. Y lo puedo utilizar 00:03:21
en Java. 00:03:23
Vamos a ver 00:03:26
si lo podemos usar. 00:03:27
Entonces, si aquí me he creado una clase 00:03:31
ejemplo. Hago un main 00:03:33
y esta cosa de aquí, 00:03:34
sustancialmente, puedo pasar una 00:03:40
serie de argumentos. 00:03:42
Ángel, 00:03:44
aquí. 00:03:45
Entonces, 00:03:48
yo puedo 00:03:49
decir, por ejemplo, si eso 00:03:51
args.length 00:03:52
¿Vale? Y podría decir 00:03:55
for 00:03:59
string s 00:04:00
dos puntos args 00:04:03
x o s 00:04:07
Esto 00:04:10
sustancialmente me va a mirar 00:04:12
cuántos argumentos tengo 00:04:14
y me va a mirar cuáles son los argumentos. 00:04:16
¿Sí? Está claro 00:04:20
que normalmente esto me dirá 00:04:21
no hay argumento. 00:04:23
Y por lo tanto no me escribe nada. 00:04:24
¿Sí? 00:04:28
Ahora, si yo me voy, lo hacemos de dos formas. Si yo me voy aquí en el workspace, me voy a, 00:04:28
esto estaba en, estaba en ejemplos, ah, objetos, aquí. En bin y en ejemplos. Y aquí es ejemplo.class, 00:04:36
es la mía. He ido en bin en el otro porque lo quiero ejecutar, ¿vale? Y aquí le doy botón 00:04:51
derecho y abrido en terminal, así estoy aquí. ¿Os acordáis si yo tengo el .class como se ejecuta 00:04:56
un programa? ¿Os acordáis si tenía el java como tenía el .class? Si sois informáticos, 00:05:05
sois programadores, no me podéis obviar estas cosas. Si tengo el .java con javac, javacompiler, 00:05:12
desde allí me crea el .class. Y una vez que tengo el .class hago java y el nombre de la clase, 00:05:20
y me lo ejecuto. 00:05:28
Me lo ejecuto. 00:05:30
Esto es. 00:05:32
A ver. 00:05:34
Ejemplo. Me voy a dar 00:05:36
ejemplos.ejemplo. 00:05:37
Aquí. 00:05:49
¿Vale? 00:05:51
Como este es un package, en vez 00:05:51
de ejecutarlo desde dentro del package, 00:05:54
yo lo estoy ejecutando desde fuera, dándole 00:05:56
que es del package 00:05:58
ejemplo y la clase ejemplo. 00:06:00
¿Vale? Entonces veis que 00:06:02
el comando es java 00:06:04
ejemplos punto ejemplo y me devuelve lo mismo de antes ahora si yo lanzo este programa 00:06:05
y le pasó unos parámetros gato cocodrilo veis que ahora tengo dos parámetros en alex el primer 00:06:22
parámetro es gato, el segundo parámetro es cocodrilo. O sea, lo que escribo a continuación 00:06:34
del comando para ejecutar, se pondrá como string uno en cada casilla del array args. 00:06:40
Y estas cosas de aquí, yo las puedo utilizar dentro del programa para que mi programa haga algo. 00:06:51
Por ejemplo, si este programa leyera en un fichero, yo podría pasarle aquí el fichero que tiene que leer. 00:06:59
Si yo, este programa tiene que crear un cierto número de objetos antes de empezar, 00:07:09
y que pueden ser cinco, pueden ser siete, yo le podría pasar aquí un siete, 00:07:19
pasar este string a entero y decir, si es siete, me crea siete objetos. 00:07:23
vamos que sea un programa que dice aquí recibir argumentos que vienen desde fuera vale sin 00:07:28
necesidad de que separe el programa y que requiera si este programa copiará un fichero yo podría 00:07:36
decirle que fichero quiero copiar y donde quiero copiarlo por ejemplo entiende ahora desde línea 00:07:44
comando esto se escribiría aquí. Si yo pongo claramente 3 separado por espacios pues tengo 00:07:54
tres argumentos gato, cocodrilo, etc. Ahora esto sin tener que salir del eclipse lo puedo hacer 00:08:03
también aquí. Cuando ejecuto, ¿vale? Esto se ejecuta con cero. Puedo hacer run configurations, ¿vale? Si me voy a run 00:08:15
configuration, esta es la clase ejemplo, ¿vale? Aquí tengo arguments. Lo que escribo aquí es como si lo 00:08:26
escribiendo después del java ejemplo. Entonces si escribo gato, cocodrilo, pues y lo aplico, 00:08:33
cuando lo ejecuto, veis que ahora son tres y me han leído estas cosas. ¿Sí? ¿Dudas? 00:08:45
Ahora ya sabéis qué es el método main y qué es esta cosa aquí. ¿Sí? Aquí lo dice, vale, 00:08:56
bla bla bla, representa el array de parámetros, los argumentos, javami-clase, si escribo 00:09:06
javami-clase con algo, tres, otra cosa, tendré algo, tres y otra cosa, teniendo en cuenta 00:09:15
que este es un array de strings, vale, por lo tanto, si tengo que transformar estos tres 00:09:19
en un número, tendré que hacer algo como integer punto parche int de este string. 00:09:27
¿Dudas? Vale, clase main, ¿vale? No método main, pues ya lo hemos hecho mil veces, ¿vale? 00:09:33
Normalmente en un sistema, antes nosotros hacíamos ejercicios que eran, este ejercicio hace algo, crea una clase y hace esa cosa, punto. 00:09:44
Ahora no es así. Ahora cuando nosotros hemos introducido los objetos, hay clases que tienen main y clases que no tienen main. 00:09:52
Una persona no tiene main. Una persona representa a una persona, el alumno representa a un alumno, la escuela representa a la escuela, 00:10:00
estos no tienen un main. Tendrán por otro lado una clase main que lo que hace es usar estos. 00:10:06
Ayer hemos hecho el ejemplo de la libreta y de las personas con las direcciones. Las personas 00:10:13
con las direcciones son modelos que representan los objetos que voy a manejar, que voy a manipular, 00:10:21
pero no tienen un main por sí mismo. Lo que tiene el main es la libreta y podría hasta no tenerlo. 00:10:30
La libreta podría ser una libreta y que luego tú tengas otra clase main que lo que hace es crear 00:10:38
varias libretas y añadir personas a las varias libretas, quitarlas, buscar información o cosas 00:10:44
por el estilo. Pero en un proyecto siempre antes o después tendrá que haber mi punto de acceso real, 00:10:50
que es el punto de acción, aquí es donde empieza mi proyecto. Entonces yo puedo tener 5, 6, 8 clases y 00:10:58
tener una clase que será la que se ejecuta. Cuidado, yo podría tener en cada clase, en persona, en objeto, 00:11:05
en coche y en el main, un main, un método main. Pero normalmente los main de los objetos, digamos que 00:11:12
se usan, pues sirven para probar esa clase y que cuando luego ya se ha acabado, pues 00:11:20
probablemente se me o lo comentó lo quito 00:11:27
yo tengo una clase un sistema como hemos hecho directa 00:11:32
libreta yo tenía tres clases vale gestionar rey no tiene un mail es una 00:11:38
clase estática con métodos estáticos para que yo pueda sustancialmente hacer 00:11:45
más fácil determinadas acciones como añadir o quitar algo de una de una red 00:11:50
Luego tengo libreta de direcciones, que en mi caso esta sería la clase main, la clase principal, porque es la que tiene dentro el main que me permite hacer algo. 00:11:55
Pero si lo miráis, la libreta hace cosas como contar las personas que hay, añadir una persona, obtener la información. 00:12:05
O sea que este main yo lo estoy usando para probar la libreta, pero no es el main. 00:12:16
el main real sería otra clase 00:12:20
donde hay un interfaz de usuario 00:12:23
que me dice, mira, ¿qué quieres hacer? 00:12:25
crear una nueva libreta 00:12:27
abrir una libreta existente 00:12:28
tú abres la libreta existente 00:12:30
ahora te dice, vale, estás en la libreta 3 00:12:32
¿qué quieres hacer? añadir una persona 00:12:34
me explicó 00:12:35
eso sería el main 00:12:37
en el caso de 00:12:38
música 00:12:45
aquí yo tenía mi clase main 00:12:46
que era la que permitía 00:12:49
trabajar con mi clase 00:12:51
partitura que era la que 00:12:53
de verdad representaba el ejercicio 00:12:55
el ejercicio son 00:12:57
trabajar sobre partituras, estoy modelizando una partitura 00:12:58
vale, una vez que he modelizado la partitura 00:13:01
no sé si funciona o no, tendré que crear 00:13:03
algo para ver si funciona, vale 00:13:05
me he creado esta clase main para hacer funcionar 00:13:07
esto es un main falso 00:13:09
no lo usaría nadie, porque 00:13:10
para poder utilizar la partitura tengo que saber 00:13:13
escribir código, y la gente 00:13:15
que usa programas no sabe escribir código 00:13:17
no quiere saber escribir código 00:13:19
cuando vosotros usáis el Word, no estáis 00:13:20
cambiando las funcionalidades de Word aplicando código. 00:13:23
Estáis usando esa aplicación, ¿se entiende? 00:13:26
Hay una interfaz gráfica de Word que os permite escribir vuestro texto sin tener que saber nada de código. 00:13:30
Por debajo el Word tendrá un montón de objetos, un montón de cosas que gestionarán el texto que estáis escribiendo, el 00:13:38
formato, la gramática para que os subraye lo que estáis 00:13:47
escribiendo mal, etcétera, etcétera, etcétera. 00:13:52
Muy bien, entonces sabemos el método main y sabemos la clase 00:14:01
main, que es donde estará el método main principal, el que 00:14:05
empieza, digamos, por ahí. 00:14:09
Entonces hablamos ahora de otro concepto que es estático y no 00:14:13
estático. No sé cómo la palabra para indicar que no es 00:14:17
static, pues no sé si es dinámico, pero lo debería buscar. En Java, cuando no utilizo la palabra 00:14:21
reservada static, me estoy refiriendo a algo que depende de un objeto concreto. O sea, que si un 00:14:32
método o una variable pertenecen a un objeto concreto, a una instancia, entonces ese variable 00:14:37
o ese método, no tendrán la palabra static. Esto quiere decir que dentro, en algún lado de este 00:14:47
método o esta variable, es distinto si lo llamo sobre, si lo uso sobre un objeto o lo uso sobre 00:14:54
un objeto distinto. Si yo hago la clase triángulos equiláteros, que sólo simula y modeliza triángulos 00:15:02
equiláteros, el concepto de lado depende de la instancia del triángulo. No todos los triángulos 00:15:13
tienen el mismo lado. Habrá un triángulo, todos son equiláteros, o sea que los tres lados son 00:15:21
iguales. Pero habrá el triángulo equilátero del lado 3, habrá el triángulo equilátero del lado 5. 00:15:28
¿Vale? Entonces, cada instancia, cada copia de este objeto que yo creo, tendrá dentro una copia de esta variable lado que será instanciada con un valor distinto. 00:15:34
Entonces, yo tengo por un lado algo que me define todos los triángulos equiláteros. 00:15:49
A partir de esto, yo puedo crear triángulos equiláteros, por ejemplo, del lado 3, o triángulos equiláteros del lado 5. 00:15:58
Es más, yo puedo crear un triángulo equilátero del lado 3 que sea distinto de este otro. 00:16:09
Son dos triángulos equiláteros distintos. 00:16:18
¿Entiendes? 00:16:22
Son dos objetos, son dos distancias. 00:16:23
Esta cosa de aquí es un molde genérico que sostancialmente me define qué características tiene y qué puede hacer un triángulo equilátero. 00:16:24
Por ejemplo, tiene que tener un lado y tiene la posibilidad de calcular el perímetro. 00:16:40
Esta es una característica 00:16:47
De los triángulos equiláteros 00:16:53
Este de aquí es un 00:16:55
Un comportamiento 00:16:57
Una funcionalidad 00:16:59
Que pueden tener los triángulos equiláteros 00:17:00
Ahora, todos estos triángulos equiláteros 00:17:02
Tendrán una copia de lado 00:17:05
Setada 00:17:08
O configurada 00:17:09
A su valor concreto 00:17:11
¿Se entiende? 00:17:13
Y si yo llamo esta funcionalidad sobre este triángulo, tendré un resultado distinto con respecto a si lo llamo sobre este triángulo. 00:17:14
Porque el calcular perímetro dependerá de una característica propia de la instancia del objeto en el que estoy trabajando. 00:17:25
¿Están de acuerdo? 00:17:36
¿Dudas hasta aquí? 00:17:37
Entonces, si yo quisiera poner el método cálculo-área, ¿sería estático o no? No estático, ¿vale? 00:17:39
Porque dependerá de este valor de aquí. Ahora, si yo quisiera ponerlo, escribo así, porque así se ve mejor, 00:17:56
el método cálcula, método cálcula, área, cálcula área, triángulo equilátero, lado L. Este señor, 00:18:04
que me calcula el área del triángulo del lado L que le paso por aquí, ¿es estático o no? Sí, 00:18:36
porque que lo llame sobre un triángulo de lado 3 o sobre un triángulo de lado 5, 00:18:48
quien cuenta, quien me calcula el área es esta variable de aquí. Entonces, 00:18:55
si yo llamo sobre este triángulo, calcular el triángulo equilátero 7, y lo llamo aquí, 00:19:01
calcular el triángulo equilátero 7, no depende de nada propio de este objeto, 00:19:08
que el triángulo 00:19:14
del lado 7 00:19:16
es, no lo sé. 00:19:19
Oiga chicos, ¿qué pasa? ¿Estáis hablando mucho? 00:19:22
¿Se entiende? 00:19:28
Entonces, si es 00:19:30
dependiente el método 00:19:31
o la variable 00:19:33
es dependiente del objeto 00:19:36
o sea, instancias distintas 00:19:38
trabajan con 00:19:39
valores y copias y funciones 00:19:41
distintas, pues entonces 00:19:44
eso es no estático. Si en vez 00:19:45
es una función que me vale 00:19:47
para todos los objetos porque hace lo mismo 00:19:50
sea el objeto que sea, por ejemplo 00:19:52
la función random 00:19:53
la función random me da 00:19:54
un valor entre 0 y 9 00:19:57
y 10, o y 1 00:20:00
¿vale? 00:20:02
entonces, ¿tiene sentido 00:20:03
llamarla sobre el triángulo de lado 3 00:20:07
o lado 5? o sea, ¿tiene diferencia? 00:20:09
esto me diría 00:20:12
un número entre 1 y 10, y este me diría 00:20:13
un número entre 1 y 10 00:20:15
ahora, si yo te dijera, no 00:20:16
me da un número aleatorio 00:20:19
entre 0 y el valor 00:20:22
de su lado, entonces ya sería 00:20:24
no estático 00:20:28
porque depende de algo 00:20:29
propio del triángulo 00:20:31
o sea, que esto me dará 00:20:33
un número entre 0 y 3 00:20:35
y esto me dará un número entre 0 y 5 00:20:37
entonces cambia si lo llamo 00:20:39
sobre un triángulo o sobre otro 00:20:41
a ver que se mueve 00:20:43
entonces un atributo de una clase 00:20:51
aparecerá en todas las instancias de esa clase 00:20:54
los objetos. ¿Vale? Pero cada instancia podrá tener 00:20:56
un valor distinto de ese atributo. Todos los 00:21:00
triángulos tienen lado. Yo estoy seguro que un triángulo tendrá lado. ¿Vale? 00:21:04
Pero el valor de lado depende de la instancia. Habrá un lado 5, 00:21:08
un lado 7, un lado 9. ¿Ok? Un método que no es 00:21:12
estático, quiere decir que hay que llamarlo sobre un objeto concreto. 00:21:16
Ah, vale. Un método que no es estático, quiere decir que hay 00:21:20
quise llamarlo sobre un objeto concreto y usará datos de este objeto concreto en su introducción. 00:21:24
Si un método, vosotros escribís un método y allí no se usa nada propio de ese objeto, 00:21:30
ningún atributo del objeto, lo más probable que sea un método estático. 00:21:36
¿Sí? Ejemplo no estático, ¿vale? Tenemos la clase Rectángulo, ¿sí? Que define un 00:21:41
Un rectángulo con su largo y su ancho tiene la posibilidad de aceptar sus datos que le paso a L y B y lo guarda en sus atributos. 00:21:53
Y tiene área que me calcula el área del rectángulo. 00:22:02
Ten en cuenta que tanto aquí como aquí yo estoy utilizando estos valores de aquí. 00:22:05
Por lo tanto, si lo llamo sobre un objeto o lo llamo sobre un objeto distinto, pues lo que pasa es distinto. 00:22:12
Depende del objeto sobre el que lía. 00:22:20
¿Sí o no? 00:22:23
¿Dudas? 00:22:25
Rectangularia, ¿vale? 00:22:29
Que es un main. 00:22:30
Veis que tiene que crear rectángulos 00:22:30
y luego llamar los métodos 00:22:33
sobre los objetos. 00:22:35
Los métodos no estáticos 00:22:38
se tienen que llamar sobre instancias. 00:22:39
¿Cuándo creo instancias con el new? 00:22:41
¿Vale? 00:22:44
La operación new lo que hace es pillarme 00:22:44
las reglas, 00:22:47
la molde, 00:22:48
el molde, la información general de esa clase, 00:22:50
y a partir de eso, a partir de la estructura general de esa clase, 00:22:56
me va a crear un objeto concreto de esa clase, ¿vale? 00:22:59
Rectángulo es una definición de todos los posibles rectángulos. 00:23:03
Si yo os digo, os doy solo este fichero aquí de la izquierda, 00:23:07
y os digo, ¿cuánto vale el rectángulo? 00:23:09
¿Cuánto vale el área? 00:23:13
¿Lo sabéis? 00:23:16
Aquí, si os fijáis, son todas cosas parametrizadas. 00:23:17
Todo depende de largo y ancho 00:23:21
Pero no se ha definido cuánto es largo y ancho 00:23:23
Se definirá 00:23:26
¿Se definirá cuándo? 00:23:28
En el momento en que creo el objeto 00:23:29
Cuando yo he creado 00:23:32
Después de esta línea 00:23:33
Después de la línea 1 00:23:35
¿Cuánto vale recto 1 punto largo? 00:23:36
Pero 00:23:42
No se ha definido ningún constructor 00:23:43
Por lo tanto usará el constructor por defecto 00:23:47
el constructor por defecto pondrá 0 en largo 00:23:49
y 0 en ancho 00:23:51
luego cuando yo lanzo setData 00:23:52
pues sustituiré los valores 00:23:56
a lo que tienen que ser 00:23:58
¿vale? 00:24:00
pero en el momento que yo creo 00:24:01
un rectángulo he creado un objeto 00:24:04
que tiene dentro de sí 00:24:06
un espacio para largo y un espacio para ancho 00:24:07
y que puede hacer estos dos trabajos 00:24:10
puede calcular 00:24:12
puede ser setData o puede calcular su área 00:24:13
¿se entiende? 00:24:16
estático 00:24:22
cuando estamos en un entorno estático 00:24:23
me refiero a algo que no pertenece a un objeto concreto 00:24:25
sino a la clase en general 00:24:28
es algo más genérico 00:24:29
es algo que me sirve para todos los objetos 00:24:31
para todos los objetos de esta clase 00:24:34
o sea, dos opciones 00:24:36
o que todos los objetos de esta clase 00:24:37
harían lo mismo 00:24:40
y por lo tanto este método es independiente 00:24:42
de si lo llamo sobre un objeto o sobre otro 00:24:45
o la segunda opción 00:24:48
es que estoy modelizando una clase 00:24:50
que no tiene instancias. 00:24:52
Que no tiene sentido 00:24:54
crear distancias distintas. 00:24:56
La clase math, que representa 00:24:58
operaciones matemáticas, 00:25:00
tiene sentido crear objetos math. 00:25:02
Tú puedes decir math 00:25:05
math1 es igual a new math 00:25:06
math2 es igual a new math. 00:25:07
¿Qué diferencia hay? 00:25:10
La matemática es diferente si lo usas 00:25:11
un objeto o otro. No, es siempre lo mismo. 00:25:14
La elevación a potencia cambia 00:25:15
si tú pillas un objeto u otro. 00:25:17
Ese peso no se le va a dar a 3 00:25:19
eso no cambia. 00:25:21
De hecho, la clase 00:25:24
math no se instante. Lo puedes hacer así, 00:25:25
pero no me sirve de nada, porque todos sus métodos 00:25:27
son estáticos. 00:25:29
Cuando un método es independiente 00:25:31
de los atributos o la clase 00:25:33
no tiene atributos, pues probablemente 00:25:35
la clase tiene que ser 00:25:38
estática. 00:25:39
¿Sí? 00:25:42
Una clase estática tendrá el mismo 00:25:43
valor para cualquier objeto que la use. 00:25:45
No depende del objeto, 00:25:48
sino de la clase. Cuidado, yo puedo poner parámetros en una clase estática que son 00:25:49
estáticos. Si hago una clase estática y le pongo un valor estático vale para toda la clase. No es 00:25:54
una variable, pero es una constante. Math.py vale 3,14 y es una variable estática, es una constante 00:26:02
estática estática final y entiendo porque no depende y no cambia de si lo 00:26:14
llamamos sobre una matemática sobre otra y es siempre 3,14 00:26:25
sí vale un método estático no se llama sobre 00:26:31
un objeto si no se llama sobre la clase vale no usa los datos de un objeto 00:26:38
concreto para ejecutarse. Puede usar los datos estáticos de esa clase. Cuando vosotros desde un 00:26:42
método estático intentáis acceder a algo que es propio de un objeto, os dará un error diciendo 00:26:49
no puedo desde un entorno, un contexto estático acceder a un contexto no estático. Lo hemos visto 00:26:55
alguna vez. Ejemplo, tenemos una clase estática que me dice staticInt operacionesHechas. Cada vez 00:27:00
que yo hago una operación, pues 00:27:10
esto le sumo uno. ¿Lo veis? 00:27:12
Entonces, en cada 00:27:15
momento yo puedo preguntar a esta clase 00:27:16
estática, ¿cuántas operaciones has hecho? 00:27:18
Independientemente de quién la haya hecho 00:27:21
y cuándo la haya hecho. 00:27:22
Realmente, cada vez que apago 00:27:24
el programa y lo reinicio, pues eso se 00:27:25
reiniciará a cero. Si quisiera 00:27:28
mantener esto, necesitaría 00:27:30
ficheros. Lo vemos más adelante. 00:27:32
Entonces, esto tiene un 00:27:35
calcular a rectángulo. Oye, lo mismo que antes. 00:27:36
Solo que como ahora aquí no hay objetos y no hay los atributos de largo y ancho, me los tienes que pasar por parámetros. 00:27:38
Pero ahora, como me los estás pasando por parámetros y yo aquí dentro uso ellos, pues no hace falta, no dependo de un objeto. 00:27:47
Este método es independiente del objeto. 00:27:56
Si el rectángulo A llama a este método poniendo 3 y 7, no tiene que ver con los datos del mismo rectángulo. 00:27:58
El rectángulo podría ser 3 por 5 y calcular el área de rectángulo de 10 y 20. 00:28:09
Entonces es independiente, no depende del objeto. 00:28:16
Por lo tanto, hablamos sobre la clase. 00:28:19
Y aquí tengo un calculaferímetro que me pilla al lado de ancho y calcula los suyos. 00:28:21
Fijaos que hay un dato estático que sustancialmente se usa desde un contexto estático, entonces se puede usar. 00:28:24
Si yo le quito ese estático y me daría un error, me diría no puedes usar un dato que está duplicado en todas las instancias. 00:28:32
En este caso sería de clase estática, o sea, cuando hago un núcleo de clase estática creo una copia y ahora me dices, súmbala. 00:28:42
¿A qué objeto la tengo que sumar? 00:28:48
si estoy en un contexto estático 00:28:49
no tengo un objeto 00:28:54
aquí dentro, ¿puedo usar this? 00:28:55
no, porque no tengo 00:29:04
un contexto, no tengo 00:29:06
un objeto 00:29:07
estoy estático, no estoy hablando de un objeto 00:29:09
y a este objeto pilla 00:29:12
su valor, no estoy hablando 00:29:13
de objetos, no tengo una instancia 00:29:16
ni siquiera la instancia de este objeto 00:29:17
porque estoy en un contexto estático 00:29:20
¿entienden? 00:29:22
¿cómo se usa? 00:29:24
Por ejemplo, el rectángulo 1 tiene área y clase estática, punto, calcular el rectángulo, 3, 6. 00:29:25
Fijaos que estoy llamando sobre la clase, como hemos hecho con gestión array. 00:29:33
Como habéis hecho con arrays. 00:29:39
Habéis usado arrays.toString. 00:29:42
¿Qué es arrays? 00:29:44
Clase con un método estático toString. 00:29:48
al que le pasas un string 00:29:52
un array 00:29:54
y el método de lo que hace es recorrer 00:29:55
el array en primer lugar 00:29:58
recorrer el array y llamar un 00:30:00
toString por cada elemento 00:30:02
fijaos que al final yo puedo decir 00:30:03
he hecho clase estática punto 00:30:08
operaciones estáticas operaciones 00:30:10
y lo puedo hacer porque estoy en un 00:30:12
contexto estático y estoy llamando 00:30:14
un objeto estático 00:30:16
un atributo estático 00:30:17
una variable estática 00:30:20
que, fijaos, la llamo sobre la clase. 00:30:22
No la llamo sobre un objeto. 00:30:24
¿Dudas? 00:30:28
Bueno. 00:30:31
Estáticos y no estáticos pueden coexistir. 00:30:33
Yo puedo tener una misma clase 00:30:36
que tenga cosas estáticas y cosas no estáticas. 00:30:37
Por ejemplo, yo tengo un rectángulo 00:30:40
que tiene una estática inter, 00:30:43
rectángulos creados, que es igual a cero. 00:30:45
Cada vez que en el constructor 00:30:47
creo un nuevo rectángulo, 00:30:49
le sumo uno a esto. 00:30:52
Entonces, al final, yo puedo preguntar al rectángulo cuántos rectángulos se han creado en general. 00:30:54
Cada rectángulo, si accede a rectángulos creados, tendrá el mismo número. 00:31:00
Si yo creo tres rectángulos, cuando rectángulo 1 accede a rectángulos creados, encontrará tres. 00:31:05
Y el 2, 3, y el 3, 3. 00:31:13
Porque no es una cosa que depende de la estancia, depende de la clase. 00:31:16
entonces cada vez que yo 00:31:19
creo un nuevo rectángulo 00:31:23
o un objeto rectángulo 00:31:24
estoy sumando uno 00:31:26
no a la copia de la variable 00:31:27
de este objeto 00:31:30
más a la clase 00:31:31
entonces todos los que acceden a esa clase 00:31:33
verán esta modificación 00:31:35
es una variable compartida 00:31:37
entre todos los rectángulos 00:31:40
en un cierto sentido 00:31:42
mientras que ancho y largo 00:31:44
cada rectángulo 00:31:47
tiene su copia de ancho y su copia de largo 00:31:48
los rectángulos creados 00:31:51
es una variable que no está dentro del objeto 00:31:54
más está dentro de la clase 00:31:56
y todos cuando acceden es compartir entre ellos 00:31:57
y si uno la modifica 00:32:00
los otros verán la modificación 00:32:01
al crear el nuevo objeto 00:32:03
se modificará 00:32:09
y lo verán también los objetos que habían sido creados antes 00:32:11
public int area 00:32:15
veis que no es estática 00:32:18
y entonces usará 00:32:20
ancho y largo del propio objeto 00:32:22
esto aquí depende del objeto 00:32:24
si lo llevamos sobre un objeto tendremos 00:32:25
un resultado, si lo llevamos sobre otro objeto 00:32:27
tendremos un resultado distinto 00:32:29
y public static int total 00:32:30
rectángulo creados, pues que devuelve 00:32:33
esta variable estática 00:32:36
es estático porque no depende 00:32:37
del objeto, esto lo llamaría 00:32:39
sobre la clase rectángulo 00:32:43
mientras esto de aquí 00:32:45
lo llamaría sobre un objeto 00:32:47
rectángulo, dudas? 00:32:49
Preguntas 00:32:52
¿Lo habéis entendido? 00:32:57
Si lo habéis entendido, ¿por qué luego lo falláis? 00:33:01
Vale 00:33:09
En la segunda hora 00:33:09
Hacemos algún ejemplo de estas cosas 00:33:11
¿Vale? Pero 00:33:14
Acabo con la teoría 00:33:14
Organización del código, esto me interesa relativamente 00:33:16
¿Vale? La idea es que 00:33:19
Los códigos en Java se pueden organizar 00:33:21
En proyectos 00:33:24
Dentro de los proyectos en la parte sur 00:33:24
Se pueden crear paquetes 00:33:27
Y dentro de los paquetes las clases 00:33:28
la idea es que cuando vosotros montáis un programa 00:33:31
un sistema un poquito más complejo 00:33:35
organizéis esta estructura 00:33:37
de una forma coherente a lo que vais a hacer 00:33:41
no me mezcléis todos dentro del mismo package 00:33:43
pero si hay un package que gestiona los alumnos 00:33:46
un package que gestiona la parte financiera de una escuela 00:33:48
un package que gestiona las materias 00:33:52
pues pueden ir en packages distintos 00:33:54
para que luego yo sepa si tengo que tocar algo 00:33:57
en qué package voy a tocar. O si tengo que importar uno de estos packages en un main o 00:34:00
cosa por el estilo porque, por ejemplo, es inútil para los profesores importar el package, para el 00:34:07
gestional de los profesores, el programa que usarán los profesores, importar el package de 00:34:12
la gestión financiera porque los profesores no manejan el dinero. Eso lo usará el aplicativo 00:34:19
que usará la secretaria para poder hacer. Overloading o sobrecarga de un método es cuando 00:34:26
yo tengo un método que se llama igual pero tiene distintos parámetros. El número de parámetros de 00:34:40
entradas distintos, el tipo de algunos de los parámetros son distintos o una combinación de 00:34:53
los dos anteriores. Yo puedo hacer mi método de int y mi método de double. Y el programa, 00:34:57
la llave de Thomasin sabrá si utilizar uno o utilizar el otro en base al parámetro que tú 00:35:04
me pasas. Si tú me pasas mi método de 3, pues lo usaré con int. Si me pasas mi método de 3.0, 00:35:10
3.0 es un double, pues entonces utilizaré la opción con double. Lo que no puede hacer es dos 00:35:19
que tenga la misma firma. La firma es el nombre y la lista de tipos de parámetros. 00:35:26
¿Sí? Tened en cuenta, lo que devuelve un método no entra en la firma. Si yo tengo, por algún lado, 00:35:32
Por ejemplo, si yo tengo por algún lado el método public void mi método de int x que 00:35:47
hace algo, no puedo hacer public void mi método de int x y decir, mira, no, porque es lo mismo, 00:36:06
pues entonces le pongo aquí int. Y esto es algo que devuelve return a 3. O sea, no me lo acepta, 00:36:18
porque la firma de este método es mi método int. Y esto tiene la misma firma, mi método int. Si yo 00:36:27
te paso, si yo llamo en algún lado, no lo sé, sobre un objeto obj punto mi método 3, es 43, 00:36:36
Java no sabe 00:36:46
si tiene que usar esto 00:36:50
o si tiene que usar esto. 00:36:51
No lo puede saber. 00:36:54
Y entonces es ambiguo, entonces se inflaba. 00:36:56
Ahora, si esto 00:36:59
yo le digo, tú eres doble, 00:37:00
pues ahora si yo lo llamo así, 00:37:06
llamará este 00:37:09
método aquí y hará esto. 00:37:10
Si yo lo llamo así, 00:37:12
llamará esto. 00:37:15
¿Entiendes? También 00:37:18
podría hacer un public 00:37:22
voy int, int, pero ponerle otra cosa, boolean. Entonces ahora este método de aquí es, la firma 00:37:25
es mi método de int, esta firma aquí es mi método de int boolean. Entonces este de aquí se llamará, 00:37:39
cuando llamo esto, estoy llamando este método de aquí, cuando llamo esta cosa aquí, estoy llamando 00:37:45
este método. Importante que sea único, que no sea ambiguo qué método voy a llamar. 00:37:52
Ahora, crear un método que se llama igual, pero tiene distintos parámetros, se llama 00:37:59
sobrecargar este método. Overload. ¿Dónde hemos usado nosotros el overload? En print, 00:38:07
por ejemplo. Print es un método que está sobrecargado porque puedo hacer print de un int, 00:38:22
puedo hacer print de un double, puedo hacer un print de un string, puedo hacer un print de un object. 00:38:29
Pero lo hemos usado pero no lo sabíamos y no lo hemos creado nosotros. ¿Dónde nosotros hemos creado 00:38:35
cosas sobrecargadas? En los constructores. Cuando tú haces un constructor que pilla un solo parámetro, 00:38:41
un constructor que pilla tres parámetros, está sobrecargando 00:38:52
el constructor. Acordaos que el constructor 00:38:54
es un método. Un método especial 00:38:56
porque devuelve un 00:38:58
objeto de esta clase, pero 00:39:00
eso es otro método. 00:39:02
¿Dudas? 00:39:04
Si entiendes el concepto de 00:39:06
sobrecargar, vale. 00:39:08
En inglés, overload. 00:39:13
¿Vale? No confundir con 00:39:14
overwrite. 00:39:16
¿Vale? Que lo veremos 00:39:19
sobreescribir. Lo veremos más 00:39:19
adelante. Por ahora lo hemos hecho, cuando hemos hecho el toString, cuando hemos 00:39:22
hecho el equals, hemos hecho la sobrescriptura, pero todavía no lo 00:39:26
entendemos bien, porque todavía no sabemos el concepto de herencia. 00:39:30
Conectación del código otra vez, vale, aquí os dice cómo navegar, qué sé yo, 00:39:34
lo leéis. Encapsulación y visibilidad son las 00:39:43
últimas dos cosas que me quedan, que sustancialmente es cuando creo un método 00:39:48
o cuando creo un atributo, ¿vale? 00:39:52
Le puedo decir dónde se puede ver este atributo, 00:39:55
dónde se puede ver este objeto, ¿vale? 00:39:59
Normalmente nosotros hemos usado public y private, ¿vale? 00:40:02
Public quiere decir que tú puedes acceder allí 00:40:06
desde donde quieras. 00:40:09
Si tú tienes acceso a esta clase, 00:40:11
puedes acceder a ese variable, a ese atributo, ¿vale? 00:40:13
Nosotros lo hemos hecho que desde otra clase accedo allí, 00:40:17
¿vale? Fenomenal. 00:40:20
Pero las dos clases estaban en el mismo package. 00:40:21
Hasta si estuvieras en packages distintos, 00:40:23
pues podrías acceder a esas variables. 00:40:26
En una variable pública, todos pueden acceder. 00:40:28
Private es el opuesto. 00:40:31
Solo se puede acceder a esa variable dentro de esa clase. 00:40:34
Como salgas de esa clase, no es accesible esa variable. 00:40:37
Si quieres que alguien pueda modificarla o leerla, 00:40:41
tendrás que crear métodos públicos, por ejemplo, 00:40:44
que permitan acceder a esa variable. 00:40:47
Y que hagan algún control. 00:40:49
y que me pidan 00:40:51
que verifiquen que yo pueda acceder 00:40:52
o que lo pueda modificar 00:40:55
como es un método 00:40:56
no es necesariamente que te lo devuelvo 00:40:59
directamente, de hecho, un get o un set 00:41:01
un método que te devuelve directamente 00:41:03
y que si tú implementas 00:41:05
tanto leer como escribir 00:41:07
sin hacer nada, pues entonces 00:41:08
podrías dejarlo public, no pasa nada 00:41:10
sin embargo 00:41:13
como hemos hecho alguna vez, si tú haces 00:41:15
un set de edad 00:41:17
pero dices que, oye, mira, yo voy a 00:41:19
aceptar la edad que me pasas tú, siempre 00:41:20
cuando sea positiva 00:41:22
ya estás haciendo una cosa distinta 00:41:24
porque si yo tenía acceso público 00:41:26
a la variable, habría podido ponerle que tu edad 00:41:28
es menos 7, como yo le he quitado 00:41:31
el acceso público a la variable 00:41:33
y ahora le he puesto un método que me 00:41:34
verifica que el número que me estás dando tú 00:41:37
sea positivo, ya estoy haciendo un control 00:41:39
adicional, esta es una cosa 00:41:41
que hemos hecho 00:41:43
¿os dais? 00:41:43
¿sí? 00:41:47
ahora, hay 00:41:49
modificadores entre medias. 00:41:50
¿Vale? Público accede 00:41:53
en todos, privado no accede en nadie. 00:41:54
Fuera de la clase. ¿Vale? 00:41:57
Luego está el package. 00:41:58
A esta variable se puede acceder 00:42:01
solo, o sea, se pueden acceder todas 00:42:02
las clases, o sea, código 00:42:04
de clases que pertenezcan al 00:42:06
mismo package. 00:42:08
Entonces, si yo tengo dos 00:42:12
clases que están 00:42:14
definidas en el mismo package, 00:42:16
por ejemplo, tengo 00:42:18
este main esta partitura si esta partitura en vez de privar os acordáis que desde el main no podía 00:42:19
acceder a autor yo aquí hago part2.autor es igual a algo se enfada ah porque es partitura 00:42:25
se enfada me dice hoy es privado no puedo vale pero esto en el mismo package entonces si yo me 00:42:41
voy aquí a donde está en partitura y le digo oye partitura autor en realidad es 00:42:47
dentro del package 00:42:57
es posible que si lo pongo así sea package ahora en teoría si puedo vale 00:43:06
claro que no le he puesto public le he puesto nada cuando es no es protective 00:43:14
ahora lo miro y luego os lo digo vale entonces tenemos para variables y 00:43:19
métodos estos cuatro niveles vale si no pongo nada es para que vale entonces para que no es 00:43:27
una palabra reservada como tal pero sino que si no pongo nada la visibilidad del del package 00:43:34
private es sólo de la clase public es de donde sea protected es no lo entendemos vale es si la 00:43:41
clase es descendente en términos de herencia de ésta o del mismo país. No lo entendemos porque 00:43:53
todavía no sabemos qué es la herencia. Simplemente esto lo recuperaremos en un futuro. Van en orden, 00:44:01
¿vale? Desde la más pública, la más permisiva, a la más estricta. Ahora, vamos a ver cómo funciona 00:44:08
Hemos visto que si yo pongo este autor, tengo partitura y tengo el main, que están en el mismo package. 00:44:19
Si yo pongo autor como package, pues lo puedo usar tranquilamente desde fuera, desde el mismo package. 00:44:29
Pero si yo me pillo en ejemplos, mi ejemplo, y intento usar aquí una partitura. 00:44:39
partitura p es igual a new a partitura que pillaba que autor la cosa los y el 00:44:46
tiempo no esto no me la ve no me la ve porque está en otro package él busca aquí dentro del 00:45:03
package la partitura y no la encuentra entonces no está la clase partitura vale muy bien la 00:45:10
la importo, esto creo que con música, como la importo, import partitura de música, ahí, 00:45:17
musica.partitura, va, text o musica.asterisco para importar todas las clases que están 00:45:39
dentro de esto, vale, entonces como ahora he importado este package y puedo utilizar 00:45:46
partitura pues perfecto vale pero ahora estoy en packages distintos es decir que si yo aquí 00:45:52
intento acceder en p.autor se enfada porque me dice no mira autor no es visible desde fuera 00:45:58
del package vale porque como yo lo he definido partitura como si nada es package entonces se ve 00:46:12
sólo en las clases que pertenecen a este Package. Si yo estoy aquí y lo pongo como public, 00:46:21
pues entonces también desde ejemplo ahora lo puedo acceder. Desde cualquier clase hasta que 00:46:25
no sea dentro del mismo Package sí puedo acceder. ¿Entiende? Entonces, privada sólo desde dentro de 00:46:36
esta clase. Sin nada, desde esta clase y desde todas las clases de su package puedo manipular 00:46:46
esta cosa directamente. Public, desde cualquier sitio. ¿Dudas? Entonces, ¿cómo podría hacer, 00:46:54
mantener esta privada y hacerla accesible desde ejemplo y desde main? Por ejemplo, 00:47:10
en sola lectura. Me debería crear aquí un método public string getAutor, que lo que hace es 00:47:18
returna autor. Aquí lo puedo usar porque estoy en la misma clase, lo puedo usar en private. Pero 00:47:32
cuando la llamo desde fuera, no estoy accediendo directamente a autor, estoy llamando este método 00:47:41
que es público. Entonces se podrá pillar tanto de aquí, bueno para escribir parte.getAutor, 00:47:48
podrá ceder porque el método es público, y también aquí. Lo mismo que he escrito aquí lo 00:48:00
puedo hacer afuera porque el método es público, lo puedo llamar también aquí. Ahora, si el método 00:48:11
y este autor fuera 00:48:22
sin nada, 00:48:25
desde main 00:48:28
lo puedo llamar, desde aquí no. 00:48:29
Porque sería solo interno 00:48:31
al packet. 00:48:33
¿Entiendes? Y fijaos que 00:48:34
¿qué ha cambiado? Pues ha cambiado 00:48:38
que ahora esta variable aquí 00:48:41
es de sola lectura, fuera 00:48:42
de esta clase. 00:48:44
Pero esta clase no se puede sobreescribir, 00:48:46
no se puede cambiar, pero sí se puede leer. 00:48:48
¿Entiendes? Y ahora 00:48:53
digo no pero quiero que se pueda también escribir entonces pongo void set autor que pilla un autor 00:48:57
y lo que hago es que autor es igual a out esto quiere decir que ahora lo puedo modificar donde 00:49:08
me da la gana lo puedo modificar desde el main que es el mismo package y lo puedo modificar 00:49:19
también desde aquí yo puedo hacer ahora tranquilamente antes de escribir el autor 00:49:24
p.setAutor 00:49:29
de gato. 00:49:32
Y me funciona. 00:49:35
Lo puedo hacer. Ahora, 00:49:36
si yo he hecho en partitura 00:49:37
un getAutor 00:49:40
y un setAutor 00:49:41
públicos 00:49:43
que hacen sólo esto, 00:49:45
es equivalente a no haber hecho nada 00:49:48
y haber dejado esto público. 00:49:49
Porque puedo leerla, puedo escribirla 00:49:53
y no hay ninguna 00:49:56
cosa extra. Entonces, 00:49:57
Entonces, para eso, quito el getter set y lo que hago es accesible directamente públicamente 00:49:59
este autor. 00:50:04
Ahora, si yo te digo, mira, leerla lo puedes leer por todos lados, no me interesa. 00:50:05
Pero cuando la vas a aceptar, yo quiero que out… fijaos, perdón, vuelvo atrás, aquí 00:50:10
nadie me prohibiría de hacer esto, ¿entiendes? 00:50:19
Estoy haciendo una partitura sin autor, con autor null. 00:50:29
Imaginamos que yo digo, no, el autor tiene que existir. 00:50:32
Entonces yo puedo decir, vale, la escritura, no hago que sea, puedes hacer lo que te da la gana. 00:50:41
Más pongo unos controles. 00:50:48
Por ejemplo, tú me has dado un algo, pero yo quiero que si esto es not null, entonces sí cámbienlo. 00:50:49
Si no, no. 00:51:02
Entonces ya aquí es distinto de haber dejado esto como public. 00:51:04
Porque esto como public yo puedo hacer lo que me da la gana con el autor hasta ponerle null. 00:51:07
Aquí yo estoy forzando que cada vez que yo intente cambiar el autor, me comprueba si es nulo o no. 00:51:11
Entonces, nunca será nulo. 00:51:17
¿Me entiendes? 00:51:20
Y yo podría decir también, i, out.length, mayor que 1. 00:51:22
¿Me entiendes? 00:51:30
Te estoy diciendo, oye, si lo que me has dado es nulo, no es nulo, y además tiene una longitud, no es una cadena vacía, 00:51:32
pues entonces sí te lo acepto como autor, si no, no. Entonces quiere decir que ahora yo estoy haciendo 00:51:39
partituras que una vez creadas no se puede modificar su autor como null, no se puede modificar su 00:51:44
autor como cadena vacía. Es distinto con respecto a haberle puesto aquí public. Ya no es la misma cosa. 00:51:50
¿Se entiende? Vale. Y poco más. Esto por ahora public, private o nada, dependiendo 00:51:58
de cómo quieras hacerlo. ¿Para qué sirve esto al fin y al cabo? Porque cuando yo creo 00:52:11
un package, yo creo un package sobre música que gestiona toda la cosa de música, yo creo 00:52:17
un package sobre la libreta y cosas por el estilo. Todas las clases que estoy haciendo 00:52:21
en este package probablemente las creo yo. Entonces dentro de este package yo tengo un 00:52:25
cierto control, que pueda acceder 00:52:30
a variables de otras clases, porque 00:52:32
como las produzco yo, como las estoy 00:52:34
codificando yo, pues son como 00:52:36
del mismo autor 00:52:38
y tú sabes cómo manejarlas bien. 00:52:39
Pero no te fías de cómo la van 00:52:42
a usar personas fuera que 00:52:44
usan tu package, que importan tu package 00:52:46
y lo quieren utilizar, pero 00:52:48
no saben bien los mecanismos internos 00:52:50
y a lo mejor cuando me van a escribir 00:52:52
los instrumentos, 00:52:54
en vez de separarlo por coma, 00:52:57
me lo separa por punto y coma y explota 00:52:58
entonces yo lo que hago es 00:53:00
la pongo privada o la pongo 00:53:02
sin nada 00:53:04
para que la proteja dentro de mi 00:53:06
de mi 00:53:08
package que yo sé usarla 00:53:10
y luego a ti te doy la posibilidad de 00:53:12
oye mira, tú puedes añadir 00:53:14
un instrumento 00:53:16
pero dime que instrumento quieres 00:53:17
añadir y yo te lo añado bien 00:53:20
te lo añado con las reglas 00:53:22
mías, no te permitas de añadir 00:53:24
comas como te da la gana, o punto y coma, o cosa por el estilo, ¿entiendes? Aún así, esto tiene sus 00:53:26
posibilidades de agregarlo, ¿vale? ¿Os acordáis cómo funcionaba? Si aquí yo como instrumento le doy viola, coma, 00:53:35
flauta, pues me estoy añadiendo dos a la vez. Si le doy no sé qué, coma, coma, no sé cuánto, pues estoy 00:53:41
pues estoy añadiendo un instrumento que no existe. 00:53:52
Vale, de la misma forma nosotros public lo hemos utilizado también en otro lado. 00:54:00
O sea que como hay niveles de visibilidad de encapsulación para 00:54:10
métodos y variables, que son estos, existen también métodos de visibilidad, 00:54:19
modificadores de visibilidad para las clases enteras. Hay public, sin nada, protected, 00:54:25
y private. Pero esto afecta la clase, o sea, donde yo puedo hacer new. Si yo tengo una clase privada, 00:54:35
solo puedo hacer new desde dentro de esa clase. Si no, no puedo. Si la tengo package, pues desde 00:54:46
todo el package, si ya tengo public lo puedo hacer donde me dé la gana. Si os acordáis nosotros también 00:54:54
decíamos que en una clase, por ejemplo la clase ejemplo, yo puedo tener una sola clase que se 00:55:00
llama ejemplo dentro del fichero ejemplo, solo una clase pública, pero nadie me prohíbe aquí poner 00:55:08
una clase, otra clase, y creando una clase completamente con sus atributos, por ejemplo, 00:55:16
int un atributo, string otro atrib, y un método, por ejemplo, public void string, 00:55:29
sí, so, un attribute, más espacio, más otro attribute, ¿vale? Entonces yo lo hago desde esta clase, por ejemplo, 00:55:44
desde dentro del main, puedo crear un objeto de otra clase, otra clase, object, es igual a new, otra clase, 00:56:09
y acceder a sus valores 00:56:19
obj.unatrib 00:56:25
y darle 00:56:28
igual a 0 a 4 00:56:29
obj.otroatrib 00:56:30
es igual a 00:56:34
y luego poner 00:56:38
obj.describe 00:56:41
estoy usando 00:56:44
esto, como si fuera una clase 00:56:47
normal, pero no está 00:56:50
dentro de otro 00:56:52
fichero va a estar dentro del mismo fichero. Si ahora lo lanzo, pues me hace lo que me dice. 00:56:54
Al principio me ha escrito esto que es la descripción de otra clase. 00:57:01
¿Dudas? Ahora, si yo esta clase aquí la hago privada, se enfadará. No sé por qué. 00:57:09
Debería poder funcionar. Se enfadará aquí porque está intentando hacer un new otra clase, 00:57:33
entonces me dice no lo puedes hacer así si yo intentara crear otra clase desde otro sitio 00:57:41
importando ejemplo no me lo permitiría porque sólo se puede hacer desde dentro cuando se usan estas 00:57:51
cosas se usan cuando yo tengo un sistema quiero hacer una clase esta clase es que se yo alumno 00:57:58
vale y la clase alumno tiene dentro un array de materias y yo quiero esta materia es crearla aquí 00:58:06
porque me sirven solo para para esta clase o sea la materia la uso solo en los alumnos entonces la 00:58:13
clase me la creo el mismo fichero que van como más empaquetadas van juntos cuando me importa 00:58:19
el fichero alumno me importa también esta clase materia que es la que me sirve para que el alumno 00:58:24
funcione aún así nosotros principalmente usaremos public class y usaremos métodos públicos y privados 00:58:29
¿Vale? Y el resto, lo tienen que saber que existe, pero lo usamos relativamente menos. ¿Vale? Y ya está. 00:58:42
Perdona, Estefano, ¿las clases privadas entonces las llegaremos a usar en algún momento? 00:58:55
No, no. 00:59:00
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
1
Fecha:
17 de diciembre de 2025 - 12:12
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
59′ 05″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
495.75 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid