Objetos | Mediateca de EducaMadrid

Voy a grabar esta clase, por lo tanto, si vosotros habláis, me autorizáis a que se grabe vuestra voz. 00:00:00

Pues hoy vamos a empezar con un tema nuevo. 00:00:08

Hemos acabado la parte, digamos, básica de la programación. 00:00:11

Hasta ahora nosotros estábamos en un estado temprano de la programación. 00:00:20

Estamos trabajando con programación estructurada. 00:00:25

Allí entran los if, entran los while, entran los for, entran las llamadas a métodos, 00:00:30

bueno, las llamadas a funciones y procedimientos que nosotros hemos visto muy poco, 00:00:37

porque ahora cuando vamos a entrar en los objetos utilizaremos mucho. 00:00:43

La programación estructurada se basa sobre esos tres pilares que hemos visto, cuatro si queremos, que hemos visto hace ya un mes, mes y medio, que son el condicional, la iteración, la llamada método y si queremos la declaración de variables, cosas básicas. 00:00:48

La unidad fundamental de la programación estructurada es la función. 00:01:12

O sea, cuando yo hago un proyecto en programación estructurada, lo divido en funciones. 00:01:23

Creo varias funciones. 00:01:29

Estas funciones se llaman una a otra y hacen lo que tiene que hacer el sistema. 00:01:31

Yo tengo un main, que es una función, digamos, inicial. 00:01:38

dentro de esta función inicial 00:01:41

voy a llamar trozos de códigos 00:01:43

a lo que le he dado un nombre 00:01:45

para identificarlos 00:01:46

y a lo que le puedo pasar parámetros 00:01:48

para que estos trozos de códigos 00:01:49

no hagan una sola función 00:01:52

sino una clase de función 00:01:54

un conjunto de funciones 00:01:55

nosotros podemos hacer una suma 00:01:57

pero luego a la suma le ponemos dos parámetros 00:02:01

para que no es que me haga siempre 3 más 4 00:02:02

si yo le paso el 3 y le paso el 4 00:02:05

hará 3 más 4 00:02:07

si yo le paso 7 y 12 00:02:08

a 3 más 12. ¿Vale? Se vuelve paramétrica. 00:02:10

Entonces no es la solución de un problema concreto, 00:02:13

sino la solución de un conjunto de problemas. 00:02:16

En la programación estructurada 00:02:20

yo creo funciones. Las funciones se llaman 00:02:22

una a otra, se complican cuanto vosotros 00:02:25

queráis, hasta crear un sistema donde tengo un mogollón 00:02:28

de funciones y una secuencia 00:02:31

con la que llamo estas funciones. 00:02:34

Las funciones dentro pueden llamar otras funciones y cosas por el estilo. 00:02:36

Pero la base, la unidad, el concepto que manipulo es la función, ¿sí? 00:02:40

O, por ejemplo, ¿entendéis? 00:02:47

Ahora, en la programación orientada a objeto, esto cambia, ¿vale? 00:02:50

El problema que tiene la programación estructurada es que sí es mejor que la no estructurada, 00:02:56

que antes era un caos, tenía todo código, saltaba por un lado o por el otro, 00:03:04

Ahora ese código lo he organizado en funciones, entonces puedo llamar a estas funciones, tengo más control. 00:03:07

Pero aún así, los sistemas muy complejos siguen siendo complejos. 00:03:13

¿Por qué? Porque las funciones no me dicen de quiénes son. 00:03:17

Yo tengo las funciones, pero puedo tener en el mismo lugar, en el mismo módulo, en el mismo package, en el mismo concepto, 00:03:24

muchas funciones que hacen cosas distintas. 00:03:33

Una me calcula el precio, una me llama, me manda un email a los clientes, otra busca proveedores, otra no lo sé. 00:03:36

Tengo un montón de funciones que son todas usadas por mi sistema para que mi sistema funcione, pero están organizadas por función. 00:03:46

No por qué hacen estas funciones o grupos de funciones que hacen lo mismo. 00:03:53

Sí que puedo intentar utilizar módulos para mejorar un poquito estas cosas, pero se mantiene un cierto nivel de caos. 00:03:58

en la gestión de las funciones. 00:04:06

Claramente todo esto es una cuestión de escalabilidad del problema. 00:04:08

Mientras el problema es sencillo, 00:04:15

todos los problemas que hemos hecho nosotros 00:04:17

no requieren ni siquiera de funciones. 00:04:19

Todos los ejercicios que hacemos nosotros, 00:04:22

que hemos hecho hasta ahora, son tan sencillos 00:04:23

que yo lo hago directamente en un mail y se acabó. 00:04:26

En un mail y se acabó. 00:04:28

Sin embargo, cuando esto se complica 00:04:32

y yo empiezo a decir, no, no, hago un ejercicito, hago un sistema, 00:04:35

hago un programa suficientemente complejo, 00:04:38

pues entonces tengo que empezar a organizar las funciones, 00:04:44

organizar los módulos, etcétera, etcétera. 00:04:47

Y funciona. 00:04:49

¿Hasta cuándo no quiero hacer algo todavía más complejo? 00:04:51

¿Y cómo la informática empezó con cosas sencillitas 00:04:54

y luego ha ido creciendo, creciendo, creciendo? 00:04:57

Hasta ahora que tenemos cosas maravillosas y mirabolantes 00:05:00

a la que constantemente estamos acostumbrados, 00:05:04

que pero hace 20, 30 años no existían, ni se pensaban. 00:05:07

El mismo, qué sé yo, YouTube, Google y cosas por el estilo 00:05:12

no tienen tan muchísimos años, ¿vale? 00:05:16

Hace 30 años no existían. 00:05:19

Pues ha llegado un momento en que hasta la programación estructural 00:05:21

no era suficiente, ¿vale? 00:05:25

Para que esta cosa funcionara se necesitaba organizar todavía mejor 00:05:27

para que yo pueda, por un lado, tener más control sobre lo que estoy haciendo 00:05:32

y, por otro lado, también reutilizar lo que estoy haciendo. 00:05:36

Porque nos hemos dado cuenta que muchos de los problemas que resolvemos en un determinado contexto 00:05:40

luego lo tenemos que resolver otra vez en otros contextos distintos, a lo mejor con pequeños cambios. 00:05:45

Si yo puedo, la solución que he encontrado en un determinado campo o en un determinado entorno, 00:05:52

aplicarla a otros 00:05:59

campos, a otros 00:06:01

entornos, reutilizando el código 00:06:03

que ya he hecho, pues todo esto 00:06:05

es una cosa positiva, ¿vale? 00:06:07

Me hace más rápido 00:06:09

el desarrollo, 00:06:11

me permite, si yo 00:06:13

utilizo el mismo 00:06:15

concepto, si yo mejoro ese 00:06:17

concepto, si yo mejoro ese elemento 00:06:19

y lo he reutilizado en 00:06:21

varios sitios, pues esta mejora se 00:06:23

aplica en todos los sitios que la he reutilizado. 00:06:25

lo que es, puede ser una cosa positiva 00:06:27

¿vale? entonces se empieza 00:06:29

a pensar al concepto de objeto 00:06:31

¿vale? el concepto de objeto 00:06:33

clase, vemos que están 00:06:35

relacionados, veremos que es 00:06:36

¿cuál es la diferencia? es sustancialmente 00:06:39

de 00:06:41

modelizar los elementos 00:06:42

de mi programa 00:06:45

basándome sobre 00:06:46

lo que quiero modelizar 00:06:48

sus características 00:06:51

y sus funcionalidades 00:06:53

O sea, en vez de crear funciones y variables así al azar, que luego se relacionan entre ellos, las voy acorpando en lo que llamarán una clase o un objeto. 00:06:55

Entonces, todas las funciones y todas las variables, todas las características de un determinado concepto, pertenecerán al mismo objeto. 00:07:05

ejemplo, si yo pillo y digo 00:07:16

quiero modelizar un coche 00:07:19

todas las características 00:07:20

del coche y todas las posibles 00:07:23

funcionalidades del coche 00:07:25

irán dentro de un mismo 00:07:26

contexto 00:07:29

de un mismo módulo 00:07:31

de lo que llamaremos una clase 00:07:33

o un objeto 00:07:34

entonces, ¿qué me interesa a mí 00:07:35

del coche? pues depende de mi proyecto 00:07:39

¿vale? si yo soy 00:07:41

estoy desarrollando un sistema para un taller 00:07:42

pues a lo mejor me interesa la marca, me interesa las piezas que se han estropeado, 00:07:45

me interesa si hay piezas de cambio y cosas por el estilo. 00:07:51

Si yo estoy haciendo un sistema para una venta de coches, 00:07:54

pues a lo mejor las piezas estropeadas no me interesan. 00:07:58

Me interesa el modelo, me interesa el precio. 00:08:01

Si yo estoy haciendo un sistema para carreras de coche, 00:08:03

pues no me interesa el precio, me interesa la velocidad máxima. 00:08:07

Entonces, las características del elemento, del objeto que voy modelizando, dependen del sistema en el que yo me meto. 00:08:11

Entonces, cuando yo tengo un proyecto y digo, vale, voy a desarrollar este proyecto, analizaré lo que necesito y diré, ok, necesito crear tres, cinco, diez objetos, diez conceptos que voy a modelizar, y cada uno de ellos diré cuáles son sus características. 00:08:20

además de las características en el mismo, no quiero decir paquete porque es otra cosa el 00:08:38

package, en el mismo objeto, en el mismo bloque, en el mismo elemento, van también qué puede hacer 00:08:47

este elemento. Entonces un coche, si tengo su marca, tengo su modelo, tengo su velocidad máxima, 00:08:55

¿qué puede hacer un coche? Dependerá siempre del contexto en el que estoy desarrollando, 00:09:02

del proyecto que estoy haciendo. Por ejemplo, si estoy haciendo un proyecto de movilidad, 00:09:07

al trazamiento, a lo mejor tengo la posibilidad de mover el coche 00:09:11

o de parar el coche. Pues esto mover y esto parar 00:09:15

serán funcionalidades, serán comportamientos de este objeto. 00:09:19

Este objeto podrá moverse o podrá pararse. 00:09:24

Y estos serán sus métodos, sus funciones y procedimientos 00:09:28

que en el mundo de la programación orientada a objetos se definirán 00:09:32

como métodos. Por ejemplo, 00:09:36

string modeliza el concepto de una cadena de caracteres y tiene un montón de comportamientos 00:09:40

que me permiten manipular estos estos cadenas de caracteres como por ejemplo tenemos el tu 00:09:48

aper string que lo que hace es pillar todas las cadenas y ponerla en mayúscula tenemos el punto 00:09:54

length que es un método que me va a contar cuántos caracteres tiene esta string que me devuelve 00:10:01

cuantos caracteres tienen, todo esto son comportamientos 00:10:06

son 00:10:08

funcionalidades útiles 00:10:09

para el mundo de los strings 00:10:13

y yo los junto todos 00:10:14

dentro de la clase string 00:10:16

de esta forma yo luego podré crear objetos string 00:10:18

y todos estos objetos 00:10:20

podrán hacer los comportamientos 00:10:22

que he definido, podrán decirme 00:10:24

cuantos son largos, podrán 00:10:26

mudarse a mayúscula, podrán mudarse a minúscula 00:10:27

podrán pillar un trozo 00:10:30

de sí mismo haciendo el substring 00:10:33

Pueden compararse con otra string 00:10:34

Y todo esto son comportamientos de ese objeto 00:10:38

¿Sí? 00:10:41

¿Dudas hasta aquí? 00:10:46

Esta introducción teórica 00:10:47

Ahora, empezamos otra vez 00:10:49

Y algunas cosillas de estas 00:10:51

Las repetiremos 00:10:53

Algunas otras cosas que hay que aprender 00:10:54

¿Vale? 00:10:56

Entonces, programación orientada a objetos 00:10:56

¿Vale? 00:10:58

Programación orientada a objetos es un paradigma de programación 00:10:59

Cuyo elemento estructural principal es el objeto 00:11:02

¿Vale? 00:11:04

este concepto de objeto lo tenemos que entender. 00:11:04

Tenemos que entender muy bien la diferencia 00:11:07

entre objeto y clase, porque 00:11:09

luego la vamos a utilizar constantemente. A partir 00:11:11

de ahora, todo lo que hacemos son objetos 00:11:13

y clases. 00:11:15

Tened en cuenta que en la programación 00:11:17

estructurada, esta misma frase 00:11:19

sería la programación estructurada, 00:11:21

en el paradigma 00:11:22

de programación, cuyo elemento estructural 00:11:25

principal es 00:11:26

la función. 00:11:27

Lo hemos dicho antes. 00:11:30

Aquí estamos en el objeto. 00:11:32

La función es un concepto menos potente del objeto, menos estructurado, menos organizado del objeto. 00:11:34

El objeto es un paso más en la organización de un proyecto, de un paradigma de programación. 00:11:46

Es algo más potente que una función. 00:11:53

El objeto incluye funciones, pero incluye varias funciones todas juntas. 00:11:56

el elemento estructural principal 00:12:01

lo dice aquí, en la función 00:12:04

las mejoras que aporta 00:12:06

la programación orientada a objetos 00:12:08

son análisis, la mente humana 00:12:11

piensa más fácilmente en objetos que en 00:12:13

procesos y datos de forma separada 00:12:15

esto 00:12:17

la programación orientada a objetos 00:12:18

nos ayuda también a entender 00:12:20

mejor problemas complejos 00:12:22

y organizarlos para hacer 00:12:25

un proyecto, cuando yo me pongo ahí 00:12:26

y digo, a ver, quiero modelizar 00:12:29

una escuela y me pongo a pensar qué es que sirve en una escuela. Cada uno de los elementos 00:12:30

que saco para modelizar esta escuela, pues probablemente son objetos y van todos, son 00:12:39

conceptos que van todos juntos con determinados comportamientos, con determinadas funcionalidades 00:12:45

que para la mente humana, como la mente humana está acostumbrada a tratar con estas cosas, 00:12:51

pues es más fácil con respecto a organizar lo mismo en un mundo sin objetos como la programación estructurada. 00:12:56

O sea que me permite hacer cosas más complejas de forma más, entre comillas, natural, 00:13:05

de forma más cercana a cómo normalmente pienso el mundo alrededor. 00:13:12

Por ejemplo, en una escuela. ¿Qué os sirve de una escuela? 00:13:18

¿Queréis vosotros hacer un programa que gestione una escuela? ¿Qué necesitáis? 00:13:21

Alumnos, ¿vale? Un objeto será el alumno. 00:13:26

Entonces, yo dentro de mi programa crearé una clase alumno y desde esta clase podré crear objetos, ¿vale? 00:13:31

Alumnos. ¿Qué me interesa de un alumno? 00:13:40

Notas. 00:13:44

Curso, exámenes, nombre, asistencia. 00:13:47

todas estas cosas se pueden 00:13:53

modelizar de alguna forma 00:13:56

dentro del objeto alumno 00:13:58

habrá cosas muy sencillas 00:14:00

como nombre, que se podrá 00:14:02

modelizar con un string 00:14:04

habrá edad del alumno 00:14:05

si me interesa saber la edad 00:14:08

o el curso, que se puede modelizar con un int 00:14:10

las notas 00:14:12

o las materias que cursa 00:14:15

a lo mejor ya son un poquito 00:14:17

más complejas 00:14:18

a lo mejor de una 00:14:19

O sea, notas y materia tienen que ir juntitos, ¿vale? 00:14:21

¿Por qué no quiero tener notas, tres, cinco, siete, cuatro? 00:14:26

¿De qué materias? Pues no lo sé. 00:14:30

Tendrán que ir juntas con otras, ¿vale? 00:14:33

Entonces a lo mejor yo me puedo crear un objeto materia 00:14:36

que dentro tenga una calificación, ¿vale? 00:14:40

Un nombre, una calificación, y luego al alumno le asocio 00:14:44

¿Qué le asocio para poderle dar notas en varias materias? 00:14:49

¿Cómo hago dentro del alumno? 00:14:57

Tengo un int que es su edad. 00:15:00

Tengo un string que es su nombre. 00:15:03

¿Cómo le doy? 00:15:05

Asumiendo que tengo las materias que son el nombre de la materia con su nota. 00:15:07

Pensamos en notas medias, finales o lo que sea. 00:15:11

Una nota sola por materia. 00:15:14

¿Cómo puedo hacer que dentro del alumno haya un array de qué? 00:15:15

Las notas, el curso, las materias 00:15:22

Un array de materia 00:15:25

Siendo materia, cada elemento del array será un objeto a su vez 00:15:27

Que dentro tendrá, que materia es con su nota 00:15:33

¿Se entiende? 00:15:36

entonces, habrá 00:15:38

características de los 00:15:41

objetos que son sencillitas 00:15:43

¿vale? el nombre, un string 00:15:45

cuidado 00:15:47

el string es ya un objeto 00:15:49

o sea, ya estáis haciendo que ponéis dentro 00:15:51

de un objeto otro objeto, pero bueno 00:15:53

el string es el nombre 00:15:54

la edad es un int, muy fácil 00:15:57

pero luego habrá un array 00:15:59

de materias, siendo 00:16:01

cada posición un objeto materia 00:16:03

y dentro del objeto materia tendré el nombre 00:16:05

de la materia con su nombre 00:16:07

¿Cómo cambio esto para que dentro de la materia de programación te pueda dar más de una nota? 00:16:08

¿Cómo cambiaríais vosotros para que un alumno que tenga una red de materias pueda tener por cada materia varias notas? 00:16:21

Una opción, repito la materia en notas, o sea, programación 5, luego programación 4, programación 3, va a bajar. 00:16:31

o 00:16:43

¿qué podría hacer? 00:16:46

claro, que en la materia dentro 00:16:51

además del nombre y una nota sola 00:16:53

en vez de una nota sola 00:16:55

tengo un array de notas 00:16:56

entonces cuando yo tengo la materia programación 00:16:58

dentro puedo encontrar todas las notas 00:17:01

de él 00:17:03

interesante, ahora tengo 00:17:05

alumno Estefano con 00:17:07

materia programación, notas 00:17:09

10, 10, 10, 10, 10, 10 00:17:11

muy bueno esto de la materia 00:17:13

¿qué me podría 00:17:14

interesar de la materia? 00:17:16

una funcionalidad de materia que me podría interesar 00:17:18

¿entendéis? tengo una materia 00:17:21

que está su nombre 00:17:24

y tiene una red de notas 00:17:26

que son las calificaciones que he obtenido 00:17:29

en todos los exámenes 00:17:30

algo que podría pedir a este objeto 00:17:31

la media 00:17:34

pues calcula media 00:17:36

podría ser 00:17:38

uno de los métodos de materia 00:17:40

y este método estaría asociado con el objeto materia. 00:17:43

Entonces ya tengo dos objetos. 00:17:50

Tengo el objeto alumno y tengo el objeto materia. 00:17:52

El objeto alumno tiene un array de materias 00:17:55

y el objeto materia tiene nombre, un array de notas 00:17:58

y tiene la posibilidad de calcular su media. 00:18:03

¿Qué más podría preguntar a una materia? 00:18:07

Otra funcionalidad que podría tener el objeto materia. 00:18:13

Es nota más alta, ¿vale? 00:18:17

Tengo otro método que es, dame nota más alta. 00:18:18

Perfecto. 00:18:21

¿Qué números están por encima del 5? 00:18:22

¿Cuántos exámenes ha aprobado? 00:18:24

Entonces me recorre la red y mira cuántos 5 más tiene, me dice 3. 00:18:26

¿Más? 00:18:31

Si ha aprobado la materia o no. 00:18:31

Si ha aprobado la materia o no. 00:18:33

Entonces tendré otra funcionalidad que es, has aprobado, que me devuelve true. 00:18:34

Si la media es superior a 5 y ha aprobado al menos 4 exámenes y... 00:18:38

¿Entendéis lo que quiero decir? 00:18:44

Y como esto es muy lógico desde una perspectiva humana, 00:18:46

o sea, nosotros lo estamos hablando así, 00:18:51

ahora lo tenemos que plasmar en el ordenador, ¿vale? 00:18:52

Pero entender lo que vamos a hacer, 00:18:55

entender qué son los objetos de mi sistema 00:18:58

y qué tengo que modelizar, 00:19:00

es muy cercano a lo que nosotros podemos pensar 00:19:02

y cómo vemos la realidad, ¿vale? 00:19:07

Ahora nosotros aprenderemos, una vez que yo tengo esta idea 00:19:10

y más o menos la he hecho en un papel, 00:19:13

pues ahora la transformó y creó el programa correcto. 00:19:14

¿Dudas? 00:19:18

¿Entonces los métodos son los ejercicios que hemos estado haciendo hasta ahora? 00:19:20

En un cierto sentido, algunos de los ejercicios que hemos hecho nosotros podrían ser métodos. 00:19:24

De hecho, nosotros hacíamos ahora todo como main. 00:19:31

Ahora, esto de aquí le podría dar un nombre. 00:19:37

Esto de aquí, ¿qué hacía? Calculaba la área del triángulo. 00:19:39

Pues lo llamo calcular a triángulo y lo pongo dentro del objeto triángulo para que un objeto triángulo pueda calcularse su área. 00:19:41

Y así, así, así, con todo eso. 00:19:51

Vale, entonces, análisis, lo hemos entendido. 00:19:55

Escalabilidad. 00:19:57

Es más fácil añadir nuevas funcionalidades o ampliar las que ya existen, ¿vale? 00:19:59

Complicar, hacer más complejo y completo un sistema es mucho más fácil. 00:20:04

Antes, yo tenía todas las funciones allí mezcladas. 00:20:09

y tenía que añadir algo, lo añadía aquí 00:20:13

y cuando otro lo buscaba 00:20:15

pues ¿dónde lo has añadido? Pues a mitad 00:20:18

de este fichero, quién sabe dónde. Pues ahora 00:20:19

si yo añado la funcionalidad 00:20:22

aprobado 00:20:24

general, ¿vale? Que te da 5 00:20:26

a todas las materias, 00:20:28

que te da 5 a todas las 00:20:29

notas de una materia, 00:20:31

¿en qué objeto 00:20:34

lo añadiríais vosotros? 00:20:36

Tengo una función que si has 00:20:39

aprobado general, te pone 5 en 00:20:41

todas tus calificaciones de una materia. 00:20:43

¿Dónde vais? 00:20:46

¿En materia o en alumno? 00:20:47

En materia. 00:20:50

Materia tendrá una función 00:20:53

que es aprobado general, que si tú 00:20:54

le llamas, sustituye todas tus calificaciones con 5. 00:20:56

Luego se hará, yo accederé 00:20:59

a un alumno, y a este alumno 00:21:00

accederé a su materia, y de este 00:21:02

su materia le diré, tú aprobado general. 00:21:04

Él se aplicará. 00:21:07

En alumno está una red de materias. 00:21:11

Mientras que en materia es una materia. 00:21:14

Eso, programación. 00:21:15

tiene su array de calificación. 00:21:17

Base de datos, tiene su array de calificación. 00:21:19

Depende de cómo entiendas la función. 00:21:23

A lo mejor no es el ejemplo mejor. 00:21:26

Pero la idea es que, dada una funcionalidad, 00:21:28

tú puedes pensar dónde la voy a poner. 00:21:31

Y la asociarás con el elemento, con el objeto, 00:21:34

en la clase donde tú piensas, donde tienes que estar. 00:21:38

De esta forma, cuando uno viene y dice, 00:21:44

oye, mira, esta función, ¿dónde está? 00:21:45

Pues lo puede saber tranquilamente 00:21:48

porque si se usa sobre un determinado objeto 00:21:49

sabe que estará definida dentro 00:21:51

de este objeto. 00:21:53

Entonces es mucho más fácil encontrarlo, 00:21:55

es mucho más fácil decir, oye, mira, 00:21:57

quiero añadir una funcionalidad, sé dónde añadirla. 00:21:59

Esta funcionalidad es una nueva funcionalidad 00:22:02

¿de qué? ¿Del alumno? Pues le añade al alumno. 00:22:03

¿De la materia? Le añade a la materia. 00:22:05

Luego, no es que existe una cosa 00:22:07

se hace así. 00:22:09

Depende de vuestro proyecto. A lo mejor 00:22:11

hay algunos proyectos que tendrías 00:22:13

sentido añadirla en alumno, en algunos otros proyectos tiene sentido añadirla 00:22:15

en materia, otros en clase, otros en la escuela, qué sé yo. 00:22:20

Vale, estás hablando de que se puede interactuar entre objetos y también entre clases, ¿no? 00:22:26

¿Dentro del proyecto, en los paquetes, también...? 00:22:29

Lo hemos hecho, ¿vale? Cuando tú en una clase pones un string o pones un 00:22:31

escáner, estás interactuando con otro sujeto. La clase Scanner y la clase Strip. Nosotros, 00:22:36

en el ejemplo este aquí un poquito borroso que estamos haciendo, tenemos la clase alumno que 00:22:46

dentro tiene una red de materias, entonces está usando otra clase. Puedes usar entre paquetes 00:22:52

diferentes puedes usar entre entre mismos paquetes puede utilizar entre clases distintas entre 00:23:01

proyectos distintos pueden llegar hasta hasta donde llegue cuando nosotros hacemos arriba un 00:23:07

import lo que estamos diciendo es voy a usar una clase de otro paquete importa hay que escáner no 00:23:14

está en tu proyecto está en otro proyecto en otro lado cuando quieres usar arriba tienes que hacer 00:23:21

import javautil.scanner 00:23:27

porque el scanner es una clase 00:23:29

desarrollada dentro 00:23:31

del package java.util 00:23:33

reutilización del código 00:23:35

claramente si yo me he hecho un alumno 00:23:40

bien hecho con todos los datos 00:23:43

con todas las funcionalidades y ahora 00:23:45

en vez de una escuela 00:23:47

quiero hacer, o sea una escuela como la nuestra 00:23:49

quiero hacer otro tipo, una universidad 00:23:51

pues a lo mejor 00:23:53

la clase alumno la puedo pillar exactamente igual de reutilizar y ya tengo movilizado al alumno 00:23:55

claramente en una universidad habrá otras cosas extra que aquí no había y que tendré que modificar 00:24:02

puede que el alumno como base esté bien pero necesite algo más entonces pillaré como base 00:24:11

el alumno y lo extenderé con funcionalidades y con características más avanzadas creando el alumno 00:24:17

universitario, que es un alumno 00:24:24

pero algo más. 00:24:27

Esto se llama herencia. 00:24:28

¿Sí? Pero la 00:24:32

cosa fundamental es que puedo reutilizar el código. 00:24:34

Es fácil reutilizar el código. 00:24:36

Es sencillo porque como lo entiendo, 00:24:38

como entiendo los varios componentes, 00:24:40

y sé que todo lo relacionado a un alumno está 00:24:42

en la clase de alumno y todo lo relacionado a la materia 00:24:44

está en la clase de materia, si importo la 00:24:46

materia, si pillo materia, pues importo 00:24:48

con ella todas las funcionalidades de materia. 00:24:50

Entonces todo lo que podía hacer antes 00:24:53

sobre la materia lo puedo volver a hacer. 00:24:54

También en mi nuevo proyecto de universidad. 00:24:55

No sabemos todavía cómo creamos objetos. 00:25:01

Estamos con el concepto de que es un objeto y ya veremos cómo se crea un objeto. 00:25:11

Hemos creado un objeto. 00:25:17

New Scanner. 00:25:19

Ahí has creado un objeto. 00:25:21

Cuando tú haces string x es igual a cocodrilo, pues estás creando un objeto. 00:25:23

No haces con el new, porque string es un objeto súper especial y súper utilizado, por lo tanto han hecho cosas malas, 00:25:28

pero tú deberías hacer string x es igual a new string de cocodrilo. 00:25:36

¿Vale? La operativa new, la función new es la que crea un objeto. 00:25:42

Lo veréis. 00:25:46

Porque la raíz debajo era... 00:25:49

¿Sí? 00:25:53

Vale, jerarquística de la programación de los objetos 00:25:53

Creamos clases que definen unos datos y un comportamiento 00:25:57

Y creamos objetos de estas clases 00:26:01

¿Vale? 00:26:02

Entonces hay dos niveles 00:26:03

La clase es un concepto más abstracto 00:26:04

Los objetos se relacionan con la clase 00:26:07

O sea, cuando yo hago el alumno 00:26:09

¿Vale? 00:26:11

Que decíamos antes 00:26:12

Yo lo que defino es la clase alumno 00:26:13

Yo no defino el alumno Estefan 00:26:16

Yo defino la clase alumno 00:26:19

La clase alumno es genedad, genérica. 00:26:22

Yo digo que un alumno tiene un nombre, y un alumno tiene notas, y un alumno tiene edad. 00:26:28

Pero no estoy diciendo cómo se llama, no estoy diciendo qué edad tiene, ni no estoy diciendo qué materias tiene. 00:26:34

Estoy definiendo un molde de todos los alumnos tendrán un nombre. 00:26:40

Y estoy seguro que todos los alumnos tendrán un nombre. 00:26:45

Y estoy seguro que todos los alumnos tendrán materias. 00:26:48

¿Sí? Pero no sé ni qué nombre ni qué materias. 00:26:52

Es un poco como cuando yo creaba una variable, pero sin instanciarla, y la instanciaba después. 00:26:56

Cuando yo decía, no, int x es igual a scan.next. 00:27:03

Pues, ¿qué hay dentro de la variable x? 00:27:08

¿Qué número hay dentro de x? 00:27:13

No lo sé. Hasta que alguien no me meta un número ahí dentro, no lo sé. 00:27:15

Pero sé que cuando lanzaré este programa, pues dentro de X se pondrá un numerito. 00:27:19

Y a partir de ahora, donde yo pongo X, estoy usando ese numerito. 00:27:27

¿Sí? Es una cosa parecida. 00:27:32

La clase me define la estructura genérica de un elemento, de un concepto. 00:27:35

Tengo el alumno. El alumno tiene estas características, nombre y notas, ¿vale? 00:27:41

Estas funcionalidades, tiene la posibilidad de inscribirse a una nueva materia, de dejar otra materia, de estudiar por el examen, qué sé yo. 00:27:49

Estas son sus funcionalidades, ¿vale? 00:27:57

Todos los alumnos pueden matricularse, todos los alumnos pueden estudiar, si quieren, aprobar. 00:28:00

Pero no he creado un alumno concreto, he creado un molde, una descripción general del alumno, ¿se entiende? 00:28:08

Esa es la clase. 00:28:16

a partir de la clase 00:28:17

yo puedo crear un alumno 00:28:20

concreto 00:28:22

digo, vale, esta es la estructura que tiene 00:28:23

que tener, ahora créame el alumno 00:28:26

Estefano 00:28:28

con la materia 00:28:29

programación y con estas notas 00:28:32

que es distinto del 00:28:34

alumno Lidia 00:28:37

con esta 00:28:39

característica, con estas materias 00:28:41

con estas calificaciones 00:28:44

distintas. Los dos tienen la misma estructura y pueden hacer lo mismo. Tienen los mismos 00:28:46

métodos, los mismos comportamientos y los mismos atributos, las mismas características, 00:28:51

pero son dos objetos distintos. La clase es la generalización de los objetos. Los objetos 00:28:57

son instancias concretas de una clase. 00:29:11

¿Qué son estos? 00:29:29

¿Qué son estos? 00:29:39

Triángulos. 00:29:41

La clase es triángulo. 00:29:42

¿Qué característica tiene la clase triángulo? 00:29:46

Tres lados. 00:29:49

Una altura. 00:29:52

Una base de una altura. 00:29:53

No lo sé. 00:29:54

Lo que me interesa es un triángulo. 00:29:55

¿Vale? 00:29:57

Pongamos los tres lados. 00:29:57

Todos los triángulos tienen que tener tres lados. 00:29:59

Luego habrá este triángulo aquí, que es equilátero, 00:30:02

que resulta que tiene las tres lados iguales 00:30:06

y que son todos lados unos. 00:30:10

Esto es un objeto. 00:30:12

Es una instancia de la clase triángulo. 00:30:14

Hay otro objeto, que es este de aquí, 00:30:18

que tiene dos, dos y uno. 00:30:20

Es un triángulo isósceles. 00:30:22

Pero es un triángulo. 00:30:25

Es siempre de la clase triángulo, 00:30:27

pero es una instancia distinta. 00:30:29

Este triángulo es distinto de este otro triángulo. 00:30:31

Pero los dos comparten la misma estructura, que tienen tres lados. 00:30:34

Y que tienen el comportamiento cálcula-perímetro. 00:30:38

Ahora, si yo llamo cálcula-perímetro sobre este objeto, ¿qué me dará? 00:30:42

¿Cuánto es? 00:30:49

Tres. 00:30:51

¿Y si llamo cálcula-perímetro aquí? 00:30:52

Cinco. 00:30:55

¿He cambiado el mecanismo con el que cálculo el perímetro? 00:30:56

No. 00:31:01

No, la definición del cálculo a perímetro es siempre lado 1 más lado 2 más lado 3. 00:31:02

Pero si lo llamo sobre esta instancia de aquí, que tiene lado 1, 1, lado 2, 1 y lado 3, 1, 00:31:09

pues hará 1 más 1 más 1 y me da 3. 00:31:16

Si llamo el cálculo a perímetro, misma fórmula, ¿vale? 00:31:18

Pero sobre este objeto de aquí, que tiene 2, 2 y 1, pues hará 2 más 2 más 1. 00:31:22

Entonces me dará 5. 00:31:28

La clase define el método de la misma forma 00:31:29

Es pilla el lado 1, suma el lado 2, suma el lado 3 00:31:33

Pero luego, llamándolo sobre instancias distintas 00:31:37

Obtendré valores distintos 00:31:42

¿Entiendes? 00:31:44

Lo mismo los alumnos 00:31:48

Todos los alumnos tendrán sus nombres, tendrán su cadena 00:31:49

Pero si yo tengo la función saluda 00:31:53

Que dice, hola, soy 00:31:55

Y dice su nombre 00:31:57

o si lo llamo sobre el alumno 00:31:58

Estefano, dirá hola soy Estefano 00:32:00

si lo llamo sobre el objeto 00:32:02

Lidia, dirá hola soy Lidia 00:32:05

en la definición general 00:32:07

yo tendré una variable 00:32:09

que será string nombre 00:32:11

que tendrá dentro el nombre del alumno 00:32:12

y la definición de la función 00:32:14

saludas hará hola soy 00:32:17

más nombre 00:32:19

¿se entiende? 00:32:20

¿sí? 00:32:24

entonces clase general 00:32:25

genérica de una definición generalizada de lo que de lo que voy a modelizar a partir de allí es un 00:32:27

molde vale pensado el molde de lava de la playa no sólo tenéis el molde para la arena de un 00:32:38

pingüino vale entonces vosotros lo tenéis lo rellenáis de arena y hacéis un pingüino pues 00:32:44

ese es un objeto el molde se queda aquí todos tendrán la misma característica pero has creado 00:32:50

objeto que ahora está allí pues pongo otra vez arena al otro otro pingüino ahora tengo dos 00:32:56

objetos pingüinos tienen la misma característica pero son distintos si yo modifico a uno y le pongo 00:33:01

piedras para para hacerlo más bonito el otro es una cosa aparte entiende todos tienen la misma 00:33:07

estructura pero son dos objetos distintos dudas los objetos colaboran entre ellos para conseguir 00:33:14

algo, ¿vale? Una vez que yo he creado varias 00:33:25

clases y he creado varios objetos, 00:33:27

pues los objetos hablarán entre ellos 00:33:29

para hacer algo. ¿Qué quiere decir 00:33:31

hablar? Pues llamar ese método, 00:33:33

cambiar características, 00:33:35

hacer cosas, ¿vale? Sustancialmente 00:33:37

llamar métodos uno de otro. 00:33:39

¿Sí? Entonces yo tengo string, 00:33:41

es un objeto, pues lo que hago 00:33:43

es string le digo pues 00:33:45

to lowercase y lo que he 00:33:46

hecho es cambiar el objeto para que 00:33:49

se disminuya. Desde mi 00:33:50

programa he comunicado con 00:33:52

ese objeto para que haga algo. 00:33:55

Entre objetos, la forma que ahorrar es 00:33:58

pasándose mensajes, ¿vale? Haciendo llamadas 00:34:00

a métodos, sustancialmente. 00:34:02

Llamando métodos de alumno 00:34:04

de materia, materia de alumno, 00:34:06

coche de taller, 00:34:09

taller de... 00:34:10

de... ¿cómo se llama? 00:34:12

Mecánico. 00:34:14

Clase de profesor, 00:34:16

qué sé yo. Pues pueden 00:34:18

comunicarse entre ellos llamándose métodos 00:34:20

y pasándose parámetros, como hemos visto ayer 00:34:22

que he pasado a los parámetros del asunto. 00:34:24

Todas estas cosas las veremos. 00:34:28

Esto es muy genérico. 00:34:29

Ahora luego vemos un ejemplo. 00:34:31

Cada clase va a ocuparse de lo que es su responsabilidad. 00:34:33

El alumno se ocupa de alumno, la materia se ocupa de materia, 00:34:36

la aula se ocupa de las cosas de la aula, etc. 00:34:40

Por ejemplo, un coche puede ser una clase 00:34:45

con unas características o con seriedad propia. 00:34:48

Un coche puede tener como característica 00:34:50

color, marca, modelo y matrícula. 00:34:52

Entonces, todos los objetos 00:34:55

que yo creo a partir de este molde 00:34:57

serán coches 00:34:59

y que tendrán como características 00:35:00

el color, la marca, el modelo y la matrícula. 00:35:02

¿Sí? 00:35:06

Yo puedo pillar un objeto, coche, cualquiera 00:35:07

y saber que él tiene una matrícula. 00:35:09

Porque es parte de su estructura. 00:35:11

¿Sí? 00:35:15

Su funcionalidad puede ser 00:35:16

desplazarse o parar. 00:35:17

Entonces, yo puedo pillar un cualquier coche, 00:35:19

es decir desplázate o pillaron cualquier cosa decir para y él lo hará porque puede hacerlo 00:35:21

una clase de coches de responsabilidad de manejar todo aquello que tenga que ver con el coche un 00:35:28

garage con muchos coches puede hacer uso de ellas o un conductor también entonces yo tendré la clase 00:35:34

conductor y la clase taller que podrá utilizar los coches utilizar estas funcionalidades de aquí 00:35:41

Por ejemplo, un conductor puede usar la funcionalidad desplazarse de un coche para moverse de Madrid a Barcelona. 00:35:47

Cuando queramos que un coche se desplace en un garage, por ejemplo, tendremos que comunicarnos con el coche específico y dar la dirección a la que queremos que se desplace. 00:36:09

Entonces, si yo he hecho un sistema de administración, de un, ¿cómo se dice?, management de coches en talleres, pues tengo una plaza libre en el taller de calle mayor, pues pillo este coche y le digo, desplázate a calle mayor. 00:36:18

Pues ahora el coche está en calle mayor y puede ir al taller de calle mayor. 00:36:34

Allí no hay piezas, hay que moverlo a otro lado, pues le diré al coche, desplázate a otro lado. 00:36:38

¿Entendéis lo que quiero decir? 00:36:44

estamos a un nivel más abstracto 00:36:45

¿vale? pero en un 00:36:59

contexto de 00:37:01

no front-end, o sea, no que veas 00:37:02

el monigote, ma back-end 00:37:05

del proyecto, o sea, del juego 00:37:07

en el que tú tienes que 00:37:09

¿cómo se dice? modelizar 00:37:11

que tu player 00:37:15

está en esta zona 00:37:17

y que se toca este sitio 00:37:19

pasa algo, pues eso sería 00:37:21

una clase 00:37:23

jugador, con dentro a lo mejor 00:37:25

unas coordinadas para saber dónde está 00:37:27

y en base a dónde está en esas 00:37:29

coordinadas le dices, uy mira, ha pisado 00:37:31

una trampa, o mira, uuuh, está 00:37:33

salvo, o... no sé. 00:37:35

Pero sí, 00:37:38

un juego, o sea, un jugador 00:37:39

dentro de un juego, de un 00:37:41

programa que podemos hacer nosotros, se puede 00:37:43

modelizar con un... 00:37:45

Es más, normalmente 00:37:47

tú, lo que creas 00:37:49

es una entidad 00:37:51

genérica que tiene puntos de vida 00:37:53

y tienes punto daño 00:37:55

y tienes velocidad de ataque 00:37:57

luego a partir de esta entidad 00:37:59

creas tanto los monstruos como 00:38:01

los jugadores 00:38:03

tienen la misma cosa 00:38:04

solo que los jugadores también tendrán inventario 00:38:07

entonces tienen todos los objetos de inventario 00:38:09

clases 00:38:11

una clase es lo que 00:38:17

en el lenguaje de programación 00:38:20

nos va a permitir definir o construir 00:38:21

uno o varios objetos, ¿vale? 00:38:24

La clase es la definición general 00:38:26

de los objetos. Los objetos son 00:38:28

instancias de una clase. 00:38:30

Podemos decir que son moldes 00:38:32

para construir objetos. Estos moldes 00:38:34

tienen que ser escritos, programados 00:38:36

y cada molde va a tener unas características. 00:38:38

Un nombre, 00:38:41

atributos y métodos. 00:38:42

Entonces, cuando yo creo una clase, 00:38:45

le doy un nombre, 00:38:46

PublicClassAlumno. 00:38:48

Esta clase es 00:38:51

alumno, ¿vale? 00:38:52

Tendrá unos atributos, el nombre, el apellido, el DNI, el NIA, las materias, el curso, lo que me interese. 00:38:54

Y luego los métodos, lo que puede hacer, estudiar, darse de alta en una materia, hacer un examen. 00:39:07

por ejemplo, la clase Persona se define en un fichero que tiene el mismo nombre de extensión, 00:39:15

.java. 00:39:26

Porque la clase Persona nosotros la haremos en el fichero Persona.java, esto lo sabemos 00:39:27

desde el principio. 00:39:34

La palabra reservada class define una clase, definimos los atributos, los datos relevantes 00:39:35

y los métodos. 00:39:42

Por ejemplo, vosotros no habéis visto todavía UML. 00:39:43

Es el Modeling Language. 00:39:47

Lo veréis en el entorno de desarrollo. 00:39:49

Pero en UML se define así. 00:39:53

Hay como cajitas, hay un diagrama que se llama el diagrama de clases 00:39:56

que te permite definir las clases. 00:40:00

Es un documento que te pueden dar y tú dices, vale, a partir de aquí, pues creo la clase. 00:40:02

Esta es una clase de una persona. 00:40:07

tiene como atributos 00:40:09

el nombre que es un string 00:40:11

y la edad que es un int, estas son las cosas 00:40:13

que me interesan de esta persona 00:40:15

y luego tiene un método escribir 00:40:16

que no recibe ningún parámetro 00:40:19

y que no devuelve ningún parámetro 00:40:21

por lo tanto es un procedimiento 00:40:23

no es una función 00:40:24

y que hará algo 00:40:26

escribir a lo mejor escribe hola soy 00:40:28

su nombre y tengo 00:40:30

su edad 00:40:32

¿vale? 00:40:33

¿cómo se traduce esto 00:40:36

en Java 00:40:38

tenemos public class persona 00:40:39

esto es persona 00:40:42

la P mayúscula, la primera letra 00:40:44

mayúscula siempre lo hemos hecho, esto va 00:40:48

en el fichero persona.java 00:40:50

luego abro llaves 00:40:51

y fijaos, fuera 00:40:54

del main, fuera de cualquier 00:40:56

otro método 00:40:58

estoy dentro 00:41:00

del bloque public class 00:41:02

donde no hemos escrito nunca, si os acordáis 00:41:03

la primera vez y yo decía, aquí no escribimos nunca 00:41:06

por un rato, luego escribiremos aquí también. 00:41:08

¿Vale? Pues pongo 00:41:11

una serie de variables 00:41:12

que serán los 00:41:15

atributos de esta persona. 00:41:16

Pregunta para vosotros. 00:41:19

¿Cuál es el ámbito de estas variables? 00:41:20

La clase persona. 00:41:26

Es decir, que todos los 00:41:28

métodos de la clase persona 00:41:30

podrán acceder a estas variables. 00:41:32

Son variables que son compartidas 00:41:35

por todos los métodos. Todos los métodos pueden acceder al nombre y todos los métodos 00:41:38

pueden acceder a la edad. Son características 00:41:42

propias de lo que luego será el objeto. Cuando yo creeré el objeto 00:41:46

tendré que instanciar el nombre y la edad. 00:41:50

Y luego tengo, Pablo, y que voy a describir, que es este método de aquí. 00:41:55

¿Veis que vacío no recibe ningún parámetro? 00:42:00

Aquí no tiene, en las paréntesis no tiene nada. 00:42:04

y devuelve nada. 00:42:06

Por lo tanto, voy. 00:42:09

Fijaos que no está el static. 00:42:11

¿Vale? 00:42:15

Porque esto es un método del objeto. 00:42:16

Cuando los métodos son de los objetos, 00:42:19

no tienen el static. 00:42:22

Y luego, si quiero, 00:42:25

porque una clase puede no tener main, 00:42:27

lo veremos, 00:42:29

pues le puedo poner un main para probar esta clase. 00:42:31

Si yo quiero aquí crear un objeto persona 00:42:34

y hacerle hacer algo, 00:42:36

pues entonces me creo un main, como lo hemos creado, y aquí dentro haré lo que tengo que 00:42:37

hacer para crear este main. Crear una persona, hacer que salude, escribir algo, etcétera. 00:42:42

Pero lo que me interesa es que cuando yo quiero crear alumno, public class alumno, 00:42:49

que tenía alumno dentro, tenía public string nombre, public int edad, y tendrá un public 00:42:55

materia, con corchete, porque será un array de materia, ¿vale? 00:43:01

Punto y coma. 00:43:08

Fijaos que no se instancian. 00:43:09

Yo no he puesto aquí public string nombre Estefano, 00:43:11

porque este es el molde general. 00:43:14

Tú tendrás un nombre. 00:43:16

¿Cuál es este nombre? 00:43:18

No lo sé. 00:43:19

Cuando creerás una persona, le pondrás cómo se llama. 00:43:19

Cuando creerás un alumno, le pondrás cómo se llama el alumno. 00:43:23

¿Entienden? 00:43:27

Y luego, ¿qué hacía el alumno? 00:43:29

el alumno estudiaba, tendré public void estudiar. Si quiero que estudie un libro concreto, 00:43:31

tendré public void estudiar libro entre paréntesis libro n, libro l. Lo haremos estas cosas, ¿vale? 00:43:38

El clases en un archivo solo puede haber una clase public, ¿vale? Public class persona 00:43:50

está en persona.java y solo puede 00:43:58

haber esta public class, pero en el 00:44:00

mismo archivo puede haber otras clases 00:44:02

que no sean public. 00:44:04

Por ahora no, en un futuro ya 00:44:06

los pondremos. Entonces yo puedo hacer 00:44:08

public class alumno 00:44:10

y luego más abajo poner class materia. 00:44:12

No es pública. 00:44:15

¿Qué quiere decir? 00:44:16

Puede haber otras 00:44:19

contenidas, pero no accesible desde el exterior. 00:44:20

¿Vale? Puede haber private 00:44:23

class materia, quiere decir que solo 00:44:24

desde dentro de esa clase se 00:44:26

puede acceder a las demás. 00:44:28

Los atributos de una clase 00:44:30

son propios de la misma 00:44:32

y se podrán consultar internamente 00:44:34

por parte de los métodos de la misma. 00:44:36

O sea, como los atributos tienen 00:44:39

como ámbito toda la clase, 00:44:40

desde los métodos se pueden acceder, 00:44:42

se pueden ver, se pueden andar a trabajar. 00:44:44

¿Vale? Hay sistemas 00:44:46

para que esto sea más difícil 00:44:48

o más fácil, para que a lo mejor yo quiero 00:44:50

que se vean desde dentro de todo el 00:44:52

package o desde dentro de todo el proyecto 00:44:54

o cosas por el estilo, ya veremos cómo se va. 00:44:56

¿Qué es un objeto? Un objeto es un elemento concreto de la clase definida, una instancia 00:44:58

de la clase. Yo tengo el molde, pongo la arena y hago nuestra llamada. En el momento de la 00:45:08

ejecución, no antes, se crean los objetos de la clase para los cuales hemos escrito 00:45:17

código. La clase es la idea general. Cuando luego ejecuto el programa, el programa se 00:45:24

para decir, ahora créame tres alumnos, el primero 00:45:28

se llama Paco, vale, perfecto, he creado 00:45:30

el alumno, objeto con nombre 00:45:32

Paco, ahora créame otra persona 00:45:34

que se llame no sé qué, pues me 00:45:36

crea el objeto persona que se llama no sé qué 00:45:38

etcétera, etcétera, ¿sí? 00:45:40

Cada 00:45:44

objeto tendrá un nombre para 00:45:44

poder utilizarlo en nuestro programa, vale 00:45:46

una referencia, como una 00:45:48

las variables que hemos creado 00:45:50

nosotros, cuando yo creo string x 00:45:52

estoy creando un objeto string 00:45:54

y su nombre para poder manipularlo 00:45:56

es este x. Cuando creo string 00:45:58

nombre, estoy creando un objeto string 00:46:00

que tiene como nombre para poder 00:46:02

manipularlo, nombre. ¿Entienden? 00:46:03

Un objeto 00:46:07

va a tener estas cosas. Va a tener 00:46:08

una identidad. O sea, 00:46:10

cada objeto es distinto 00:46:12

de otros objetos. Si yo tengo un objeto 00:46:14

persona aquí y otro objeto persona aquí, 00:46:16

si cambio el nombre a la persona 1, 00:46:18

la persona 2 no se ve 00:46:20

afectada. 00:46:22

Si yo tengo Stefano y Lidia, 00:46:24

dos personas, y ahora 00:46:26

a Estéfano le cambio el nombre en 00:46:27

Superestéfano, pues 00:46:29

a Superestéfano le he cambiado el nombre, pero 00:46:31

Lidia se sigue llamando Lidia. Son dos objetos 00:46:33

individuales. 00:46:36

¿Sí? 00:46:38

Atributos. El estado. 00:46:40

O sea, cada objeto, mientras que 00:46:41

en la clase yo he definido cuáles 00:46:43

son las características, 00:46:46

el objeto las tendrá estanciadas. 00:46:48

Si os acordáis aquí, 00:46:50

nosotros hemos dicho, la persona tiene 00:46:52

nombre y edad. Pero no te digo 00:46:53

qué nombre y qué edad. Ahora, 00:46:56

Un objeto sí te tengo que decir qué nombre tiene y sí te tengo que decir qué edad tiene. 00:46:57

La clase no tiene un valor específico para el nombre, pero un objeto sí. 00:47:03

Como antes los triángulos. 00:47:13

Todos los triángulos tienen tres lados, pero un objeto concreto de triángulo tendrá lado 1, 1, lado 2, 2 y lado 3, 7. 00:47:15

Creo que no es un triángulo. 00:47:23

¿Sí? 00:47:25

Y luego tendrá unos métodos, ¿vale? O sea, lo que puede hacer. 00:47:28

Una vez que tengo a la persona, puedo decir, persona, saluda. 00:47:33

Y Estefano le dirá, hola, soy Super Estefano, que es lo que me duele. 00:47:35

Aquí os lo he explicado un poquito. 00:47:42

La identidad, los objetos se crean en una memoria RAM, 00:47:43

en una zona de la memoria que se llama el chip. 00:47:46

Lo hemos visto alguna vez. 00:47:51

Su identidad se definirá con un valor de referencia único del objeto. 00:47:53

¿Os acordáis qué es esto? 00:47:57

Efectivamente. 00:48:08

¿Os acordáis que cuando decíamos que entre objetos no se puede hacer el punto equals porque lo que está comparando no es el objeto mismo? 00:48:09

No, no se puede usar el igual igual porque no está comparando lo que es el objeto, sino la referencia. 00:48:17

Porque nosotros los objetos los trabajamos por referencia. 00:48:22

Cuando yo creo un nuevo objeto, lo que obtengo es un puntador, una dirección, un lugar de la memoria donde allí está este objeto. 00:48:27

¿Vale? 00:48:37

Entonces, esta referencia me guía a donde empieza en la memoria este objeto. 00:48:38

Es un código especial que ya vas a utilizar para decir, 00:48:43

¿estos son objetos o no? 00:48:47

¿Sarán distintos el objeto persona Estefano y el objeto persona Lidia? 00:48:48

Pues son dos objetos distintos. 00:48:53

Y tendrán referencia, número de referencia distinto. 00:48:55

Por eso, si yo hago igual, igual, pues me dirán que no. 00:48:58

Hasta si yo quiero una persona que se llama Estefano 00:49:01

y otra persona que se llama Estefano, 00:49:03

estos son dos objetos distintos 00:49:06

y si cambio 00:49:08

el primer Stéfano 00:49:11

a otro nombre, el segundo Stéfano 00:49:12

se queda Stéfano 00:49:15

¿sí? volveremos 00:49:16

sobre este tema 00:49:19

el Java no se trabaja con DCM de memoria 00:49:19

gracias, ¿vale? 00:49:22

se usa un concepto más abstracto 00:49:24

¿vale? el nombre simple es lo que identifica un objeto 00:49:27

en algunos lenguajes de programación 00:49:29

como CE o C++ 00:49:31

C++ se orienta a objetos 00:49:32

tenéis que manipular la memoria. 00:49:34

Cuando creáis un objeto, 00:49:37

le tenéis que decir, oye, mira, reserva 00:49:39

este trozo de memoria y allí 00:49:40

me creas el objeto. Y que 00:49:42

cuando ya no lo usáis, le tenéis que decir, 00:49:44

oye, mira, destruyeme esa memoria 00:49:46

y líberala. 00:49:48

¿Sí? 00:49:51

En Java, gracias, pues 00:49:52

esto no lo hacemos. Yo quiero un objeto, 00:49:54

digo, hazme un objeto. Y es la 00:49:56

Java Virtual Machine que se encarga de encontrar 00:49:58

dónde está 00:50:00

Entonces, decíamos, aquí en Java yo no me refiero a construir un trozo de memoria y luego trabajo con esta memoria, 00:50:01

como en C++ o cosas por el estilo, sino que yo tengo una referencia al bloque de memoria, 00:50:23

no sé cuánta memoria ha gastado, no sé 00:50:28

cómo gestiona la memoria, no sé 00:50:30

cuándo destruye o cuándo crea un objeto, 00:50:32

pues que lo haga él. Lo hace 00:50:34

la Java de Tornosheet. Yo 00:50:36

paso de eso. Yo simplemente utilizaré 00:50:37

una referencia a ese objeto y él me lo 00:50:40

hace encontrar todo ya hecho. 00:50:42

Un objeto 00:50:45

es un valor que se puede asignar a 00:50:46

una variable cuyo tipo es la clase. 00:50:48

Entonces yo, un objeto string, 00:50:50

la clase string, puedo crear un objeto 00:50:52

que sea string x es igual 00:50:54

a no sé qué. Si hago un alumno, 00:50:56

puedo crear alumno 00:50:58

mi primer alumno, es igual 00:51:00

y creo un objeto alumno. 00:51:02

Si quiero hacer una persona, puedo hacer persona 00:51:04

mi persona, es igual 00:51:06

como hacía 00:51:08

las variables antes. Ahora haremos ejemplos. 00:51:10

Si queremos 00:51:13

crear un objeto tipo persona, 00:51:14

podemos identificar 00:51:16

persona alumno, por ejemplo. 00:51:17

¿Cuál es el nombre 00:51:22

de esta variable? 00:51:24

alumno, el tipo de esta variable 00:51:24

persona 00:51:29

el valor de esta variable 00:51:31

todavía no lo sé 00:51:33

no está estanciado 00:51:35

he creado la variable, pero no hay 00:51:36

dentro un objeto 00:51:39

¿sí? 00:51:40

llego hasta aquí y me paro 00:51:49

un momento, ¿vale? porque esto ya 00:51:51

lo hemos hablado, entonces hemos dicho que 00:51:52

siempre al final del objeto tenemos por un lado 00:51:54

la identificación, por otro lado los atributos 00:51:56

son las características que define 00:51:59

un objeto, ¿vale? 00:52:00

tiene una visibilidad 00:52:02

¿vale? este es el public 00:52:04

private protected, es decir 00:52:06

¿dónde se ven estas variables? 00:52:08

por ahora nosotros ponemos todo public 00:52:10

y se ve por todos lados, pero 00:52:12

luego más adelante empezaremos a cambiar 00:52:14

un poquito esta visibilidad 00:52:16

para proteger algunos datos 00:52:18

algunos datos que tienen que ser 00:52:20

importantes o 00:52:22

controlados 00:52:24

pues no quiero que alguien 00:52:25

desde fuera de mi proyecto entre y diga 00:52:28

cámbialo, entonces lo protejo, ¿vale? 00:52:30

Lo veo. 00:52:32

Los tipos pueden ser 00:52:35

o primitivos, int, float, 00:52:36

cosas por el estilo, otra clase, 00:52:38

string, scanner, persona, 00:52:40

alumno, coche, triángulo, 00:52:42

etcétera, etcétera, 00:52:45

y el identificador de atributos, ¿vale? 00:52:46

Por ejemplo, 00:52:48

nombres de tipo string, que es una clase, 00:52:51

edades de tipo int, que es un tipo 00:52:54

primitivo, ¿vale? 00:52:56

Y el estado de un objeto 00:52:57

será definido para los valores. 00:52:59

yo hago una fotografía instantánea 00:53:01

en un cierto momento, miro los valores 00:53:02

de todos sus atributos, ese es su estado 00:53:05

en este momento la persona 00:53:07

Estefano se llama Estefano 00:53:09

y tiene edad 44 00:53:11

fotografía 00:53:13

si cambio algo, porque es el cumpleaños 00:53:14

por ejemplo 00:53:17

cambia desde 44, 43, 44 00:53:18

o lo que sea, pues 00:53:21

ahora ha cambiado su estado 00:53:23

¿entiendes? 00:53:25

¿y los métodos? 00:53:27

Pues los métodos son los servicios que proporciona este objeto, lo que puede hacer este objeto, ¿vale? 00:53:29

Pues el objeto, hemos dicho persona, puede saludar, el objeto alumno puede estudiar, el objeto coche puede desplazarse o pararse, etc. 00:53:35

Cada uno de estos servicios es un método, y un método tiene un nombre, unos parámetros que utiliza y un valor que se devuelve, que puede ser void. 00:53:43

cuando yo defino una funcionalidad 00:53:53

le digo, ¿cómo se llama esta funcionalidad? 00:53:57

cálculo a perímetro 00:53:59

si pilla o no parámetros 00:54:00

¿vale? podría ser que le paso 00:54:02

los lados o que no le paso ningún lado 00:54:04

porque usa los atributos suyos 00:54:06

y luego si al final me devuelve 00:54:08

algo, por ejemplo, el cálculo a perímetro podría decir 00:54:10

me devuelves al final un int 00:54:12

porque hace la suma 00:54:14

de los lados y me lo devuelve 00:54:16

o un double o lo que sea 00:54:18

es importante 00:54:20

saber qué método implementó una clase, qué parámetros tiene que utilizar y qué devuelve, 00:54:22

¿vale? Porque si no, no puede utilizar los métodos. No es importante cómo se hacen las cosas, 00:54:27

sino qué se puede hacer. Cuando yo te digo el alumno puede estudiar, ¿vale? A mí no me interesa 00:54:32

qué hace el método estudiar. Eso puede ser hasta que lo implemente otra persona. ¿Println vosotros 00:54:39

la habéis implementado. 00:54:46

No. Pero la habéis 00:54:49

usado. ¿Qué hace 00:54:50

Println? ¿Cómo se hace escribir en 00:54:52

pantalla? Ni idea. 00:54:54

Pero lo usáis. 00:54:57

Lo usáis porque sabéis que existe 00:54:59

Println y que pilla un determinado 00:55:01

parámetro, que es un string. 00:55:03

Sabéis cómo se usa, 00:55:05

cómo hace las cosas, no me interesa. 00:55:07

Mismo concepto. Hay un 00:55:10

mogollón de clases 00:55:11

y de objetos por ahí 00:55:13

y yo los puedo utilizar sin saber 00:55:15

cómo lo hacen las cosas por debajo. 00:55:17

¿Sí? 00:55:21

Y esto me permite también reutilizar 00:55:22

el código, etcétera, etcétera. 00:55:24

Entonces ahora, 00:55:25

dispuesto a una breve pausa, 00:55:27

vamos a crear una clase. 00:55:29

¿Sí? Una clase 00:55:32

persona. Y vamos a ver qué podemos 00:55:33

hacer con ella. 00:55:35

¿Sí? Paro esto. 00:55:37

Vale. 00:55:41

Vamos a hacer 00:55:42

un poquito de práctica, ¿vale? 00:55:43

Para entender lo que hemos dicho hasta ahora en palabras abstractas, ¿vale? 00:55:45

Entonces, he creado un nuevo proyecto con objetos donde pondré los ejemplos, ¿vale? 00:55:52

Por favor, vamos a crear una nueva clase, ¿vale? 00:56:00

Y vamos a crear la clase Persona. 00:56:05

Esta es mi clase Persona, ¿vale? 00:56:11

¿Qué me interesa de una persona? 00:56:13

¿Cuáles son los atributos? 00:56:15

¿Cuáles son las características principales de una persona? 00:56:18

Pues string, nombre. 00:56:21

Fijaos que aparece un colorín nuevo. 00:56:25

Azul. 00:56:29

Antes esto era negro. 00:56:31

No era como un marroncito, un color amarillento, una cosa del estilo. 00:56:33

Ahora es azul. 00:56:38

Cuando es un atributo, lo marca de azul. 00:56:39

¿Vale? 00:56:42

Y fijaos dónde lo estoy escribiendo. 00:56:42

aquí no hay ningún main, e int edad. Me quedo aquí por ahora. Entonces, cada persona 00:56:44

que yo crearé tendrá un nombre o una edad. ¿Qué puede hacer una persona? Por ejemplo, 00:56:57

public void cumplirAños. ¿Qué hará la función cumplirAños? 00:57:06

Que cuando sea la fecha de la fecha de nacimiento, edad más uno, o algo así. 00:57:20

Vale, pero tú la llamarás el día de su cumpleaños. Hagámoslo sencillo. Entonces, ¿qué haré? 00:57:28

edad 00:57:32

más más 00:57:34

podría ser 00:57:36

que nosotros 00:57:40

cuando yo llamo cumplir años 00:57:42

quiera saber 00:57:44

cuál es la nueva edad 00:57:45

por lo tanto 00:57:47

podría decirle, oye mira, devuélveme un entero 00:57:49

haces edad más más 00:57:52

y devuelves 00:57:54

edad 00:57:56

ahora es una función, cuando yo llamo cumpleaños 00:57:57

cumplir años 00:58:02

Pues él pillará la edad actual de esta persona 00:58:03

Le hace cumplir el año 00:58:05

Entonces le pone un más más 00:58:07

Y luego me devuelve la nueva edad 00:58:08

Para que yo pueda usarla o no 00:58:11

¿Sí? 00:58:13

Muy bien 00:58:16

¿Qué más puede hacer una persona? 00:58:17

Saludar 00:58:23

En un momento, ¿eh? 00:58:23

Public 00:58:26

El saludar 00:58:26

Yo quiero que la persona diga 00:58:30

Ahora me llamo su nombre 00:58:31

Y tengo no sé cuántos años 00:58:33

¿Vale? 00:58:34

¿Devuelve algo? No. Voy. Saludad. Si, so. Hola. Soy. Más nombre. Más. Y tengo. Más edad. Más años. 00:58:35

fijaos que este nombre, este dad 00:59:01

son azules 00:59:05

como estos 00:59:06

fijaos que si yo aquí hago 00:59:08

int 00:59:11

num 00:59:11

es igual a 3 00:59:13

lo veis que esto no es azul 00:59:16

esta es una variable local, solo existe aquí dentro 00:59:18

mientras esta es una variable 00:59:21

del objeto 00:59:23

existe en toda la versión 00:59:24

¿si? 00:59:26

¿lo veis la diferencia, no? 00:59:29

bueno 00:59:31

una persona pero puede saludar no en general no a una persona concreta a 00:59:31

alguien vale entonces yo tendré public void saludar string nombre del otro esto 00:59:39

es un método que me pilla una variable un parámetro yo te voy a decir oye 00:59:54

persona saluda a Juan. Entonces él dirá, hola Juan, soy mi nombre y tengo mi edad. 01:00:02

Aquí se han aparecido, pero aquí pondrá, hola, más nombre del otro. Ahora, ¿os he 01:00:11

dicho yo qué persona es esta? ¿Quién es? 01:00:41

¿No? ¿Os he dicho quién es el otro 01:00:45

que saluda? ¿Veis que aquí es todo 01:00:48

genérico? No sé. Yo sé 01:00:50

cómo lo va a hacer. Sé qué va a hacer. 01:00:53

Pero no sé con qué datos 01:00:57

exactamente va a hacer. Luego volveremos aquí. 01:00:59

¿Vale? Imaginámonos que yo 01:01:08

quiera saber la edad sin cumplir los años. 01:01:11

¿Puedo? 01:01:14

nosotros por ahora esto lo hemos dicho que son public 01:01:15

¿vale? 01:01:19

luego veremos que hay 01:01:21

hagamos uno 01:01:23

public 01:01:27

int 01:01:29

get edad 01:01:31

normalmente 01:01:33

aquellos métodos que lo que hacen 01:01:34

es devolver uno de los 01:01:38

atributos, se llaman 01:01:39

getters, son get 01:01:41

y el atributo, get 01:01:43

nombre me dará nombre, get edad me dará edad. Entonces tengo get edad, que lo que hace es 01:01:45

return, edad. Fijaos que esto no escribe nada en pantalla, solo que cuando lo llamo yo tendré 01:01:53

de vuelta la edad de esta persona en este momento. Y luego existen los sectors. Los 01:02:03

sectors son para modificar la cosa. Por ejemplo, si yo quiero cambiar mi nombre, pues tendré 01:02:12

public void set nombre que lo que hará es nombre es igual algo a nuevo nombre como le paso nuevo 01:02:18

nombre string nuevo nombre si entonces yo me echo mi clase a mi clase persona lo que hace es tener 01:02:36

un nombre, una edad. Todas las personas 01:02:56

tendrán un nombre y edad. ¿Qué pueden hacer todas las personas? 01:02:58

Pueden cumplir el año, 01:03:00

pueden saludar, pueden saludar 01:03:02

a otra persona, a otro nombre 01:03:04

que le doy yo, o pueden 01:03:06

saber, puedo saber su edad 01:03:08

o puedo cambiar su nombre. 01:03:10

¿Vale? 01:03:13

Perfecto. 01:03:15

Ahora podría hacer un main 01:03:17

y usar esta persona. 01:03:18

¿Vale? O usar varias personas. 01:03:20

El main lo puedo hacer aquí, 01:03:22

Pero para cambiar un poco las cosas 01:03:24

Lo voy a hacer en otra clase 01:03:26

¿Vale? 01:03:28

Para ver qué se puede hacer 01:03:29

Antes 01:03:30

A ver si se me ha olvidado algo 01:03:32

Ahora tenemos 01:03:35

Vamos a hacer antes la otra clase 01:03:39

Y luego nos crea una clase 01:03:41

Lo podría hacer aquí 01:03:44

¿Vale? 01:03:46

Pero para que veáis 01:03:46

Luego a lo mejor lo muevo aquí 01:03:47

La clase que será main persona 01:03:50

que es la clase que va a usar 01:03:53

la persona. 01:03:56

Esta sí tiene un main. 01:03:58

Mi punto de acceso de mi proyecto 01:04:00

empezará aquí. 01:04:02

Fijaos que persona 01:04:05

no tiene un main. 01:04:06

Persona por sí misma no se puede 01:04:08

ejecutar, no hace nada. 01:04:10

Persona me 01:04:12

representa una persona, pero por sí 01:04:14

misma no hace nada. Será 01:04:16

otro proyecto que creará personas 01:04:17

y las hará interactuar entre ellas. 01:04:19

Entonces, la pregunta ahora es, vale, ¿y cómo creo personas? 01:04:23

Yo sé que puedo hacer persona, persona1, como variable. 01:04:28

Yo puedo crear una variable de tipo persona. 01:04:36

Pero, ¿cómo le meto dentro a una persona? 01:04:40

Vamos a ver. 01:04:43

Para crear un objeto se necesita un constructor. 01:04:45

¿Vale? 01:04:51

Un constructor es un método especial 01:04:51

¿Vale? 01:04:54

Que no devuelve nada 01:04:56

Pero no en el sentido que devuelve void 01:04:58

Que tampoco devuelve void 01:05:00

¿Qué devuelve? 01:05:02

Devuelve un objeto de esa clase 01:05:07

¿Vale? 01:05:09

Entonces 01:05:12

Para crear 01:05:13

A ver, aquí se me perdió algo 01:05:16

Además una clase proporciona un método especial 01:05:19

Que son constructores 01:05:21

Que son los que se encargan de crear nuevos objetos de esa clase 01:05:22

Si tiene que llamar exactamente igual que la clase. 01:05:25

¿Vale? 01:05:29

O sea, el constructor de persona se llamará persona. 01:05:29

Muy bien. 01:05:32

Los métodos constructores no devuelven nada. 01:05:33

Porque en realidad devuelven un objeto de esa clase. 01:05:36

Entonces, como solo devuelve un objeto de esa clase, 01:05:39

pues no se le pone cosa que devuelve. 01:05:41

Se ejecutan al momento de la creación del objeto. 01:05:43

Cuando tú haces la creación del objeto, 01:05:46

pues se ejecuta ese constructor. 01:05:48

Para usar un constructor, tengo que usar el comando new. 01:05:51

Y el código contenido de los constructores se suele usar para inicializar los atributos del objeto. 01:05:55

A ver si quitas de pronto el ejemplo. 01:06:02

Si no defino ningún constructor, o sea, actualmente yo en la clase persona no he definido ningún constructor, ¿justo? 01:06:06

Pues existe un constructor por defecto. 01:06:13

El constructor por defecto inicializa los atributos como pueda. 01:06:16

O sea, int lo inicializa a cero, las variables numéricas en general a cero, los booleanos 01:06:21

a falso, los objetos a nulo, que es un comodín para decir que no existe ningún objeto. 01:06:30

Si defino yo un constructor, si digo, vale, no, espera, no uses el constructor por defecto, 01:06:42

un constructor mío propio, puede ser inautomático y el constructor por defecto deja de existir. 01:06:47

Y si yo quiero un constructor por defecto igual antes, tengo que construir también eso. Ahora lo 01:06:53

veremos. Se pueden definir distintos constructores. Por ejemplo, un constructor de una persona que 01:06:59

pide nombre y edad y otro constructor de una persona que solo pide el nombre y que asuma 01:07:04

que la edad sea cero. Nace un nuevo niño, creo la persona, le doy el nombre y se da el cero. 01:07:10

Ejemplo. Public Persona, lo veis aquí. Con String Enter. Y aquí define. Y esto 01:07:17

a veces solo con el nombre. Vamos a crearlo aquí. En vez de darle un ejemplo, lo creamos 01:07:29

ahí. Entonces, me voy a crear una persona ahora. New Persona. Y ya está. Esto está 01:07:35

creando el constructor por defecto de persona porque porque aquí no hay ningún 01:07:48

constructor todavía no lo ha creado entonces por defecto él me ha creado una 01:07:53

persona así y ahora le puedo decir persona 1 01:07:59

saluda quien me escribirá esto en pantalla 01:08:04

Hola, soy nada y tengo nada años. 01:08:22

A no ser que si no está... 01:08:26

¿Otras opciones? 01:08:28

A ver. 01:08:31

Hola, nul y cero. 01:08:32

Hola, soy nul y tengo cero años. 01:08:35

Porque int es cero. 01:08:40

El valor por defecto de int es cero. 01:08:43

El valor por defecto de string, siendo string un objeto, es nulo. 01:08:46

Por lo tanto, me debería escribir. 01:08:50

Hola, soy Nuli y tengo cero años. 01:08:56

Ahora, hagámosles cumplir años. 01:09:02

Persona 1, cumplir años. 01:09:05

Y ahora saluda otra vez. 01:09:11

Persona 1, punto saludar. 01:09:13

En principio tiene cero años. 01:09:21

Aquí ha cumplido dos años. 01:09:23

Y ahora dice que tiene uno. 01:09:24

¿Qué le cuesta? 01:09:27

Un boli. 01:09:30

Sí. 01:09:32

Vale, ahora, como cumplir años no hace nada, podríamos poner que en cumpleaños, cuando lo hace, escribe también 01:09:32

Cumpleaños feliz 01:09:44

Vale, en italiano si aprendéis 01:09:50

Santiago, riarte 01:09:57

Sí, es lo más bonito. 01:10:10

¿Sí? 01:10:12

Vale, entonces, si os fijáis, he modificado el cumplir años, 01:10:22

y ahora cuando llamo a cumplir años, me escribe aquí Tantia Curiatez. 01:10:25

¿Sí? 01:10:29

Vale. 01:10:32

Ahora, pero crear una persona así que se llame null, 01:10:34

vamos a crear nosotros 01:10:39

un constructor 01:10:42

vale, entonces decimos 01:10:44

cuando creo una persona 01:10:45

normalmente yo lo pongo justo después 01:10:47

de los atributos, los constructores 01:10:49

atributo, constructores, métodos 01:10:52

vale, entonces yo hago 01:10:54

public persona 01:10:56

que parámetros 01:10:58

pilla 01:10:59

mi constructor 01:11:00

tendrá un string 01:11:03

nombre 01:11:06

e un int 01:11:07

edad. 01:11:10

¿No veis que se llaman igual 01:11:13

pero este es azul 01:11:14

y esto es 01:11:16

es 01:11:17

no sé qué color es este. 01:11:18

Marlón. 01:11:22

Por ahora hagámoslo así. 01:11:24

¿Vale? 01:11:27

Entonces, ahora voy aquí 01:11:28

y le digo 01:11:30

nombre es igual a n 01:11:31

edad 01:11:35

es igual a n. 01:11:37

esto que está haciendo me crea una persona a esta persona el constructor me dice cuando 01:11:38

creas una persona tienes que pasarme un string un entero el string que me has pasado lo usaré 01:11:46

como nombre el entero que más pasado lo usaré como ya ahora si yo guardo esto me 01:11:53

persona se enfada. ¿Por qué se enfada? 01:12:04

Porque el constructor por defecto deja de existir. 01:12:09

Porque el constructor por defecto ha dejado de existir. El constructor por defecto, que es 01:12:14

el que no tiene parámetros, ahora ya no existe. Entonces no puedo crear 01:12:19

una persona usando el constructor sin parámetros. ¿Entiendes? 01:12:24

¿Y si yo lo quisiera? Si yo lo quisiera, debería aquí, explícitamente, crearme un public Persona sin parámetros, 01:12:33

que ahora pondrá nombre anónimo y edad 0. 01:12:45

Ahora vuelve a no quejarse, pero ahora no me dirá soy null, me dirá soy anónimo, 01:12:54

Porque yo aquí la he, si ahora lo lanzo, veis, me dice soy anónimo, porque ha usado el constructor sin parámetros. 01:13:04

Entonces ha usado este constructor de aquí y entonces ha puesto nombre anónimo edad cero. 01:13:19

¿Sí? 01:13:27

¿Y cómo hago desde aquí para usar este otro constructor en vez? 01:13:29

Hola, soy Sara, tengo 34 años 01:13:33

Anteaburete 01:13:56

Hola, soy Sara, tengo 35 años 01:13:57

Vamos a ver un momento el consultor, por favor 01:14:00

Ah, bueno 01:14:05

Vale, muy bien 01:14:09

Hagamos saludar a Sara 01:14:16

Otra persona 01:14:19

¿A quién saludamos? 01:14:20

Paco 01:14:28

Hola, Paco, soy Sara 01:14:29

ahora no estoy usando 01:14:37

este método de aquí 01:14:39

pero estoy usando 01:14:42

este método de aquí 01:14:45

porque al haberme pasado un string 01:14:47

ahora 01:14:50

uso esto 01:14:51

¿se entiende? 01:14:53

¿sí? 01:15:07

persona 01:15:14

persona dos 01:15:15

es igual 01:15:17

a new persona 01:15:19

persona uno 01:15:21

punto saludar 01:15:33

¿cómo puedo hacer 01:15:35

que persona uno 01:15:43

salude a persona dos? 01:15:44

se enfada 01:15:55

¿por qué? 01:15:57

¿qué tipo tiene persona dos? 01:16:00

tipo persona 01:16:05

¿y qué necesito poner yo 01:16:07

dentro de saludar? 01:16:09

El nombre sería entonces el punto... 01:16:10

Entonces, ¿cómo puedo yo...? 01:16:13

Probámoslo. 01:16:15

Para ver el caos, ¿vale? 01:16:20

Le digo, ah, claro, haz así. 01:16:22

Y no funciona. 01:16:26

El caos. 01:16:29

¡Caos! 01:16:32

Está poniendo la referencia al objeto. 01:16:35

¿Qué es esto? 01:16:38

¿Qué es esto? 01:16:40

Mi paquete. 01:16:43

¿Qué es esto? 01:16:46

La clase. 01:16:52

¿Qué es esta cosa aquí? 01:16:54

Esta sería, 01:17:08

no es exactamente, pero la referencia 01:17:10

del objeto 01:17:12

cuando yo no sé 01:17:13

cómo se escribe un objeto 01:17:16

y él no lo sabe porque no se lo he dicho 01:17:18

pues me escribe, soy un objeto 01:17:19

de este tipo, et 01:17:22

a la posición 01:17:24

de memoria, ahí está 01:17:26

por lo tanto, no, esto no me vale 01:17:28

¿cómo podría hacer? 01:17:34

string 01:17:37

punto nombre 01:17:38

Esto es 01:17:41

Array.length 01:17:47

¿Recordáis? 01:17:49

¿Vale? 01:17:53

El length es un atributo 01:17:54

De la clase de los arrays 01:17:57

Aquí yo 01:17:59

Si tengo un objeto de persona 2 01:18:01

Puedo decir 01:18:03

Oye, mira, accede 01:18:05

A su campo nombre 01:18:07

Entonces ahora 01:18:09

Me dice, hola anónimo, soy Sara. ¿Por qué? Porque el pobre persona 2 es un anónimo. 01:18:11

Ahora modificamos estas cosas. Persona 2, punto, set nombre, ¿cuál tema es difícil? 01:18:22

¿Cómo? Pepe. 01:18:34

Hola, Pepe, soy Sara 01:18:35

y tengo 34 años 01:18:43

¿Lo veis? 01:18:45

¿Sí? 01:18:52

Cuando inicializas un objeto 01:18:58

para saber cuál es la diferencia entre uno y otro 01:19:00

sí o sí cogen 01:19:03

todos los atributos 01:19:04

no hay opción en la que pille 01:19:06

solo uno y otro 01:19:08

No se comparan los objetos 01:19:09

nos sabemos comparar objetos 01:19:12

si pero lo digo porque cuando creas 01:19:14

va a pillar todos los atributos 01:19:17

si o si 01:19:19

eso no hay opción 01:19:19

a ver, tú puedes pillar 01:19:21

nosotros hemos hecho uno 01:19:25

con dos atributos 01:19:27

y hemos hecho uno con 01:19:28

ninguno 01:19:30

podemos hacer uno con un atributo solo 01:19:31

y el hecho es que tú tienes que 01:19:34

inicializar las variables de alguna forma 01:19:36

si no las inicializas se inicializarán 01:19:38

a su valor por defecto. 01:19:41

Claro, pero si o si 01:19:43

si la pilla 01:19:43

el nuevo objeto 01:19:44

que se vaya a instanciar 01:19:45

si o si pilla 01:19:46

todos los atributos 01:19:47

entonces solo que no se... 01:19:48

Tendrá esos atributos 01:19:49

solo que no se van a instanciar. 01:19:50

Los objetos anul 01:19:53

en los tipos primitivos 01:19:54

a su valor primitivo. 01:19:55

Claro, y eso es 01:19:57

la diferencia 01:19:58

entre uno y otro. 01:19:58

Valores, 01:19:59

sus atributos, 01:20:00

los valores de los atributos 01:20:00

que se van a instanciar. 01:20:01

Puede no estar 01:20:05

también en los mismos valores. 01:20:06

Lo que lo diferencia 01:20:07

es que están en posiciones distintas. 01:20:08

Si yo creo 01:20:10

si yo creo persona 2 así 01:20:11

y ahora creo persona 3 así 01:20:13

estos tienen exactamente 01:20:15

los mismos valores 01:20:19

pero no son el mismo objeto 01:20:20

mirad 01:20:22

persona 2 01:20:25

punto saluda 01:20:29

y también 01:20:32

persona 3 01:20:38

estos dos señores 01:20:39

son lo mismo 01:20:47

si 01:20:50

ah bueno 01:20:53

SISO, persona 2, igual, igual, persona 3. 01:20:54

H. 01:21:06

Son dos copias de un objeto por los mismos valores. 01:21:11

Pero no son el mismo objeto. 01:21:17

De hecho, si yo ahora hago cumplir los años a persona 2, 01:21:19

y vuelvo a escribir los dos, no son el mismo objeto. 01:21:29

porque 01:21:34

esto 01:21:36

ha cumplido años 01:21:38

pero el otro no 01:21:40

si ahora le digo 01:21:41

escríbeme 01:21:44

esa cosa malvada que no sabemos 01:21:55

que es 01:21:57

dos y tres 01:21:57

veis que esto 01:21:59

es una persona 01:22:02

en esta locación 01:22:04

y esta es una persona en una locación 01:22:06

completamente distinta 01:22:08

son dos objetos distintos 01:22:09

ahora 01:22:13

persona 01:22:14

P4 es igual 01:22:16

a persona 2 01:22:19

y ahora aquí escribo 01:22:20

si hizo 01:22:27

P4 01:22:29

veis que esto y esto son iguales 01:22:30

estos son dos referencias 01:22:37

al mismo objeto 01:22:41

si ahora 01:22:43

Ahora yo hago persona dos punto cumpleaños y luego digo me imprimes, saludas, P4 punto 01:22:45

saludar. Veis que persona cuatro ha cumplido años. Pero en ningún lado he hecho P4 punto 01:22:59

cumpleaños. Pero es que esto y esto son lo mismo. De hecho... 01:23:15

¿Proyecta? ¿Truque? ¿Cuál es el concepto? Sí, con muchos conceptos, ¿eh? 01:23:30

Pregunta para vosotros, ¿vale? Entonces, nosotros hemos hecho un método saludar 01:23:44

que no tiene nada y que dice, hola, soy no sé qué, tengo edad, ¿vale? Un método que 01:23:50

dice, oye mira, te doy un string y tú escribes lo que sea. ¿Puedo saludar a una persona? ¿Cómo haría? 01:23:56

Quiero un método saludar que salude a una persona, no a un string, no a un nada. 01:24:15

Voluntarios. No todos a la vez, por favor. 01:24:24

Quiero un método saludar 01:24:27

Pero que no salude una string 01:24:36

Salude una persona 01:24:38

¿Cómo lo hago? 01:24:39

Saludar persona 01:24:43

Dictamente 01:24:45

Public void 01:24:47

Saludar 01:24:50

Persona 01:24:52

Persona 01:24:56

¿Y qué hago? 01:24:58

Sí, son. 01:25:04

¿Y yo? 01:25:05

Hola. 01:25:07

Hola. 01:25:08

Más. 01:25:09

Persona. 01:25:10

Más. 01:25:12

Más. 01:25:16

O sea, bien, sí, más, bien, sí. 01:25:17

No. 01:25:18

Si pongan así, me pone el código real. 01:25:19

Ah, punto, nombre. 01:25:22

Bien, sí. 01:25:25

Bien, son. 01:25:26

Entonces, ahora lo que voy a hacer es acceder a la persona que me has pasado como parámetro, ¿no? 01:25:36

y acceder allí 01:25:42

a ese objeto 01:25:44

a su campo nombre 01:25:45

y lo pongo aquí 01:25:47

entonces ahora 01:25:49

esto me permite 01:25:52

en el lado 01:25:53

aquí, limpio un poco 01:25:55

porque si no 01:25:58

aquí tengo tres personas 01:25:59

¿vale? dámosles nombres 01:26:01

distintos, este es Paco 01:26:04

que tiene 18 años 01:26:05

esto es 01:26:08

Entonces, ahora puede hacer que persona 1, punto, saludar, persona 2. 01:26:10

Ahora, ¿cuál de estos tres métodos estará utilizando? 01:26:39

¿Veis? Esto funciona. Hola, Paco. Soy Sara. Son los dos espacios. 01:26:44

¿Cuál de estos tres métodos está utilizando? ¿Esto, esto o esto? 01:26:49

El último. 01:26:58

¿No veis que los tres métodos se llaman igual? 01:27:00

¿En qué se diferencian? 01:27:04

En los parámetros que le estás pasando. 01:27:07

En los parámetros que le estás pasando. 01:27:09

Esto se llama sobrecarga del método. 01:27:12

Un método se puede sobrecargar. 01:27:16

Overload, en inglés. 01:27:23

Overload, que no es overwrite, que es otra cosa que veremos más adelante. 01:27:26

¿Qué quiere decir? 01:27:31

Los métodos se pueden diferenciar si su firma es distinta. 01:27:34

La firma de un método es su nombre y los tipos de parámetros. 01:27:40

O sea, la firma de esto es saludar void. 01:27:49

La firma de esto es saludar string. 01:27:53

La firma de esto es saludar persona. 01:27:57

Yo no puedo poner otro método que tenga la misma firma de un método ya existente. 01:28:00

Pero se llaman distinto. 01:28:18

Encima no cuenta cómo se llaman. 01:28:21

Conta el tipo. 01:28:22

La firma de esto es saludar de string. 01:28:24

La firma de esto es saludar de string. 01:28:27

Pero, si yo cambio esto y pongo int repetición, 01:28:31

pues ya la firma de esto aquí es saludar de string, int. 01:28:37

Por lo tanto, es distinto de los demás. 01:28:42

¿Cómo sé cuál de esto uso? 01:28:44

Dependiendo de los parámetros que me pasas. 01:28:46

No me pasas parámetros. 01:28:48

uso el que no tiene parámetro 01:28:49

me pasa solo un string, uso esto 01:28:51

me pasa un string de un int, uso esto 01:28:53

me pasa una persona, uso esto 01:28:56

es lo mismo que pasa 01:28:58

con println, lo hemos visto ayer 01:29:02

println está sobrecargado 01:29:03

porque hay un println 01:29:06

de string, un println de int 01:29:08

un println de double, un println de float 01:29:09

un println de... 01:29:12

¿entiendes? 01:29:16

vale, como uso esto 01:29:18

¿qué hace esto aquí? claramente 01:29:20

for 01:29:22

y si es igual a cero 01:29:23

y menor que rep 01:29:27

y más más 01:29:30

¿vale? entonces ahora tengo 01:29:32

un método que se usa 01:29:48

un string 01:29:50

y luego 01:29:52

le pongo cuatro 01:29:54

pues saluda a esta persona cuatro veces 01:29:56

¿sí? útil 01:29:58

no, pero 01:30:10

¿dudas? 01:30:11

entonces tú el mismo método 01:30:16

esto te serviría para que 01:30:18

diferentes funciones el mismo método según los parámetros no no no esto te sirve para crear la 01:30:20

misma función pero con parámetros distintos lo que no tenéis que hacer bajo ningún concepto es 01:30:25

que saludar haga una cosa cuando lo llamas con string y una cosa completamente distinta cuando 01:30:34

lo llamas con int eso está mal porque yo cuando cuando leo el saludar me espero que salude y si 01:30:39

Y cuando lo llamo saludar con un int, me saluda diciendo hola. 01:30:47

Y cuando lo salga con un string, lo que me hace es calcular la media de las asignaturas. 01:30:50

Digo, ¿qué es eso? 01:30:56

Saludar tiene que hacer lo mismo. 01:30:58

Lo que pasa es que lo hace con distintos parámetros. 01:31:00

Saludar, saluda. 01:31:03

Luego puede saludar un anónimo, puede saludar sin decir el nombre, puede saludar diciendo el nombre de una persona, 01:31:04

puede saludar saludando a la persona, puede saludar a la persona cuatro veces, puede saludar a la persona calurosamente, puede saludar... 01:31:09

No lo sé, creo. 01:31:16

Y en el caso de una función, también se podría sobrecargarlo, ¿no? 01:31:18

Esta es una función, es verdad. 01:31:23

Esto es un... 01:31:25

Métodos son... esto es un... 01:31:27

En el momento en que aquí devuelves... perdón. 01:31:29

Aquí devuelves algo, pues es un... pero es lo mismo. 01:31:31

Nosotros somos métodos, ¿vale? 01:31:34

Que luego devuelvo un valor o no... 01:31:36

Sí, pero en una función que te tiene que devolver también puedes sobrecargarlo. 01:31:38

Porque no. 01:31:42

Y igualmente te tiene que devolver el valor en el tipo de... 01:31:44

Tienen que hacer lo que tienen que hacer. 01:31:48

Si tú quieres hacer una cosa distinta, no lo llames igual. 01:31:49

Vale. 01:31:52

Si tú ahora quieres hacer una cosa que no hace saludar, pues llámalo cocodrilo. 01:31:53

Vale. 01:31:57

¿Por qué lo quieres llamar igual? 01:31:58

O sea, llamarlo igual le llevaría a confusión. 01:32:00

Porque luego tú tienes que recordar que saludar de int hace una cosa 01:32:02

y saludar de flota hace una cosa completamente distinta. 01:32:07

No es lógico. 01:32:10

Interesante. 01:32:11

Ahora, ¿qué más podemos hacer con estas cosas? ¿Más o menos? Vale, ahora mirad esta cosa aquí, 01:32:12

que luego la veremos más en un futuro, pero ¿qué pasa si yo aquí le pongo privado? 01:32:21

Que el nombre no se veía. 01:32:28

Que ahora nombre se ve solo dentro de persona. O sea, que aquí yo lo puedo usar porque estoy 01:32:32

dentro de persona y pueda acceder a su nombre pero cuando desde fuera desde una 01:32:44

clase que no es persona intentó acceder al nombre pero como podría acceder 01:32:51

a esto desde fuera debería crearme un método que me permite eso public 01:33:03

string get nombre return nombre 01:33:19

Entonces, ahora aquí, este método es public. Entonces, yo lo puedo llamar desde fuera. 01:33:28

public string getNombre, returnNombre. Y el método getNombre sí se puede llamar desde fuera, 01:33:38

porque es public. Yo no puedo acceder al atributo nombre, pero sí puedo acceder al tipo nombre. 01:33:54

¿Qué ha logrado con esto? 01:34:01

¿Qué utilidad tiene haber hecho esta cosa? 01:34:07

¿Qué ha logrado con esto? 01:34:12

¿Qué ha logrado con esto? Fijaos, vuelvo a ser público. ¿Lo puedo leer? 01:34:18

Persona dos punto nombre es igual a... 01:34:36

igual a cocodrilo. Y ahora lo llamo otra vez persona2, ya se llama cocodrilo. Ahora, si 01:34:39

yo pongo esto private, ya no puede. O sea, con este jueguecito he programado la posibilidad 01:35:01

de que las personas desde fuera 01:35:20

pueden saber mi nombre 01:35:23

pero no lo pueden sobreescribir 01:35:24

esta cosa aquí 01:35:27

es privada 01:35:33

solo se puede acceder desde persona 01:35:34

esto quiere decir que si yo 01:35:36

intento acceder desde fuera 01:35:39

no puedo 01:35:40

me dice es privada 01:35:42

aquí encima dice 01:35:43

no lo puedo ver 01:35:45

esto quiere decir que he hecho 01:35:48

un atributo que es de sola lectura. Lo puedo leer, porque hay una forma de leerlo, pero 01:35:53

no lo puedo modificar. No lo puedo modificar. Sí que puedo, porque tengo siete nombres 01:36:01

que es público. Ahora, ¿qué pasa, pero? Que yo aquí podría poner que si tienes los 01:36:11

privilegios, entonces sí cámbialo. Si tienes 01:36:21

los permisos para cambiarlo, entonces 01:36:24

cámbialo. Pero si no los tienes, no. 01:36:29

Por ejemplo, anescan. 01:36:33

es igual a newscanner. 01:36:36

System.ring. Si eso, dame la password. 01:36:41

ring.vd es igual 01:36:55

a scan.next.cfd.equals1,2,3,4, pues entonces cambia el nombre. 01:36:58

Se ha implementado un nivel de seguridad increíblemente alto, ¿vale? 01:37:26

Creo que tengo un error por algún lado. 01:37:37

Falta una. 01:37:40

Falta, tenemos ya. 01:37:42

Y, sustancialmente, lo que me hace es, si tú intentas hacer el set nombre, 01:37:46

fijaos que no puedo ahora directamente cambiarlo porque es privado. 01:37:51

Desde fuera no lo puedo cambiar. 01:37:54

pero puedo decir, oye mira 01:37:56

intenta cambiarlo con get 01:37:58

con set nombre 01:38:00

entonces ahora me dice 01:38:01

vale, muy bien, pero que hará 01:38:13

ahora intenta 01:38:15

llamar el set nombre 01:38:17

y cuando intenta cambiar el set nombre 01:38:19

me dice, para, para, para, para, dame la password 01:38:21

si yo la password 01:38:23

es correcta, entonces 01:38:25

la persona cambiará su nombre, dirá 01:38:27

si tú no eres el administrador 01:38:29

y no tienes la password, esta operación no te deja hacer 01:38:31

dame la password 01:38:33

Pico, pico, pico, pico, pico y cinco. Pues veis que sigue siendo Paco. Sin embargo, si soy el administrador y tengo la clave secreta, la del PIN de mi banco, mi espera ha cambiado. 01:38:40

¿Dudas? Lo he dicho porque es la del PIN de vuestro banco también, ¿sabéis? 01:38:59

Nadie se cree que la vas a tener. 01:39:06

¿Qué hora es eso? 01:39:09

Psicología. 01:39:11

Ahora, esto es una tontería, porque alguien mira el código y sabe en password, pero si 01:39:12

este de aquí fuera un acceso a una base de datos, donde en esta base de datos están 01:39:18

el usuario, los usuarios administradores, que queda si tú eres un administrador, en 01:39:23

el caso de un administrador te permite cambiar, en el caso de que no eres un administrador 01:39:27

no te permite, pues ya sería una cosa distinta. 01:39:30

Segundo de DAM en acceso a datos. 01:39:33

básicamente el set 01:39:39

porque no estoy viendo otro sentido, sería 01:39:41

para eso, porque si no, ¿para qué lo harías 01:39:43

privado? O sea, set y get, si tú 01:39:45

pones un public aquí 01:39:47

no te sirve de nada el set y get 01:39:49

¿vale? La idea, pero es 01:39:51

que tú deberías proteger 01:39:53

tus objetos diciendo 01:39:55

los objetos, los atributos, los hago 01:39:57

privados y doy la 01:39:59

posibilidad de get y set 01:40:01

a las otras personas 01:40:03

pero controlados 01:40:04

tanto en el get como en el set 01:40:06

yo puedo añadir código 01:40:09

la ventaja del CET y del GET 01:40:10

que nosotros normalmente no usamos, normalmente lo usamos así 01:40:12

pero en la realidad 01:40:15

es que tú deberías aquí poner 01:40:16

un código que proteja 01:40:18

ese atributo 01:40:20

diciendo, mira, te voy a dar la edad 01:40:22

solo si tú tienes 01:40:24

los derechos 01:40:26

si tú eres esa persona, si tú eres 01:40:28

un administrador, si tú tienes una password 01:40:30

si tú tienes un certificado 01:40:33

entonces eso lo codificaría aquí 01:40:34

es la diferencia de 01:40:37

si yo pongo private 01:40:38

cualquiera puede leerlo 01:40:39

y escribirlo sin ningún control 01:40:43

o sea, yo puedo ahora 01:40:45

acceder a persona3 01:40:47

punto edad 01:40:49

y decirle, tienes menos 8 años 01:40:52

perfecto 01:40:55

pero yo podría decir 01:40:57

no, mira, vamos a hacer otra cosa 01:41:00

vamos a hacer que 01:41:02

edad es privada 01:41:04

y que cuando alguien 01:41:05

hace un set de edad 01:41:08

¿Dónde está? No está todavía. Tenemos el get, pero no el set, ¿vale? 01:41:09

Cuando alguien hace un public void set edad que me da un entero e, 01:41:15

yo compruebo que e sea mayor que cero. 01:41:26

Si e es mayor que cero, edad es igual a e. 01:41:31

Esto quiere decir que ahora cuando alguien intentará acceder a edad no puede, 01:41:40

dice, vale, no te preocupes, lo intento 01:41:44

con set de edad 01:41:46

e intento darte 01:41:47

un valor negativo 01:41:50

y esto no lo permito. 01:41:51

Y ahora hago persona tres 01:41:58

punto saludar. 01:42:00

Estefano ahora saludará, pero no 01:42:06

con menos ocho años, con la edad que tengo. 01:42:08

Porque 01:42:11

como menos ocho es negativo, pues lo he 01:42:15

controlado. Entonces, esto me permite decir 01:42:17

ok, te doy la posibilidad de acceder 01:42:19

y de modificarlo, pero 01:42:22

según mis reglas, un valor negativo 01:42:23

no te permito darlo. 01:42:25

Valor superior a 120 no te permito darlo. 01:42:27

Que luego, en un futuro, 01:42:32

aquí lo podemos hacer es 01:42:34

else 01:42:35

close 01:42:36

new 01:42:39

extraction 01:42:46

Entonces, 01:42:48

explode. Si tú intentas 01:42:57

un error, pues que salte un error 01:43:03

que luego 01:43:05

alguien puede recoger diciendo 01:43:07

alguien ha intentado poner un dato que no es 01:43:09

correcto. Y a lo mejor desloguear 01:43:11

el usuario que lo ha intentado porque es 01:43:13

un usuario malicioso. O ponerle un 01:43:15

tico por algún lado y decir, lo has intentado una vez. 01:43:17

La tercera vez que intentas hacer 01:43:20

algo que no es de mi sistema, te ha hecho el sistema. 01:43:21

Y de allí 01:43:25

puedes complicar cuando te da. 01:43:25

Vale, cosilla. 01:43:28

Pero yo, a mí no me 01:43:30

gusta hacer las cosas sencillas. 01:43:31

¿Vale? Y cuando voy 01:43:33

a leer esto, no entiendo 01:43:34

qué es N y qué es E. 01:43:37

¿Qué es N? 01:43:39

¿Qué es N? 01:43:40

Ni idea. ¿Es el nombre? Ah, pongo 01:43:42

nombre. Ah. 01:43:44

Int, edad. 01:43:47

Ahora sí que lo entiendo. 01:43:49

¿Qué ha pasado? 01:43:54

Vamos a ver qué hace. Pues lo lanzo. 01:44:00

Uy, soy nule. 01:44:05

Tengo cero años. ¿Qué ha pasado? 01:44:06

¿Veis los colorines? 01:44:12

lo veis que no está cambiando estos porque aquí he creado unas variables local y entonces aquí 01:44:13

dentro tiene prioridad este nombre a esta edad y me está simplemente diciendo oye mira pone dentro 01:44:25

de la variable localidad lo que hay dentro de la realidad no está cambiando nada podría hacer 01:44:32

setNombre 01:44:45

de nombre. 01:44:47

Sí. 01:44:51

Y además sería guay 01:44:53

porque si yo en setNombre 01:44:55

he puesto algunas condiciones 01:44:57

para decir el nombre no tiene que ser más largo 01:44:59

de 20 gratis, pues aquí 01:45:01

lo está aplicando. Pero 01:45:03

¿cómo hago yo a decir 01:45:07

oye, quiero usar esto? 01:45:12

Porque cuando estoy fuera 01:45:14

yo puedo hacer 01:45:16

persona3.nombre 01:45:17

entonces es el nombre 01:45:19

del objeto persona3 01:45:21

pero cuando estoy aquí 01:45:23

¿cómo hago a decir, oye, quiero el nombre 01:45:24

pero no el nombre este de aquí 01:45:29

quiero el nombre 01:45:31

del objeto 01:45:32

¿sí me explico? o sea, quiero el nombre 01:45:34

del objeto que 01:45:37

seré, que pero ahora 01:45:39

no soy, porque ahora estoy definiendo la clase 01:45:41

no hay ningún objeto aquí 01:45:43

¿pero cómo hago referencia al objeto 01:45:44

que construiré en un futuro 01:45:47

si todavía no tengo la referencia. 01:45:49

Dis. 01:45:55

Ah, y la palabra reservada 01:45:55

dis, este, este objeto. 01:46:00

Entonces, dis.nombre 01:46:03

accede a este objeto 01:46:06

su variable nombre. 01:46:08

Y aquí lo puedo usar 01:46:11

porque estoy dentro de persona, 01:46:12

entonces nombre, hasta si es privado, 01:46:14

pero es accesible. 01:46:16

Es porque es bonito 01:46:30

cuando tú haces un constructor 01:46:40

que lo que le pases 01:46:41

tenga el mismo nombre 01:46:43

de lo que efectivamente van a instanciar. 01:46:46

Pero si no le pongo el dis 01:46:48

tiene el problema que es ambiguo. 01:46:50

Y él lo pilla como local 01:46:53

en vez que como así. 01:46:54

Entonces para desambiguar 01:46:56

yo le estoy diciendo que el nombre que me has pasado 01:46:57

tú como variable local, ponlo 01:47:00

dentro de este objeto 01:47:02

su campo nombre. 01:47:04

Esto me vale 01:47:09

si es público, si es privado, 01:47:10

normalmente los 01:47:12

constructores suelen tener 01:47:13

este aspecto. 01:47:16

Si lo piensas, cuando yo 01:47:21

hago set nombre 01:47:22

de nombre, 01:47:23

oye, set nombre 01:47:30

¿de qué objeto? 01:47:31

De este nombre. 01:47:35

es que estoy haciendo 01:47:36

dis.setNombre 01:47:43

sin decirlo 01:47:44

claro, pero eso sería lo mismo que lo que has puesto arriba 01:47:46

¿verdad? 01:47:50

ese dis.setNombre sería 01:47:52

lo mismo que dis.nombre 01:47:54

no es lo mismo 01:47:57

porque dis.nombre cambia directamente 01:47:59

esta variable, si yo aquí le pongo 01:48:01

pensa edad, ¿vale? 01:48:02

nosotros hemos dicho que edad tiene que ser positiva 01:48:05

yo aquí puedo pasarle menos 7 01:48:07

mientras que si usara 01:48:09

setedad, pues como pasa 01:48:13

por aquí, no me permite. 01:48:16

¿Sí? 01:48:24

Podría yo poner, 01:48:26

para que está seguro, 01:48:27

this.edad 01:48:30

es igual a 01:48:32

edad. 01:48:33

Porque esto ahora lo llamo edad. 01:48:35

Perdón, era edad. 01:48:42

Ahí. Ahora sí. 01:48:45

Y esto pone a cero. 01:48:47

Cuando tú llamas setedad, yo por defecto te lo pongo 01:48:48

a cero. Independientemente 01:48:51

del número que me has dado tú. 01:48:53

Si es un número aceptable, pongo el número que has puesto tú. 01:48:54

Y si no, lo dejo a cero. 01:49:01

Tú me pones menos ocho y te pongo cero, por defecto. 01:49:04

Entonces, ahora, si alguien hace aquí persona, Sara, de menos 34, 01:49:08

él con esto lo pillaría. 01:49:15

Con esto no. 01:49:19

pero nadie me prohíbe 01:49:20

aquí 01:49:25

hacer mi comprobación 01:49:26

si edad es mayor 01:49:28

que cero 01:49:31

pues ponle eso 01:49:31

de donde lo quieres hacer 01:49:33

como lo quieres hacer, si el setter ya lo tienes 01:49:41

si el getter ya lo tienes, si lo quieres poner 01:49:43

el getter y el setter, porque a lo mejor tú quieres 01:49:45

que edad no sea accesible 01:49:47

desde fuera, entonces si yo pillo 01:49:49

getter edad y me lo cargo 01:49:51

setter edad 01:49:53

y me lo cargo, y esto lo hago 01:49:55

privado. Pues ahora 01:49:57

la edad no la puedes 01:50:00

modificar desde fuera. La puedes 01:50:02

modificar solo con métodos 01:50:04

de mi clase, que son 01:50:06

cuando lo creas, puedes dar una edad 01:50:08

pero yo miro que sea 01:50:10

mayor que cero, para que tú no me 01:50:12

des un número negativo. Si me 01:50:14

das un número negativo, esto no lo haces, entonces 01:50:16

se queda al valor por defecto, o sea, cero. 01:50:18

Y que cuando 01:50:23

tú quieras aumentar, tienes que 01:50:24

cumplir los años. 01:50:26

En el que yo podría hacerlo más complejo, 01:50:28

decir qué día es hoy, cuál es tu cumpleaños 01:50:30

y en base a eso ver si te doy más uno 01:50:32

o no. 01:50:34

Pero ahora yo tengo una variable 01:50:36

que sólo gestionan mis 01:50:38

métodos. Y como yo sé cómo 01:50:40

tienen que funcionar, evito 01:50:42

que la gente me ponga años 7.000. 01:50:44

Evito que la 01:50:47

gente ponga años 01:50:47

menos 4.000. 01:50:50

Porque todos los métodos 01:50:51

los estoy gestionando yo. La edad 01:50:53

varía con métodos que funcionan 01:50:55

bien porque los he implementado yo como 01:50:57

programador. Tú puedes usar mis métodos, 01:50:59

pero como varía 01:51:02

y como gestiona, tú no puedes 01:51:03

directamente llegar a la edad y poner lo que te da 01:51:05

la gana. Tienes que pasar bajo mi control. 01:51:07

Porque no hay un método 01:51:10

o un acceso que te 01:51:11

permita poner lo que te da la gana en edad. 01:51:13

Esto es un tema 01:51:17

un poquito más avanzado. Se me ha ido por allí. 01:51:17

Existe. 01:51:21

Lo volveremos a ver. 01:51:21

entonces lo que sí que me interesa 01:51:22

es el dis 01:51:28

aquí está 01:51:29

y luego estamos en los métodos estáticos 01:51:32

y hemos acabado este bloque 01:51:37

ahora hacemos ejercicio 01:51:39

la diferencia entre los métodos 01:51:40

que nosotros hemos hecho ahora 01:51:46

todos los métodos lo veis que no tienen ninguno 01:51:47

estático 01:51:49

y los métodos estáticos 01:51:50

son que 01:51:54

los métodos no estáticos son sobre los objetos. Los métodos estáticos son sobre la clase. O sea, 01:51:56

un método que varía su comportamiento dependiendo del objeto sobre el que lo llamo es sin estático. 01:52:09

un objeto que hace lo mismo 01:52:20

lo llame sobre un objeto 01:52:24

lo llame sobre otro objeto 01:52:27

pues este método 01:52:28

es estable 01:52:30

con un ejemplo 01:52:31

voy a hacer una nueva clase 01:52:37

la clase triángulo 01:52:45

la clase triángulo tiene 01:52:54

interlado 1 01:52:57

interlado 2 01:52:58

interlado 3 01:53:00

tiene un método 01:53:02

public 01:53:04

no sé si estático o no 01:53:07

int 01:53:09

calcula perímetro 01:53:13

que haces return 01:53:15

L1 01:53:22

más L2 más L3 01:53:24

pregunta para vosotros 01:53:26

este triángulo 01:53:31

o sea este método 01:53:33

es estático o no 01:53:35

si lo llamo sobre triángulos distintos 01:53:36

da un resultado distinto 01:53:46

con el mismo resultado. No está. ¿Estamos a acuerdo con esto? Vale. public int calcula 01:53:49

perímetro de INT LADO1, INT LADO2, INT LADO3. RETURN LADO1 más LADO2 más LADO3. ¿Estático o no? 01:54:14

Vamos a ver la diferencia en un main. 01:54:38

Como os he dicho, el main lo puede hacer en otra clase, 01:55:10

pero también lo puede hacer aquí. 01:55:12

Entonces tengo un main. 01:55:14

Me creo dos triángulos. 01:55:15

Triángulo 1. 01:55:18

Triángulo de 1. 01:55:21

es igual a un nuevo triángulo. 01:55:22

¡Ay! ¿Qué me falta? 01:55:28

¡Exacto! 01:55:30

Constructor. 01:55:31

¡Pablo! 01:55:34

Triángulo 01:55:36

de 01:55:37

int L1 01:55:39

int L2 01:55:42

int 01:55:44

L3 01:55:46

dis.L1 01:55:49

es igual a L1 01:55:53

Dis.L2 es igual a L2 01:55:54

Dis.L3 es igual a L3 01:55:58

Es una versión simplificada 01:56:01

No todas las triplas de números son un triángulo 01:56:03

1, 1, 7000 no es un triángulo 01:56:08

Ok, vuelvo aquí 01:56:11

Entonces te digo 01:56:16

Fijaos que ya no existe el constructor por defecto 01:56:17

Porque he usado un constructor con 3 capas 01:56:21

3, 4, 5 01:56:23

Terno fitabólico 01:56:26

este es un triángulo, si, triángulo T2 es igual a new triángulo 3, 3, 3, triángulo equilátero del lado 3. 01:56:27

Ahora, si yo hago siso T1 punto cálculo a perímetro, o si yo hago siso T2 punto cálculo a perímetro, 01:56:45

A que estos me dan valores distintos 01:56:59

¿Por qué? 01:57:04

Porque calcula perímetro es un método propio del objeto 01:57:08

Y usará los atributos del objeto para calcularse 01:57:12

Entonces este objeto aquí que tiene como atributos 3, 4, 5 01:57:18

Hará 3 más 4 más 5 01:57:22

Mientras que este objeto aquí que tiene 3, 3, 3 01:57:24

Pues hará 3 más 3 más 3 01:57:27

¿Están de acuerdo hasta aquí? 01:57:29

Vale 01:57:31

Ahora, imaginámonos que esto no sea estático. 01:57:32

Entonces, si no es estático, yo no puedo llamar calcular perímetro de 4, 4, 4. 01:57:35

Bueno, espera que... 01:57:47

Vamos 5, 5, 5. 01:57:49

¿Y qué se enfada? ¿Por qué se enfada? 01:57:53

Me dice, the method calcular perímetro int, int, int is undefined for the type triángulo. 01:57:55

no puedo 01:58:03

porque desde un entorno estático 01:58:06

estoy intentando acceder 01:58:08

a un objeto 01:58:10

porque esto sin estático es de un objeto 01:58:12

le tengo que decir 01:58:14

a qué objeto llamarlo 01:58:16

por ejemplo T1 junto 01:58:17

ahora dice, ah sí, claro 01:58:19

pero se enfada 01:58:21

porque dice 01:58:23

si yo lo pongo así 01:58:24

se enfada porque dice 01:58:45

cannot make a static reference 01:58:47

to a non-static method 01:58:50

calcula perímetro 01:58:51

no puede hacer una referencia estática 01:58:52

a un método que no es estático 01:58:55

¿Qué quiere decir? Estoy en un mundo estático 01:58:58

Estoy en un mundo que no es de un objeto 01:59:00

Es de la clase 01:59:02

Y tú me estás diciendo cálcula perímetro 01:59:03

Pero cálcula perímetro me has dicho 01:59:06

Que no es de una clase, es de un objeto 01:59:08

¿Pero de qué objeto? 01:59:10

No me has dicho sobre qué objeto trabajar 01:59:12

¿Vale? 01:59:14

Entonces digo, vale, muy bien 01:59:16

Trabaja sobre T1 01:59:17

Ah, ahora sí 01:59:19

¿Vale? 01:59:22

Está usando este señor de aquí 01:59:23

Que le paso tres parámetros 01:59:25

y me lo calcula. Ahora, si yo lo llamo sobre T1 o lo llamo sobre T2, ¿cambia algo? 01:59:27

Es que no le he puesto el System Out, ¿eh? Esto de aquí es el de arriba. Si, eso. Y esto va allí adentro. 01:59:47

Si lo llevamos sobre T1, T2 01:59:57

¿Cambia algo? 02:00:10

No, porque ahora no depende este calcular 02:00:15

El perímetro de qué objeto 02:00:17

No depende de sus valores 02:00:19

Mas depende de los valores que ponga aquí 02:00:22

O sea que esta es una función 02:00:24

Que no depende del objeto 02:00:28

No usa cosas dentro del objeto 02:00:30

No usa nada de los atributos de los objetos 02:00:33

Lo veis que aquí 02:00:35

no uso ningún atributo del objeto 02:00:36

entonces es una función 02:00:38

independiente del objeto 02:00:40

es una función 02:00:43

de la clase 02:00:44

no, el igual depende del objeto 02:00:46

porque tú haces este objeto 02:00:50

igual a este otro objeto, son dos objetos que usas 02:00:51

el igual se lo llamas 02:00:54

solo el mismo objeto 02:00:56

como el random 02:00:57

el math.random 02:00:59

no has creado 02:01:03

math x es igual a new math 02:01:04

Y luego has hecho X punturando. 02:01:06

Has usado más punturando más X. 02:01:09

¿Sí? 02:01:13

Es decir, que como este de aquí es independiente del objeto sobre el que lo llamo, 02:01:15

debería ser estático. 02:01:20

Ahora, si es estático, no lo llamo sobre un objeto. 02:01:23

Lo llamo sobre la clase. 02:01:29

Que ahora, si estoy en esta misma clase, 02:01:39

puedo hasta no nombrarla, porque él sabe. 02:01:45

yo estoy dentro de la clase triángulo, este es el main del triángulo y entonces hace una llamada 02:01:47

estática a un entorno estático. Perfecto. Pero si estuviera en el main, main triángulo, con un main, 02:01:53

y quisiera usar el triángulo, o sea que ahora este main de aquí me lo copia allí. Él aquí se enfadaría 02:02:07

porque decía, oye, mira, en esta clase 02:02:22

no hay un método cálculo a perímetro. 02:02:24

¿Qué cálculo a perímetro 02:02:27

quieres usar? Quieres usar 02:02:28

el de la clase 02:02:30

triángulo. 02:02:34

Tengo que 02:02:41

especificar, cálculo a perímetro 02:02:41

de qué clase. 02:02:43

Como esto es estático, 02:02:45

¿veis que es en cursiva? 02:02:47

Como esto es estático, 02:02:50

no se llama sobre un objeto. 02:02:52

Se llama sobre 02:02:54

la clase. 02:02:55

¿Por qué es estático y no estático? Esa es la clave, ¿vale? 02:02:59

Un método es estático si no usa los atributos del objeto. 02:03:03

Es no estático, o sea, no se pone nada, si usa la cosa del objeto. 02:03:09

Un método, llamámoslo estático y dinámico, si un método es estático, se llama sobre la clase, 02:03:17

si un método es dinámico, se llama sobre el objeto. 02:03:24

Porque este método usará los valores del objeto 02:03:30

Entonces le tengo que decir qué objeto 02:03:34

Mientras este método no usa los valores de un objeto 02:03:36

Porque usa estos valores de aquí 02:03:41

Si yo, por ejemplo, hiciera una clase que se llama geometría 02:03:43

Donde hago cosas de geometría 02:03:48

Calcula el triángulo de un cuadrado 02:03:51

Calcula el triángulo del... 02:03:53

Perdón, el perímetro de un cuadrado 02:03:55

El área de un cuadrado 02:03:57

Pero sin usar objetos 02:03:57

es una clase general de geometría 02:03:59

que te permite hacer todas estas cosas 02:04:02

y eso serían todos métodos estáticos 02:04:04

como la clase 02:04:06

MAF 02:04:08

tú dices 02:04:08

quiero hacer una elevación a potencia 02:04:12

2 elevado a la 7, tengo el método 02:04:13

PAO, vale, PAO 2 7 02:04:15

te hace 2 elevado a la 7 02:04:18

¿de qué objeto? existe un objeto 02:04:19

no hay un objeto 02:04:24

sobre el que llamar la potencia 02:04:26

de 2 a la 7, que se lo llama sobre este 02:04:28

objeto te da un resultado y si lo llamas sobre un objeto distinto te da un 02:04:30

resultado distinto. La elevación a potencia no es dependiente de un objeto, 02:04:34

es una función matemática genérica. Por lo tanto, es estática. Píllame un número 02:04:39

al azar entre 0 y 1. Depende de un objeto. 02:04:46

Depende de los parámetros 0 y 1. Si yo te los paso, ya está. Ahora, ¿podría ser un 02:04:55

objeto donde pone 02:05:03

atributo 02:05:04

número mínimo, atributo número máximo 02:05:06

y que tenga un método que 02:05:09

diga random que me pilla 02:05:11

desde el número mínimo al número máximo. 02:05:13

Sí, en ese caso 02:05:15

no sería estático. 02:05:16

Sería 02:05:20

propio del objeto. 02:05:21

Porque está usando dos parámetros del objeto. 02:05:22

Pero entonces no se lo paso. 02:05:26

El random en este caso no sería. 02:05:27

Sería un random sin parámetros 02:05:29

y el dentro va a usar 02:05:30

haremos esto primero 02:05:32

a ver, paso número uno 02:05:36

topo este 02:05:38

Objetos - Contenido educativo

Del mismo autor…

Giving advice (Year 6)

El modelo de Grenoble

20251205 POO-Ejer_2

20251205 POO-Ejer_1

20251030 JSON_2

20251204 UD2-BDR_6

20251204 UD2-BDR_5