Saltar navegación

prog2324 Objetos y clases 2 - 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 20 de diciembre de 2023 por Stefano C.

8 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, voy a grabar, por lo tanto, si habláis, me estáis autorizando. 00:00:00
Entonces, hemos hablado de clase, hemos dicho que la clase es un molde, ¿vale? 00:00:05
Es un molde para crear objetos. 00:00:10
Una sola clase, que es una abstracción, es una generalización de muchos objetos 00:00:12
que puedo crear. 00:00:18
A partir de una clase puedo crear muchas instancias distintas, 00:00:19
todas tendrán la misma estructura, pero cada uno tendrá valores distintos, 00:00:23
parecidos o mezclados, pues da igual, son entidades separadas que se llamarán objetos, ¿vale? 00:00:28
Cada objeto es una instancia, cada objeto es un trozo de memoria separado, ¿vale? 00:00:36
Los objetos no tienen que ver nada uno con otro, pertenecen todos a la misma clase, 00:00:41
la clase es única, los objetos son instancias distintas. 00:00:46
¿Se entiende esto? 00:00:50
¿Sí? 00:00:51
Vale. 00:00:52
Entonces un objeto es un elemento concreto de la clase definida, 00:00:53
una instancia de la clase, como se suele decir, ¿vale? 00:00:56
Cuando se habla de instancia, es que yo tengo mi molde, he pillado la arena, 00:00:59
la he puesto dentro del molde, la he puesto allí y me ha salido la figurita del elefante. 00:01:04
Vale, fenomenal. 00:01:08
Ahora ya tengo un elefante. 00:01:09
Ahora hago otro elefante al lado, tengo dos elefantes, he usado el mismo molde, 00:01:10
pero tengo dos elefantes distintos. 00:01:16
Y si modifico uno de los dos elefantes, el otro elefante se queda como ha estado antes. 00:01:18
¿Se entiende? 00:01:23
¿Puedes tener dos elefantes iguales? 00:01:25
Como yo puedo llamarme Estefano Quieres, puede haber otra persona que se llame Estefano Quieres. 00:01:29
Ahora, lo natural y lo obvio, estas son dos personas distintas, 00:01:32
si viene otra persona que se llama Estefano Quieres aquí, 00:01:37
posiblemente notáis que somos dos personas distintas, 00:01:39
no hay que decir, de repente son iguales. 00:01:42
Probablemente tú como programador quieres poderlos diferenciar 00:01:44
y es por eso que tenemos los identificadores. 00:01:50
Tú le dices, además de nombre y apellido, le pongo también el DNI 00:01:53
y entonces sé que Estefano Quieres con DNI1 no es el mismo objeto persona 00:01:58
de Estefano Quieres con DNI2. 00:02:03
Pero ahí también no es tan fácil, 00:02:07
porque tú deberías tener un método, una forma concreta y compleja 00:02:09
de verificar que si alguien intenta crear otro Estefano Quieres con DNI1, 00:02:17
debería decir, no, no puedes. 00:02:23
Y esto lo tienes que programar tú, 00:02:24
porque el fichero por sí mismo te permite crear. 00:02:26
O sea, el identificador por sí mismo no es único, 00:02:28
tienes que garantizar tú que sea único. 00:02:31
¿Cómo? Construyendo una base de datos 00:02:34
y todas las personas que crean la guardas en esa base de datos 00:02:36
y cada vez que creas una nueva te vas a esa base de datos 00:02:40
y le dices, ¿existe ya? No, pues entonces lo creo. 00:02:42
¿Existe ya? Sí, pues entonces no lo creo. 00:02:44
¿Sí? O un fichero o un... 00:02:46
En el momento de la ejecución se crean los objetos de la clase 00:02:51
para los cuales hemos escrito código. 00:02:55
Cada objeto tendrá un nombre para poder utilizarlos en nuestro programa. 00:02:57
No un nombre entendido como atributo nombre, 00:03:02
sino un identificador, ¿vale? 00:03:04
En particular, un objeto va a tener una identidad, 00:03:06
es decir, tengo que tener algo para distinguir los dos elefantes que he hecho, 00:03:10
esto lo llamo elefante 1, esto lo llamo elefante 2, 00:03:16
y ahora ya puedo distinguirlos a nivel de programación, 00:03:19
o esta es la variable A y esta es la variable B 00:03:22
y son dos personas distintas, 00:03:25
o esta es una raíz de personas y en cada celda de las personas 00:03:26
pongo una persona distinta, 00:03:29
algo para identificarlos, 00:03:33
los atributos que constituyen el estado de un objeto, ¿vale? 00:03:35
Un objeto tendrá sus 3, 4, 7, 29 variables que lo definen. 00:03:41
Nombre, apellido, edad, ¿vale? 00:03:46
En cada momento yo puedo hacer una foto a este objeto 00:03:48
y definir su estado. 00:03:54
Su estado es los valores en este momento de todos sus atributos. 00:03:56
En este momento hago una foto a la persona Stephano Chiesa, 00:04:05
pues su estado es Stephano Chiesa 18. 00:04:11
Mañana cumple los años, cumple 19, 00:04:16
pues entonces su estado se ha modificado en Stephano Chiesa 19. 00:04:19
Cada objeto tendrá su estado. 00:04:26
Si yo cumplo los años, es que las otras personas cumplen años también. 00:04:30
Solo aquellos objetos que ejecutan él, 00:04:35
hoy es mi cumpleaños, pues lo que harán es pillar edad y sumarle 1. 00:04:39
¿Vale? 00:04:46
Y también tienes unos métodos, que son los métodos definidos por la clase, 00:04:47
que definen el comportamiento de este objeto, 00:04:51
lo que puede hacer este objeto. 00:04:54
Si no tengo un método que me hace cumplir los años, 00:04:56
pues mi objeto no puede cumplir años. 00:05:00
¿Se entiende, no? 00:05:05
¿Ya? 00:05:07
La identidad, ¿vale? 00:05:13
Profundizando cada una de estas cosas. 00:05:14
Pues los objetos se crean en la memoria RAM. 00:05:16
Yo tengo un espacio en la memoria RAM 00:05:18
cuando lanzo el proceso de la Java Virtual Machine, 00:05:20
que es el intérprete de Java, 00:05:24
pues ese se crea un espacio dentro de este espacio de la RAM, 00:05:26
que lo solicita al sistema operativo. 00:05:30
El sistema operativo dice, yo necesito ejecutarme, 00:05:32
tómate estos megas, ¿vale? 00:05:35
Ok, estos son mis megas donde puedo trabajar. 00:05:38
Una parte de este espacio de aquí, que la llamará el heap, 00:05:40
¿vale? 00:05:44
Es la zona donde voy a crear los objetos. 00:05:45
Si mi programa me dice crear objetos, 00:05:47
los voy a meter allí dentro. 00:05:49
Tengo este espacio y voy a crear objetos. 00:05:51
¿Es infinito? No, porque la RAM no es infinita. 00:05:53
¿Vale? 00:05:55
Toda memoria, pues si me pongo aquí con un while true a crear objetos, 00:05:56
antes o después explota. 00:06:00
Su identidad se definirá con un valor de referencia único del objeto. 00:06:03
¿Os acordáis cuando yo os decía, hablando de los arrays, 00:06:07
que cuando yo creaba el array X dentro de la variable X 00:06:12
no había el array por sí mismo, 00:06:17
sino una referencia donde está el array? 00:06:20
Pues es esta referencia. 00:06:24
Cuando yo creo el objeto, 00:06:27
la Java Machine arranca y pilla un trozo de RAM. 00:06:36
¿Vale? 00:06:40
Este es el trozo donde puedo hacer las cosas. 00:06:41
Un trozo de esta RAM será el heap. 00:06:43
Y aquí es donde se crean los objetos. 00:06:54
Me dicen, oye mira, créate un nuevo objeto. 00:06:56
Vale, entonces aquí yo crearé un objeto. 00:06:58
Este es mi objeto persona que tiene dentro su nombre, 00:07:00
su apellido y su edad. 00:07:04
¿Vale? 00:07:06
Si creo un nuevo objeto, tendré un nuevo objeto con nombre, 00:07:07
apellido y edad. 00:07:11
¿Vale? 00:07:13
Y cada uno de estos de aquí será referenciado con una posición 00:07:14
en esta memoria. 00:07:20
Digamos así, no es exactamente así en Java, 00:07:21
pero para entendernos. 00:07:23
Y aquí por algún lado donde tendré mi variable persona1 00:07:26
y mi variable persona2, 00:07:30
pues aquí dentro lo que tengo es un puntero a este punto de aquí 00:07:32
y aquí un puntero, una referencia a este punto de aquí. 00:07:37
¿Vale? 00:07:45
Parecido a lo que era con los arrays. 00:07:46
Porque el array no es objeto. 00:07:48
String también es un objeto. 00:07:50
String funciona así, más o menos. 00:07:52
String es especial. 00:07:55
¿Sí? 00:07:57
Vale. 00:07:58
En Java no se trabaja directamente con direcciones de memoria, 00:08:01
sino con un concepto un poquito más abstrato, 00:08:04
que son los nombres simbólicos. 00:08:06
O sea, cuando tú programas en Java, 00:08:08
no vas a referirte al objeto diciendo, 00:08:10
oye, este es el objeto arroba579342. 00:08:13
Vale, vete a esa posición de memoria. 00:08:17
Pues tú le darás un nombre, le das el nombre persona1, 00:08:19
y trabajas con persona1. 00:08:22
Porque queremos un nivel de abstracción más abstrato. 00:08:24
No queremos ir a mirar la memoria dentro. 00:08:26
Quiero que la Java Virtual Machine me esconda todas estas cosas 00:08:29
para que yo sea más libre de pensar a mi problema 00:08:32
y no a los problemas técnicos de dónde está la memoria. 00:08:35
En otros lenguajes de programación, que son más a bajo nivel, 00:08:38
pues a lo mejor puedes ir a trabajar con los espacios de memoria directamente, 00:08:42
con las posiciones de memoria. 00:08:46
Tienes más control sobre lo que pasa, 00:08:48
porque puedes decidir qué hacer con la memoria literalmente, 00:08:52
pero claramente es mucho más complejo hacer cosas grandes. 00:08:56
Porque tienes que... 00:09:00
Es como... 00:09:02
¿Habéis jugado alguna vez algún juego? 00:09:04
Esto de micromanagement, 00:09:06
en el que todas las cosas que tienes que hacer tienen su opción 00:09:08
y tú tienes que controlar absolutamente todo 00:09:12
y llega un momento que mata 00:09:14
porque te ganan, 00:09:16
porque se te ha olvidado activar el no sé qué... 00:09:20
Pues es eso. 00:09:22
La diferencia entre decir 00:09:24
ataca y todo mi ejército va atacando 00:09:25
y te atropelamos aquí, te atropelamos aquí... 00:09:27
Pues es lo mismo. 00:09:29
Un objeto es un valor que se puede asignar a una variable 00:09:35
cuyo tipo es la clase. 00:09:39
La clase define el tipo, 00:09:41
el objeto es un valor específico de este tipo. 00:09:43
Es decir, 00:09:46
un objeto con pinzas 00:09:48
es un literal. 00:09:52
¿Sí? 00:09:55
¿Acordáis los int? 00:09:56
Yo tenía tres, 00:09:58
es un literal de tipo int. 00:10:00
¿Sí? 00:10:02
True es un literal de tipo boolean. 00:10:03
Un objeto... 00:10:06
Estefano pieza con la edad que tiene... 00:10:08
Pues es un literal de tipo persona. 00:10:10
La clase define un nuevo tipo. 00:10:18
Los objetos son valores de ese tipo. 00:10:25
No exactamente, sería el conjunto de actividad. 00:10:32
Porque el objeto es todo, 00:10:35
es un bloque. 00:10:37
¿Sí? 00:10:39
Tú estás definiendo un nuevo tipo 00:10:40
que no es un tipo primitivo, no es un int. 00:10:42
Porque una persona no es un int, 00:10:44
una persona es string string int. 00:10:47
Y este tipo nuevo que estoy creando, 00:10:50
que representa una persona, lo llamo tipo persona. 00:10:53
Las clases definen tipos. 00:10:57
De hecho, lo sabéis, 00:11:00
porque vosotros sabéis que string x es igual a gato. 00:11:02
Y cuando ponéis string x, 00:11:06
¿qué variable es? 00:11:08
La variable x de tipo string. 00:11:11
Y string no es una clase. 00:11:14
Pues sí, es una clase, porque es ese mayúsculo. 00:11:17
Entonces, lo habéis hecho. 00:11:20
Ahora nosotros hacemos persona. 00:11:22
Persona1 es igual a un objeto persona. 00:11:24
¿Sí? Y lo vemos en un minuto. 00:11:28
Si queremos crear un objeto tipo persona, 00:11:32
le daremos un identificador 00:11:34
para poder trabajar con él. 00:11:36
Bueno, aquí, ¿vale? 00:11:38
A esto. 00:11:40
Estoy creando una nueva variable. 00:11:43
¿Cuál es el tipo de alumno? 00:11:45
Persona. 00:11:47
¿Qué quiere decir? 00:11:48
Que un alumno es de tipo persona 00:11:49
que seguirá la estructura definida en la clase persona. 00:11:51
Es un objeto de la clase persona. 00:11:55
Cuidado, aquí todavía no hay objetos. 00:11:58
Esto es como cuando hacía int x. 00:12:00
¿Qué valor tiene x? 00:12:03
No está todavía el valor de x. 00:12:05
Pero he definido que existirá. 00:12:07
Esta es una variable 00:12:09
que contendrá un valor de tipo persona. 00:12:12
O sea que aquí dentro tiene que ir un objeto. 00:12:15
No puede hacer persona alumno es igual a 3. 00:12:17
Porque 3 no es tipo persona. 00:12:20
Es tipo int. 00:12:22
Atributos. 00:12:32
Son las características que definen un objeto. 00:12:33
Cada atributo tiene una visibilidad, 00:12:36
un tipo y un identificador del atributo. 00:12:39
¿Qué son estos? 00:12:42
La visibilidad es esto de public, private, 00:12:44
protected y lo que sea. 00:12:46
Lo veremos. 00:12:48
Por ahora son public. 00:12:50
Tiene un tipo, 00:12:52
que puede ser un tipo primitivo, 00:12:54
como antes que he hecho que mi atributo 00:12:56
era int edad. 00:12:58
O una clase, como cuando hacía string. 00:13:00
Hemos dicho que a una persona 00:13:03
yo le puedo dar una casa o un coche. 00:13:05
Yo puedo ponerle como atributo 00:13:07
Aquí. 00:13:09
Como atributo a una persona 00:13:13
le puedo poner public 00:13:15
coche con la C mayúscula 00:13:17
mi coche. 00:13:19
Y ahora lo que pasa es que una persona 00:13:21
tiene como atributo 00:13:23
un objeto de tipo coche. 00:13:25
Ahora lo hacemos. 00:13:29
O sea con ejemplos. 00:13:31
Y el nombre de este atributo. 00:13:34
Dentro de mi clase este atributo 00:13:36
se llamará edad. 00:13:38
Se llamará mi coche. 00:13:40
Se llamará segundo coche. 00:13:42
¿Qué sé yo? 00:13:44
Por ejemplo una persona 00:13:46
tiene nombre edad como atributo. 00:13:48
Por lo tanto el nombre 00:13:50
de tipo string es una clase 00:13:52
y el edad es un tipo int 00:13:54
es un tipo primitivo. 00:13:56
El estado de un objeto 00:14:00
está definido por los valores 00:14:03
de sus atributos en un momento concreto. 00:14:05
Hago una foto ahora 00:14:07
y veo cuál es 00:14:09
el nombre en este momento 00:14:11
y cuál es la edad en este momento 00:14:13
este es el estado de este objeto en este momento. 00:14:15
¿Puede variar? Sí, si yo quiero. 00:14:17
Si yo hago métodos 00:14:19
que puedan variar su edad como cumplir los años 00:14:21
pues su estado puede cambiar. 00:14:23
Ahora tiene 18 años 00:14:25
cumple edad, pues ahora tiene 19. 00:14:27
Ha cambiado su estado. 00:14:29
El estado puede variar a cambiar los valores 00:14:31
de los atributos. 00:14:33
Dudas hasta aquí. 00:14:35
Y luego están los métodos. 00:14:39
Identificación, atributos y métodos. 00:14:41
Los métodos son 00:14:43
es el contrato que 00:14:45
los objetos proporcionan 00:14:47
servicios a otros objetos. 00:14:49
Yo soy el objeto persona 00:14:51
y tengo mis métodos. ¿Qué son mis métodos? 00:14:53
Son los métodos saludar 00:14:55
y los métodos cumplir años. 00:14:57
Estos son servicios que otros pueden pedir 00:15:00
a mi como objeto 00:15:02
para que yo lo haga. 00:15:04
Si alguien pide a mi 00:15:06
como objeto, oye, saluda 00:15:08
pues yo escribiré 00:15:10
Hola, me llamo Estefano 00:15:12
y si alguien pide a mi como objeto 00:15:14
el cumpleaños 00:15:16
pues yo actualizaré mi estado 00:15:18
añadiendo uno a la edad. 00:15:20
Estos son servicios 00:15:22
a disposición de quien quiera 00:15:24
y quien quiera utilizarlos puede acceder a mis servicios 00:15:26
es decir, haz esto, y yo lo hago. 00:15:29
¿Cómo? 00:15:33
Un método suele tener 00:15:37
un nombre 00:15:39
como antes creábamos las funciones 00:15:41
le dábamos cálcula media 00:15:43
unos parámetros 00:15:45
los parámetros que poníamos entre paréntesis 00:15:47
que pero pueden no estar 00:15:49
saluda, por ejemplo 00:15:51
puede no tener parámetros 00:15:53
y lo que devuelve 00:15:56
o sea, yo hago todo el trabajo 00:15:58
y al final del trabajo, ¿qué hago? 00:16:00
te devuelvo algo 00:16:02
o no 00:16:04
lo que ya antes se llamaba función o procedimiento 00:16:06
pues ahora se llama método 00:16:08
y puede devolver algo o no 00:16:10
es igual a antes 00:16:12
porque nosotros hemos hecho eso 00:16:14
hemos impropiamente utilizado los métodos 00:16:16
como función y procedimiento 00:16:18
pero eran métodos antes también 00:16:20
Es importante saber 00:16:22
qué método implementa una clase 00:16:24
qué parámetros tienen los métodos 00:16:26
y qué devuelven 00:16:28
para que otros programas puedan utilizar esos métodos 00:16:30
es decir, que yo cuando 00:16:32
pillo la clase Persona 00:16:34
me la voy a leer y digo 00:16:36
¿qué puede hacer Persona? 00:16:38
pues tiene sus atributos, puede hacer esto, esto, esto 00:16:40
vale, ahora sé utilizarla 00:16:42
si no sé qué métodos están implementados 00:16:44
pues no puedo utilizar propiamente una clase 00:16:46
Cuidado, no es importante 00:16:48
cómo se hacen las cosas 00:16:50
sino lo que se puede hacer 00:16:53
a mí, como programador 00:16:55
me interesa de la clase Persona saber 00:16:57
que puede saludar 00:16:59
y que puede cumplir años 00:17:01
con estos dos, me vale 00:17:03
quien ha hecho esa clase 00:17:05
probablemente sabrá 00:17:07
cómo se hacen esas cosas 00:17:09
la habrá implementado él 00:17:11
pero a mí no me interesa saber cómo 00:17:13
me interesa utilizar su clase 00:17:15
y utilizarla 00:17:17
cuando vosotros utilizáis Println 00:17:19
System.8.Println 00:17:22
Println es un método 00:17:24
vosotros, ¿sabéis cómo se hace? 00:17:26
¿sabéis cómo se escribe en pantalla? 00:17:28
¿qué hace por detrás 00:17:30
para que aparezcan 00:17:32
vuestras letras en la pantalla 00:17:34
en la consola? 00:17:36
no, pero a vosotros os interesa saber 00:17:38
que existe Println para poder escribir en consola 00:17:40
¿sí? 00:17:42
la idea es siempre extraer 00:17:44
yo me hago Persona 00:17:46
cumplir los años es un código infernal 00:17:48
que pilla una base de datos 00:17:50
va a otro lado, cosa así 00:17:52
un millón de líneas de código 00:17:54
no me interesa, eso es que Persona tiene cumplir años 00:17:56
llamo cumplir años y cumple años 00:17:58
¿sí? 00:18:00
¿dónde creamos una clase? 00:18:06
los atributos de una clase 00:18:10
son ser responsabilidad de la clase misma 00:18:12
por eso si quiero permitir 00:18:14
que se lean o se modifiquen 00:18:16
para implementar métodos adecuados para ellos 00:18:19
los getter y los setter 00:18:21
mira 00:18:23
esta es mi clase Persona 00:18:25
¿vale? 00:18:27
mi clase Persona tiene string apellido 00:18:29
y string nombre 00:18:31
¿y luego qué tiene? 00:18:33
tiene métodos 00:18:35
tiene el método que devuelve 00:18:37
un string que es get apellido 00:18:39
¿sí? 00:18:41
si yo llamo sobre un método de tipo Persona 00:18:43
sobre un objeto de tipo Persona 00:18:45
llamo el método get apellido 00:18:48
lo que hará él es pillar 00:18:50
el contenido de esta variable 00:18:52
y devolverlo 00:18:54
¿sí? 00:18:56
y luego está set apellido 00:18:58
set apellido es 00:19:00
dame un valor 00:19:02
yo este valor 00:19:04
lo voy a poner 00:19:06
dentro de esta variable de aquí 00:19:08
¿sí? 00:19:14
get nombre y set nombre 00:19:16
¿vale? estos son getter y setter 00:19:18
veremos más adelante 00:19:20
hablaremos otra vez de ellos 00:19:22
normalmente 00:19:24
lo que yo quiero es que estos 00:19:26
atributos de aquí 00:19:28
los atributos de una clase 00:19:30
no sean públicos 00:19:32
yo no quiero que desde otra clase 00:19:34
un coche pueda cambiar mi nombre 00:19:36
a Luigi 00:19:38
no puede 00:19:42
hacer otra persona desde fuera 00:19:45
es acceder a mi método 00:19:47
set nombre 00:19:49
donde me dice 00:19:51
Luigi 00:19:53
y que aquí dentro, en vez de ser tan sencillo 00:19:55
haga una prueba 00:19:57
en plan, oye, pero tú eres una persona que puede cambiar nombre 00:19:59
eres el ayuntamiento 00:20:01
si eres el ayuntamiento, tienes esta credencial 00:20:03
bla bla bla bla bla 00:20:05
código código código código 00:20:07
entonces hazlo, y si no, no 00:20:09
no sé si me explico lo que quiere decir 00:20:11
si yo no hago esto 00:20:14
y aquí permito directamente acceder a mi nombre 00:20:16
cualquiera puede acceder a mi nombre y cambiarlo 00:20:18
si yo me creo un método 00:20:20
esto lo hago 00:20:22
o así o privado, veremos la diferencia 00:20:24
¿vale? de esta forma aquí 00:20:26
no se puede hacer desde fuera 00:20:28
se puede hacer solo de dentro de aquí 00:20:30
y yo me creo un método 00:20:32
que comprueba, antes de poner aquí 00:20:34
nombre, si es válido o no 00:20:36
pues me garantizo 00:20:38
que mi nombre no se pueda cambiar 00:20:40
fijaos que el método es público 00:20:43
se puede acceder desde fuera 00:20:45
pero el acceso a la variable no 00:20:47
no sé si se nota esta cosa 00:20:49
es más bien una pincelada de emisión 00:20:51
es lo que decía antes del DNI 00:20:53
imaginaos aquí una variable DNI 00:20:55
si yo tengo 00:20:57
la variable DNI directamente 00:20:59
alguien puede acceder y decir 00:21:01
DNI ahora pon ahí dentro cocodrilo 00:21:03
y él dice vale 00:21:05
sin embargo, si yo me hago un set DNI 00:21:07
que aquí dentro 00:21:09
dice for int igual a cero 00:21:11
y menor de la longitud 00:21:13
de la string que me has pasado y más más 00:21:15
y lo que va a mirar 00:21:17
charat cero es un número, charat uno es un número 00:21:19
charat dos es un número, hasta charat sete 00:21:21
son números 00:21:23
y luego viene una letra 00:21:25
pues ya estoy comprobando 00:21:27
algo más 00:21:29
¿entendéis? 00:21:31
lo veremos, por ahora me interesa más bien 00:21:33
esta cosa aquí 00:21:35
fijaos que 00:21:37
las variables estas 00:21:40
las estoy usando en todos los métodos 00:21:42
de la clase 00:21:44
¿por qué? porque son atributos 00:21:46
¿dónde es el scope? 00:21:48
de estos dos 00:21:50
desde aquí hasta aquí 00:21:52
por lo tanto lo puedo utilizar en cualquier lado 00:21:54
otra cosa 00:21:56
que podríais haber notado 00:21:58
es que yo aquí tengo 00:22:00
string apellido 00:22:02
y aquí tengo string apellido 00:22:04
entonces ¿cómo no? 00:22:06
¿qué me confundo entre 00:22:09
esta variable 00:22:11
y esta variable? 00:22:13
podría confundirme 00:22:15
porque aquí dentro existirá 00:22:17
apellido esta variable de aquí 00:22:19
pero yo quiero utilizar esta variable de aquí 00:22:21
¿cómo las diferencio? 00:22:23
esta de esta 00:22:25
y del colorido 00:22:31
este objeto 00:22:35
esto es la variable que me han dado aquí 00:22:37
una variable local a este método 00:22:39
¿veis que el color es el mismo? 00:22:41
pero lo que me has dado tú 00:22:43
que es el nuevo apellido que quieres cambiar 00:22:45
en mi objeto, yo quiero cambiar 00:22:47
esta variable, para poder acceder 00:22:49
a esta variable, utilizo 00:22:51
this, ¿qué es this? 00:22:53
esto, ¿esto qué? 00:22:55
este objeto 00:22:57
si yo soy la persona uno y me están llamando 00:22:59
este apellido 00:23:01
será el apellido de la persona uno 00:23:03
si yo soy la persona dos 00:23:06
y le están cambiando el apellido 00:23:08
será el apellido de la persona dos 00:23:10
del objeto 00:23:12
que está ejecutando esto 00:23:14
si tú llamas esto sobre el objeto uno 00:23:16
pues lo pondrá 00:23:18
en el campo apellido 00:23:20
del objeto uno, si tú estás llamando esto 00:23:22
sobre el objeto treinta siete 00:23:24
pues lo utilizará la variable del objeto 00:23:26
treinta siete 00:23:28
el concepto de this 00:23:30
this sirve porque si yo hiciera esto 00:23:32
sin el this 00:23:36
este apellido sería este apellido 00:23:38
no habría diferencia, ¿cómo puedo saber 00:23:42
si estoy copiando esto dentro de esto 00:23:44
o esto dentro de esto 00:23:46
o esto dentro de esto 00:23:48
si son todos iguales, se llaman apellidos 00:23:50
solución 00:23:52
aquí lo llamo a 00:23:54
entonces no hay 00:23:56
ambigüedad y hago apellidos igual a 00:23:58
apellido es sólo esto 00:24:00
pero hay situaciones en que 00:24:03
this sirve 00:24:05
es para introducir cosas 00:24:07
es mucha teoría 00:24:09
pero porque quiero llegar 00:24:11
a esto y luego hacemos ejemplos 00:24:13
¿qué son los constructores? 00:24:15
¿qué son los constructores? 00:24:17
crear objetos 00:24:19
¿hemos dicho que queremos crear objetos? 00:24:21
pues para crear objetos necesitamos constructores 00:24:23
los constructores son 00:24:25
métodos especiales 00:24:27
que lo que hacen es crearme 00:24:29
un objeto 00:24:31
¿cómo se crea un objeto? 00:24:33
¿qué hará falta 00:24:35
para crear una persona? 00:24:37
¿qué es una persona? 00:24:41
yo tengo mis atributos 00:24:45
nombre, apellido y edad 00:24:47
entonces ¿qué me sirve para crear un objeto? 00:24:49
un objeto-persona 00:24:51
que tú me des valores para estos tres atributos 00:24:57
creame una nueva persona 00:25:00
que se llame Estefano 00:25:02
su apellido sea Kiesa 00:25:04
y su edad sea 42 00:25:06
además 00:25:10
una clase produce un método especial 00:25:12
que se llama constructores 00:25:14
un constructor se tiene que llamar 00:25:16
como una clase 00:25:18
los constructores 00:25:20
no devuelven nada 00:25:22
no tienen ni void ni nada 00:25:24
porque en realidad lo que están devolviendo 00:25:26
tú llamas a ese constructor 00:25:29
y te crea un objeto 00:25:31
se ejecutan en el momento de la creación del objeto 00:25:33
y se ejecutan utilizando el new 00:25:35
nosotros ya lo hemos utilizado 00:25:37
voy más rápido 00:25:41
porque quiero ver esto 00:25:43
aquí estamos 00:25:47
clase-persona 00:25:53
tiene nombre y edad 00:25:55
este señor de aquí es un constructor 00:25:58
si os fijáis es parecido 00:26:02
a un método 00:26:04
pero aquí no tiene ni void ni int ni nada 00:26:06
es public-persona 00:26:08
se llama como la clase 00:26:10
y que pilla 00:26:12
pilla un string-nom 00:26:14
y un int-e 00:26:16
entonces cuando yo llamaré este constructor 00:26:20
con la new 00:26:22
ahora lo vemos al lado 00:26:24
voy a crear una nueva persona 00:26:26
que se llama stefano,42 00:26:28
lo que hace es que pillará este stefano 00:26:32
y lo pondrá en el nombre 00:26:34
de este objeto 00:26:36
y pillará 42 00:26:38
y lo guardará dentro de la edad de este objeto 00:26:40
y me ha creado el objeto 00:26:44
esto sería col-dis 00:26:48
pero como esto y esto se llaman distintos 00:26:50
pues no me hace falta 00:26:52
si esto se llamara nombre y esto se llamara edad 00:26:55
pues aquí debería hacer 00:26:57
dis.nombre es igual a nombre 00:26:59
dis.edad es igual a edad 00:27:01
yo creo un objeto 00:27:07
una vez que lo he creado 00:27:09
si quiero poder modificar o leer 00:27:11
mis datos 00:27:13
pues tengo varias opciones 00:27:15
leerlo directamente aquí 00:27:17
si son públicos 00:27:19
pero si en este caso son privados 00:27:21
pues entonces necesito un getter and setter 00:27:24
¿por qué necesito un getter and setter? 00:27:26
porque no leo 00:27:28
o escribo directamente 00:27:30
sino que tengo más control 00:27:32
porque alguien cuando quiere leer o quiere modificar 00:27:34
tiene que pasar por mi método 00:27:36
y yo en mi método puedo poner un if 00:27:38
puedo poner un while,puedo poner un control 00:27:40
para ver si tu puedes o no acceder a esos datos 00:27:42
luego hablaremos de todas estas cosas 00:27:48
¿qué es esto? 00:27:50
¿qué es esto? 00:27:54
es otro constructor 00:28:00
pero este es un constructor que se llama 00:28:02
cuando tu tienes 00:28:04
una persona que sabe su nombre 00:28:06
pero no sabe su edad 00:28:08
entonces 00:28:10
lo llamas así 00:28:12
esto y esto crean objetos 00:28:14
solo que esto crea un objeto 00:28:16
con nombre y edad asignado 00:28:18
mientras esto aquí crea un nombre 00:28:20
un valor por defecto 00:28:22
podría hasta poner que aquí 00:28:24
edad es igual a menos uno 00:28:26
como indicar una edad desconocida 00:28:28
¿cómo se llaman estos señores? 00:28:30
así 00:28:32
sintaxis 00:28:38
nombre de la clase 00:28:40
nombre de la variable 00:28:42
es igual a new nombre de la clase 00:28:44
los parámetros 00:28:46
esto es el constructor 00:28:48
por ejemplo 00:28:51
persona, persona1 00:28:53
esta es una variable 00:28:55
de tipo persona 00:28:57
es igual, crea un nuevo objeto 00:28:59
de tipo persona 00:29:01
que se llama Lola y tiene 30 años 00:29:03
persona, persona2 00:29:07
es una nueva persona 00:29:09
que se llama Pepe y tiene 25 años 00:29:11
estos son dos objetos distintos 00:29:13
tienen nada que ver uno con otro 00:29:15
los dos son de tipo persona 00:29:17
misma estructura pero dos entidades distintas 00:29:20
y puedo utilizar persona, persona3 00:29:24
es igual a personaPaco 00:29:26
esto me crea un objeto 00:29:28
su edad será cero 00:29:30
porque por defecto un int es cero 00:29:32
y ahora puedo utilizar persona1 00:29:38
y decir persona1.cumpleaños 00:29:40
¿qué pasa con persona1.cumpleaños? 00:29:46
que este de aquí se sumará a 1 00:29:48
y se vuelve 31 00:29:50
sin afectar ni esto ni esto 00:29:52
porque son objetos distintos 00:29:54
misma clase pero objetos distintos 00:29:56
instancias distintas 00:29:58
¿alguna persona cumpleaños? 00:30:04
¿qué es el sentido? 00:30:06
si se llama Laura no puede cumpleaños 00:30:09
si dentro de cumpleaños 00:30:15
tu dices 00:30:17
if nombre.e 00:30:19
cual es Laura 00:30:21
entre comillas 00:30:23
nada 00:30:25
elce edad++ 00:30:27
cuando se llama cumpleaños 00:30:31
si te llaman Laura no cumples 00:30:33
yo lo pondría 00:30:36
depende de lo que quieras hacer 00:30:38
puedes hacerlo de dos formas 00:30:40
o dentro de persona 00:30:42
dentro del método cumpleaños 00:30:44
pones eso 00:30:46
que nunca una persona 00:30:48
que se llame Laura 00:30:50
comprará los años, nunca 00:30:52
porque todas las veces que alguien que se llama Laura entra allí 00:30:54
pues no le suman los años 00:30:56
o lo puedes hacer desde fuera 00:30:58
aquí dices 00:31:00
if persona3.getName 00:31:02
.equals Laura 00:31:05
entonces no haga nada 00:31:07
y si no cumpleaños 00:31:09
pues entonces la persona Laura 00:31:11
puede cumplir 00:31:13
pero en este caso concreto 00:31:15
en tu programa no 00:31:17
¿escáner es un objeto? 00:31:25
si persona1 es igual 00:31:35
le llamas un método 00:31:37
si el método que tu llamas 00:31:45
te devuelve algo lo puedes hacer 00:31:47
si el método que tu llamas 00:31:53
te crea un objeto coche 00:31:55
porque el método de personas 00:31:57
es comprar coche 00:31:59
entonces crea un coche y te lo devuelve 00:32:01
coche, mi nuevo coche 00:32:03
es igual a persona1.compracoche 00:32:05
compracoche se llama sobre persona1 00:32:11
persona1 compra el coche 00:32:13
y gasta dinero suyo 00:32:15
crea un coche y este coche se guarda 00:32:17
en la variable 00:32:19
haremos ejemplos 00:32:21
por ahora nos paramos aquí 00:32:23
después de recreo vamos a hacer ejemplos 00:32:25
para todas estas cosas 00:32:27
Subido por:
Stefano C.
Licencia:
Reconocimiento
Visualizaciones:
8
Fecha:
20 de diciembre de 2023 - 12:01
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
32′ 31″
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:
86.63 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid