Saltar navegación

Clases (Modificadores acceso y 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 15 de enero de 2024 por Stefano C.

6 visualizaciones

Más información Transcripción

Descargar la transcripción

voy a grabar esta clase por lo tanto si tenéis si decís algo o preguntáis algo 00:00:00
pues me dais autorización a que se grabe también vale entonces hasta ahora 00:00:06
nosotros hemos visto un poquito unas pinceladas de lo que es la orientación 00:00:11
a objetos 00:00:17
y polimorfismo y cosas por el estilo todavía no los hemos tocado sólo vamos a tocar más adelante 00:00:19
las interfaces etcétera etcétera pero por algún lado tenemos que empezar 00:00:31
estamos viendo sustancialmente la diferencia entre clase objeto ahora 00:00:36
estamos trabajando allí estamos viendo que la clase es un molde es una 00:00:39
generalización de un concepto que estoy modelizando y luego una vez que tengo 00:00:45
este molde tengo esta estructura genérica de cómo tienen que ser las 00:00:51
entidades que pertenecen a esta clase pues la instancio y creo gestos 00:00:56
concretos vale la clase cuadrado medida en general la característica del 00:01:02
cuadrado y las operaciones que puede hacer sobre el cuadrado y luego yo 00:01:07
crearé un cuadrado concreto el cuadrado de lado 4 y sobre ese cuadrado 00:01:10
podré hacer todas las operaciones genéricas que hemos dicho antes 00:01:15
hoy vamos a ver algunos conceptos adicionales siempre sobre el que se 00:01:19
relacionan con el concepto de clases sobre el desarrollo de las clases vale 00:01:25
son varios conceptos vamos viendo uno tras otro y se quedan allí para que 00:01:30
vosotros luego los interior y 6 la primera cosa que vamos a ver es el 00:01:36
famoso método vale nosotros este método lo estamos utilizando desde el 00:01:43
primer día que hemos empezado a programar en ya desde el primer día que 00:01:48
hemos creado un programita pues empezamos con la estructura básica de un 00:01:52
programa en java pusimos esta cosa aquí y dije va a ignorar todo vosotros lo que 00:01:57
vais a hacer es trabajar dentro de este método main y allí ponéis el ejercicio 00:02:02
vale con el tiempo hemos visto que tienen algunas palabras pablo y que 00:02:07
estática voy de cosa por estilo que no suenan cada día más porque estamos 00:02:13
aprendiendo que es hoy es el momento un poquito de entender algo más sobre qué 00:02:18
es este método main que quieren decir las palabras que están por allí etcétera 00:02:25
etcétera método main nosotros hemos visto como el punto de acceso a mi 00:02:29
programa vale siempre el ordenador necesita saber cuál es la primera 00:02:35
instrucción que tiene que ejecutar para luego poder empezar a trabajar ya los 00:02:42
objetos llamar a otros métodos etcétera entonces este método main con este 00:02:46
prototipo es el es un método especial no es un método que tú te puedes inventar 00:02:51
es así porque es una forma de reconocerse tutor todos los otros métodos 00:02:59
llámalos como quieras a los parámetros que quieras pero existe este método 00:03:04
especial que si yo lo encuentro entiendo que es el punto de acceso de la 00:03:10
ejecución es donde empieza mi trabajo hemos visto también que en un programa 00:03:15
complejo donde haya varias clases puede ser que haya varios men sí cada clase 00:03:22
puede tener su men pero hemos visto también que normalmente en mi programa 00:03:30
tendré un men principal un men men que es el que hace trabajar de verdad mi 00:03:35
programa que empieza mi sistema vale y luego puede haber otros men que son más 00:03:43
bien de prueba para decir he hecho una clase quiero probar esa clase que hacer 00:03:48
algunos a ver si está funcionando como tiene que funcionar y por lo tanto me 00:03:52
creo un men la uso de objetos de esa clase 00:03:58
vimos vemos que este men es estático es un método estático si os acordáis 00:04:04
vosotros antes de navidad antes de empezar con orientación objetos cuando 00:04:10
creáis una función o una procedura cuando creáis otro método siempre le 00:04:16
ponéis el estático vale llamaba y desde el método men que era estático otros 00:04:20
métodos que también eran estáticos porque no había objetos vale cuando un 00:04:27
método no depende de ningún objeto pues entonces es estático en general 00:04:32
cuando algo dentro de java no depende de un objeto no es una característica una 00:04:38
tributo de un objeto no es un método propio de un objeto pues entonces es más 00:04:45
propio de la clase entonces es un método estático men el método men es un 00:04:50
método estático porque porque cuando yo pido cuando yo llamo el men cuando yo 00:04:57
empiezo a trabajar con el men todavía no he creado ningún objeto no existen 00:05:01
objetos entonces no tengo un objeto sobre el que llamar el método men no 00:05:06
existiría entonces necesariamente tiene que ser algo que no dependa de la 00:05:10
creación de un objeto si el men no fuera estático yo debería hacer antes 00:05:16
una niu de algo crear un objeto es sobre este objeto llamar el men cosa que no 00:05:21
puede hacer porque sería hacer algo antes del inicio del propio de la propia 00:05:26
del propio programa de hecho es estático se puede buscar su 00:05:31
locación sin necesidad que exista un objeto de esa clase vale 00:05:38
imaginemos que sea mi clase no es obligatorio que una clase tenga un men 00:05:43
vale una clase puede perfectamente vivir 00:05:49
existir sin que tenga un men dentro lo que pasa es que por sí misma no no 00:05:55
podrá hacer nada hasta cuando otra clase con un men creará un objeto de esa 00:06:00
clase lo usará o usará sus métodos estáticos ahora veremos un poquito más 00:06:05
adelante que es estático y que vale pero si yo quiero ejecutar esa clase yo 00:06:11
quiero que esa clase sea ejecutable pues entonces sí que necesito que tenga el 00:06:19
método men otra cosa del método men que no hemos 00:06:25
visto hemos visto relativamente es que el método men tiene un parámetro esta 00:06:30
cosa aquí que al principio escribiréis porque os lo decía yo hoy hoy en día 00:06:36
con vuestros conocimientos podéis empezar a entender qué es esto que es 00:06:42
esto que es string es una red vale es una red que se llama 00:06:47
args que es una red de string args que es args 00:06:54
argumentos parámetros y que es esta cosa aquí esta cosa aquí deriva del hecho 00:07:03
que cuando yo lanzo una clase puedo al momento de lanzarla darle algunos 00:07:11
parámetros en el momento en que la ejecuto 00:07:20
si vosotros habéis utilizado alguna vez el cmd la pantalla negra donde están los 00:07:25
con los comandos y habéis hecho un ping habéis hecho un ping alguna vez en vuestra 00:07:31
vida ping sería la clase sería lo que ejecuto es un programa pero a este 00:07:35
programa le tengo que pasar un parámetro que tengo que decir a quien 00:07:41
hacer el ping o a lo mejor le paso más de un parámetro sabéis que puedo poner 00:07:45
ping menos t y la ip a la que hago el ping estas cosas que añado después del 00:07:49
comando son parámetros que paso son argumentos y en java como funciona esta 00:07:56
cosa imaginábamos que una clase mi clase vale 00:08:04
se ejecutaría que están en el fichero mi clase punto java si se compilaría os 00:08:08
acordáis lo hicimos el uno de las primeras veces con javac mi clase punto 00:08:16
java javac que está por java compiler lo que crearía pillaría mi clase punto 00:08:22
java y crea mi clase punto clas que sería una traducción vale una compilación 00:08:29
desde el lenguaje java que habéis escrito vosotros hacia otro lenguaje 00:08:37
intermedio que es el bytecode que es el que interpreta luego la java virtual 00:08:43
machine como intérprete os acordáis de estas cosas 00:08:48
vale una vez que yo he creado la clase para ejecutar la clase mi clase en este 00:08:53
caso uso el comando java mi clase sin el punto clas vale entonces esto el 00:08:59
comando real es java que es como el que dice mira crea una arranca la java 00:09:05
virtual machine arranca lo que hace falta para ejecutar mi programa y le 00:09:13
pasas como parámetro mi clase que será el punto clas que será un código en 00:09:17
bytecode y el intérprete el java virtual machine empieza a leer este fichero de 00:09:24
aquí y interpretar los comandos que están allí dentro 00:09:29
cada comando lo ejecuta otro comando lo ejecuta otro comando lo interpreta lo 00:09:32
ejecuta sin embargo puedo usar el comando java mi clase y luego poner 00:09:37
cosas detrás separada por un espacio vale por ejemplo en este caso java mi 00:09:47
clase algo tres otra cosa estas cosas de aquí 00:09:53
me las encuentro en ax 00:09:59
o sea que si yo lanzo este comando de aquí y luego dentro del main a cedo 00:10:07
arx de 0 encontraré esto y si acedo a arx de 1 encontraré esto si acedo a arx de 2 00:10:13
encontraré otra cosa 00:10:24
de qué tipo 00:10:29
string o sea que esto es 3 es 3 como string 00:10:32
si luego yo allí quería un número y lo quiero cambiar pues de alguna forma 00:10:39
tendré que transformar este número en este string en un número como pues hay 00:10:45
formas de hacer antes o después 00:10:51
como en eclipse no lanzamos las cosas así hay por algún lado una opción al 00:10:55
ejecutar que me dice oye mira cuando lanzas este programa cuando lanzas este 00:11:01
main pasale estas cosas como argumentos ahora después hacemos una prueba para 00:11:09
ver dónde está y cómo funciona y para qué me sirve esto pues a lo mejor 00:11:15
imaginaos que vosotros hacéis una clase que cuando empieza tiene que cargar un 00:11:20
fichero que está en el sistema operativo con el sistema en falsista me 00:11:25
dejaba por algún lado y que este fichero no siempre tiene que ser mismo vale 00:11:30
dependiendo de lo que haces cargas uno o otro a lo mejor en vez de lanzar ya va mi 00:11:35
clase luego allí dentro y la búsqueda pues a lanzas ya va mi clase y el nombre 00:11:41
del fichero y él sabe que cuando empieza en arx de 0 se encontrará el 00:11:45
nombre del fichero que tiene que ir a mirar 00:11:51
es una forma de pasarle datos a mi programa va a hacerme midad en mi 00:11:54
programa dependiente de un parámetro que se da se proporciona a la hora de 00:12:00
ejecutar el momento en que lanzó el programa le paso estos parámetros al 00:12:08
lado ejemplos son por ejemplo tingo que recibe un parámetro de dónde hacer el 00:12:13
mismo sí entonces esto alguna vez en vuestra vida pues puede ser que sea que 00:12:19
sirva existe está allí y no sirve para entender esta cosa de aquí porque está 00:12:27
aquí y para qué sirve 00:12:35
también esta es una rey yo puedo preguntar 00:12:39
oye cuál es la longitud de arx de arx arx.length si arx.length es igual a cero 00:12:44
quiere decir que no hay parámetros adicionales si arx.length es mayor que 00:12:52
cero que decir que el usuario me ha dado algunos parámetros entonces yo puedo 00:12:59
hacer un programa que si el usuario no me ha dado ningún programa ningún 00:13:03
parámetro ningún argumento a lanzarlo pues haga una cosa y si el usuario me ha 00:13:07
dado algunos argumentos pues interprete estos argumentos mire que hacen esos 00:13:13
argumentos ejecute algo y luego siga con mi programa 00:13:18
¿se entiende? ¿dudas? 00:13:22
cómo se usa después lo veremos 00:13:26
además del método main existe la clase main cuidado no en el sentido que se 00:13:30
tiene que llamar así ¿vale? cuanto que en un programa en un sistema en un conjunto 00:13:37
de clases yo siempre tengo que elegir cuál de estas clases es mi clase 00:13:44
principal la clase principal normalmente es la clase que yo lanzo 00:13:50
la clase que tiene un método main y es el método main que yo lanzo cuando 00:13:56
quiero hacer funcionar mi sistema yo he hecho un sistema de gestión de alumnos 00:14:01
de una escuela ¿vale? y tendrá alumno tendrá escuela tendrá aula tendrá un 00:14:06
montón de clases ¿vale? y a lo mejor cada una de estas clases tiene un main para 00:14:11
probar las funcionalidades alumno tiene un main para probar la funcionalidad del 00:14:16
alumno clase tiene un main para probar las funcionalidades de la clase ¿vale? pero de 00:14:20
todas estas habrá una clase será la clase escuela algo para decir ¿vale? que tiene un 00:14:26
main que cuando lo lanzo no sirve para probar escuela sino que lanza 00:14:33
efectivamente el programa que estoy desarrollando lanza la interfaz para que 00:14:36
yo pueda luego añadir alumnos quitar alumnos me hace el menú de asociar un 00:14:40
alumno con un aula con una asignatura etcétera etcétera los programas que 00:14:45
creamos nosotros esa clase de allí es en un cierto sentido la clase principal 00:14:49
siempre en un sistema debería haber una clase principal para que esta es la que 00:14:53
se lanza para ejecutar ¿si? no tiene por qué llamarse main repito puede llamarse 00:15:00
escuela puede llamarse lo que sea la gama la idea sería que en un cierto sentido 00:15:07
sea fácil de reconocer para que cuando un programador pilla mi código pues sepa 00:15:12
cuál es la clase que tiene que ejecutar ¿si? 00:15:18
vale esto sobre el concepto del método main y lo que es ¿vale? para que si otro 00:15:23
tema de esta clase es el concepto de estático y no estático ¿vale? ya lo hemos 00:15:33
dicho hace tres minutos ya lo hemos dicho también el miércoles si no me equivoco 00:15:39
que salió un poquito pero la idea es tenemos una palabra reservada un 00:15:44
modificador ¿vale? que es la palabra estática esta palabra a veces la hemos 00:15:50
usado a veces no hemos visto si os habéis centrado que todo lo que es 00:15:56
dependiente de objetos no tiene esta palabra todo lo que no depende de un 00:16:01
objeto por sí mismo sino que depende más bien de la clase ¿vale? que puede 00:16:06
funcionar sin crear objetos pues entonces es estático ¿si? 00:16:11
primero si yo no uso la palabra reservada estática lo que estoy haciendo 00:16:18
es que o este esta variable o este atributo o este método se refieren a un 00:16:24
objeto concreto a una instancia de una clase ¿si? no puedo acceder a este 00:16:33
atributo o no puedo ejecutar este método si no hay un objeto concreto 00:16:40
creado antes sobre el que yo pueda acceder o que yo pueda utilizar ¿vale? 00:16:47
entonces un atributo de una clase aparecerá en todas las instancias de 00:16:52
esa clase esto sería si es estático ¿vale? pero cada instancia tendrá un valor 00:16:57
distinto de ese atributo esto es no estático en el sentido cuando yo en la 00:17:05
clase cuadrado digo que es que tiene un lado ¿vale? este lado en todas las 00:17:10
instancias de esa clase aparecerá el atributo lado pero cada objeto tendrá un 00:17:18
valor propio distinto de los otros objetos este valor no es compartido 00:17:25
entre instancias de la clase tendréis cuadrado 1 que tendrá lado 4 y el 00:17:30
cuadrado 2 que tendrá lado 5 ¿vale? el cuadrado 1 tiene lado pero el valor que 00:17:36
tiene dentro es distinto del cuadrado 2 ¿se entiende esto? entonces yo tengo mi 00:17:42
molde cuando lo instancio tengo que mirar todos los atributos que no son 00:17:48
estáticos y darle un valor y esto en un cierto sentido crea el estado de ese 00:17:54
objeto y le da en cierto sentido independencia ¿vale? los valores que tengo 00:17:59
aquí no son los mismos que tiene otro objeto son objetos separados e 00:18:07
independientes si modifico un objeto no afecto el otro ¿si? 00:18:11
un método que no es estático ¿vale? quiere decir que hay que llamarlo sobre 00:18:18
un objeto concreto y usará datos de ese objeto concreto en su ejecución lo 00:18:23
hicimos un ejemplo el miércoles ¿vale? es decir que cuando un método no es 00:18:30
estático quiere decir que depende de un objeto es decir usa atributos y 00:18:35
variables de ese objeto concreto si un método no usa ningún atributo de un 00:18:42
objeto y llamarlo sobre objetos distintos haría exactamente la misma 00:18:49
cosa posiblemente tiene que ser estático si no es estático quiere decir que 00:18:53
depende de la instancia ¿si? también tener en cuenta que cuando estamos en el mundo 00:18:59
no estático todo se referencia al objeto ¿vale? es decir si yo creo un objeto 00:19:06
objeto x es igual a new object ¿vale? un nuevo objeto luego los métodos y los 00:19:16
atributos de este objeto lo llamamos con x punto vete a ese objeto el objeto x y 00:19:23
allí dentro acceda su variable atributo 1 vete al método x y acceda a su método 00:19:30
método 1 con estos parámetros pero siempre es x punto algo lo estoy 00:19:36
llamando sobre el objeto para saber a qué objeto me refiero puesto que estos 00:19:41
dependen del objeto pues tengo que utilizar el objeto mismo si tengo tres 00:19:45
objetos x, y, z pues tendré que elegir a cuáles de estos tres objetos voy a 00:19:50
utilizar para poder acceder a sus variables o acceder a sus métodos ¿se entiende? 00:19:56
¿dudas? 00:20:03
esto es un ejemplo de no estático aquí tenemos rectángulo ¿vale? la clase 00:20:07
rectángulo tiene variables no estáticas largo y ancho tiene 00:20:17
método set data que me permite poner esta cosa aquí no tiene un constructor 00:20:23
por ejemplo en este caso y permite hacer el área fijaos que cuando hago 00:20:28
este es un método ¿vale? el método área lo veo aquí no le paso parámetros ¿por qué? 00:20:36
porque área este es un método que pertenece a este objeto cuando yo lo 00:20:42
llamaré la llamaré sobre un objeto concreto entonces largo y ancho que voy 00:20:47
a utilizar aquí no son parámetros que me pasas tú para calcular el área son el 00:20:53
largo y el ancho de ese rectángulo concreto entonces si lanzo este método 00:20:57
en el rectángulo que tiene 2 y 4 me utilizará 2 y 4 como parámetros si 00:21:05
lanzo este método en el rectángulo que tiene 20 y 30 pues utilizaré 20 y 30 00:21:10
para estos parámetros ¿se entiende? y esto es así cuando yo tengo mi clase 00:21:16
rectángulo área que tiene el main ¿vale? aquí me creo dos rectángulos distintos ¿vale? 00:21:24
excepto los datos los parámetros de rectángulo 1 esto es un método que se 00:21:33
está llamando sobre el objeto rectángulo 1 no toca nada y para nada las variables 00:21:40
de rectángulo 2 y cuando el resultado es rectángulo 1 punto área pues veis que 00:21:45
no le paso ningún parámetro esto que me calculará me irá a rectángulo 1 que 00:21:51
tiene valores 5 y 6 y por lo tanto utilizará dentro del área el valor de 00:21:56
5 y 6 para ancho y largo ¿si? cuando lo hago con rectángulo 2 estoy 00:22:00
haciendo un rectángulo completamente distinto y calculará sobre el otro 00:22:06
distinto fijaos que los métodos como también si 00:22:09
quisiera acceder a sus parámetros a sus atributos se llaman sobre el objeto 00:22:14
sobre este objeto ¿vale? dudas 00:22:20
sin embargo ¿qué pasa cuando en vez utilizamos estática? que antes lo usábamos 00:22:31
sin saber que era y ahora en vez empezamos a entender un poquito que es 00:22:36
¿vale? cuando lo que lo que estoy utilizando sea un 00:22:40
atributo sea una variable sea un método no depende de un objeto es 00:22:49
independiente de la instancia es parte de la clase pero independiente de la 00:22:55
instancia ¿vale? es decir que toda la instancia de esta clase siempre harían 00:23:01
lo mismo independientemente de que su ancho y largo sea distinto o que sus 00:23:08
variables sean distintas pues entonces este método no depende de los objetos 00:23:12
sino es un método estático 00:23:17
tú puedes hacer un atributo estático pero no es un atributo los atributos son 00:23:23
de los objetos entonces cada objeto tiene sus atributos aquí es que tú 00:23:28
estás usando un valor que no es propio de cada objeto sino que por ejemplo es 00:23:33
compartido por todos los objetos 00:23:40
entonces estas las cosas estáticas no dependen del objeto dependen de la 00:23:45
clase ¿vale? a lo mejor son funcionalidades o son valores interesantes para esa clase 00:23:53
¿vale? pero no dependen del objeto en concreto hago un ejemplo a ver si lo 00:23:59
entendemos clase alumno ¿si? nombre el nombre de un alumno es estático o no 00:24:07
estático no estático porque un alumno se llamará de una forma y otro alumno se 00:24:14
llamará de otra forma la edad de un alumno no estático el número de alumnos 00:24:20
que has creado 00:24:28
el número de alumnos que has creado en un cierto momento de la vida de tu 00:24:35
programa has creado hasta aquí siete alumnos eso depende del objeto 00:24:41
si yo creo el objeto 1 objeto 2 objeto 3 y ahora le pregunto al objeto 1 al alumno 00:24:49
1 ¿cuántos alumnos hay? ¿cuánto me dice? 3, ¿al alumno 2? 3, ¿al alumno 3? 3 00:24:55
pues esta información depende del objeto 00:25:06
pues esta información sería estática 00:25:11
no cambia de un objeto a otro y es una información como compartida entre todas 00:25:16
las instancias de la clase todos los instancias de la clase pueden acceder a 00:25:22
cuántos alumnos hay hasta ahora y a lo mejor el alumno 1 cuando se ha creado 00:25:26
él pues era uno solo pero ahora que han creado otros 10 pues él tendrá que 00:25:31
decir hoy mira hay 11 alumnos también 00:25:36
¿si tiene tendencias? 00:25:40
espera, espera que aquí, ok boomer, entras en youtube los videos tendencias 00:25:47
es algo que se comparte por todos los usuarios 00:25:55
¿no? 00:25:57
tú contas con tu novia y te van a salir los videos 00:25:59
pero yo me van a salir los mismos 00:26:01
es algo que 00:26:03
bueno, es un momento de sábado 00:26:05
mira, a un nivel muy abstracto quizás 00:26:07
quizás 00:26:11
a un nivel lo práctico hay que ver cómo está hecho 00:26:13
¿vale? 00:26:15
pero la idea podría ser eso 00:26:17
podría ser 00:26:21
asumiendo que 00:26:23
porque yo creo que eso también no son lo mismo para todos 00:26:25
esos son los mismos para todos 00:26:27
los que tengan los mismos intereses 00:26:29
pero a mí me va a dar 00:26:31
los videos tendencia 00:26:33
los intereses míos hacia otros 00:26:36
y eso depende de un atributo mío personal 00:26:38
pero bueno 00:26:40
no lo sé 00:26:42
si hay algo 00:26:44
a ver para youtube 00:26:46
si lo pillas 00:26:50
considerando que no es programación 00:26:52
pero para hacer un ejemplo 00:26:54
si yo dijera que 00:26:56
youtube funciona con unos cuantos videos 00:26:58
te lo aconsejo en base a tus cosas 00:27:00
y unos cuantos videos son los mismos 00:27:02
para todos 00:27:04
pues eso de allí podría ser estático 00:27:06
en un cierto sentido 00:27:08
¿sí? 00:27:10
si tú lo piensas 00:27:22
como documento 00:27:24
DNI 00:27:26
a lo mejor 00:27:28
pero si lo piensas como tu DNI 00:27:30
pues tú tienes tu nacionalidad 00:27:33
tendrás España 00:27:35
porque tu atributo nacionalidad 00:27:37
es español 00:27:39
pero si mañana cambias nacionalidad 00:27:41
tú cambias eso 00:27:43
depende de ti 00:27:45
sobre nacionalidad 00:27:47
si considerásemos 00:27:53
no al usuario 00:27:55
sino al documento por sí mismo 00:27:57
como una clase 00:27:59
no como DNI 00:28:01
sino como DNI Español 00:28:03
pero sería también final 00:28:11
no cambias 00:28:13
no es una variable 00:28:15
es una constante 00:28:17
si lo piensas así 00:28:19
¿sí? 00:28:21
hay un ejemplo aquí 00:28:23
ahora lo vemos 00:28:25
¿vale? 00:28:27
una variable estática tendrá 00:28:30
el mismo valor para cualquier objeto 00:28:32
que la use 00:28:34
no depende del objeto sino de la clase 00:28:36
es en un cierto sentido una variable global 00:28:38
yo ponga allí un valor 00:28:40
este valor puede cambiar 00:28:42
pero si cambia, cambia para todos 00:28:44
¿sí? 00:28:46
como las leyes 00:28:48
las leyes son estáticas 00:28:52
sí 00:28:56
es complejo 00:28:58
sacarme del mundo informal 00:29:00
y hacer analogías de ese estilo 00:29:02
puede ser peligroso 00:29:04
a lo mejor hay cosas 00:29:06
luego no estoy seguro 00:29:08
si es para todos igual 00:29:10
un método estático no se llama 00:29:12
sobre un objeto sino sobre la clase 00:29:14
esto es importante 00:29:16
cuando el método no es estático 00:29:18
se hace referencia a un objeto 00:29:20
¿vale? aquí 00:29:22
rec2.setData 00:29:24
rec2.area 00:29:26
mientras que si 00:29:28
quiero 00:29:30
si tengo un método estático 00:29:32
pues lo llamo sobre la clase 00:29:34
nosotros hemos usado el otro día 00:29:36
math.random 00:29:38
¿os acordáis? 00:29:40
math no es un objeto 00:29:42
es la clase math 00:29:44
entonces random es un método estático 00:29:46
¿por qué es un método estático? 00:29:48
porque es un método que devuelve 00:29:50
un número entre 0 y 0,9 periódico 00:29:52
entonces que lo llame sobre un objeto 00:29:54
o sobre otro 00:29:56
siempre hará lo mismo 00:29:58
darte un número aleatorio entre 0 y 0,9 00:30:00
no depende del objeto sobre el que lo llame 00:30:02
¿si? por lo tanto es estático 00:30:04
la clase tiene un atributo 00:30:18
que es el número de alumnos 00:30:20
¿el alumno tendría ese atributo también? 00:30:22
no lo tiene el alumno 00:30:24
lo tiene la clase 00:30:26
pero cuando tú tienes un alumno 00:30:34
creas los atributos de ese alumno 00:30:36
no los estáticos 00:30:38
vamos a hacer 00:30:46
esta clase es estática 00:30:48
donde tiene 00:30:50
static e int 00:30:52
operaciones hechas 00:30:54
este señor de aquí 00:30:56
no es un 00:30:58
atributo 00:31:00
de un objeto 00:31:02
es un atributo 00:31:04
es una variable que depende 00:31:06
de esta clase, es estático 00:31:08
me cuenta cuantas operaciones 00:31:10
han sido hechas 00:31:12
al principio hay 0 00:31:14
quien tiene esta 00:31:16
información, ¿la tiene un objeto? 00:31:18
la tiene la clase 00:31:22
¿cada objeto puede acceder a esta 00:31:24
cosa? si 00:31:26
y todos verán la misma 00:31:28
y si un objeto la modifica 00:31:30
todos los demás verán la modificación 00:31:32
es un objeto, es una variable 00:31:34
compartida entre todas las instancias 00:31:36
mientras que 00:31:38
una variable 00:31:40
de un objeto, un atributo de un objeto 00:31:42
se lo modifica, los otros 00:31:44
objetos no se ven afectados 00:31:46
son independientes, este de aquí 00:31:48
es una variable que vale para todos 00:31:50
una variable de clase 00:31:52
no una variable de objeto 00:31:54
no lo entiendo 00:32:08
esto puede cambiar 00:32:10
pues entonces 00:32:13
no es estático 00:32:15
si tu en tu programa 00:32:23
te das cuenta que has creado una operación 00:32:25
estática y luego te das cuenta que 00:32:27
eso depende de los objetos 00:32:29
pues entonces has hecho un error de diseño 00:32:31
porque eso no es una variable de clase 00:32:33
si distintos 00:32:35
objetos tienen valores distintos 00:32:37
pues entonces quiere decir que 00:32:39
no es de clase 00:32:41
será de un grupo 00:32:43
tendrá 3 y un grupo tendrá 4 00:32:45
entonces allí luego hay técnicas 00:32:47
para esta, dividirla en 2 00:32:49
subclase 00:32:51
clase estática 1 y clase estática 2 00:32:53
y estos comparten 00:32:55
una y estos comparten otra 00:32:57
pero eso ya con herencia 00:32:59
operaciones, esta clase estática 00:33:05
aquí tiene 2 tipos 00:33:07
de operaciones 00:33:09
tiene el método estático 00:33:11
calcular a rectángulo 00:33:13
fijaos 00:33:15
de que rectángulo 00:33:17
tengo aquí objetos rectángulos 00:33:19
no, entonces como lo hago esto de aquí 00:33:21
pues le paso directamente 00:33:23
los valores 00:33:25
te digo, mira, aquí habrá 00:33:27
cuando te pido 00:33:29
calcularlo a un rectángulo 00:33:31
te paso el largo y el ancho del rectángulo 00:33:33
fenomenal 00:33:35
esto 00:33:37
hace que independientemente 00:33:39
de que objeto llame 00:33:41
este método de aquí 00:33:43
no es que yo voy a mirar los atributos de este objeto 00:33:45
y entonces objetos distintos 00:33:47
hacen cosas distintas 00:33:49
no, te voy a pasar parámetros 00:33:51
directamente y por lo tanto 00:33:53
que lo haga un objeto, lo haga otro 00:33:55
no depende del objeto 00:33:57
depende de los parámetros 00:33:59
que le paso aquí 00:34:01
se entiende eso 00:34:03
entonces este de aquí 00:34:05
es desvinculado de las 00:34:07
de las instancias 00:34:09
de esta clase 00:34:11
y que hace esta operación 00:34:13
pues lo mismo que antes 00:34:15
calcula esta cosa aquí 00:34:17
y luego soma uno 00:34:19
a las operaciones hechas 00:34:21
antes no tenía 00:34:23
una variable estática 00:34:25
antes cada rectángulo 00:34:29
al máximo podía tener 00:34:31
una variable suya 00:34:33
diciendo 00:34:35
cuantas operaciones han hecho sobre de mi 00:34:37
esto de aquí 00:34:43
es cualquier 00:34:45
operación de esta que se haga 00:34:47
quien lo haga 00:34:49
pues suma uno a estas operaciones hechas 00:34:51
entonces en un determinado momento yo puedo acceder 00:34:53
a esta variable y ver cuantas operaciones 00:34:55
se han hecho, quien la ha hecho no lo se 00:34:57
pero si que se han hecho 66 00:34:59
operaciones en esta ejecución 00:35:01
está claro que si apago 00:35:03
y empiezo otra vez 00:35:05
pues esto será reseteado a cero 00:35:07
si la persistencia de datos 00:35:11
entre una ejecución y otra la veremos más adelante 00:35:13
que es escribir en ficheros 00:35:15
y tengo también otra 00:35:19
otro método estático 00:35:21
que es calcula perímetro rectángulo 00:35:23
que me da siempre el ancho 00:35:25
y el largo, me calcula el perímetro 00:35:27
esta también es una operación 00:35:29
suma uno a las operaciones 00:35:31
entonces luego que hago 00:35:33
como se usa esto 00:35:37
pues si aquí tengo un main 00:35:39
me imagino 00:35:41
dos rectángulos, el rectángulo uno 00:35:43
que está de 3 y 6, uno es 3 00:35:45
que son los mismos, este sería el rectángulo 2 00:35:47
son los mismos valores 00:35:49
que le daba antes 00:35:51
como calculo el área del rectángulo 00:35:53
pues haciendo 00:35:55
la operación estática punto 00:35:57
calcula rectángulo de 3,6 00:35:59
este es el método 00:36:03
estos son los parámetros de rectángulo 00:36:05
que me he imaginado yo 00:36:07
cuidado, no hay un objeto rectángulo aquí 00:36:09
no he hecho por ningún lado 00:36:11
y lo que hace 00:36:13
es llamarlo sobre la clase 00:36:15
no sobre una instancia 00:36:17
como lo veo esto fácilmente 00:36:19
porque empieza por mayúsculo 00:36:21
entonces es una clase 00:36:23
más punto random 00:36:25
más la M mayúscula 00:36:27
son las 00:36:29
dudas? 00:36:31
si no le das estos dos 00:36:41
si yo te pongo calcular 00:36:49
rectángulo de 4 00:36:51
no existe este método 00:36:53
a menos que yo 00:36:55
no sobrecargue el método 00:36:57
arriba y cree también 00:36:59
un método como este de aquí 00:37:01
que solo recibe un int 00:37:03
que es ancho y largo 00:37:05
que es para calcular cuadrados 00:37:07
y entonces si que me volvería a funcionar 00:37:09
fijaos que yo me calculo 00:37:17
el área del rectángulo 00:37:19
otro rectángulo distinto 00:37:21
luego el perímetro de otra cosa 00:37:23
y luego al final digo 00:37:25
he hecho clase estática 00:37:27
punto operaciones hechas 00:37:29
operaciones, que me escribirá esto? 00:37:31
cuanto vale esto? 00:37:35
tres 00:37:43
por cada una de estas operaciones 00:37:45
me habrá sumado uno 00:37:47
de los tres 00:37:49
fijaos que acedo 00:37:51
a una variable 00:37:53
de la clase 00:37:55
no de un objeto 00:37:57
entonces 00:37:59
cuando estoy en ámbito estático 00:38:01
trabajo con las clases 00:38:03
cuando estoy en ámbito no estático 00:38:05
trabajo con instancias 00:38:07
de la clase 00:38:09
los métodos 00:38:11
y los atributos 00:38:13
digamos así, las variables 00:38:15
no estáticas 00:38:17
la llamo sobre una clase 00:38:19
los métodos y atributos 00:38:21
no estáticos 00:38:23
lo llamo sobre un objeto 00:38:25
dudas? 00:38:29
preguntas? 00:38:31
todo lo que no es estático 00:38:33
es propio del objeto 00:38:35
cambia entre objetos 00:38:37
y no se interfiere 00:38:39
uno con otro 00:38:41
son independientes 00:38:43
estático depende de la clase 00:38:45
y varias instancias 00:38:47
que miran, pues mirarían 00:38:49
la misma cosa 00:38:51
es compartida entre instancias 00:38:53
dudas? 00:38:57
y la pregunta es 00:39:03
pero una clase puede ser o estática 00:39:05
o no estática 00:39:07
no se mezclan las cosas 00:39:09
se puede mezclar 00:39:11
estático y estático 00:39:13
¿habéis mezclado alguna vez 00:39:15
estático y estático? 00:39:17
¿todas las veces que habéis hecho un objeto 00:39:23
y luego has hecho un main, el main es estático? 00:39:25
entonces sí 00:39:27
se puede mezclar 00:39:29
cosas 00:39:31
estática y no estática 00:39:33
pueden coexistir 00:39:35
yo me puedo hacer la clase 00:39:37
rectángulo 00:39:39
todos los rectángulos tienen un ancho 00:39:41
y todos los rectángulos tienen un largo 00:39:43
pero la clase rectángulo 00:39:45
tiene una variable estática 00:39:47
que es cuántos rectángulos 00:39:49
se han creado 00:39:51
entonces cada vez 00:39:53
que yo 00:39:55
ejecuto 00:39:57
un constructor 00:39:59
de rectángulo al que le paso 00:40:01
los parámetros 00:40:03
lo que hago es asignar 00:40:05
siempre hemos hecho los valores 00:40:07
a los atributos 00:40:09
pero además la variable estática 00:40:11
esa de arriba 00:40:13
más más 00:40:15
¿sí? 00:40:17
entonces cuando llamo el área 00:40:19
hago el ancho por largo 00:40:21
y luego 00:40:23
public static int 00:40:25
total rectángulos creados 00:40:27
me hago un método estático 00:40:29
que lo que hace es 00:40:31
devolverme cuántos rectángulos 00:40:33
se han creado 00:40:35
¿sí? 00:40:37
entonces cuando luego haré un main 00:40:39
que usa esta clase de aquí 00:40:41
habrá algunos métodos 00:40:43
que lo llamaré sobre instancia 00:40:45
de rectángulo, haré new rectángulo 00:40:47
y luego sobre este objeto creado 00:40:49
por ejemplo calcularé el área 00:40:51
o puedo preguntarle el largo 00:40:53
y habrá otras cosas que en vez 00:40:55
la llamo sobre 00:40:57
sobre la 00:41:01
¿sí? 00:41:03
¿entiende? 00:41:05
ahora luego haremos esto 00:41:07
hacemos un ejemplo 00:41:09
pero la idea 00:41:11
es esta de aquí 00:41:13
estas son como variables 00:41:15
compartidas que no dependen 00:41:17
de la instancia del objeto 00:41:19
y que todos los objetos pueden ver 00:41:21
¿vale? 00:41:23
en un cierto sentido 00:41:25
no sé si quería decir 00:41:27
algo más sobre esto 00:41:29
¿vale? 00:41:33
vale 00:41:41
vale 00:41:45
hagamos una cosa 00:41:49
Subido por:
Stefano C.
Licencia:
Reconocimiento
Visualizaciones:
6
Fecha:
15 de enero de 2024 - 11:51
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
41′ 54″
Relación de aspecto:
4:3 Hasta 2009 fue el estándar utilizado en la televisión PAL; muchas pantallas de ordenador y televisores usan este estándar, erróneamente llamado cuadrado, cuando en la realidad es rectangular o wide.
Resolución:
960x720 píxeles
Tamaño:
116.30 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid