Saltar navegación

241210Args y Static 1 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 10 de diciembre de 2024 por Stefano C.

10 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar esta clase, si habláis me dais consentimiento para que grabe esta voz. 00:00:00
Entonces, nosotros hemos hecho los primeros pasos en el mundo de la programación orientada a objetos. 00:00:06
Hemos empezado a ver la diferencia entre objetos y clases, hemos empezado a ver que es un constructor, 00:00:14
hemos visto el concepto de sobrecargar un constructor o sobrecargar un método. 00:00:19
Hemos visto... ¿qué más hemos visto? Poco más. 00:00:25
Hemos visto las bases para poder crear objetos, hemos hecho ejemplos, etc. 00:00:30
Antes de entrar en las capacidades avanzadas de la programación orientada a objetos, como son herencia, como son polimorfismo, como son cosas por el estilo, 00:00:35
pues tenemos que acabar de dar unas pinceladas siempre sobre el concepto de clases y sobre lo que se puede hacer en una clase. 00:00:49
Algunas cosas son cosas que hemos visto siempre allí y no sabemos exactamente qué es 00:00:56
Pues ahora vamos a ver qué es 00:01:01
Y algunas cosas ya las hemos dicho en ejemplos anteriores, pues hoy las formalizamos 00:01:03
Entonces, primer punto, el método main 00:01:09
Nosotros desde el primer día, desde aquel día de septiembre en el que empezamos el primer Hello World 00:01:13
En el que, además de public class no sé qué, escribimos un public static void main, ¿vale? 00:01:20
Y, si os dais cuenta, cada día que pasa, vamos añadiendo algo más que nos hace entender qué es este public static main void, ¿vale? 00:01:27
Por ejemplo, al principio no sabíamos nada de todo esto. 00:01:40
Hoy sabemos que main es el nombre, que void, ¿qué quiere decir void? 00:01:44
Que el main no me espero que devuelva algo 00:01:48
¿Vale? 00:01:52
Static, todavía no lo entendemos muy bien 00:01:54
Pero entendemos que cuando es static no depende de un objeto 00:01:57
Y cuando no es static depende de un objeto 00:02:02
O sea que el main no necesita haber creado un objeto sobre el que llamar el main 00:02:05
¿Vale? 00:02:09
Y es normal porque cuando empiezo no tengo objetos 00:02:10
¿Sí? 00:02:13
Public, que es accesible desde fuera 00:02:15
de esta clase, hoy veremos mejor 00:02:18
el concepto de visibilidad 00:02:21
y que pilla como parámetro 00:02:23
una cosa que se llama args 00:02:26
que es una variable, que es un array de string 00:02:29
esto es todo lo que sabemos 00:02:33
esto lo sabemos más o menos leer, lo entendemos más o menos 00:02:35
sabemos que es un método especial, es el punto de acceso 00:02:39
a mi programa, a mi sistema 00:02:42
Siempre tendrá que haber un punto de acceso más importante 00:02:43
Esto no quita que pueda hacer varias clases con un main 00:02:48
Pero mi sistema tendrá que empezar con un main concreto 00:02:52
Habrá una clase, clase principal, la clase inicio, la clase de llamarla como os da la gana 00:02:56
Que será la clase que tendrá el main, que es el que crea todos los objetos que tiene que crear 00:03:00
Y a partir de allí sale y empieza mi sistema 00:03:06
¿Vale? Como es static, se puede invocar su ejecución si necesita de que exista un objeto de la clase a la que pertenece 00:03:09
¿Vale? Entonces se puede lanzar ya directamente, si esta es la clase, mi clase, ¿vale? 00:03:18
Puede tener o no un main, nosotros hemos hecho clases con main y clases sin main 00:03:24
¿Recordáis? ¿Sí? Vale 00:03:28
¿Qué es esto de string args? ¿Sí? 00:03:30
En realidad, StringArgs representa un array de parámetros con el que yo ejecuto el programa. 00:03:34
Si vosotros habéis usado algún programita en línea de comando, muchos de estos programas, después del programa, admiten parámetros. 00:03:43
¿Habéis usado un ping alguna vez en vuestra vida? 00:03:53
Ping es el comando, pero luego, después del ping, admite parámetros. 00:03:56
En particular, ¿a quién haces ping? 00:04:01
o ping menos t 00:04:04
y a quien hacéis ping 00:04:06
el menos t es un parámetro 00:04:09
que permite hacer ping para siempre 00:04:10
hasta que tú lo bloquees 00:04:12
entonces, todos los programas 00:04:13
que nosotros podemos crear 00:04:16
admiten parámetros 00:04:18
yo puedo crear en mi 00:04:20
programa Java 00:04:22
un programa que al lanzarlo 00:04:24
le añado parámetros 00:04:27
en el momento del lanzamiento 00:04:28
en línea de comando 00:04:30
Y primero utilizamos el programa Java C 00:04:40
Java C 00:04:43
Que es sustancialmente 00:04:43
El compilador de Java 00:04:46
Que transforma el punto Java en un punto class 00:04:47
Transforma Java como lo conocéis vosotros 00:04:50
En otro lenguaje intermedio 00:04:53
Que se llama el bytecode 00:04:54
Y luego hacíamos Java 00:04:55
Y el nombre de la clase 00:04:58
Y esto crea la Java Virtual Machine 00:05:00
Le pasa como parámetro el nombre de la clase 00:05:02
Y ya está 00:05:04
Entonces 00:05:05
Yo tenía Java C 00:05:07
mi clase 00:05:15
punto java 00:05:18
esto me crea 00:05:20
mi clase punto class 00:05:23
y luego hacía java mi clase 00:05:25
esto es 00:05:27
lo básico 00:05:30
ahora yo puedo a esta 00:05:31
cosa de aquí darle 00:05:34
unos parámetros, es decir que cuando lo llamo 00:05:36
así, vale, podría 00:05:38
por ejemplo pasarle aquí 00:05:40
1, 10 00:05:42
esto le estaría pasando dos 00:05:44
parámetros, el parámetro 1 y el parámetro 10 00:05:46
¿sí? que por ejemplo 00:05:48
luego podría utilizar como 00:05:50
no sé, imaginamos que mi clase sea 00:05:52
una 00:05:54
una clase que lo que hace es generar 00:05:55
números aleatorios 00:05:58
pues yo quiero crear que cuando la lanzo así 00:05:59
sea un número aleatorio entre 1 y 10 00:06:02
si lo lanzo así 00:06:04
genera un número aleatorio 00:06:05
entre 10 o 100 00:06:08
¿sí? o sea que si lo estoy pasando 00:06:09
no pidiendo al usuario 00:06:12
oye usuario, dame un número 00:06:14
dentro del código 00:06:16
sino que al momento de lanzarlo 00:06:18
yo le puedo dar unos parámetros 00:06:21
determinados, por ejemplo 00:06:23
esto se usará en un futuro para pasarle 00:06:25
un fichero, por ejemplo, yo lanzo mi clase 00:06:27
y aquí le digo el nombre 00:06:29
del fichero, log.txt 00:06:31
y esto será el fichero 00:06:33
que él utilizará durante 00:06:35
esta ejecución, si cambio en log2 00:06:37
pues usará un fichero distinto 00:06:39
esto podría ser un 00:06:41
fichero de configuración 00:06:43
configuración, config.cfg, qué sé yo, entonces cuando él arranca dentro de este fichero encontrará una serie de parámetros que utilizará para arrancar de una determinada forma, quién es el servidor, quién es el local, cuántos jugadores puede admitir, no lo sé, lo que me haga falta, ¿vale? 00:06:45
Ahora, cuando yo lanzo algo así, Java, mi clase, y pongo cosas aquí, ¿dónde acaban estos datos? Es decir, ¿cómo puedo pillar estos datos desde dentro del programa? 00:07:07
Y estos datos se van insertando en un array de string donde en la posición cero está el primer argumento, en la segunda está el segundo argumento, en la tercera posición está gato. 00:07:25
Y este array es este array. ¿Se entiende? 00:07:43
entonces, una vez que yo lanzo el main 00:07:48
tengo estos argumentos que pueden estar vacíos 00:07:53
nosotros hemos usado hasta ahora vacío 00:07:56
no hemos nunca rellenado algo allí 00:07:58
pero puede ser que yo lance 00:08:00
mi programa pasándole lo que se llaman 00:08:02
argumentos, y como los encuentro 00:08:04
los encuentro como string 00:08:06
dentro de args 00:08:07
args de 0 00:08:09
será el primer argumento, args de 1 00:08:11
será el primer argumento, me puedo preguntar 00:08:13
¿cuánto es grande args? 00:08:15
y si args.length es 0 00:08:17
Quiere decir que no me has pasado argumentos 00:08:20
Si args.length es mayor que 0 00:08:22
Quiere decir que me has pasado algún argumento 00:08:24
Y ahora hacemos pruebas 00:08:27
¿Vale? 00:08:27
Una clase, mi clase, cotoriego, comando, Java, mi clase 00:08:29
Java, mi clase, algo, 3, otra cosa 00:08:31
Generaría que en args de 0 estaría algo 00:08:33
En args de 1 estaría 3 00:08:36
Cuidado, como string 00:08:39
No como número 00:08:40
Si lo quiero como número 00:08:42
Tengo que hacer algo para transformarla en número 00:08:43
Pero esto es un array de string 00:08:46
¿Sí? 00:08:48
Y en el args de dos estaría otra cosa, ¿vale? Separado por espacios, allí pongo los valores, los string. En Eclipse se puede hacer lo mismo sin tener que llegar allí diciéndole, oye, mira, estos son los parámetros cuando ejecutas la clase, ¿vale? 00:08:49
Decíamos antes que existe un punto de acceso a mi sistema, una clase main 00:09:04
Clase main quiere decir principal, cuidado, no el método main, la clase main 00:09:13
No se tiene que llamar así, se puede llamar inicio, se puede llamar con el nombre de vuestro programa 00:09:18
Se puede llamar como os da la gana, pero esa es la clase que yo tengo que ejecutar 00:09:23
Eso no quiere decir que tenga que tener un solo main, cada clase puede tener su main 00:09:27
De hecho, muchas veces las clases tienen un main para probar esa clase. 00:09:32
Yo hago la clase persona, que simula a una persona, y dentro tiene un main para crear dos o tres personas y hacerles algo. 00:09:36
Luego creo la clase coche, y dentro de la clase coche tengo un main que prueba esa clase. 00:09:44
Y luego tengo clase garage o taller, que asocia personas a clases, y eso es mi sistema de verdad. 00:09:50
Las tres tienen un main 00:09:56
Pero dos de los main no hacen prácticamente nada 00:09:59
Prueban solo la clase interna 00:10:02
O hacen cosillas pequeñas 00:10:03
Y es el main principal 00:10:05
Es la clase taller que permite lanzar el sistema 00:10:06
¿Se entiende? 00:10:09
Vale 00:10:11
Estas clases pueden tener o no un main 00:10:12
Si lo tienen normalmente se utiliza para probarlo unitariamente 00:10:15
Aunque con utilidades como JUnit 00:10:17
¿Habéis visto yo JUnit ya? 00:10:20
No, lo veréis 00:10:22
No es lo habitual 00:10:22
no tiene por qué llamarse main, se puede llamar como se le da la gana 00:10:26
y es el detonante de mi sistema 00:10:29
paramos aquí, hacemos un ejemplito 00:10:31
esto es un proyecto, voy a hacer un package 00:10:59
de ejemplos 00:11:07
args 00:11:10
ejemplos args 00:11:13
y creo un ejemplo arg 00:11:17
con un main 00:11:20
yo tengo este aquí para hacer un ejemplo 00:11:23
pues lo que puede hacer es decir si args.length es cero, si so, este programa no se usa así, tienes que darme parámetros o argumentos, args, ¿sí? 00:11:29
Esto es típico. Cuando vosotros lanzáis un programa sin lanzarlo con los parámetros correctos, lo que suele salir es una descripción de cómo se usa. 00:12:03
Pinga secas no hace nada porque te dice, mira, pinga después necesita algunos de estos parámetros. 00:12:23
Si están entre corchetes, normalmente es que son opcionales. 00:12:29
Puede ser "-t", "-a", "-ncount", "-liz", y luego tiene que poner un nombre destino, que es donde haces el ping. 00:12:35
Entonces, estos son todos parámetros. 00:12:42
Y luego te explica todos los parámetros. 00:12:44
"-t", hace esto, "-a", hace esto, "-liz", hace esto. 00:12:45
Entonces, la idea es que si tu programa necesita parámetros y tú no le das parámetros, 00:12:50
Pues lo que haga él es decirte, oye, mira, no se usa así, se usa de esta forma. 00:12:59
Te explica cómo se usa, ¿vale? 00:13:06
Nosotros lo hacemos más sencillo, que dice que si sustancialmente no me has pasado ningún parámetro, 00:13:08
pues entonces dime que este parámetro, este programa no se usa así, tienes que darme parámetros. 00:13:13
Si ahora lo lanzo, me está diciendo esto. 00:13:17
Y de esto deduzco una cosa que es, que args no es null. 00:13:21
O sea, que esta cosa alguien la ha creado. Justo. Porque si no, esto me habría explotado. Con un null pointer exception. El hecho de que esto no haya explotado quiere decir que alguien, mágicamente, por debajo, me ha creado este objeto. Este objeto no es null. Este objeto existe. 00:13:33
Alguien ha creado este objeto 00:13:56
Antes de que yo empezara 00:13:58
A ejecutar esto 00:14:01
¿Quién? 00:14:02
La Java Virtual Machine 00:14:05
Al asumir que a llamar esto 00:14:06
La Java Virtual Machine habrá creado 00:14:10
Un array a partir de los argumentos que le he dado 00:14:11
Y se lo habrá pasado aquí 00:14:14
¿Vale? Entonces 00:14:16
Este de aquí 00:14:17
Es un objeto, es un objeto real 00:14:19
Que existe 00:14:21
Ahora, ¿cómo le doy esta cosa? 00:14:22
En realidad yo debería hacer, por ejemplo, java ejemplo args algo, ¿vale? 00:14:26
Entonces este algo se metería aquí dentro, ¿sí? 00:14:35
En Eclipse no lo puede hacer así, ahora vemos cómo se hace, pero antes hagámoslo de hacer algo. 00:14:39
else, asumiendo que 00:14:47
si no es cero 00:14:49
entonces quiere decir que hay algo 00:14:51
¿vale? entonces 00:14:53
vamos a hacer que liste por ejemplo 00:14:55
lo que tenga 00:14:57
entonces lo que hago es for 00:14:58
string s 00:15:01
dos puntos args 00:15:03
siso s 00:15:05
¿vale? esto lo que me 00:15:12
hace es que me escribe los parámetros que te he dado 00:15:16
¿sí? entonces si yo lo lanzo 00:15:18
ahora, me dice no, este programa 00:15:20
no es aquí, tiene que darme unos argumentos 00:15:22
¿Cómo le doy argumentos? 00:15:24
Aquí cuando lanzáis, tenéis al lado una flechita negra 00:15:27
Si le dais aquí, le podéis dar Run Configurations 00:15:32
Run Configurations, abre un menú que dice cuando lanzo este señor 00:15:37
Fijaos que aquí os aparecen todos los main que podéis lanzar 00:15:42
Entonces a veces que le dais a lanzar y en vez de lanzar vuestro programa 00:15:47
está lanzando otro programa, podéis venir aquí y seleccionar 00:15:51
cuál es el main que queréis lanzar, si no aparece aquí, es que os habéis 00:15:55
equivocado en escribir el main y el main no está correcto, entonces él no lo reconoce como 00:15:59
main, entonces no lo puede lanzar, entonces nosotros estamos 00:16:03
lanzando ejemplo args y si 00:16:07
os fijáis aquí arriba, está arguments 00:16:11
si pincháis en arguments, esto es lo que 00:16:14
escribiríais después de Java mi clase o Java ejemplo args en este caso. 00:16:19
Entonces, si yo escribo aquí gato turrón 22 y algo más, 00:16:25
pues yo estoy mandando cuatro parámetros. 00:16:36
Uno, dos, tres y cuatro parámetros. 00:16:39
en el momento en que lo lanzo 00:16:41
run 00:16:45
veis que ahora ya 00:16:47
ha encontrado algo dentro de args 00:16:49
en args de 0 00:16:52
me ha escrito gato 00:16:54
turrón 22 00:16:56
algo más 00:16:57
¿se entiende? 00:16:58
entonces 00:17:03
¿qué podéis hacer aquí? 00:17:05
si hizo 00:17:11
args.length 00:17:12
para que me diga 00:17:14
que tiene cuatro parámetros 00:17:20
y luego me dice cuáles son los parámetros 00:17:23
este es un array, normal y corriente 00:17:24
¿vale? 00:17:27
esta es una forma de pasarle datos 00:17:28
en vez de 00:17:31
dentro desde el usuario 00:17:32
en el momento en que se lanza 00:17:34
¿vale? y muchos programas 00:17:36
cuando se lanzan ya tienen varios 00:17:39
argumentos, usa esos argumentos 00:17:40
y trabaja 00:17:43
repito que por ahora 00:17:44
sepa que existe, esto es para completar 00:17:46
que es esto, porque hasta ahora no lo sabíamos 00:17:49
y ahora tenemos todos los elementos para entender que es esto, por lo tanto 00:17:52
lo vemos, probablemente 00:17:55
lo usaremos relativamente poco, porque normalmente 00:17:57
damos datos de otra forma, pero 00:18:01
es una forma, por ejemplo, lo que decía 00:18:03
de poder pasar por parámetros 00:18:07
a vuestros programas, ficheros 00:18:10
de configuración alternativos o cosas por el estilo que si aquí no hay nada 00:18:13
pilla el fichero de configuración por defecto si aquí se lo explícito pues 00:18:17
pillará los datos que yo le doy dudas sobre esto 00:18:23
paz si acabo de hacerte un ejemplo imagínate que tú tienes un fichero con 00:18:32
con información algo que podéis utilizar vosotros si vosotros conocéis ping si por ejemplo trabajar 00:18:40
es el próximo curso con apache o cosas por el estilo que son servidores web pues servidores 00:18:49
web tienen un conjunto de ficheros de configuración vale y tú a lo mejor cuando lanzas el apache puede 00:18:57
decir apache a secas y lo que estás lanzando es con los ficheros de configuración suyos o le 00:19:04
puedes explicitar, oye mira, no uses 00:19:09
los ficheros normales 00:19:11
pero usa este fichero de aquí, ¿qué te 00:19:14
paso yo? ¿vale? o por ejemplo 00:19:15
en el ping, el ping normalmente lo que 00:19:17
hace es lanzar cuatro veces un mensaje 00:19:20
a otro, ¿vale? pero si 00:19:22
tú no quieres lanzarlo cuatro veces, tú lo quieres 00:19:24
lanzar infinitas veces para comprobar 00:19:26
el momento en que se 00:19:28
cierra la comunicación 00:19:29
pues entonces le puedes dar el parámetro menos t 00:19:31
¿vale? entonces si tú haces tu 00:19:34
java que normalmente 00:19:35
hace una cosa, pero si le pones el parámetro 00:19:37
menos t, hace una cosa distinta 00:19:39
o el parámetro t hace otra cosa 00:19:41
pues lo puedes hacer con este de aquí 00:19:43
tú tienes tu programa que funciona sin parámetros 00:19:45
o no funciona sin parámetros 00:19:47
por ejemplo, el ejercicio que hemos hecho ahora 00:19:49
no funciona sin parámetros 00:19:51
si tú no le das parámetros, te dice, oye, me tienes que dar parámetros 00:19:52
¿sí? 00:19:55
y en el momento en que en vez tiene parámetros, pues lo que hace 00:19:57
te lo escribe por pantalla 00:19:59
no lo sé, ¿vale? a lo mejor algunos 00:20:00
ejemplos, tú piensa 00:20:03
a los ejercicios que has hecho, que empieza 00:20:04
con dame tu nombre, dame tu edad 00:20:07
pues esta cosa aquí en vez de pedírsela 00:20:10
habrías podido ponerla directamente como argumento 00:20:13
en el momento en que lo lanzas, no es lo normal 00:20:16
porque depende de 00:20:18
mientras lo que pides por consola es 00:20:20
comunicación con el usuario 00:20:25
pues esto es otra cosa, no es el usuario 00:20:26
normalmente que hace esto, sino son parámetros tuyos 00:20:31
que al momento de lanzarlos te sirven de alguna forma 00:20:33
Por ejemplo, podrías decidir dónde, podrías hacer un numerito, 1, 2, 3, que es el nivel de verbose de tu programa. 00:20:36
Que si es 1, no escribe nada. Si es 2, escribe solo las cosas más importantes. 00:20:46
Y si es 3, escribe cualquier cosa que está haciendo. Existe esto, se llama verbose. 00:20:52
Entonces tú, cuando escribes algo en pantalla, en vez de escribirlo directamente, preguntas, 00:20:57
sí, args de cero 00:21:02
vale, no sé qué, pues entonces lo escribes 00:21:04
y si no, no 00:21:06
por ejemplo, si args 00:21:07
de cero 00:21:11
punto equals 00:21:12
verbose 00:21:16
entonces 00:21:17
de cero 00:21:27
entonces escribe también esta frase 00:21:31
si no, no, entonces si yo lo lanzo 00:21:34
ahora, pues no me lo va a escribir 00:21:36
porque el primer 00:21:38
elemento es gato 00:21:40
Si yo cuando lanzo este de aquí 00:21:41
Le digo, no, entra en modalidad verbose 00:21:44
Entonces la primera opción es verbose 00:21:48
Pues ahora al lanzarlo me escribe también los parámetros que tengo 00:21:52
Vale 00:21:57
No, esto 00:22:05
Vale, entonces clase main más o menos, método main más o menos 00:22:08
Entonces, concepto de static 00:22:14
Lo hemos visto, lo hemos probado 00:22:18
Hemos hecho algunos ejemplos y algunas cosillas 00:22:21
Vamos a intentar darle una espincelada más 00:22:23
Para entender la diferencia de cuando hago algo static 00:22:28
Y cuando hago algo no static 00:22:31
Ten en cuenta que esto es algo que luego se os olvida con el tiempo 00:22:33
Pero es una de las cosas muy importantes de la programación orientada a objetos 00:22:36
Por lo tanto, por favor, atención 00:22:41
Y si no lo entendéis, levantad la mano, no hay ningún problema 00:22:44
Entonces, cuando no pongo static 00:22:47
Cuando Java no utiliza la palabra reservada static 00:22:50
Me estoy refiriendo a algo que depende de un objeto concreto 00:22:56
Eso quiere decir que este método, esta variable, este lo que sea 00:22:59
Tiene que estar asociado a un objeto 00:23:04
y que objetos distintos tendrán resultados distintos haciendo lo que estoy llamando, ¿vale? 00:23:07
Static puede ser una variable o un método, por ahora, nosotros, ¿vale? Como lo usamos. 00:23:17
Si es una variable, no static quiere decir que es una variable propia del objeto. 00:23:22
Objetos distintos tendrán copias distintas de esa variable, con el mismo nombre, pero copias distintas, 00:23:28
Y que si yo llamo el nombre de la persona 1 o el nombre de la persona 2, pues tendré cosas distintas ahí dentro. Cada uno tiene lo suyo. Y cuando en vez de no estático un método, no es lo mismo. El resultado será distinto si yo lo llamo sobre el objeto persona 1 o sobre el objeto persona 2. 00:23:34
Por ejemplo, el método saludar no es estático, que no pilla parámetros, y lo que hace es decir hola, me llamo, y su propio nombre, pues si lo llamo sobre persona 1, dirá hola, me llamo, como se llama la persona 1, Paco, y si lo llamo sobre la persona 2, dirá hola, me llamo, Sara, porque la persona 2 tiene como nombre Sara. 00:23:53
¿Se entiende? 00:24:16
Entonces, un atributo de una clase 00:24:19
Aparecerá en todas las instancias de esa clase 00:24:21
Los objetos, pero cada instancia 00:24:23
Podrá tener un valor distinto de ese atributo 00:24:25
¿Sí? 00:24:27
Y un método que no es estático 00:24:29
Quiere decir que hay que llamarlo 00:24:30
Sobre un objeto concreto 00:24:33
Y usará datos de ese objeto concreto 00:24:34
En su ejecución 00:24:37
Normalmente un método no estático 00:24:38
Debería usar algo propio del objeto 00:24:40
Algún variable del objeto 00:24:43
Si no usa nada del objeto 00:24:45
No depende de ese objeto 00:24:48
Y por lo tanto 00:24:50
Podría ser que no lo quiera 00:24:51
No es estático, sino que lo quiera estático 00:24:54
¿Sí? 00:24:56
Ahora hacemos el ejemplo 00:24:58
El ejemplo de no estático 00:24:59
La clase rectángulo 00:25:00
Tiene un largo y un ancho 00:25:03
Tiene una 00:25:06
Funcionalidad que es setData 00:25:08
Que me da el largo 00:25:10
L y B 00:25:11
Y me pone que largo es igual a L y ancho es igual a B 00:25:12
O 10.largo y 10.ancho, me da igual 00:25:17
Y luego tiene área que no pilla parámetros 00:25:20
¿Por qué no pilla parámetros? 00:25:24
¿Dónde encuentro los parámetros para calcular el área? 00:25:26
Desde sus propios atributos 00:25:29
Rectángulo área será igual a largo por ancho 00:25:32
Que son estos, 10.largo por 10.ancho 00:25:37
Y devuelve el área de rectángulo 00:25:41
¿Cómo se usa este señor? 00:25:43
Pues este señor para poder utilizarlos 00:25:46
Necesito crear un rectángulo 00:25:48
Si no creo objetos rectángulos 00:25:53
No puedo hacer nada 00:25:55
Entonces creo REC1 y REC2 00:25:57
Que son dos rectángulos 00:26:01
Al primero le excepto los datos a 5 y 6 00:26:02
Entonces es un rectángulo 5 por 6 00:26:05
Al segundo le excepto los datos 1 y 3 00:26:08
Entonces es un rectángulo 1 por 3 00:26:11
Cuando hago int result es igual a rec.area 00:26:12
Lo que estoy haciendo, rec1.area 00:26:17
Estoy diciendo, oye, cálculame el área 00:26:19
Llámame este método 00:26:21
Pero sobre aquel objeto que es rec1 00:26:22
Que tiene lado 5 y alto 6 00:26:26
O lo que sea 00:26:30
Entonces este método de aquí 00:26:30
Me usará los datos de rectángulo 1 00:26:34
Entonces será 5 por 6 00:26:37
Y este 5 por 6 lo pondrá en resultado 00:26:38
Y luego cuando lo escribe, lo escribe en resultado 00:26:42
Cuando hago esto y vuelvo a usar result 00:26:44
Pero lo llamo sobre rectángulo 2 00:26:48
Pues este es el mismo método 00:26:51
Pero ahora no lo está usando con los datos de rect1 00:26:53
O sea 5 y 6, más lo está usando con los datos de rect2 00:26:57
O sea 1 y 3 00:27:00
Entonces el resultado de área 00:27:01
Depende sobre el objeto que yo lo estoy llamando 00:27:05
Por lo tanto, no es estático 00:27:08
Por lo tanto, área no es estática 00:27:12
¿Dudas? 00:27:17
¿Preguntas? 00:27:21
¿Cuándo en vez de algo es estático? 00:27:25
Cuando estamos en un entorno estático 00:27:29
Me refiero a algo que no pertenece a un objeto concreto 00:27:31
Sino a la clase en general 00:27:35
Entonces yo estoy definiendo la clase rectángulos, la clase persona, la clase lo que sea 00:27:37
Y hay algunos conceptos, algunas variables, algunos atributos o algunos métodos 00:27:44
Que no dependen de personas distintas 00:27:51
Sino que cada persona siempre dará el mismo resultado, siempre tendrá el mismo valor 00:27:55
Es como si fuera una variable compartida entre todas las personas 00:28:01
o un método que cualquier persona que lo llame, en realidad, no use nada de esa persona para poder hacer algo, ¿vale? 00:28:06
Entonces no tiene sentido llamarlo sobre un objeto persona, no tiene ni siquiera sentido tener un objeto persona. 00:28:17
Por ejemplo, imaginamos una variable que dice homo sapiens, entonces todas las personas tienen como variable asociada que su especie es homo sapiens, ¿vale? 00:28:24
Eso no depende de una persona o de otra. 00:28:35
No puedo pillar a otra persona y decir, no, pero tú no eres homo sapiens, eres otra cosa. 00:28:38
Entonces, eso es para todas las personas. 00:28:43
Entonces, esa de allí no sería una variable de objeto, una variable no estática, 00:28:47
sino sería una variable estática porque todas las personas compartirían su especie. 00:28:52
Entonces, cualquier persona que llama, tú no llamarías, si se llama la variable especie, 00:28:58
persona1.especie o persona2.especie. 00:29:02
Si no, llamarías persona.especies, donde persona es la clase. 00:29:05
Ahora hacemos ejemplo. 00:29:11
Una variable estática tendría el mismo valor para cualquier objeto que la use, 00:29:13
no depende del objeto sino de la clase. 00:29:17
Y un método estático no se llama sobre un objeto sino se llama sobre la clase. 00:29:20
Cuando ayer hicimos utils y poníamos dentro leer número, 00:29:24
yo no creaba un objeto de utils. 00:29:30
Utils x es igual a new utils, y luego hacía x.learnumero, ¿vale? 00:29:32
Sino que hacía directamente utils.learnumero. 00:29:37
Estaba llamando el método sobre la clase, no sobre un objeto. 00:29:41
No usa los datos de un objeto concreto para ejecutarse. 00:29:46
Puede usar los datos estáticos de esa clase, ¿vale? 00:29:49
En contextos estáticos se puede utilizar las cosas estáticas. 00:29:52
En contextos estáticos no puede usar cosas estáticas. 00:29:58
¿Qué quiere decir? Si estoy en un método static que depende de la clase, que no está llamado sobre un objeto, no puedo usar variables de un objeto porque no sabría de qué objeto es. 00:30:03
Un método no estático usa los valores del objeto sobre el que lo llamo. Cuando en área tengo que utilizar largo y ancho, sé que son los largos y anchos de este objeto. 00:30:15
pero si yo este método de aquí lo hago estático 00:30:34
entonces no lo llamo sobre un rectángulo 00:30:38
y lo llamo sobre rectángulo como área 00:30:40
como clase, punto área 00:30:44
pues cuando llega aquí y dice úsame largo, ¿largo de quién? 00:30:47
no lo estás usando sobre un objeto, lo estás usando sobre la clase 00:30:50
entonces no tengo ese valor, ese valor es propio de un objeto 00:30:53
tengo que crear un objeto para saber cuánto hay dentro de largo 00:30:56
entonces no lo puedo usar, ahora hacemos ejemplos 00:30:59
en Eclipse y veréis que se enfada. 00:31:02
Después. ¿Vale? Entonces, lo mismo 00:31:10
no es lo mismo. Sí, es lo mismo. Lo mismo 00:31:16
en modalidad estática. 00:31:20
¿Vale? Tengo una clase estática. Aquí tengo un static int 00:31:25
operaciones hechas, que es cero. ¿Vale? Y aquí, mirad, 00:31:28
calcular el rectángulo hace lo mismo que el otro. 00:31:32
Pero como esto es estático, no depende de un objeto 00:31:36
Por lo tanto, esos valores, el ancho y el largo, no los tengo 00:31:41
Se los tengo que pasar como parámetro 00:31:45
Entonces, en el ejemplo anterior, este método se llamaba sobre un objeto 00:31:47
Y era este objeto que empaquetaba los datos necesarios para poder hacer lo que tenga que hacer 00:31:55
Aquí, como no tengo un objeto, los datos necesarios se los estoy pasando por parámetro 00:31:59
y una vez que se lo he pasado por parámetro 00:32:04
hace lo mismo 00:32:08
y fijaos que dentro de un contexto estático 00:32:09
puede usar una variable estática 00:32:12
una variable de esta clase 00:32:14
que es operaciones hechas 00:32:16
cada vez que haga una operación 00:32:17
me suma uno aquí 00:32:19
entonces yo puedo saber 00:32:20
cuantas veces han sido hechas estas operaciones 00:32:22
tanto calcular área como calcular perímetro 00:32:26
porque fijaos que aquí también hace operaciones hechas 00:32:28
y me está contando que cada vez que alguien hace esto 00:32:31
Pues me suma 1 allí 00:32:34
Entonces en cualquier momento puedo decir 00:32:35
¿Cuántas operaciones se han hecho hasta ahora? 00:32:37
Y me dirá cuántas veces se ha calculado un área 00:32:39
O cuántas veces se ha calculado un perímetro 00:32:41
¿Por qué me sirve esto? No lo sé 00:32:44
Eso ya veremos usos 00:32:45
El main, si os fijáis, dice 00:32:49
El área de rectángulo 1 tiene 00:32:54
Fijaos que ahora el método estático 00:32:56
Lo llamo sobre una clase 00:33:00
No sobre un objeto 00:33:02
En ningún momento he hecho una new 00:33:03
¿Vale? Pero ahora 00:33:05
Este solo no me sirve 00:33:08
Para calcular el área del triángulo 00:33:10
Le tendré que decir cuáles son 00:33:11
El ancho y el lado del triángulo 00:33:13
Entonces lo pongo aquí 00:33:15
El ancho y el largo 00:33:17
¿Sí? 00:33:19
Aquí estoy haciendo 00:33:22
El cálculo de otro rectángulo 00:33:23
Está aquí, ¿vale? 00:33:25
Y perímetro, lo que sea 00:33:27
Al final puede escribir 00:33:29
Cuántas operaciones se ha hecho 00:33:31
Cuántas operaciones dará 00:33:33
¿Cuánto dará esto? 00:33:34
Hola, buenos días 00:33:45
Tres 00:33:47
Porque cuando llama este método 00:33:49
Se habrá sumado uno 00:33:52
Cuando llama este método 00:33:54
Se habrá sumado otro 00:33:56
Cuando llama este método 00:33:57
Se habrá sumado un tercero 00:33:59
Entonces, ¿cómo accedo a ese variable? 00:34:01
Pues utilizando su clase 00:34:04
Punto 00:34:06
El nombre de la variable 00:34:07
¿Dudas? 00:34:08
Hagamos un ejemplo 00:34:18
static 00:34:24
y un ejemplo 00:34:26
no static 00:34:31
un ejemplo 00:34:38
main 00:34:42
entonces 00:34:43
tengo un ejemplo static y un ejemplo no static 00:34:48
¿vale? pongamos que en el ejemplo 00:34:53
no static este es un objeto 00:34:55
¿vale? tenga algún parámetro 00:34:56
dentro, por ejemplo tiene 00:34:59
un int edad 00:35:01
¿sí? 00:35:03
entonces 00:35:04
ahora yo puedo hacer un programa 00:35:05
un método 00:35:08
que sea el método 00:35:09
public 00:35:10
boolean 00:35:15
puedes entrar 00:35:17
a la 00:35:20
disco 00:35:22
que me dice que si 00:35:23
edad es mayor 00:35:28
igual que 18 00:35:31
return true 00:35:32
return false 00:35:36
Si la edad que tiene 00:35:39
Este valor 00:35:46
Es mayor o igual a 18 00:35:48
Puedes entrar a la discoteca 00:35:50
Si no, no 00:35:51
Ten en cuenta que esto sería así 00:35:52
Funciona igual 00:35:55
Necesitaría un constructor 00:35:58
Entonces tengo un public 00:36:02
Ejemplo 00:36:04
No static 00:36:06
Que recibe un int 00:36:07
Y lo que hago es this.edad 00:36:10
es igual a e 00:36:13
¿si? vale, perfecto 00:36:14
entonces, esto quiere decir 00:36:18
que en mi ejemplo main 00:36:20
lo que puedo hacer yo es crear un 00:36:21
ejemplo no 00:36:23
static 00:36:25
es igual a new 00:36:29
ejemplo no 00:36:31
static 00:36:34
no static 00:36:39
se me ha castellanizado 00:36:46
¿Sí? 00:36:50
Puedo crear también otro objeto 00:36:51
Que 00:36:55
Tiene xc 00:37:01
¿Vale? Y ahora me puedo preguntar 00:37:03
Si eso, uno 00:37:06
Si entra uno 00:37:10
A la discoteca, más 00:37:13
Uno punto 00:37:14
Puede entrar a disco 00:37:15
Y dos 00:37:17
Dos, ¿qué me lo llaman? 00:37:25
Entonces, uno 00:37:32
Usará sus datos 00:37:33
Y me dará true 00:37:35
2 usará sus datos 00:37:37
y me dará false 00:37:40
hasta aquí 00:37:41
hagamos lo mismo 00:37:43
en versión estático 00:37:46
en versión estático 00:37:48
lo que hago yo es 00:37:51
utilizar un método 00:37:53
que pero no depende de los atributos 00:37:58
de esta clase 00:38:00
entonces hago un public 00:38:01
static 00:38:04
Voyder, no, Boolean 00:38:06
Entra 00:38:09
Se lo llamo igual 00:38:13
Puedes entrar a disco 00:38:14
Esto será prácticamente igual dentro 00:38:18
Pero el problema es que ahora 00:38:27
La edad yo no lo tengo 00:38:31
Porque no es de un objeto 00:38:32
Antes yo tenía el objeto y decía 00:38:35
Puedes entrar, voy a mirar tu edad 00:38:37
Y en base a eso te digo si sí o no 00:38:39
Pero ahora no 00:38:40
Entonces, ¿de dónde saco este dato? 00:38:42
le pondré un parámetro aquí 00:38:46
¿vale? entonces aquí habrá un int edad 00:38:51
es decir que este método lo que hace es 00:38:54
puedes entrar a disco pero le tienes que pasar la edad 00:38:57
y en base a la edad que le has pasado 00:39:00
lo hará uno 00:39:02
¿cómo se usa esto? pues desde ejemplo main 00:39:05
si yo quiero usarlo haré 00:39:09
ejercicio 00:39:11
3 que no es un objeto 00:39:13
Y daré 00:39:19
Ejemplo static 00:39:22
Lo estoy llamando sobre la clase 00:39:27
Punto 00:39:28
Veis que ahora me aparece aquí 00:39:30
El método static 00:39:32
Puedes entrar a Discord 00:39:33
Que pero necesitará ponerle aquí 00:39:35
Un valor 00:39:38
Con 20 00:39:40
Esto me dará true 00:39:43
Y esto me tendrá que dar 00:39:44
False 00:39:57
¿Veis la diferencia? 00:40:01
Este de aquí no se puede utilizar a menos que no tenga un objeto, porque este método depende del objeto y usa datos de este objeto. 00:40:09
Llamándolo sobre dos objetos distintos, tendré resultados distintos. 00:40:23
Este no depende de ningún objeto porque no usa parámetros de los objetos, usa estos parámetros de aquí, los parámetros que yo le paso. 00:40:29
Pero su resultado no depende de ningún objeto 00:40:37
Distintos objetos harían lo mismo 00:40:41
Me explico 00:40:45
Imaginémonos que yo aquí 00:40:46
Cree otra versión 00:40:48
¿Vale? 00:40:54
Pero no estática 00:40:56
Que haga esto 00:40:58
¿Sí? 00:41:01
Ahora 00:41:06
Esto yo lo puedo llamar desde aquí 00:41:06
Sí 00:41:09
¿Cómo? 00:41:10
Así, déjame copiar esto 00:41:11
Uno bis 00:41:18
Dos bis 00:41:22
¿Vale? 00:41:24
Yo puedo llamar el otro método, sí 00:41:26
Pero le tengo que poner 00:41:28
Algo así 00:41:30
Fijaos 00:41:32
Este señor de aquí tiene dentro 00:41:34
Que tiene, no sé cuántos años tiene 00:41:36
Y este aquí 15 00:41:38
Decía 8 y 15 00:41:40
¿Vale? O sea que esto me debería dar true 00:41:42
Y esto me debería dar false 00:41:44
¿Sí? Sin embargo 00:41:46
True y true 00:41:48
¿Por qué? 00:41:51
Porque ahora ya no dependo de este objeto. 00:41:53
Llamándolo sobre objetos distintos, lo que cuenta es esta variable de aquí. 00:41:56
Porque si os fijáis en su definición, esta es la definición del objeto, ¿vale? 00:42:03
Del no estático, pues se está usando esta edad de aquí. 00:42:08
Entonces, este método, que yo lo he metido como no estático, 00:42:15
o sea, le estoy diciendo, lo tienes que llamar sobre un objeto. 00:42:20
Pero en realidad no depende del objeto, depende solo de esta cosa de aquí 00:42:22
Entonces que yo lo llame sobre un objeto 1 o yo lo llame sobre un objeto 2 00:42:27
Con el mismo parámetro no tiene ninguna diferencia 00:42:33
Entonces esto debería ser estático 00:42:37
Cuando el resultado de este método no depende del objeto sobre el que lo llamo 00:42:41
Debería ser estático, ¿se entiende? 00:42:48
Si yo quito uno, me da error porque en esta clase, él lo busca en esta clase aquí, en la clase ejemplo main, y no hay este método. 00:42:52
Si yo lo llamo sobre ejemplo no static, me da error porque no hay un método estático que se llame así dentro de la clase ejemplo no static. 00:43:10
¿Por qué? Si ahora pusiera aquí static 00:43:31
Pues entonces 00:43:35
Este de aquí 00:43:37
Ahora me dice muy bien 00:43:38
Este de aquí también 00:43:40
¿Vale? Pero es feo 00:43:42
Porque estoy llamando un método estático 00:43:44
Sobre un objeto, esto no tiene sentido 00:43:47
No se suele utilizar 00:43:48
¿Sí? 00:43:50
Él asume que, como lo estás llamando sobre este método 00:43:52
Él asume que lo estás llamando 00:43:55
Sobre esta clase 00:43:57
Porque este objeto es 00:43:58
de esta clase, pero 00:44:00
veis que te lo marca 00:44:03
te dice 00:44:05
el método estático 00:44:05
método estático 00:44:08
este de aquí, de la clase 00:44:11
ejemplo no estático, debería 00:44:13
ser accedido 00:44:15
en un 00:44:17
modo estático, o sea 00:44:18
no sobre un objeto, sino sobre la clase 00:44:20
aún así 00:44:23
te dice, bueno, entiendo lo que querías hacer 00:44:25
pero te lo marco 00:44:27
Repito que si aquí quito lo static 00:44:29
Pues esto se enfada 00:44:35
Y repito también que este método de aquí 00:44:37
Debería ser static 00:44:41
Porque no hace referencia aquí dentro 00:44:43
A nada de este objeto 00:44:47
¿Dudas? 00:44:48
Más cosillas 00:44:53
Y fijaos que este es un error 00:44:54
¿Vale? 00:44:56
Porque yo 00:44:57
Me has dicho que no es estático 00:44:58
Que depende de un objeto 00:45:00
Entonces cuando yo lo llamo sobre una clase 00:45:01
no sabría, no lo puede hacer 00:45:04
porque necesito el objeto para poder llamar 00:45:06
el último ejemplo 00:45:08
es con 00:45:13
variables estáticas, porque el 00:45:14
acceso a esta variable aquí 00:45:16
más o menos lo tenemos claro 00:45:19
lo hemos ya hecho, vale, yo desde aquí 00:45:20
puedo poner 00:45:22
siso1.edad 00:45:23
y esto me escribe 00:45:30
la edad de 1 00:45:33
aquí, 19 00:45:34
La cosa que todavía no hemos utilizado 00:45:36
No hemos visto 00:45:41
Es que en el ejemplo estático 00:45:42
Yo puedo crear una variable estática 00:45:44
Static 00:45:47
Public 00:45:48
Static 00:45:50
Personas 00:45:52
En la disco 00:45:57
Que me está diciendo 00:45:59
Cuántas personas han entrado en la disco 00:46:08
Entonces 00:46:10
Cuando puedes entrar en la cosa 00:46:12
Si yo entro aquí dentro y tienes mayor que 18 00:46:14
Entonces has entrado en la disco 00:46:17
Puedo hacer personas en la disco 00:46:18
Más, más 00:46:22
Sí 00:46:25
Que si tú pones int así 00:46:27
Ahora para que esto funcione 00:46:35
Necesitas un ejemplo, un objeto ejemplo static 00:46:37
Sin embargo, si lo pones así 00:46:39
No necesitas un ejemplo static 00:46:43
Y que si lo pones así 00:46:44
Cada objeto ejemplo static 00:46:46
tiene una copia distinta de personas en la disco 00:46:49
entonces si este objeto suma uno 00:46:52
este objeto no lo suma 00:46:54
no está compartido entre objetos de esta cosa 00:46:56
mientras que así es una cosa de la lista 00:47:01
entonces cada vez que yo ejecutaré 00:47:06
este tipo de estos 00:47:10
estaré sumando uno a esta variable 00:47:13
si entra, si no entra no 00:47:15
Y entonces aquí me puedo preguntar si eso, gente en la disco, estática, y puedo hacer ejemplo static, punto, y acceder a esta variable de aquí. 00:47:18
Fijaos que esto no es de un objeto, es de una clase. 00:47:45
Entonces si yo lo lanzo ahora, en la clase estática hay uno. 00:47:52
¿Vale? Porque he llamado solo una vez 00:47:56
¿Dudas hasta aquí? 00:47:58
Vale 00:48:06
Si yo pongo esto 00:48:06
Como estático 00:48:10
Esto depende de esta clase 00:48:11
¿Vale? Entonces todas las clases 00:48:13
Todas las 00:48:16
Esta clase tiene una única variable 00:48:17
¿Vale? Una única variable personal a disco 00:48:20
Cuando se está sumando 00:48:22
O restando sobre esta variable 00:48:24
Todos 00:48:25
Hay solo esa variable 00:48:26
Entonces todos que acceden a esta variable ven que ha cambiado 00:48:30
Si yo esto lo quito como static 00:48:34
Ahora esta de aquí es una cosa que depende de un objeto 00:48:37
Entonces primero no puedo acceder a ella como ejemplo static.personal.disco 00:48:43
Porque depende de un objeto, necesito un objeto ejemplo static 00:48:48
Tendré que hacer new ejemplo static por algún lado 00:48:53
Y que si ahora en un new ejemplo static sumo 1 00:48:56
En otro objeto 00:49:00
No tendré la misma variable 00:49:02
Tendré variables distintas 00:49:04
A ver si lo consigo hacer 00:49:06
Fijaos que esto no lo puedo hacer ahora 00:49:09
¿Por qué no? 00:49:12
Porque este es un objeto 00:49:20
Y yo estoy en un entorno estático 00:49:22
Esto es 00:49:24
Estoy hablando de la clase 00:49:26
No estoy en ningún objeto concreto 00:49:27
Y de repente te digo 00:49:31
Oye, añádele uno a persona en la disco 00:49:32
Pero es algo que depende de un objeto 00:49:34
Y no te he dicho de qué objeto 00:49:36
Por lo tanto no lo puede hacer 00:49:38
Y se enfada y te lo dice 00:49:40
No puedes hacer una referencia estática 00:49:42
A un campo no estático 00:49:46
Que es este campo aquí 00:49:48
Desde un entorno estático 00:49:50
En el que no saben qué objeto estás trabajando 00:49:54
Porque estás trabajando sobre la clase 00:49:57
No puedes modificar un campo no estático 00:49:59
Que depende de un objeto 00:50:03
Puedes trabajar con cosas estáticas también 00:50:04
Pero no con cosas no estáticas 00:50:12
Vamos a meter algo parecido aquí 00:50:14
A esto en el otro 00:50:21
En el ejemplo no estático 00:50:23
Public si queréis, ahora luego vemos que es este de public 00:50:28
Y hagamos que si puede entrar a la clase 00:50:32
A la cosa pues hago 00:50:38
Personas en la disco 00:50:42
Más 00:50:45
Tiene que ir antes 00:50:45
Parece lo mismo 00:50:49
¿Sí? Ahora, ¿cómo uso 00:50:54
Esto? En un determinado 00:50:57
Momento, yo aquí he entrado 00:51:02
Personas, ha entrado personas 00:51:04
¿Vale? Hagamos 00:51:06
Que los dos puedan entrar 00:51:08
Pueden entrar, ¿vale? 00:51:09
Entran, entonces ahora 00:51:16
Me pregunto, si hizo 00:51:18
Uno punto 00:51:20
personas en la disco 00:51:21
exciso 00:51:23
dos puntos personas en la disco 00:51:25
¿cuánto me debería dar? 00:51:30
si esto está pensado 00:51:42
como quiero saber cuántas personas 00:51:44
hay en la disco en este momento 00:51:46
esto está mal hecho, porque cada uno 00:51:47
contará a sí mismo 00:51:50
¿veis? sin embargo 00:51:51
la que es estática 00:51:58
si yo pongo dos personas 00:51:59
que sí pueden entrar 00:52:02
a ver 00:52:03
Donde están 00:52:06
Aquí, aquí, aquí 00:52:06
Si pongo dos personas que 00:52:11
Pueden entrar 00:52:13
Ahora me dirá que hay dos personas 00:52:15
En la disco 00:52:18
¿Se entiende la diferencia? 00:52:21
O sea, que unes todo depende del objeto 00:52:25
Cada objeto tiene sus copias de cosas 00:52:27
¿Vale? 00:52:29
Paint 00:52:30
Cuando yo hago una cosa no estática 00:52:31
Yo tengo aquí mi edad 00:52:36
Y también mi personas en la disco 00:52:39
¿Sí? 00:52:43
Cuando creo otro, este es uno, cuando creo otro objeto, dos, tengo mi edad y tengo mi persona, se la disco, es una copia distinta, cuando modifico esto, no se modifica esto, porque son dos objetos distintos, ¿sí? 00:52:47
Entonces, cuando yo llamo el método no estático, irá a mirar este valor de aquí, que es 20, y por lo tanto sumará 1 aquí. 00:53:08
Cuando voy aquí y veo que este aquí es 25, me dirá, muy bien, puedes entrar y sumará 1 aquí. 00:53:17
Esto no me va a 2. Cada uno conta por separado. 00:53:23
Sin embargo, todos estos son instancias de una clase. 00:53:28
Si yo hago un persona en la disco estático, esto no depende de ningún objeto. 00:53:32
Y cuando aquí se suma, no depende de este objeto o de este objeto, 00:53:44
sino depende de la clase en general. 00:53:51
Entonces, para completar. 00:53:54
Y si yo quisiera, en este ejemplo de aquí, que cada uno tuviera su edad, o sea, quiero crear personas así, pero luego quiero saber cuántas personas en la disco hay, lo podría hacer. 00:53:57
Sí. ¿Cómo? Pues esta variable de aquí la hago estática, porque de un contexto estático no puedo acceder a un contexto no estático, pero desde un contexto no estático sí puedo acceder a un contexto estático. 00:54:17
entonces ahora en este ejemplo aquí edad es propia del objeto pero personas en 00:54:50
la disco no es propia del objeto es propia de la clase y que cada vez que 00:54:58
yo admito una persona en la disco estoy sumando uno a esta variable estática de 00:55:04
esta clase ahora esto se enfada porque ahora esta persona la disco aquí no la 00:55:11
debería llamar sobre el objeto sino la debería llamar sobre la clase y 00:55:21
entonces ahora también las dos personas que han entrado 00:55:32
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:
10
Fecha:
10 de diciembre de 2024 - 10:38
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
55′ 40″
Relación de aspecto:
16:10 El estándar usado por los portátiles de 15,4" y algunos otros, es ancho como el 16:9.
Resolución:
1152x720 píxeles
Tamaño:
186.06 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid