Saltar navegación

Intro a programación Orientada a Objetos - 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 18 de noviembre de 2022 por Stefano C.

42 visualizaciones

Más información Transcripción

Descargar la transcripción

Estoy grabando, si vosotros habláis me dais con el consentimiento a grabar vuestra voz, si no levantad la mano y lo paro, ¿vale? 00:00:00
Entonces, hasta ahora hemos estado trabajando con programación estructurada, ¿vale? 00:00:10
Y es la base de la programación, ¿vale? 00:00:20
O sea que, digamos que lo que hemos visto hasta ahora es para programas relativamente sencillos 00:00:22
y es lo que se ha usado por mucho tiempo para programar en el mundo laboral, ¿vale? 00:00:27
Ahora, hace bastante tiempo empezamos a ver que la programación estructurada tenía sus límites. 00:00:34
En particular, esto de basarse sobre funciones, de basarse sobre procedimientos, etc., etc., 00:00:41
Llevaba un momento que en proyectos particularmente complejos, en sistemas complejos 00:00:48
Pues se volvía difícil mantener el código 00:00:55
Se necesitaba un paso más en lo que era el paradigma de organización 00:01:01
El paradigma de cómo me enfrentan los problemas 00:01:06
Y entonces surgió la programación orientada a objetos 00:01:09
Es un nuevo paradigma, es un modo de pensar los programas un poco distintos con respecto a como se pensaba, como lo habéis pensado hasta ahora, introduciendo algunos conceptos básicos sobre el que, ladrillos básicos sobre el que construir luego la programación, una programación más ordenada, más estructurada, termino feo, pero ese es el concepto, más organizada, más fácil luego de mantener y de entender. 00:01:13
Y sobre todo de reutilizar 00:01:43
¿Vale? 00:01:44
Entonces, la programación orientada a objetos 00:01:47
¿Vale? 00:01:49
O object oriented programming 00:01:50
¿Vale? En inglés 00:01:54
Es un paradigma de programación 00:01:55
¿Vale? Cuya estructura principal 00:01:58
Es esta cosa llamada objeto 00:02:00
¿Vale? 00:02:02
Tenemos que 00:02:03
Trabajar un poco sobre 00:02:05
El concepto de objeto 00:02:07
Porque es la base, digamos 00:02:09
con el que luego vamos a programar 00:02:11
y tenemos que entender 00:02:13
si en algún momento nos queda claro 00:02:14
que es un objeto 00:02:17
es importante que me lo digáis 00:02:18
ahora, las próximas veces 00:02:21
lo repetiremos 00:02:22
haremos ejemplos 00:02:24
intentemos darle una definición 00:02:26
pero si aún así 00:02:29
o si os quedan dudas 00:02:31
es importante que me lo preguntéis 00:02:33
yo no veo muy bien la diferencia 00:02:34
entre clase y objeto, pues lo hablamos 00:02:37
el elemento estructural 00:02:39
principal que teníamos 00:02:43
antes era la función, la hemos visto ahora 00:02:45
entonces todo se basaba en funciones 00:02:47
que al fin y al cabo 00:02:49
nosotros hemos programado mucho sin funciones 00:02:50
la programación es esa 00:02:53
yo podía hacer un main gigantesco 00:02:54
sin llamar ninguna función 00:02:56
ningún problema 00:02:58
el problema es que cuando quería 00:02:59
que mi código fuera 00:03:02
parametrizado, que tuviera parámetros 00:03:04
que hiciera cosas 00:03:06
En dependiendo de si el parámetro vale una cosa o otra 00:03:08
Pues entonces ya con el main solo se me queda corto 00:03:10
Y necesito las funciones 00:03:14
¿Vale? 00:03:16
¿Qué mejoras aporta la programación orientada a objetos? 00:03:18
Es decir, ¿vale? 00:03:22
¿Y por qué vamos por ahí? 00:03:22
¿Qué nos esperamos? 00:03:24
Estas, ¿vale? 00:03:26
Análisis 00:03:27
La mente humana piensa más fácilmente en objetos 00:03:28
Que en procesos y datos de forma separada 00:03:30
¿Vale? 00:03:32
Se ha visto cuando se empezó a crear la programación de estos objetos que la mente humana suele pensar en objetos, en entidades que tienen juntas que son y que hacen. 00:03:33
Cuando vosotros pensáis a un animal, cuando vosotros pensáis a una persona, cuando vosotros pensáis a un cuadrado 00:03:55
Vuestra mente, en un cierto sentido, tiende a asociar lo que es y qué se puede hacer sobre él 00:04:01
¿Cuadrado? ¿Qué es? 00:04:09
Es una figura geométrica con un lado, que todos los lados son iguales 00:04:12
¿Y qué puedo hacer sobre él? 00:04:15
Puedo calcular el área, puedo calcular el perímetro 00:04:17
Una persona, ¿qué es una persona? 00:04:20
Pues una persona que es un ser 00:04:25
Es una entidad que tiene 00:04:27
Estas particulares 00:04:29
Características, un nombre 00:04:30
Una altura, un peso 00:04:33
Un... no sé 00:04:34
Lo que queráis vosotros 00:04:36
¿Qué puede hacer esta persona? 00:04:40
No sé, un momento, puede saludar 00:04:42
Puede comprar algo 00:04:45
Puede moverse, puede... no sé 00:04:47
¿Vale? Claramente 00:04:49
Dependiendo de que estamos nosotros programando 00:04:50
Y que vamos a programar 00:04:53
Pues nos interesarán más algunas características 00:04:55
Y algunas funciones que otras 00:04:57
¿Vale? 00:04:59
Si yo estoy programando un sistema de viajes en avión 00:05:00
No me interesa mucho que una persona pueda saludar 00:05:05
¿Para qué? 00:05:09
¿Vale? 00:05:10
Pero me puede interesar su nombre, apellido y DNI 00:05:11
Sí, eso es como característica 00:05:14
Porque cuando vuela luego tendrá que tener asociado eso 00:05:16
Y me podrá interesar la posibilidad de desplazar físicamente esa persona 00:05:18
Tendré una variable que me dice dónde está 00:05:23
Y tendré una función o un método 00:05:26
¿Vale? Se reconoce que es un método 00:05:29
Que me puede cambiar la posición donde está 00:05:31
Para que yo pueda decir que si tú haces un vuelo desde Madrid a Pisa 00:05:33
Antes tu localización era Madrid 00:05:37
Y ahora te la cambia a Pisa porque estás movido 00:05:42
No sé, me estoy inventando todo, ¿vale? 00:05:44
Pero la idea es un poco pensar en esto de aquí. Y esta forma de pensar las cosas en objetos, en entidades que tienen unas características y unas funcionalidades todo junto, es más fácil de pensar para nosotros seres humanos, ¿vale? 00:05:46
Entonces, es más fácil pensar en esto que pensar en datos por una parte y procesos en otras, que era como se pensaba cuando se utilizaba la programación estructural, ¿vale? 00:06:06
Segunda cosa, escalabilidad, ¿vale? Es más fácil añadir nuevas funcionalidades o ampliar las que ya existen. 00:06:20
Cuando yo trabajo en objetos, trabajo con este paradigma, mejorar en un cierto sentido, añadir funcionalidades, añadir, aumentar, escalar el problema, ¿vale? Cuando se habla de escalar el problema es hacer el problema más grande, ¿vale? 00:06:26
Es decir, añadir números de clientes, añadir, no sé, que antes yo trabajaba solo en una región y ahora quiero llegar a nivel nacional y cosas por el estilo. 00:06:43
La programación orientada a objetos me da recursos, me da herramientas más fáciles para poder hacer este tipo de proceso. 00:06:57
Puedo pillar un objeto que ya existe y extenderlo 00:07:06
Y añadirle cosas 00:07:12
Yo tenía personas, pero ahora quiero crear la entidad, el objeto, el concepto de trabajador 00:07:14
Y sé que el trabajador es una persona 00:07:23
Entonces pillo todo lo que tiene una persona 00:07:26
Y además le añado lo propio de un trabajador 00:07:29
Un trabajador sigue teniendo nombre, apellido y DNI 00:07:33
Como todas las personas 00:07:38
Pero además tendrá trabajo 00:07:39
No todas las personas tienen trabajo 00:07:41
Para hacer un ejemplo 00:07:44
El trabajador sigue teniendo trabajo 00:07:46
Entonces es como una extensión 00:07:48
Se puede escalar el problema 00:07:50
Y también reutilizar el código 00:07:53
Como yo tengo los objetos que están empaquetados 00:07:55
Con tus características 00:08:00
Y las propiedades 00:08:01
Las funcionalidades 00:08:02
Que tienen este tipo de objeto 00:08:05
Reutilizar 00:08:07
El código que me hace una determinada cosa 00:08:09
Es mucho más fácil 00:08:11
Porque ya está organizado 00:08:12
En programación 00:08:14
Reutilizar 00:08:17
Código es fundamental 00:08:18
¿Vale? 00:08:21
Lo que no se quiere en programación 00:08:22
Es que cada vez se reinvente la rueda 00:08:24
Se reinvente la misma cosa 00:08:27
¿Vale? No quiero que cada vez 00:08:29
Que empiece un proyecto nuevo 00:08:31
Empezar otra vez desde String 00:08:33
Venga, me hago mi implementación de String 00:08:35
Así luego puedo hacer cadenas de caracteres 00:08:37
No, String ya existe 00:08:39
Y lo usamos 00:08:41
Ah, me voy a hacer un programa que lee desde teclado 00:08:42
No, ya existe Scanner, reutiliza Scanner 00:08:44
Todo lo que estamos utilizando nosotros 00:08:47
Que no sabemos de dónde viene 00:08:49
Pero aún lo usamos 00:08:50
Scanner, String, Println 00:08:51
Cosa por estilo 00:08:55
Lo que estamos haciendo en realidad 00:08:56
es reutilizar código, código que está 00:08:58
escondido en un cierto sentido 00:09:00
¿vale? está 00:09:02
guardado dentro 00:09:03
del API, dentro de la cosa de acá 00:09:06
de las funcionalidades 00:09:08
que me da Java por defecto 00:09:10
y yo lo reutilizo sin necesidad 00:09:12
de ser yo que lo implemente otra vez 00:09:15
la idea es que lo que yo produzco 00:09:16
luego sea posible 00:09:19
reutilizarlo en otros 00:09:20
proyectos, en otros sistemas 00:09:22
en otros programas 00:09:24
que hace mi compañía sin necesidad 00:09:27
de crearlo otra vez, porque ya existe 00:09:28
se puede mejorar 00:09:30
se puede optimizar 00:09:32
se puede sobreescribir 00:09:34
parte diciendo, mira este método 00:09:36
de aquí funciona bien, pero este otro método 00:09:38
funciona de gulín, re hago 00:09:41
solo esta parte de aquí 00:09:43
pero la idea es reutilizar 00:09:43
¿si? entonces todas estas 00:09:46
son cosas, son ventajas que me 00:09:48
aporta la programación ahorita 00:09:50
de objetos y que quiero poder 00:09:52
utilizar 00:09:55
entonces la característica 00:09:57
de la programación de objetos en general 00:10:00
creamos clases que definen 00:10:02
unos datos y un comportamiento 00:10:04
y creamos objetos de estas clases 00:10:06
esta es la idea fundamental de la programación 00:10:08
de objetos 00:10:10
yo lo que creo es una clase 00:10:10
de hecho nosotros empezamos siempre con public 00:10:13
clase 00:10:15
una clase 00:10:16
que es en general 00:10:20
es una representación 00:10:21
abstracta 00:10:23
de un objeto 00:10:25
¿vale? cuando yo creo la clase 00:10:27
cuadrado, no estoy creando 00:10:29
un cuadrado concreto 00:10:32
estoy creando 00:10:34
todos los posibles 00:10:35
cuadrados del mundo 00:10:37
estoy creando un molde 00:10:39
¿vale? la idea 00:10:42
de que a partir del 00:10:44
concepto abstracto de cuadrado 00:10:45
que tendrá sus características 00:10:48
porque todos los cuadrados tienen 00:10:49
una determinada característica, por ejemplo 00:10:52
lado a partir de allí luego crearé cuantos cuadrados reales cuantos 00:10:53
objetos cuadrados quiera yo que pero serán instancias particulares de este 00:10:59
cuadrado me explico en cierto sentido 00:11:05
cuando yo pienso cuadrado este es un cuadrado 00:11:13
Cuadrado del lado 1 00:11:17
Pero oye, este también es un cuadrado 00:11:19
Cuadrado del lado 2 00:11:22
¿Sí? 00:11:26
Y luego está esto 00:11:28
¿Un cuadrado? 00:11:30
Bueno, más o menos 00:11:33
Cuadrado del lado 7 00:11:34
¿Vale? 00:11:35
Son todos cuadrados, ¿vale? 00:11:39
Ahora, ¿cuál es la idea general del cuadrado? 00:11:44
La idea general del cuadrado es una figura geométrica 00:11:46
que tenga los lados todos iguales, ¿vale? 00:11:49
de L 00:11:51
entonces mi idea es crear 00:11:51
una clase, ¿vale? 00:11:55
un programa 00:11:57
que considere en general 00:11:59
un cuadrado de lado L 00:12:01
¿vale? y luego 00:12:03
a partir de esta idea general 00:12:05
la clase, puedo 00:12:07
crear cuantas estancias quiero 00:12:09
esta clase 00:12:13
que son objetos reales 00:12:14
Habrá el objeto que es el cuadrado del lado 1, el objeto que es cuadrado del lado 2, el objeto que es cuadrado del lado 7 00:12:17
Es más, puede haber dos cuadrados del lado 1 00:12:24
Son dos objetos distintos, ¿vale? 00:12:27
Todos, pero tendrán las mismas características, las mismas funcionalidades y los mismos valores, digamos, como decirlo 00:12:33
características atributos cosas que los definen todos tendrán siempre las mismas tendrán lados 00:12:44
y tendrá la funcionalidad calcular área y calcular perímetro todos los tienen pero claro calcular la 00:12:52
área sobre este objeto no es lo mismo que calcular la vez sobre este objeto darán resultados distintos 00:13:00
Pero el procedimiento con que se calcula el área es lo mismo 00:13:07
Entonces, la idea de lo que puede hacer 00:13:11
Que tiene un lado, calcular el área, calcular el perímetro 00:13:14
Iría definida en la clase 00:13:18
La clase me define que los cuadrados tienen lado 00:13:20
Y que los cuadrados tienen un método que es calcular área 00:13:25
Y un método que es calcular perímetros 00:13:29
A partir de esta plantilla general 00:13:31
Que me puede crear todos los cuadrados posibles del mundo 00:13:34
Yo voy a crear objetos 00:13:39
Que son instancias particulares de una clase 00:13:41
No es un cuadrado genérico 00:13:45
Es el cuadrado de lado 1 00:13:48
Es un cuadrado de lado 1 00:13:49
Porque puedo tener 3 objetos distintos 00:13:52
Y los 3 sean cuadrados de lado 1 00:13:55
¿Por qué no? 00:13:58
Yo me he creado el molde 00:13:59
Con este molde puedo crear todos los cuadrados que quiero 00:14:01
Y luego voy creando objetos 00:14:04
Que son cuadrados 00:14:05
Cuadrados, objetos 00:14:07
¿Vale? La diferencia entre objeto y clase 00:14:13
La clase es 00:14:15
Más bien la abstracción en general 00:14:17
La definición 00:14:19
De lo que estoy modelizando 00:14:21
Y el objeto es 00:14:23
Objeto físico de esa clase 00:14:26
¿Sí? 00:14:29
No sé si me explico más o menos 00:14:31
Haremos más ejemplos 00:14:32
Y la idea es un poco filosóficos entre ellos, entonces hay que entenderlo, ¿vale? 00:14:34
Los objetos colaboran entre ellos para conseguir algo, ¿vale? 00:14:44
Entonces yo en mi programa lo que tendré que hacer es crear varios objetos, objetos de distintos tipos, depende del programa que estoy haciendo, ¿vale? 00:14:48
Que tengo un programa muy complejo de, como hemos dicho antes, de viajes, pues tendré el objeto persona que representa a la persona que vuelan. 00:14:56
Vuelan, tendré el objeto piloto 00:15:03
O la clase piloto 00:15:05
Que representa los objetos pilotos 00:15:07
Que son los que conducen los aviones 00:15:09
Tendré la clase avión, tendré la clase 00:15:11
No lo sé, aeropuerto 00:15:12
Tendré lo que me sirve 00:15:14
Para crear el sistema y que luego 00:15:16
Todos estos objetos colaboran 00:15:18
Entre ellos, se manden mensajes 00:15:21
Entre ellos, ¿vale? 00:15:23
Que es lo siguiente 00:15:24
Entre objetos la forma de colaborar es pasándose mensajes 00:15:25
¿Vale? 00:15:29
El pasarse mensajes en el mundo de la programación 00:15:30
A objetos es sustancialmente 00:15:33
Llamar métodos 00:15:34
Cuando yo llamo un método 00:15:35
De una función o una procedura 00:15:37
¿Vale? Que aquí se llamarán métodos 00:15:41
De otro objeto, le estoy 00:15:42
En un cierto sentido mandando un mensaje 00:15:44
Está mandando un mensaje a este objeto 00:15:46
De decir, oye mira, calcula tu área 00:15:48
Vale, mi área está aquí, y me la devuelve 00:15:49
¿Sí? 00:15:51
Cada clase va a ocuparse de lo que es 00:15:56
Su responsabilidad, esto es importante también 00:15:58
Si yo hago la clase cuadrado 00:16:00
Todo lo que está dentro de la clase cuadrado 00:16:02
Está relacionado con los cuadrados 00:16:05
¿Vale? 00:16:07
Dentro de la clase cuadrado tiene que estar 00:16:09
Solo lo que tiene que ver con el cuadrado 00:16:11
Y todo lo que tiene que ver con el cuadrado 00:16:14
No sé si me explico lo que quiero decir 00:16:17
¿Vale? 00:16:20
Si tengo otro método que calcula la área del triángulo 00:16:21
No tendrá que estar en la clase cuadrado 00:16:24
Tendrá que estar en la clase triángulo 00:16:26
Cada uno a suyo 00:16:28
¿Vale? 00:16:29
De esta forma 00:16:30
Aíslo bien las funcionalidades y las características de cada uno de los objetos 00:16:31
De las clases con las que voy trabajando 00:16:38
Y entonces, cuando sé que tengo que modificar algo 00:16:41
Pues sé dónde tengo que ir a buscarlo 00:16:44
Sé quién es el responsable de esa cosa 00:16:46
No sé si me explico 00:16:50
¿Dudas? 00:16:52
Ejemplo que viene por aquí 00:16:54
Un coche puede ser un ejemplo de clase, ¿vale? 00:16:55
El coche en general es una clase, ¿vale? 00:16:58
¿Qué características puede tener un coche? 00:17:02
Pues, por ejemplo, puede tener color, marca, modelo, matrícula 00:17:06
Todo depende de qué estoy modelizando, ¿vale? 00:17:10
Si estoy modelizando un vendedor, un concesionario de coches 00:17:15
Pues entonces a lo mejor el color es fundamental 00:17:22
Si estoy modelizando un sistema de tráfico automático por la ciudad 00:17:24
Pues a lo mejor que el coche sea verde o naranja no me interesa 00:17:32
Pero todo depende de lo que estoy representando con esta clase 00:17:35
¿Qué funcionalidades puede tener un coche? 00:17:43
Por ejemplo, desplazarse o parar 00:17:47
Si yo le digo desplazarse, se empieza a mover 00:17:49
Si yo le digo parar, pues está quieto en algún lado 00:17:51
o aparca, ¿vale? 00:17:54
una clase de coche es 00:17:57
responsabilidad de manejar todo aquello que 00:17:58
tenga que ver con el coche 00:18:00
un garaje con muchos coches 00:18:01
puede hacer uso de ellas 00:18:04
o un conductor también, ¿vale? 00:18:06
es decir, yo podría crear 00:18:08
además de la clase coche, una clase 00:18:10
garaje o una clase conductor 00:18:12
que estén de alguna forma 00:18:14
relacionados con coche, porque el garaje 00:18:16
tendrá como clientes coches 00:18:18
que vienen y entran en el garaje 00:18:20
o el conductor 00:18:22
será asociado a un coche y dirá yo como conductor puedo conducir este coche y puede hacer que se 00:18:24
desplace entonces cuando el conductor quiere utilizar el coche pues le mandará un mensaje 00:18:30
de desplázate y el coche se moverá para hacer un ejemplo estamos cuando queramos que un coche 00:18:36
se desplace en un garaje tendremos que comunicarnos con el coche específicos y darle la dirección a la 00:18:44
que queremos que se desplaza por ejemplo si esto es un poco un ejemplo de lo que 00:18:49
se dice dudas podemos hacer otro ejemplo 00:18:55
decime vosotros una clase un objeto un algo que queréis 00:19:01
modelizar un 00:19:06
otro coche coche persona venga persona entonces qué 00:19:11
Característica tiene persona 00:19:18
Dene y nombre, apellido 00:19:19
¿Qué más? 00:19:23
Dirección 00:19:27
Queremos saber dónde vive 00:19:28
No sé 00:19:29
Dependerá de lo que quiero modelizar 00:19:29
Así 00:19:34
Definir una persona en general 00:19:34
Es complejo, ¿vale? 00:19:38
A lo mejor hay características 00:19:39
Que no me sirven 00:19:42
¿Vale? 00:19:44
Depende de por qué lo estoy haciendo 00:19:45
Claramente, y haré un estudio 00:19:47
Del programa que estoy haciendo 00:19:49
Y diré, mira, una persona para mí es 00:19:51
Esta cosa aquí 00:19:53
Porque necesito saber esto y esto 00:19:55
Porque lo uso dentro de mi programa 00:19:57
Si una 00:19:59
Característica no la utilizo 00:20:01
Pues no lo pongo 00:20:03
¿Sí? ¿Y qué puede hacer una persona? 00:20:05
Siempre depende 00:20:16
De lo que vamos a hacer 00:20:17
En general, lo pienso así, pues puede comer 00:20:18
Entonces, puede 00:20:21
Dormir, qué sé yo 00:20:22
Venir a clase, depende de lo que estoy haciendo 00:20:25
A lo mejor si estoy hablando de una universidad 00:20:27
O de una escuela, pues a lo mejor 00:20:29
Tendré la función atender a clase 00:20:31
O falta, o qué sé yo 00:20:33
¿Sí? ¿Dudas? 00:20:35
Vale, entonces las clases 00:20:39
Una clase es lo que en un lenguaje 00:20:41
De programación nos va a permitir 00:20:43
Definir o construir uno o varios objetos 00:20:46
Es un molde, ¿vale? 00:20:48
Es la idea que a partir de allí 00:20:49
construyo objetos 00:20:51
pero los objetos no los puedo construir cada uno 00:20:53
como le da la gana 00:20:55
los objetos serán todos iguales 00:20:56
porque todos están hechos por el mismo molde 00:20:59
luego tendrán valores 00:21:02
distintos en sus características 00:21:04
pero todos tendrán las mismas características 00:21:05
todos los cuadrados tienen lado 00:21:08
luego el lado valdrá 7 00:21:10
8, 97, pero todos tendrán lado 00:21:12
todos los rectángulos 00:21:14
tendrán dos lados 00:21:16
el lado corto y el lado largo 00:21:17
pero no tienen que tener 00:21:19
Luego, que uno tenga 1 y 7 00:21:21
Y uno tenga 25 y 3 00:21:23
Me da igual 00:21:24
¿Sí? 00:21:25
¿Dudas? 00:21:27
Podemos decir que son moldes para construir objetos 00:21:30
Estos moldes tienen que ser escritos o programados 00:21:32
Y cada molde va a tener unas características 00:21:35
Por ejemplo, nombres, tributos y métodos 00:21:38
¿Vale? 00:21:40
Es decir, que cuando yo creo un molde de estrella aquí 00:21:41
Cada molde tendrá un nombre 00:21:43
O sea, cada clase tiene que tener un nombre 00:21:45
Nombres que hemos puesto nosotros 00:21:47
Nosotros normalmente ponemos ejercicio 1 00:21:48
ejercicio 2 o clase persona o clase coche vale es un nombre es el nombre que 00:21:50
voy a dar a esta clase además del nombre que servirá para luego referirme a ella 00:21:57
y que constituirá un tipo nosotros conocemos el objeto string la clase 00:22:02
string y luego string nosotros lo utilizamos como tipo cuando creamos una 00:22:08
variable hacemos string mi variable entonces todos los las clases constituirán un tipo de variables 00:22:13
de que se podrá devolver en una función que se podrá utilizar para hacer algo pero cuando yo 00:22:23
sustancialmente estoy construyendo una clase al fin y al cabo lo que estoy definiendo es un tipo 00:22:30
de datos vale y este tipo de datos luego se instancia con valores sólo que cuando es un 00:22:34
entero, sus valores son 3, 4, 5 y 7 00:22:41
cuando yo estancio 00:22:43
un tipo, persona 00:22:45
lo que estoy diciendo es que se llama 00:22:46
Estefano Chiesa 00:22:48
que se llama Paco, no sé qué 00:22:50
Fernández, y que tiene 00:22:53
37 años, y que no sé qué 00:22:55
¿sí? 00:22:57
además del nombre tendrá atributos 00:23:00
que son las características 00:23:02
lo que nosotros hemos llamado las características 00:23:04
de las clases, pues 00:23:06
de los sujetos, pues 00:23:08
En realidad, en terminología de programación orientada a objetos 00:23:09
Se llaman atributos 00:23:14
Entonces, cada clase tiene atributos 00:23:15
¿Cuáles son los atributos del cuadrado? 00:23:17
El lado 00:23:22
¿Cuáles son los atributos del coche? 00:23:23
Color, matrícula, etc. 00:23:28
Y luego los métodos 00:23:30
Los métodos es qué puede hacer esa clase 00:23:31
¿Qué puede hacer? 00:23:35
Que pueden hacer los objetos de esa clase 00:23:37
Que pueden hacer las instancias 00:23:40
De esa clase 00:23:43
¿Dudas? 00:23:44
Vale, en Java 00:23:50
Una clase, por ejemplo, persona 00:23:52
Se define en un fichero que se llama 00:23:54
Persona.java, ¿vale? 00:23:56
Eso lo hemos definido 00:23:57
Veremos que luego puede no ser así 00:23:58
Pero en general por ahora es así, ¿vale? 00:24:01
Cuando nosotros empezamos con public class 00:24:04
Persona 00:24:06
Esa cosa tiene que estar escrita dentro de un fichero 00:24:07
Que se llama persona.java 00:24:10
¿Vale? Y esto principalmente 00:24:12
Por esto public 00:24:14
Es esto 00:24:14
¿Vale? El hecho que es una clase 00:24:16
Pública implica que 00:24:19
Tiene que estar dentro del 00:24:21
Persona.java 00:24:23
Si no fuera pública podría no estar ¿Vale? 00:24:24
Pero por ahora todas nuestras clases son públicas 00:24:27
Por lo tanto 00:24:29
La clase reservada class 00:24:29
Es la que define una clase ¿Vale? 00:24:33
Aquí estoy definiendo una clase 00:24:35
Estoy diciendo oye mira esta es una clase 00:24:37
Que es pública que se llama persona 00:24:39
Este es el nombre, ¿vale? De las tres características que hemos visto antes, nombres, atributos y métodos, este es el nombre que doy a la clase. 00:24:41
Luego definimos los atributos, ¿vale? Que son los datos relevantes. Por ejemplo, esto es UML, ¿vale? No sé si habéis visto ya UML, lo veréis probablemente en entorno de desarrollo, más en concreto, ¿vale? 00:24:51
Pero la clase persona tiene dentro los atributos nombre y edad 00:25:06
¿Vale? 00:25:11
Nombre es un string 00:25:12
Edad es un int 00:25:14
¿Sí? 00:25:16
Y finalmente los métodos 00:25:17
¿Vale? 00:25:20
Los métodos son lo que puede hacer 00:25:21
Como por ejemplo tiene el método de escribir 00:25:22
Que no recibe ningún parámetro 00:25:24
Y no devuelve ningún parámetro 00:25:27
¿Vale? 00:25:30
Este es un método que no devuelve nada 00:25:30
Es parecido a un procedimiento 00:25:33
¿Sí? 00:25:35
¿Y qué hará escribir? Pues no lo sé 00:25:36
Ni idea, luego veremos 00:25:38
¿Vale? Entonces 00:25:41
Si esta es un poco la idea 00:25:42
De lo que quiero hacer, luego en Java 00:25:45
Eso se traduce en esta cosa 00:25:47
Aquí, ¿vale? 00:25:49
Public class persona 00:25:51
Me define que estoy creando persona 00:25:52
Fijaos que esto se abre aquí 00:25:55
Y se cierra al final 00:25:56
Todo es clase 00:25:58
¿Vale? 00:26:00
Ahora, nosotros estamos acostumbrados 00:26:03
A tener el main 00:26:05
Pero fijaos en esto 00:26:06
Aquí estoy definiendo 00:26:08
Cosas 00:26:10
Son variables 00:26:13
Fuera del main 00:26:15
Dentro de la clase 00:26:17
Pero fuera del main 00:26:19
¿Lo veis? 00:26:21
Hasta ahora nosotros esto lo hacíamos todo dentro del main 00:26:22
Ahora no 00:26:25
Porque estas no son variables cualquiera 00:26:26
Estos son los 00:26:28
Atributos 00:26:29
Los atributos de una clase 00:26:31
Se declaran dentro de la clase 00:26:33
Pero fuera de cualquier método 00:26:36
¿Vale? 00:26:38
Esto serán 00:26:40
La descripción general 00:26:41
Del molde que me da una persona 00:26:45
Para mí una persona lo que tiene de interesante 00:26:46
Es nombre, edad 00:26:49
Y cuando yo crearé 00:26:50
Un objeto persona 00:26:53
Lo que tendré que hacer es instanciar 00:26:54
Estos atributos 00:26:57
Tendré que decir cuál es el valor 00:26:59
De su nombre y cuál es el valor 00:27:01
de ciudad y yo podré tener objetos personas que tengan distintos nombres y 00:27:03
distintas edades o el mismo nombres y distintas edades o distintas edades y 00:27:14
mismo nombre o mismo nombre misma edad me da igual pero el concepto es que 00:27:20
serán objetos distintos puedo llamar yo puedo buscar y otro 00:27:24
stefano que tenga mi misma edad por ejemplo si quiero evitarlo tendré que programar que esto 00:27:28
no es posible pero esto ya es avanzado y luego hemos dicho que nuestra clase persona tiene que 00:27:35
tener un método de escribir vale pues entonces aquí está public voy de escribir porque es void 00:27:42
porque hemos dicho que no devuelve nada y porque no pilla nada porque hemos dicho que no pilla 00:27:49
Ningún parámetro 00:27:55
¿Vale? Es un ejemplo 00:27:56
¿Qué quiere decir que la persona 00:27:58
Tiene el método de escribir? 00:28:01
Pues no lo sé, es un ejemplo, no sirve de nada 00:28:03
¿Vale? Pero en mi programa 00:28:05
Escribir tenía sentido 00:28:07
Pues entonces lo pongo 00:28:09
Y luego una clase puede tener 00:28:10
Un método main que como hemos visto 00:28:13
Es un método especial porque es el método 00:28:15
De punto de acceso a mi trabajo 00:28:17
¿Vale? Entonces cuando yo 00:28:19
Empiezo el programa 00:28:21
Y tengo que empezar por algún lado 00:28:22
¿Por dónde empiezo? Pues por el main 00:28:24
¿Dudas? 00:28:26
Hemos ya dicho que en un archivo solo puede haber una clase public 00:28:34
¿Vale? 00:28:37
Entonces yo tengo public class 00:28:38
Lo que sea 00:28:40
Y tiene que estar en lo que sea.java 00:28:41
¿Vale? 00:28:44
En realidad veremos que luego después puedo tener otras clases que no sean public 00:28:45
Hay otros 00:28:50
Modificadores que puedo poner que no sean public 00:28:51
que son, por ejemplo, protected o private, y veremos qué son, por ahora no me interesa, ¿vale? 00:28:57
Y los atributos de una clase son propios de la misma, y se podrán consultar internamente, ¿vale?, en los métodos. 00:29:06
Es decir, que aquí dentro, dentro de este método de aquí, y dentro de este método de aquí, y dentro de todos los métodos, 00:29:13
Yo tengo acceso a estas variables 00:29:23
Estas variables las puedo utilizar 00:29:25
Y aquí dentro 00:29:27
Puedo utilizar nombre, por ejemplo 00:29:29
System.out.println 00:29:31
Nombre, y será este nombre 00:29:33
Aquí, vale 00:29:35
En principio, luego veremos 00:29:36
Detalles sobre esto 00:29:39
Pero la idea es que cuando yo creare un objeto 00:29:40
Que tiene su propio nombre, pues aquí dentro 00:29:43
Los puedo utilizar 00:29:45
Fijaos también en una cosa 00:29:45
Interesante que se me ha pasado antes 00:29:49
¿Notáis algo raro aquí? 00:29:51
Ya hemos perdido el static 00:29:54
¿Vale? 00:29:57
¿Y qué quiere decir eso? 00:29:59
Pues ya lo veremos 00:30:00
Sostancialmente, cuando es static 00:30:01
Se refiere a la clase 00:30:04
Cuando no es static 00:30:07
Se refiere al objeto 00:30:09
A la instancia 00:30:11
De la clase 00:30:13
¿Vale? 00:30:14
Los métodos static 00:30:16
No dependen del objeto 00:30:17
Sería lo mismo 00:30:20
Sea cual sea el cuadrado 00:30:21
Que lo utiliza 00:30:23
Mientras que los métodos no static 00:30:25
Dependen del objeto 00:30:28
No es lo mismo llamar 00:30:30
Ese método sobre el cuadrado 00:30:31
Del lado 1 que sobre el cuadrado del lado 7 00:30:34
Haremos ejemplos y lo veremos con más detalle 00:30:36
Simplemente 00:30:40
Para que os suene 00:30:41
Y aquí pasamos a objetos 00:30:43
Entonces hasta ahora hemos visto la clase 00:30:45
Que es un objeto 00:30:48
Pues un objeto es un elemento concreto de la clase definida 00:30:49
Y he pillado el molde general y he hecho un objeto concreto a partir de ese molde 00:30:53
¿Vale? Podré crear todos los objetos que me da la gana 00:31:00
Pero ese es un objeto único 00:31:03
Es una instancia de una clase 00:31:05
¿Vale? 00:31:07
Cuando se dice instanciar una clase 00:31:08
Quiere decir que a partir de la clase que he creado 00:31:10
Voy a crear un objeto 00:31:13
¿Vale? 00:31:15
En el momento de la ejecución se crean los objetos de las clases para los cuales hemos escrito código 00:31:16
¿Vale? Entonces cuando nosotros empezamos a ejecutar nuestro programa 00:31:23
Pues vamos a crear los objetos y le vamos a poner las características y los atributos que se necesitan 00:31:29
Vamos a rellenar sus características, vamos a darle los valores que tienen que valer 00:31:36
¿Vale? Cada objeto tendrá que tener un nombre para poder utilizarlo 00:31:41
¿Vale? Será parecido a lo que es una variable, ¿vale? 00:31:45
Por ejemplo, cuando nosotros utilizamos scanner, scan igual new scanner, estamos creando una nueva instancia de la clase scanner, un nuevo objeto de la clase scanner que se llamará scan. 00:31:51
Su nombre es scan, ¿vale? 00:32:06
ScannerScan me define 00:32:08
Oye, mira, te voy a crear un objeto scan 00:32:10
De tipo scanner, ¿vale? 00:32:14
Que es un new scanner 00:32:17
Un nuevo objeto de tipo scanner 00:32:18
¿Sí? 00:32:20
Un objeto que tiene una identidad 00:32:22
Una individualidad 00:32:24
Es decir, tengo que de alguna forma 00:32:26
Poderme referir a ese objeto que es único 00:32:28
¿Vale? 00:32:30
La clase me define una clase de objetos 00:32:31
Mientras que un objeto es un objeto único 00:32:34
Es algo único, es una instancia única 00:32:38
El atributo, ¿vale? 00:32:42
El atributo es que me los han definido las clases 00:32:44
Y ahora le doy valores concretos, ¿vale? 00:32:47
Fijaos, la clase aquí me dice 00:32:50
Oye, mira, ¿tienes un nombre o le da? 00:32:52
Sí, pero ¿qué nombre? 00:32:54
Hasta que yo no cree un objeto 00:32:56
No sé qué nombre tiene 00:32:58
¿Sí? 00:33:00
Y el conjunto de los atributos de un objeto 00:33:04
se define su estado 00:33:08
¿cuál es el estado de un objeto? 00:33:09
pues pillo todos los atributos 00:33:12
le hago una fotografía ahora 00:33:14
y eso es su estado actual 00:33:16
por ejemplo, la clase persona 00:33:17
que me representa 00:33:20
me llamo Estefano, tengo 40 años 00:33:21
pues entonces 00:33:24
mi foto actual es Estefano 00:33:25
con 40 00:33:28
cuando cumplo los años mi estado cambia 00:33:28
dudas 00:33:34
y los métodos 00:33:35
Que definen el comportamiento 00:33:37
Serán los mismos métodos definidos en la clase 00:33:39
¿Vale? 00:33:41
Hemos dicho que en la clase lo que hacía 00:33:42
Me daba los métodos que yo puedo utilizar sobre mí 00:33:43
Para hacer algo 00:33:46
Para comportarme 00:33:47
Para cambiar 00:33:49
O hacer algo 00:33:50
Por ejemplo, yo puedo tener en la clase persona 00:33:51
El método cumpleaños 00:33:53
Que lo que hace es actualizar el atributo edad 00:33:55
Haciendo edad++ 00:33:59
¿Dudas? 00:34:01
Entonces, cuando yo creo un objeto 00:34:02
¿Dónde se crea el objeto? 00:34:11
Es decir, yo tengo una clase 00:34:15
La clase me define en general 00:34:16
Cómo será hecho este objeto 00:34:18
Y ahora creo uno, creo un New Scanner 00:34:21
¿Dónde se crea este objeto? 00:34:23
Pues normalmente se crea en la memoria RAM 00:34:25
Digámoslo así 00:34:27
Hay un trocito de memoria 00:34:28
En realidad, un poquito más complejo de esto 00:34:31
La Java Virtual Machine tiene un trozo de memoria 00:34:33
Un bloque de memoria 00:34:36
Que se llama el HIP 00:34:39
HEP 00:34:40
¿Sabéis la traducción en español? 00:34:41
En italiano me la sé 00:34:47
En español no 00:34:48
HIP 00:34:49
HEP 00:34:50
No, no es salto 00:34:51
Es como un montón 00:34:55
El concepto es montón 00:34:56
Mucho en italiano 00:34:59
No sé, ahora lo buscaré 00:35:01
La idea es que allí es donde se crean los objetos 00:35:03
Entonces, cuando yo creo un nuevo objeto, en este espacio de memoria que yo tengo, me guardo un trocito de memoria y allí guardo los atributos de ese objeto. 00:35:05
Y además, lo referencio. Hago un puntero que apunta a este trozo de memoria. 00:35:15
Y ese puntero es lo que yo utilizo para poder ir a trabajar con ese objeto. 00:35:23
Cuando hago ScannerScan igual NewScan, el NewScan me crea un objeto y me devuelve un puntero a ese trozo de memoria 00:35:28
Ese puntero, ese trozo de memoria es mi variable Scan 00:35:38
No sé si lo entiendo, si me explico 00:35:42
En Java no se trabaja con direcciones de memoria directamente, ¿vale? 00:35:46
Es un concepto un poco más abstracto, pero la idea está por ahí, ¿vale? 00:35:53
Es decir, que yo tengo una referencia para poder ir a buscar este objeto 00:35:56
Será un nombre simbólico que hace él para identificar ese objeto en concreto 00:36:00
Ese objeto en concreto es el que utilizo 00:36:07
Cuando yo hago string nombre es igual a Estefano 00:36:11
Pues he creado un objeto por algún lado con escrito dentro Estefano 00:36:15
Y hago una referencia a él que es el nombre 00:36:19
¿Vale? Cuando yo utilizaré nombre a partir de ahora me estoy refiriendo a ese trozo de memoria 00:36:23
Un objeto es un valor que se puede asignar a una variable cuyo tipo es la clase 00:36:27
¿Vale? Lo que hacemos nosotros, scanner, scanner, es igual a new object, o sea, new scanner 00:36:34
Entonces, new scanner es un objeto scanner, se puede asignar a una variable de tipo scanner 00:36:39
Si queremos crear un objeto de tipo persona, por ejemplo, le damos un identificador como persona alumno 00:36:43
¿Vale? Entonces, este es el identificador 00:36:50
Este es el tipo 00:36:53
Tú das 00:36:55
A partir de ahora 00:36:59
A partir de haberlo creado 00:37:01
Esto todavía no ha creado 00:37:02
Un objeto 00:37:04
¿Vale? 00:37:07
Pero cuando yo le asignaré un objeto 00:37:07
Ahora veremos cómo 00:37:09
Pues a partir de ahora 00:37:10
Usando alumno 00:37:11
Me referiré a ese objeto 00:37:12
Persona alumno 00:37:13
Es como cuando hago 00:37:16
Int x 00:37:17
¿Vale? 00:37:17
He creado la variable 00:37:18
Pero no he creado todavía 00:37:20
El valor de la variable 00:37:22
¿Sí? 00:37:23
Atributos 00:37:25
Son las características de definir el objeto 00:37:28
Cada atributo tiene una visibilidad 00:37:30
Lo hablaremos en futuro 00:37:33
Por ahora todos son public 00:37:35
O no ponemos nada 00:37:37
Un tipo que puede ser primitivo 00:37:38
O puede ser otro objeto 00:37:41
Y aquí las cosas se complican 00:37:43
Por ahora son primitivos 00:37:44
Pero por ejemplo cuando usamos string 00:37:45
Pues string es otro objeto 00:37:48
Entonces ya lo hemos usado 00:37:50
Cuando aquí pensamos en esto 00:37:51
Y estamos haciendo que un atributo es un string 00:37:53
String es otra clase, es otro objeto 00:37:58
Entonces estamos usando un objeto dentro de un objeto 00:38:00
Ya lo estamos haciendo 00:38:04
¿Vale? 00:38:05
No nos damos cuenta pero ya lo estamos haciendo 00:38:07
Y el identificador del atributo 00:38:09
¿Vale? 00:38:12
O sea, ¿Cómo se llama? 00:38:13
String nombre, puede ser nombre 00:38:14
Por ejemplo, persona tenía nombre que es de tipo string 00:38:15
Que es una clase 00:38:20
Y edad, que es de tipo int, que es un tipo primitivo 00:38:21
¿Vale? 00:38:24
El estado de un objeto está definido por los valores que tienen sus atributos en un determinado momento 00:38:25
Ya lo hemos dicho antes 00:38:32
¿Dudas? 00:38:33
Y luego los métodos 00:38:39
Ya todo esto lo hemos dicho, ¿vale? 00:38:40
Son los servicios que puede proporcionar este objeto a otros 00:38:42
¿Vale? 00:38:48
Otros objetos pueden llegar a mí, yo tengo estos métodos 00:38:49
Y pueden decir, ejecuta este método 00:38:52
O llamo a este método 00:38:54
Y yo hago lo que dice ese método 00:38:56
¿Vale? Como por ejemplo soy la persona 00:38:58
Que hace el método 00:39:01
Cumplir años 00:39:02
Si alguien llama a mi método cumplir años 00:39:04
Yo lo que hago es sumar uno a mi variable edad 00:39:06
Porque he cumplido 00:39:09
¿Sí? 00:39:10
¿Quién llama esto? Pues puede llamarlo 00:39:12
Un main, puede llamarlo otro objeto 00:39:14
Puedo llamarlo yo mismo 00:39:17
En otra parte 00:39:19
En otro trozo de código 00:39:20
Ya veremos quién es que trabaja 00:39:22
Si os acordáis, la base de la programación orientada a objetos 00:39:26
Es que los objetos interactúan entre ellos 00:39:29
Mandándose mensajes y llamándose métodos uno a otro 00:39:33
¿Vale? Y con eso hago la tarea que tengo que hacer 00:39:37
Entonces, un método suele tener un nombre, unos parámetros 00:39:40
Y un valor que se devuelve, ¿vale? 00:39:47
Siempre y cuando no se devuelve nada 00:39:49
Y esto ya lo hemos visto hoy tranquilamente, cuando hemos visto funciones y procedimientos hemos estado trabajando sobre esto 00:39:51
Los nombres de las funciones, los parámetros que pillo y que trabajo con ellos, que puedo tener o no puedo tener 00:39:59
Y hemos visto que al final puede que mi método produzca un resultado y que yo quiera devolver ese resultado 00:40:07
O puede ser que simplemente este resultado lo imprimo en pantalla, por ejemplo 00:40:17
Y entonces no lo tengo que devolver 00:40:20
¿Vale? 00:40:22
Es importante saber qué métodos implementa cada clase 00:40:26
Qué parámetros tienen los métodos y qué devuelven, ¿vale? 00:40:29
Y esto, hay una cosa que se llama el API, lo veremos, ¿vale? 00:40:33
Y empezaremos a utilizarlo más adelante 00:40:37
Que, sustancialmente, es la colección de todas las clases 00:40:40
Que ya existen hechas en Java 00:40:44
Y que yo puedo reutilizar 00:40:47
Como por ejemplo String o Scanner 00:40:49
¿Vale? 00:40:51
Y hay miles de clases ya hechas 00:40:51
Que yo puedo reutilizar 00:40:54
Y que están programadas ya 00:40:56
Y que las puedo utilizar directamente 00:40:58
Nosotros veremos List, ArrayList, etc, etc, etc 00:41:00
Más adelante 00:41:04
Entonces vamos a crear una clase 00:41:04
¿Cómo se crea una clase? 00:41:07
¿Sí? 00:41:09
Por ejemplo 00:41:10
La clase Persona 00:41:11
Tiene string apellido 00:41:13
Y string nombre 00:41:17
Para cambiar un poco 00:41:18
Tiene dos atributos 00:41:20
Public string getApellido 00:41:22
Es un método 00:41:26
¿Qué hará este getApellido? 00:41:27
Pues devuelve el apellido 00:41:29
¿Sí? 00:41:30
Veis que no es static 00:41:35
Lo que hace es devolver un string 00:41:38
Y este string es este apellido 00:41:42
Pregunta para vosotros 00:41:44
Si yo llamo GetApellido sobre mí 00:41:46
O sobre otra persona 00:41:49
¿El resultado será el mismo o será distinto? 00:41:50
El mismo 00:41:58
Si yo me llamo sobre mí, me dirá que me llamo Chiesa 00:41:59
Y si te lo llamo sobre ti, te dice que te llamo Chiesa 00:42:01
¿Es igual? 00:42:04
Te lo he dicho, sobre dos personas distinto 00:42:08
Sobre dos objetos personas 00:42:09
¿Pero entonces se refiere a la clase? 00:42:12
¿Al apellido de clase o al apellido de objeto? 00:42:17
Esto es la definición de clase 00:42:19
¿Vale? 00:42:21
Pero la clase es un molde 00:42:22
Que me define como están hechos los objetos 00:42:23
En este caso el molde es apellido y nombre 00:42:26
Claro, el molde me dice 00:42:27
Que cada persona tendrá dos atributos 00:42:30
Apellido y nombre 00:42:33
Entonces cuando creo un objeto 00:42:34
El objeto tendrá seguramente un apellido 00:42:35
Y seguramente un nombre 00:42:38
Pero cada objeto tendrá su apellido y su nombre 00:42:39
Entonces cuando yo pillo un objeto cualquiera 00:42:41
Y le llamo 00:42:44
El método que está apellido 00:42:45
Y me devuelve su apellido 00:42:47
Será el apellido 00:42:49
De ese objeto 00:42:51
Entonces si lo llamo sobre objetos distintos 00:42:53
Me devolverán el apellido de cada uno del objeto 00:42:56
Cada uno distinto 00:43:00
Entonces serán siempre objetos distintos 00:43:00
Entonces el resultado es distinto 00:43:03
¿Vale? 00:43:05
Es un poquito la razón de por qué no es tal estático 00:43:06
¿Vale? 00:43:09
O sea que el resultado de este método 00:43:11
Depende del objeto sobre el que lo llamo 00:43:14
Si lo llamo sobre persona 1 00:43:17
Pues me contestará una cosa 00:43:20
Si lo llamo sobre persona 2, me contestará una cosa distinta 00:43:22
¿Sí? 00:43:25
Y luego está este de aquí 00:43:28
¿Qué hace este método de aquí? 00:43:29
SetApellido 00:43:31
Me dice 00:43:31
Yo me llamo apellido, no devuelvo nada 00:43:42
Pero pillo un 00:43:45
Un valor 00:43:47
¿Vale? Que se llama apellido igual 00:43:49
¿Y qué hace? 00:43:51
Lo que tú me has dado 00:43:53
Ponlo dentro 00:43:54
Esta cosa rara de aquí 00:43:57
¿Qué es esta cosa rara de aquí? 00:43:59
El apellido de dis 00:44:00
¿Qué es dis? 00:44:04
Este 00:44:06
¿Este qué? 00:44:07
Este objeto 00:44:09
Pero esa es la palabra que hay que poner para ese objeto 00:44:11
Fijaos 00:44:14
¿Qué color tiene? 00:44:16
Entonces es una 00:44:18
Palabra reservada 00:44:20
Esta es una palabra 00:44:22
Especial 00:44:24
Para decir este objeto 00:44:25
¿Vale? 00:44:28
Esta cosa aquí te está diciendo 00:44:30
Vale, te he dado una variable que se llama apellido 00:44:31
Este apellido 00:44:34
El valor que te he pasado por lo dentro 00:44:35
De este apellido 00:44:38
Este es el apellido como atributo 00:44:40
Este es apellido como variable local 00:44:45
¿Sí? ¿Cómo? 00:44:48
Este de aquí que devuelve 00:44:58
Lo que hay aquí dentro 00:44:59
Son métodos 00:45:02
O sea, no es que tengan que 00:45:07
Estos son los servicios 00:45:09
Que yo te proporciono 00:45:12
Tú me puedes pedir mi apellido 00:45:14
¿Vale? 00:45:16
Entonces, cuando tú pedirás get apellido 00:45:18
Yo te doy mi apellido 00:45:20
¿Vale? Ahora, ¿para qué lo usas? 00:45:21
No lo sé, a eso no lo sé 00:45:23
¿Vale? ¿Para qué puede servir esto de set apellido? 00:45:25
Puede servir al principio 00:45:29
Cuando tú te has creado 00:45:30
Y todavía no tienes un apellido 00:45:31
Para que te dé tu apellido 00:45:33
Para que te configure 00:45:34
Estos valores de aquí 00:45:36
¿Vale? 00:45:38
Y son ejemplos de métodos 00:45:40
¿Vale? 00:45:42
En realidad, estos de aquí 00:45:43
Son los que se llaman los getter y setter 00:45:44
¿Vale? 00:45:47
Por cada apellido 00:45:48
O sea, por cada atributo 00:45:50
Puede haber un get y un set 00:45:51
De ese atributo 00:45:53
¿Vale? 00:45:54
¿Tengo atributo apellido? 00:45:55
Tengo get apellido y set apellido 00:45:56
¿Tengo nombre? 00:45:58
Tengo get nombre y set nombre 00:46:00
Pero lo veremos más adelante 00:46:01
Más en detalle estas cosas 00:46:03
¿Vale? 00:46:04
Pero ahora simplemente que 00:46:04
Es para que veáis 00:46:05
Es que una clase tiene 00:46:08
Un nombre 00:46:09
Atributos 00:46:10
Y varios métodos 00:46:13
¿Dudas? 00:46:20
Aquí hay muchas cosas 00:46:24
Que tenemos que ver 00:46:25
Pero con calma 00:46:26
Sí, sí, luego 00:46:28
Tendré objetos 00:46:31
Es que no puedo hacer ejemplos 00:46:34
Hasta al menos aquí 00:46:37
¿Vale? 00:46:38
Los constructores 00:46:39
La última cosa 00:46:41
Y me acabo aquí, ¿vale? 00:46:43
Son los constructores 00:46:45
Cuando yo creo un nuevo objeto 00:46:46
Necesito algo que me construya ese objeto 00:46:48
¿Vale? 00:46:51
Y normalmente 00:46:53
Esto se llama constructor 00:46:54
El lunes hacemos ejemplo de estas cosas 00:46:56
¿Vale? 00:46:58
Y ya metemos con todo esto 00:46:59
Fijaos que 00:47:00
El último, último 00:47:02
Cuando yo creo un nuevo objeto 00:47:03
Entra en juego 00:47:06
Este comando de aquí 00:47:08
que nosotros hemos visto 00:47:10
hemos visto cuando creamos por ejemplo 00:47:12
new scanner 00:47:15
o cuando hemos hecho un nuevo 00:47:15
array 00:47:19
entonces siempre que yo creo 00:47:20
un objeto nuevo 00:47:23
tendré que utilizar una new 00:47:24
por algún lado 00:47:26
la new es el objeto que 00:47:27
es el procedimiento 00:47:30
el comando que lo que me hace 00:47:32
es crearme físicamente el objeto 00:47:34
No, el new está asociado con lo que es un constructor 00:47:38
Que es un método especial 00:47:44
Y ya veremos qué es 00:47:45
Porque cada objeto, como es distinto de los otros objetos 00:47:46
Tendrá que tener un método especial llamado constructor 00:47:51
Que es el que me construye 00:47:54
Idioma/s:
es
Autor/es:
Stefano chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
42
Fecha:
18 de noviembre de 2022 - 14:31
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
47′ 56″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
154.63 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid