Saltar navegación

Prog2324 Objetos y Clases - Contenido educativo

Ajuste de pantalla

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

Subido el 20 de diciembre de 2023 por Stefano C.

10 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, muy bien, estoy grabando estas clases, por lo tanto, si hay alguna pregunta o habláis, pues me dais la autorización a que esté grabado en este vídeo, ¿vale? 00:00:00
Entonces, decíamos que hasta ahora nosotros hemos trabajado con programación estructurada. 00:00:11
Programación estructurada se basa en pocos conceptos como son las variables, como son los arrays, como son los if, como son los while, bueno, más que if y while, 00:00:17
los operadores, los comandos condicionales y los comandos iterativos, ¿vale? 00:00:29
Luego pueden ser de varias formas, el while, the while, the for, más o menos son todo lo mismo, pero son más útiles en un caso o otro, ¿vale? 00:00:35
La dentro, lo vimos al principio, si miráis las transparencias iniciales cuando introducimos el concepto de programación estructurada, 00:00:43
la unidad básica de la programación estructurada es lo que es la función o el método, ¿vale? 00:00:52
Nosotros no nos hemos enfocado muchísimo en esto, lo hemos utilizado, lo hemos visto algunos ejemplos, pero no hemos hecho mucho hincapié 00:00:59
porque ahora ese concepto de función o procedimiento se sustituirá con otro concepto que es prácticamente igual, 00:01:09
pero bueno, tiene algunos matices, que es el método, ¿vale? 00:01:17
En Java, tanto las funciones como los procedimientos, todo lo que hemos hecho oficialmente se llaman métodos, ¿sí? 00:01:20
Y ahora sí que eso será fundamental, ¿vale? A partir de ahora los métodos tenemos que utilizarlo, ¿vale? 00:01:28
Hasta ahora ha sido una introducción, ahora haremos más hincapié allí y cuando estructuraremos lo que es una clase, lo que son, 00:01:36
crearemos objetos, pues veremos para qué sirven los métodos y cómo tenemos que crear los métodos. 00:01:43
Entonces hoy empezamos con la programación orientada a objetos, es un cambio de paradigma, es un cambio de paradigma grande, ¿vale? 00:01:50
Nosotros tenemos la suerte de que ya esto existe y está implementado y que funciona bastante bien, 00:01:58
tened en cuenta que el cambio de estructurada a objetos es un cambio fuerte, ¿vale? 00:02:06
Es un cambio muy interesante porque permite hacer las tareas de programación que hemos hecho hasta ahora 00:02:12
y que haréis por el resto de vuestra vida si seréis programadores, de una forma más intuitiva, de una forma más sólida, de una forma más reutilizable, ¿vale? 00:02:24
Entonces la programación orientada a objetos, ¿vale? 00:02:35
Que P-O-O-O-O-O-P es como se suele encontrar por allí para no escribir todo, es un paradigma de programación 00:02:38
cuyo elemento estructural principal es el objeto, ¿vale? 00:02:46
Entonces antes el elemento estructural era la función, hemos dicho, pues ahora pasamos a un nuevo elemento estructural. 00:02:49
Mis programas no están basados en hago funciones, están basados en pienso objetos, construyo objetos, ¿qué es un objeto? 00:02:56
Ahora lo vamos a ver con K, ¿vale? 00:03:05
Pero todo el planteamiento de solución de mis algoritmos, de mis estructuras, de mi sistema, está basado en clases y objetos 00:03:07
y veremos las relaciones entre clases y objetos, ¿sí? 00:03:17
El elemento estructural de este paradigma de programación imperativo, programación imperativo estructural era la función, ¿vale? 00:03:21
Ahora ya no. 00:03:27
Las mejoras que aportan las programaciones orientadas a objetos son, primero, mejora en el análisis, ¿vale? 00:03:28
La mente humana es más orientada a pensar los problemas y las soluciones a los problemas en términos de objetos 00:03:34
que en términos de procesos y datos separados, ¿vale? 00:03:43
Entonces, cuando ahora veremos que es un objeto, cuando empezaremos a decidir el objeto, 00:03:47
la idea del objeto es que sea algo que se acerque un poquito más a como nosotros pensamos lo que nos rodea alrededor, ¿vale? 00:03:51
Y, por lo tanto, debería ser más intuitivo programar orientado a objetos que programar de forma estructural. 00:04:00
Escalabilidad, es más fácil enfrentarse a problemas que crecen, ¿vale? 00:04:08
Cuando hablamos de escalabilidad dentro del ámbito informático es ponerse de frente a un problema que puede crecer, que puede escalar, ¿vale? 00:04:15
Entonces, cuando un problema es muy sencillo, normalmente cualquier solución básica nos vale. 00:04:26
Cuando los problemas se van complicando, si no nos hemos hecho un esquema mental, un esquema práctico de la solución bien hecho, 00:04:33
pues puede ser que la solución ya no funcione, la solución se vuelva demasiado ineficiente, 00:04:45
puede ser que la solución no me valga para grandes números o por muchos datos o por acceso a problemas complejos, ¿sí? 00:04:50
La orientación a objeto mejora esta posibilidad, mejora la posibilidad de, vale, yo he hecho esta solución, 00:05:00
he visto que cubre este problema a una cierta escala, cuando el problema se vuelve más complejo, 00:05:09
pues solo tengo que retocar algunas cosas de los objetos y posiblemente mi sistema sigue funcionando, si lo he estructurado bien, etc. 00:05:17
Pero tiene, digamos, una facilidad mejor con respecto a lo que era la programación iterativa estructurada, que es lo que hemos hecho hasta ahora. 00:05:25
Y también reutilización de código, es una cosa muy importante. 00:05:33
La idea es que nosotros crearemos clases y crearemos objetos y estos objetos, si los creamos bien, los podemos reutilizar en otros proyectos. 00:05:38
Si yo me creo una serie de clases, objetos, etc., etc., que simulan una persona y, por lo tanto, 00:05:48
ahí dentro hay todos los datos y las funciones y los procedimientos que puede hacer una persona, 00:05:56
si ahora creo un proyecto totalmente nuevo que tiene que ver con personas, 00:06:01
puedo recoger todas las clases y los objetos que he creado de las personas en el proyecto anterior y reutilizarlos completamente en el nuevo. 00:06:06
Antes, como no había objetos, había más bien funciones, tenía que ir en mi proyecto eligiendo cuáles eran las funciones que sí me pueden valer en el nuevo proyecto 00:06:16
para reutilizarlo desde el viejo. 00:06:30
Ahora mismo, con la orientación a objetos, es un poco distinto, porque en un cierto sentido ya los tengo empaquetados. 00:06:33
Yo tendré mi clase persona con los datos de la persona y con los métodos de la persona, 00:06:40
entonces, cuando quiero utilizar otro sistema donde hay una persona, pues reutilizo esa clase, reutilizo ese código. 00:06:45
Entonces, la idea de por qué esto ha sido importante y es todavía importante es porque mejora estos campos y los hace más intuitivos y más interesantes. 00:06:54
Características de la programación orientada a objetos. 00:07:06
Nosotros vamos a crear clases. 00:07:10
Nosotros ya hemos creado clases. 00:07:13
Cuando vosotros empezáis cualquier programa, ¿con qué palabras empezáis el programa? 00:07:15
Public class. 00:07:23
Public class y el nombre de la clase. 00:07:25
Todos los ejercicios que habéis hecho desde el principio han sido clases. 00:07:27
Ya sabéis crear una clase. 00:07:33
Si os acordáis, también las primeras veces, cuando vimos el Hello World, el primer programa, 00:07:35
decíamos, esto es System.AutoTune.Println.HelloWorld. 00:07:41
Hola mundo. 00:07:45
Fenomenal. 00:07:46
Esto es lo que nos interesa. 00:07:47
Todo el resto, ¿por qué está allí? 00:07:48
Y os dije en esos días, ¿por qué estamos orientados? 00:07:50
Java es un lenguaje orientado a objetos, pero nosotros por ahora ignoraremos la parte orientada a objetos. 00:07:54
Por lo tanto, me lo escribe él. 00:08:00
Me escribe el public class. 00:08:02
Yo no sé qué es. 00:08:04
Por ahora me fío y ya veremos en un futuro. 00:08:05
Ahora es ese futuro en el que empezaremos a entender qué es también la parte del principio y la parte del final. 00:08:07
Las clases definen dos cosas sustancialmente. 00:08:19
Cuando yo escribo una clase, tengo que definir dos cosas. 00:08:23
Los datos que voy a utilizar en esta clase y los comportamientos que pueda hacer esta clase. 00:08:25
¿Sí? 00:08:32
La clase de ejemplo de persona, pues yo tendré que definir una persona en general, 00:08:33
qué datos son relevantes para esta persona. 00:08:39
Vosotros tenéis que modelizar una persona. 00:08:43
¿Qué datos consideráis interesantes? 00:08:46
¿Qué datos consideráis interesantes? 00:08:49
¿Altura? 00:08:54
¿Qué más? 00:08:57
¿Peso? 00:08:58
¿Qué más? 00:08:59
¿DNI? 00:09:01
¿Qué más? 00:09:02
¿Nombre? 00:09:03
¿Edad? 00:09:05
¿Vale? 00:09:06
Puedo saber qué es importante en una persona, así seguro. 00:09:07
¿De qué dependerá una persona? 00:09:15
Los datos importantes de una persona. 00:09:18
En general dependerá del contexto. 00:09:23
¿Para qué es mi programa? 00:09:25
Si mi programa es para la ciudadanía, para hacer un censo electoral, 00:09:27
la altura de la gente no me interesa. 00:09:31
Si mi programa es un gimnasio con orientación también a perder peso, 00:09:34
a tener que ver con qué se come, formaciones nutricionales y cosas por el estilo, 00:09:44
pues a lo mejor saber cuánto es alto y cuánto pesa una persona, 00:09:51
pues puede ser interesante. 00:09:54
Puede ser que el mismo concepto de persona en varios contextos, 00:09:57
en varios sistemas, en varios programas, 00:10:05
pues tenga una definición un poco distinta. 00:10:08
¿Vale? 00:10:12
Pero a lo mejor puedo pillar cosas básicas que sí me valdrían para todos. 00:10:13
¿Vale? 00:10:18
A lo mejor, ¿eh? 00:10:19
No lo sé, en algunos casos se puede hacer. 00:10:20
Si yo estoy modelizando a una persona, saber su nombre, apellido, 00:10:22
pues puede ser útil tanto en un gimnasio como si hago un censo para el estatal, 00:10:28
no sé, como si puede ser una aplicación médica o lo que sea. 00:10:35
¿Vale? 00:10:38
Un identificador como el DNI, pues me podría valer para todas esas cosas. 00:10:39
¿Sí? 00:10:43
A lo mejor no lo llamo DNI porque a lo mejor si lo uso en otra nación 00:10:44
no me vale el DNI, pues lo llamo identificador o ID de la persona, 00:10:49
pero podría ser útil. 00:10:53
¿Vale? 00:10:55
Y luego veremos que la programación a objetos me permite decir, 00:10:56
vale, ya he hecho una persona, la he hecho así, vale, perfecto, 00:10:59
la pillo y la puedo reutilizar en otro sistema. 00:11:01
Y es más, puedo pillar como base lo que ha creado otra persona 00:11:04
o otro programador sobre persona y luego adaptarla a mis necesidades. 00:11:08
Yo tengo una persona ya hecha que tiene solo nombre, apellido e identificador 00:11:14
y ahora quiero hacer mi gimnasio, pues necesito más datos aquí, 00:11:21
pues puedo pillar la persona ya como está hecho y extenderla 00:11:25
y crear datos adicionales y métodos adicionales para una persona 00:11:30
que es para mi contexto concreto. 00:11:35
Eso lo veremos más adelante. 00:11:38
Además de los datos, yo necesito definir los comportamientos. 00:11:41
¿Qué puede hacer esta clase, esta entidad que yo estoy modelizando? 00:11:49
Una persona. 00:11:57
Una persona puede, tiene su nombre y tiene su apellido, vale, 00:11:58
esto lo hemos dicho, son los datos, vale, los datos puros de esta persona. 00:12:01
¿Pero qué puede hacer una persona? 00:12:05
En mi programa, en mi modelo de lo que estoy modelizando de una persona, 00:12:08
¿qué son las actividades que puede hacer una persona? 00:12:14
Y lo tengo que pensar y ver en mi contexto. 00:12:18
Por ejemplo, en un gimnasio la persona podría hacer, usar una máquina 00:12:21
o hacer ejercicio, vale, entonces tendré un método que será hacer ejercicio 00:12:26
que se llamará sobre las personas, o sea, las personas podrán hacer ejercicio 00:12:33
y cuando sea una persona, un objeto persona, una cosa persona por ahora, 00:12:37
ya veremos la diferencia entre falsos objetos, 00:12:42
llama el método hacer ejercicio, pues allí estará el código 00:12:44
que tiene que hacer, que le pasa este objeto a esta persona 00:12:48
cuando yo ejecuto el método hacer ejercicio. 00:12:53
¿Sí? A lo mejor por algún lado tengo una variable de calorías gastadas hoy 00:12:58
y el método hacer ejercicio pues aumenta el número de calorías gastadas, no lo sé. 00:13:04
Entonces, estas son las dos cosas interesantes de una clase, 00:13:12
cuando yo defino una clase, defino sus datos y sus comportamientos, vale, 00:13:16
y la cosa interesante también es que todo esto va empaquetado, 00:13:20
esto es un único bloque, una única clase que me define sus datos, 00:13:24
todos los datos necesarios para modelizar esa clase 00:13:29
y todos los posibles comportamientos, todos los posibles métodos, 00:13:34
todas las posibles acciones, en cierto sentido, que puede hacer esa clase, 00:13:40
esa persona en nuestro caso. 00:13:46
¿Dudas? 00:13:49
Una clase no puede estar dentro de otra clase, ¿no? 00:13:50
Una clase, sí, pero esto ya, muy avanzado. 00:13:53
En un fichero solo yo puedo declarar varias clases y hay mecanismos 00:13:58
para lo que se llama las clases anónimas, para crear una clase dentro de otra clase. 00:14:02
Los objetos colaboran entre ellos para conseguir algo, ¿vale? 00:14:11
La idea es que antes nosotros utilizamos un solo fichero, 00:14:15
yo tenía mi fichero, ahí dentro tenía todos los datos, todas las funciones, 00:14:19
todo lo que tenía que hacer, ejecutaba el main y ya está, se acabó. 00:14:23
Ahora, la idea es que yo voy a crear varias clases, 00:14:27
cada clase que me representa algo del sistema en que yo estoy trabajando, ¿vale? 00:14:32
Y luego tendré un main o varios mains o lo que sea, 00:14:38
que en un cierto sentido hace relacionarse entre ellos estos objetos, estas clases. 00:14:42
Por ejemplo, puedo tener la clase Persona, 00:14:48
y puedo tener la clase Gimnasio, que tiene dentro objetos de tipo máquina, 00:14:50
para que luego yo pueda pillar una persona, asociarla a una máquina determinada, 00:14:56
es decir, oye, esta persona está usando esta máquina. 00:15:01
Para luego, a lo mejor, si mi sistema es una gestión de un gimnasio, 00:15:05
donde yo tengo que configurar que, oye, mira, 00:15:12
a media hora una persona ha pillado esta máquina, 00:15:14
entonces esta máquina está bloqueada, no la puede pillar otra persona, 00:15:16
pues entonces tendré que jugar con estas cosas. 00:15:19
A lo mejor habrá un objeto, una clase, que sea Suscripción, 00:15:23
que se asociará con una persona para saber qué tipo de abono tiene esta persona, 00:15:26
si tiene clases solos, si viene todos los días, todos los martes, 00:15:32
o si tiene 30 horas a la semana, no lo sé. 00:15:36
Todo eso dependerá de mi sistema, cuánto lo quiero complicar y cosas así. 00:15:39
Está claro que al principio nosotros haremos ejemplos muy sencillos 00:15:43
y iremos complicando un poco las cosas. 00:15:46
Los programas reales son sistemas relativamente complejos, 00:15:48
que vosotros sabréis en el tercer trimestre del próximo curso. 00:15:53
Con un poco de suerte. 00:15:59
Entre objetos, la forma de colaborar es pasándose mensajes. 00:16:02
Es decir, entre objetos que están trabajando, 00:16:06
entre personas, o entre una persona y una máquina, 00:16:09
se mandan mensajes. 00:16:12
Esto de mandarse mensajes es muy a alto nivel. 00:16:14
En la realidad, siendo más concretos, son llamadas a métodos. 00:16:18
Cuando yo llamo a un método de otro objeto, de otra clase, 00:16:23
lo que está haciendo, en un cierto sentido, es mandarle un mensaje, 00:16:27
pedirle cosas. 00:16:30
Le mando parámetros, los parámetros que estaban entre paréntesis 00:16:32
en la declaración, ¿os acordáis? 00:16:36
Y él me devuelve, o no, porque puede que no le mande nada, 00:16:38
o puede que no me devuelva nada, un resultado, ¿vale? 00:16:42
Que es las funciones y los procedimientos que teníamos antes. 00:16:47
Ahora los llamamos métodos, pero la idea es esta, ¿vale? 00:16:51
Entonces, si yo tengo una persona, y tendré su método, 00:16:54
salúdame, que cuando yo lo llamo, me dice hola. 00:16:57
Y tendré el método, dime cómo te llamas, 00:17:01
y cuando yo le diré, dime cómo te llamas, 00:17:03
me dirá, me llamo, y va a pillar dentro de sus datos 00:17:05
su nombre y su apellido. 00:17:08
¿Se entiende? 00:17:11
¿Dudas? 00:17:13
Pero ahora estamos a muy alto nivel. 00:17:15
No hemos empezado con ejemplos concretos. 00:17:17
Vamos adelante para empezar a mueblar lo que es, 00:17:19
luego, los ejemplos prácticos que haremos después. 00:17:23
Cada clase va a ocuparse de lo que es su responsabilidad. 00:17:26
Otra cosa interesante. 00:17:29
No voy a hacer como ahora, que yo tengo un programa 00:17:31
y pongo todo allí, ¿vale? 00:17:35
Estoy haciendo mi programita, 00:17:37
tengo solo el main y algunas funciones que tengo por allí, 00:17:39
pues pongo todo dentro de la misma clase, 00:17:42
como hemos estado haciendo ahora, dentro del mismo fichero, 00:17:44
y allí está mezclado todo lo que hace mi programa. 00:17:46
Ahora no. 00:17:50
Ahora lo que intento hacer es dividir y modelizar las cosas 00:17:51
de forma más en módulos, en bloques, en paquetes distintos. 00:17:55
¿Vale? 00:18:01
Entonces, estoy en el gimnasio. 00:18:02
Bueno, no, ahora estoy en un taller de coches. 00:18:05
¿Vale? 00:18:09
Entonces, ¿a mí qué me interesa de este taller de coches? 00:18:10
Bueno, me interesarán los coches, 00:18:14
por lo tanto ahí tendré una clase que representa 00:18:16
todos los datos del coche y todo lo que puede hacer sobre un coche. 00:18:18
Luego me interesarán los clientes, 00:18:22
pues entonces tendré una parte, una clase, unos objetos clientes 00:18:24
que tendrán dentro todos los datos de los clientes. 00:18:31
Si han pagado, no. 00:18:34
Si quieren facturas y no sé qué. 00:18:35
¿Vale? 00:18:37
Todo ahí. 00:18:38
Tendré los mecánicos, que son otros tipos de personas, 00:18:39
pero que son los que puedan arreglar los coches. 00:18:43
Si no tengo un mecánico disponible, no puedo arreglar el coche, etc. 00:18:45
Cada una de estas entidades dentro de mi sistema 00:18:48
será una clase aparte y solo se empaquetará dentro de esa clase 00:18:53
los datos y los métodos que se refieren a esa clase. 00:18:59
¿Vale? 00:19:04
Es su responsabilidad. 00:19:05
No pondré en un coche si ha pagado o no, 00:19:06
porque no es el coche que paga. 00:19:10
No sé si me explico lo que quiero decir. 00:19:12
¿Sí? 00:19:14
Luego, no es una cosa absoluta. 00:19:15
Es una cosa de cómo yo defino mi sistema, mi programa 00:19:19
y para qué sirve. 00:19:24
¿Vale? 00:19:25
A lo mejor el programa que estoy haciendo yo no es de contabilidad 00:19:26
y por lo tanto no le interesa al cliente. 00:19:29
Es solo para los mecánicos 00:19:31
y la gestión de qué mecánico repara qué coche. 00:19:33
Entonces en mi programa me da igual saber quién es el cliente de este coche. 00:19:38
A mí me interesa tener coches mecánicos 00:19:44
y una forma de que el mecánico diga 00:19:46
oye, mira, este coche lo he pillado yo 00:19:48
entonces lo bloquea 00:19:50
y si viene otro mecánico 00:19:51
intenta ver si este coche está libre para repararlo 00:19:52
dice no, ya está un mecánico asignado 00:19:55
y por lo tanto lo deja en paz. 00:19:57
No lo sé. 00:19:59
¿Vale? 00:20:00
Son todos... cosas. 00:20:01
¿Vale? 00:20:04
Aquí, ejemplo. 00:20:05
Un coche puede ser un ejemplo de clase. 00:20:06
¿Vale? 00:20:08
Con las características y las funcionalidades propias. 00:20:09
Un coche puede tener como características 00:20:11
dependiendo de lo que sea 00:20:13
pues un color, la marca, el modelo y la matrícula. 00:20:15
Para mi programa yo decido que la cosa importante de un coche 00:20:19
es que quiero saber cuál es su color, su marca, su modelo y su matrícula. 00:20:23
Estos son los cuatro datos que me interesan. 00:20:27
¿Y qué son estos? 00:20:29
Int, string... 00:20:31
¿Qué son? 00:20:33
No lo sé. 00:20:35
Depende. 00:20:36
¿Vale? 00:20:37
¿Una matrícula qué es? 00:20:38
Un string, porque tiene números y cartas. 00:20:43
¿Color qué es? 00:20:46
String, si lo quiero guardar como azul, verde, naranja. 00:20:51
Si yo tengo una tabla de colores 00:20:56
y el uno es el negro, el dos es el verde, el tres es... 00:20:59
pues es un int. 00:21:02
Si yo lo quiero guardar como RGB 00:21:03
pues serán tres int. 00:21:06
¿Entendéis lo que quiero decir? 00:21:10
Esto yo tengo que definir 00:21:12
cuáles son las características de la clase 00:21:14
y además tengo que definir 00:21:16
cada uno de estas características, 00:21:19
cada uno de estos atributos, como se llamarán, 00:21:21
cada una de estas variables 00:21:24
qué tipo tiene. 00:21:26
¿Vale? 00:21:28
En base a mis exigentes. 00:21:29
Las funcionalidades que me interesan del coche, 00:21:32
estoy definiendo el coche, 00:21:36
es desplazarse o parar. 00:21:38
He decidido que mi coche puede hacer dos cosas. 00:21:40
Puedo llamar el método desplazarse, 00:21:42
que entonces se moverá de un kilómetro, qué sé yo, 00:21:44
o el método parar, 00:21:47
que entonces quiere decir que lo paro, 00:21:49
se apaga y se queda ahí. 00:21:51
¿Por qué? 00:21:53
No lo sé. 00:21:54
Es una gente. 00:21:55
¿Vale? 00:21:56
Podría hilar más fino 00:21:57
y tener que el coche tiene el método arrancar, 00:21:58
el método apagar el coche, 00:22:01
el método desplazarse 00:22:03
y que cuando llamo el método desplazarse, 00:22:04
si antes no he llamado el método arrancar, 00:22:06
pues no me tiene que funcionar. 00:22:08
Entonces tendré un booleano por ahí 00:22:10
para saber si el motor está encendido o no 00:22:12
y cuando llamo arrancar, 00:22:14
comprobaré si hay gasolina, 00:22:16
porque aquí tengo otra característica 00:22:18
que es litros en el depósito, 00:22:20
qué sé yo. 00:22:24
¿Vale? 00:22:25
Depende de lo que estamos nosotros modelizando. 00:22:26
Está claro que aquí no le voy a poner 00:22:28
qué sé yo, 00:22:32
tamaño de las ruedas, 00:22:35
si en mis sistemas el tamaño de las ruedas 00:22:37
no me sirve de nada. 00:22:39
¿Vale? 00:22:41
A lo mejor, pero ahí está, 00:22:42
porque yo he dicho, 00:22:43
oye, mira, 00:22:44
otro proyecto que hemos hecho ya antes, 00:22:45
pues tiene ya un coche, 00:22:47
pillo ese coche 00:22:50
y en ese coche, 00:22:51
porque en ese sistema servía, 00:22:52
pues está la información 00:22:54
de tamaño de las ruedas. 00:22:56
Pero yo, 00:22:58
para no rehacer todo el trabajo otra vez, 00:22:59
pues pillo esa misma clase, 00:23:01
la uso y en mi sistema luego, 00:23:03
pues ese dato o no se pone 00:23:06
o no se lee nunca 00:23:08
y por lo tanto está allí, 00:23:10
ocupa un poco de espacio, 00:23:11
pero me da igual. 00:23:12
Dependerá también de mis exigentes. 00:23:13
Una clase de coche 00:23:16
se responsabilizará de manejar 00:23:18
todo aquello que tenga que ver con el coche. 00:23:20
Un garaje con muchos coches 00:23:22
puede hacer uso de ella 00:23:24
o un conductor también. 00:23:26
¿Vale? 00:23:28
Entonces yo tengo mi clase de coche 00:23:29
y todo lo referente al coche 00:23:30
está allí dentro. 00:23:32
Pero luego, 00:23:34
¿cómo uso este coche? 00:23:35
Pues puedo tener taller 00:23:36
que esté dentro del coche. 00:23:38
Puedo tener garaje 00:23:40
que es, 00:23:42
porque tengo una mansión 00:23:43
y 27 coches, 00:23:44
entonces me he hecho un sistema 00:23:45
para ver qué coches 00:23:47
están aparcados 00:23:48
en mis 27 plazas de garajes 00:23:50
y cuáles no. 00:23:52
O puedo hacer 00:23:53
que hay una otra clase 00:23:54
que se llama conductor 00:23:56
que está asociado 00:23:57
o piloto o lo que sea, 00:23:58
que está asociado con el coche 00:23:59
y usará ese coche. 00:24:01
No lo sé. 00:24:02
Ya veremos cómo hacemos 00:24:03
todas estas cosas 00:24:04
y las asociamos. 00:24:05
Lo que tiene que quedar claro 00:24:06
es que ahora yo tengo una clase 00:24:07
que define 00:24:09
cuáles son las características 00:24:10
y cuáles son las funcionalidades 00:24:12
de esa clase 00:24:14
que se puede hacer 00:24:15
y que todo va empaquetado allí. 00:24:16
Si es la clase coche, 00:24:18
todo lo de coche está allí. 00:24:19
Si es la clase persona, 00:24:21
todo lo de persona 00:24:22
tiene que estar allí. 00:24:23
No puedo tener otra clase 00:24:24
que tiene un dato de persona. 00:24:25
No puedo hacer 00:24:28
la clase persona con el nombre 00:24:29
y luego la clase identificación 00:24:30
con el apellido de esa persona. 00:24:32
Pues no. 00:24:34
El apellido de esa persona 00:24:35
tiene que estar dentro de persona. 00:24:36
¿Dudas? 00:24:39
Cuando queramos 00:24:43
que un coche se desplace 00:24:44
en un garaje, 00:24:45
tendremos que comunicarnos 00:24:47
con el coche específico 00:24:48
y darle la dirección 00:24:49
a la que queremos que se desplace. 00:24:50
Aquí se asume que desplazar 00:24:53
tiene como parámetro 00:24:55
una dirección 00:24:56
y tú haces desplazar a este sitio 00:24:57
y él se desplaza a este sitio. 00:25:00
Cuando yo quiero 00:25:04
que el garaje tendrá una dirección 00:25:05
y yo quiero poner un coche 00:25:08
dentro de ese garaje, 00:25:09
en un main tendré que decir 00:25:10
píllame este coche 00:25:12
sobre este coche 00:25:15
dile desplázate a la dirección 00:25:16
del garaje 00:25:20
y entonces él se desplazará. 00:25:21
¿Dudas? 00:25:25
¿Se entiende más o menos 00:25:26
esta idea en general? 00:25:27
Entonces ¿qué es una clase? 00:25:32
Una clase es lo que 00:25:35
en el lenguaje de programación 00:25:36
nos va a permitir 00:25:37
definir o construir 00:25:38
uno o varios objetos. 00:25:39
Una clase es un molde. 00:25:41
Es la definición abstracta 00:25:44
de los objetos. 00:25:47
La clase es persona. 00:25:49
Luego está la persona 00:25:51
que se llama Estefano, 00:25:52
la persona que se llama Carlos, 00:25:53
la persona que se llama Sara. 00:25:55
Todas las personas concretas 00:25:59
son objetos de la clase persona. 00:26:01
Todos tienen la misma estructura. 00:26:07
Todos tienen nombre, 00:26:10
apellido, identificador. 00:26:11
Porque la clase me dice 00:26:13
que una persona tiene 00:26:14
nombre, apellido, 00:26:16
identificador. 00:26:17
Pero la clase no me dice 00:26:18
qué nombre, qué apellido 00:26:19
y qué identificador. 00:26:21
En el momento en que yo creo 00:26:24
un nuevo objeto de una clase, 00:26:25
o sea una persona específica, 00:26:28
al crearla le diré 00:26:30
tú eres una persona 00:26:32
por lo tanto tu estructura 00:26:33
y tu comportamiento 00:26:34
son lo que están definidos 00:26:35
en la clase. 00:26:36
Pero tú en particular 00:26:37
tienes nombre Estefano, 00:26:38
tienes apellido quiesa, 00:26:40
tienes identificador, 00:26:41
lo que sea. 00:26:43
Entonces normalmente, 00:26:46
en un cierto sentido, 00:26:47
la clase una 00:26:48
y a partir de una clase 00:26:50
puedo crear un montón de objetos. 00:26:52
Los objetos son instancias 00:26:55
de una clase. 00:26:58
Yo pillo una clase 00:26:59
en la instancia de un objeto. 00:27:01
La clase es un molde vacío 00:27:04
cuando yo relleno 00:27:07
los varios campos de esa clase 00:27:09
estoy creando un objeto de esa clase 00:27:11
y puedo crear todos los objetos 00:27:13
que quiero. 00:27:15
Pregunta para vosotros. 00:27:16
¿Puedes volver a repetirlo? 00:27:19
Sí. 00:27:24
Esto no sería igual 00:27:25
que las tablas en base de datos. 00:27:27
Si tienes una tabla 00:27:29
con ciertos atributos, 00:27:31
por ejemplo, 00:27:33
persona, tienes DNI, 00:27:34
tienes... 00:27:36
Si una tabla es la clase, 00:27:37
cada registro es un objeto. 00:27:40
Vale. 00:27:43
Pero no son ni clases ni objetos. 00:27:45
¿Vale? 00:27:47
Porque faltaría toda la parte del método. 00:27:48
En base de datos no lo hay. 00:27:50
Pero como paralelo, 00:27:52
¿por qué no? 00:27:53
La tabla te dice, 00:27:54
mira, aquí va nombre, 00:27:55
apellido y edad. 00:27:57
¿Vale? 00:27:59
Y no te ha dicho nada. 00:28:00
Te ha dicho la estructura, 00:28:01
pero no te ha dicho 00:28:03
qué hay dentro. 00:28:04
Y luego tú vas rellenando con record. 00:28:05
Sí. 00:28:07
Esto es parecido. 00:28:08
La clase te dice, 00:28:09
en general, 00:28:11
qué características tiene 00:28:12
lo que estamos modelizando 00:28:14
y qué puede hacer, 00:28:17
qué métodos puede ejecutar 00:28:19
este objeto. 00:28:23
¿Vale? 00:28:24
Y a partir de allí, 00:28:25
tú dices, 00:28:26
vale, yo me puedo crear 00:28:27
un objeto concreto 00:28:28
rellenando sus campos 00:28:29
y luego utilizándolo con sus métodos. 00:28:31
¿Sí? 00:28:33
Y... 00:28:34
Entonces, la clase, repito, 00:28:37
es un molde, 00:28:39
es una abstracción, 00:28:40
¿vale? 00:28:43
Una categoría, 00:28:44
una clase de lo que estoy modelizando. 00:28:45
Los objetos son instancias concretas. 00:28:49
Son, píllame este molde 00:28:53
y asígnale, 00:28:55
allá donde había campos vacíos, 00:28:56
porque no sé, 00:28:58
yo sé que tiene que poner un nombre, 00:28:59
pero no sé cuál nombre, 00:29:00
pues ahora asígnale un nombre. 00:29:01
Y yo desde una clase sola 00:29:03
puedo hacer muchos objetos distintos. 00:29:05
Cada objeto será un trocito de memoria, 00:29:07
será como una variable, 00:29:10
pero no una variable sencilla 00:29:11
como el tipo int, 00:29:13
que es un cuadradito con dentro el número. 00:29:15
Será un cuadrado grande 00:29:17
con varios campos, 00:29:19
con muchas cosas, 00:29:20
pero es un bloque único 00:29:21
guardado por algún lado en la memoria, 00:29:22
en una zona de la memoria 00:29:24
que se llama el heap, 00:29:26
heap, 00:29:28
¿vale? 00:29:29
Que es donde la Java Virtual Machine 00:29:30
crea los objetos. 00:29:32
Pregunta, dos preguntas para vosotros. 00:29:35
¿Cómo se creará un nuevo objeto? 00:29:37
New, ¿vale? 00:29:41
Cuando veis new, 00:29:43
la palabra new, 00:29:45
y nosotros la hemos visto por ejemplo 00:29:47
en los array, ¿vale? 00:29:48
Allí es que se está creando un nuevo objeto. 00:29:50
Cuando nosotros crearemos nuevos objetos 00:29:53
de una clase, 00:29:55
pues pondremos new y ese nombre, 00:29:57
nombre de la clase, ¿sí? 00:29:59
Y le pasaremos los parámetros necesarios 00:30:01
para que construya lo que tiene que construir. 00:30:03
Y a ese punto se creará un objeto. 00:30:05
Y si yo lo llamo diez veces el new, 00:30:07
pues me he creado diez objetos distintos. 00:30:09
¿El objeto puede tener heredad? 00:30:12
¿Puede partir de distintas clases? 00:30:15
No, no heredamos. 00:30:18
La herencia viene después. 00:30:21
Por ahora son objetos separados 00:30:23
y cosa por este, ¿vale? 00:30:24
Esto de la herencia os lo digo 00:30:26
porque luego lo haremos, lo veremos. 00:30:27
Pero por ahora vamos a lo básico. 00:30:29
Y no, en Java no puede. 00:30:32
En C++ sí. 00:30:35
Depende del lenguaje programado. 00:30:37
Podemos decir que son moldes para construir objetos. 00:30:40
Estos moldes tienen que ser escritos o programados 00:30:43
y cada molde va a tener unas características 00:30:46
que son el nombre de este molde, 00:30:48
cómo se llama la clase, la clase persona, 00:30:51
los atributos, 00:30:53
que son las características propias de esta clase, 00:30:55
y los métodos, o sea, las funcionalidades 00:30:58
que ofrece esta clase. 00:31:01
Entonces, clase animal. 00:31:03
Nombre de la clase animal. 00:31:12
Atributos de la clase animal. 00:31:15
¿Qué nos interesa? 00:31:18
¿Qué nos oye? 00:31:24
Peso. Peso del animal. 00:31:26
¿Qué es peso? 00:31:28
Es un string, es un boolean. 00:31:30
Double. ¿Qué representa? 00:31:35
Gramos, kilos, toneladas, gramos. 00:31:37
Pues entonces yo pondría peso en gramos. 00:31:41
Así, peso en mayúscula M, gramos. 00:31:44
¿Qué más nos interesa del animal? 00:31:49
Alimentación. 00:31:54
¿Qué pilla alimentación? 00:31:56
¿Qué tipo es? 00:31:59
Un string. 00:32:03
¿Vale? Puedo poner cualquier cosa. 00:32:04
Vale. 00:32:06
¿Qué más me interesa del animal? 00:32:09
Color, raza. 00:32:15
Pongo todo lo que sea en atributos. 00:32:16
¿Vale? 00:32:18
Esto será que cada objeto animal que creo 00:32:19
tendrá su peso en gramos, 00:32:22
su raza, su color, 00:32:24
su alimentación. 00:32:27
¿Vale? 00:32:29
Estas son las cosas. 00:32:30
¿Y por qué hay alimentación? 00:32:31
Porque posiblemente este es un animal 00:32:32
que utilizaré en un sistema de un zoo. 00:32:35
¿Vale? 00:32:39
Y tengo que saber cada animal que está comiendo 00:32:40
para luego poderle dar la comida correcta. 00:32:42
¿Sí? 00:32:45
O es un sistema de preservación animal 00:32:46
de especies raras 00:32:50
y por lo tanto tengo que saber 00:32:52
en qué hábitat y qué comen cada uno de ellos. 00:32:54
Lo sé. 00:32:56
Está claro que si es una cosa 00:32:57
en que la alimentación no tiene sentido, 00:32:59
pues quito la alimentación. 00:33:01
¿Se entiende eso? 00:33:03
¿Y qué puede hacer un animal? 00:33:04
Comer. 00:33:06
¿Vale? 00:33:08
Cuando yo llamaré el método comer, 00:33:09
que le paso un objeto que come, por ejemplo, 00:33:11
o sea, un algo que come, 00:33:14
él comprobará que la alimentación sea correcta 00:33:17
porque si no, no lo come, 00:33:20
y si lo come, subirá su peso. 00:33:22
Lo sé. 00:33:24
Tamagotchi. 00:33:27
Tamagotchi total. 00:33:28
¿Vale? 00:33:29
¿Se entiende esto? 00:33:30
¿Dudas? 00:33:32
¿Idea de clase? 00:33:35
Cuando hablo de clase, 00:33:37
hablo de algo general. 00:33:38
¿Vale? 00:33:40
Es la abstracción. 00:33:41
Yo puedo tener aquí veinte personas, 00:33:43
veinticinco personas. 00:33:46
¿Vale? 00:33:47
Lo que estoy haciendo es hacer 00:33:48
que tenéis en común 00:33:51
para abstraer y decir, 00:33:53
vale, todos vosotros tenéis un nombre, 00:33:54
todos vosotros tenéis un apellido, 00:33:56
todos vosotros tenéis un... 00:33:58
¿Vale? 00:33:59
Y a este punto, 00:34:00
cada uno de vosotros tendrá estanciado 00:34:01
el nombre, apellido y los otros atributos 00:34:03
con lo vuestro. 00:34:06
¿Sí? 00:34:08
Yo soy una persona, como todos vosotros, 00:34:09
pero soy una persona que en el nombre tiene Stefano 00:34:11
y en el apellido tiene Kiki. 00:34:14
¿Verdad? 00:34:16
¿Pensaba una clase? 00:34:19
Siempre como ejemplo persona. 00:34:20
Se define en un fichero que tiene el mismo nombre 00:34:22
y extensión. 00:34:24
O sea, que la clase persona, 00:34:25
normalmente, se define en persona.java, 00:34:27
que es lo que hemos hecho nosotros. 00:34:30
En realidad, toda la clase que es pública, 00:34:32
la que se llama public class, 00:34:35
tiene que estar dentro de... 00:34:37
O sea, la public class persona 00:34:39
tiene que estar en persona.java. 00:34:41
La class persona no, 00:34:43
pero lo veremos más adelante. 00:34:45
La palabra reservada class 00:34:48
es la que define una clase. 00:34:49
Definimos los atributos datos relevantes 00:34:52
y los métodos comportamientos de la clase. 00:34:54
Aquí existe una cosa que es el UML, 00:34:56
Universal Modeling Language. 00:35:00
No sé si habéis visto, 00:35:03
o habéis empezado a ver en... 00:35:05
Hay algunos de los diagramas que aprenderéis 00:35:10
y que aprenderéis a amar, 00:35:13
que se llama diagrama de clases, 00:35:15
donde podéis definir las clases 00:35:17
para que luego se mezclen entre ellas, etc. 00:35:20
Entonces, por ejemplo, la clase persona 00:35:23
puede ser esta cosa aquí, 00:35:26
que es una descripción de... 00:35:32
¿Cómo se llama la clase persona? 00:35:34
¿Qué atributos tiene? 00:35:37
Tiene un string, que es su nombre, 00:35:39
e un int, que es su edad. 00:35:42
¿Y qué puede hacer? 00:35:44
¿Cuáles son los métodos de personas? 00:35:46
El escribir, que no pilla ningún variable 00:35:48
y no devuelve nada. 00:35:52
Esta persona, por como me la han definido, 00:35:56
tiene un solo método, 00:35:59
tiene un solo comportamiento, 00:36:00
una sola funcionalidad, 00:36:01
que es escribir. 00:36:02
¿Y qué hace esto? 00:36:03
No lo sé. 00:36:04
¿Vale? 00:36:05
No sé por qué no está escrito. 00:36:06
¿Cómo podría extender esto? 00:36:08
Pues persona con nombre, apellido, edad, 00:36:10
dirección e identificador. 00:36:13
¿Vale? 00:36:15
Estos irían aquí, porque son atributos. 00:36:16
¿Y qué funciones tiene? 00:36:18
Pues podría tener la función mudanza, 00:36:20
que me cambia la dirección. 00:36:23
Podría tener la función saludar, 00:36:25
que me dice hola, me llamo no sé qué, 00:36:28
tengo no sé cuántos años y te saludo. 00:36:30
No lo sé. 00:36:35
Depende de lo que estoy haciendo. 00:36:36
No. 00:36:42
Podría... 00:36:43
No, no es, no sé. 00:36:44
¿Vale? 00:36:45
Podría que haya funciones que no tocan estas cosas. 00:36:46
Sería raro. 00:36:49
¿Vale? 00:36:50
Porque normalmente lo que estoy haciendo aquí 00:36:51
es empaquetar datos 00:36:53
y cómo se manejan esos datos, 00:36:55
en un cierto sentido, 00:36:58
las funcionalidades. 00:36:59
Está claro que si la persona puede hacer una cosa 00:37:00
que no tiene nada que ver con lo que 00:37:02
tiene como atributos, 00:37:04
puede pasar, 00:37:06
pero me debería preguntar muy bien 00:37:08
por qué este método está en persona. 00:37:11
Porque a lo mejor no es un método de persona. 00:37:13
Si aquí yo tengo el método de conduce coche, 00:37:15
que lo que hace es mover un coche, 00:37:19
pues a lo mejor no es de persona. 00:37:21
A lo mejor lo debería buscar, 00:37:23
meter en coche mismo 00:37:25
y que luego la persona como atributo 00:37:27
tenga un coche 00:37:29
y entonces pueda acceder a ese coche y moverlo. 00:37:30
¿Por qué? 00:37:35
Y aquí a lo mejor me adelanto un poco. 00:37:36
Estos atributos 00:37:38
claramente son tipos primitivos. 00:37:40
Pero también pueden ser objetos. 00:37:43
Entonces yo puedo asignar a una persona 00:37:46
un objeto casa 00:37:50
que tendrá su domicilio, 00:37:53
tendrá el color de las ventanas, 00:37:55
tendrá cuántas plantas son 00:37:57
y los metros cuadrados. 00:37:59
Entonces aquí yo tendré un atributo 00:38:00
que no es mi casa dos puntos string, 00:38:02
es mi casa dos puntos casa con la C mayúscula. 00:38:06
¿Y qué es casa? 00:38:09
Pues una clase. 00:38:10
Me puedo ir a mirar esa clase 00:38:12
y ver qué hay ahí. 00:38:14
Y luego puedo instanciar una casa 00:38:16
y tener mi casa 00:38:19
con mis 2.500 metros cuadrados mínimo 00:38:21
con alquiler 25 euros al mes. 00:38:25
¿Sí? 00:38:29
¿Dudas? 00:38:30
Ahora, ¿cómo se traduce esto 00:38:32
en esto? 00:38:35
Public las personas. 00:38:41
¿Vale? 00:38:43
Aquí es donde va el nombre. 00:38:44
Con las nomenclaturas típicas de Java, ¿vale? 00:38:46
Las clases empiezan por mayúsculas. 00:38:53
¿Ok? 00:38:55
De esta forma, cuando yo veo una cosa así, 00:38:56
puedo saber si es una clase, 00:38:58
si es un método, 00:39:00
si es una variable, 00:39:01
si es un lo que sea. 00:39:02
¿Sí? 00:39:03
Aquí va el método escribir, 00:39:05
que hemos dicho que es void 00:39:09
porque no pilla nada 00:39:11
y devuelve nada, 00:39:12
por lo tanto es así. 00:39:13
Si pusiera que aquí escribe un string, 00:39:15
pues aquí dentro podría ser string, 00:39:18
saludo, 00:39:20
y que aquí escriba el saludo, 00:39:21
no lo sé. 00:39:22
¿Vale? 00:39:23
Y aquí el cuerpo de este método. 00:39:24
O sea, ¿qué hace este método? 00:39:26
Una clase puede o no tener el main. 00:39:27
¿Os acordáis qué era el main? 00:39:31
¿Cómo os definí yo el main? 00:39:34
El punto de acceso a mi programa. 00:39:37
Y hasta ahora tenía sentido. 00:39:40
O sea, tengo una clase, 00:39:43
le tengo que decir que este es el punto de acceso, 00:39:44
pues no, es esa clase. 00:39:46
Pero ahora en un sistema 00:39:48
donde yo tengo varias clases, 00:39:49
tengo persona, 00:39:51
tengo casa, 00:39:52
tengo coche, 00:39:53
tengo taller, 00:39:54
pues en todos estos 00:39:55
habrá al menos una clase 00:39:57
que tendrá un main. 00:39:59
Y eso es de donde se empieza a ejecutar. 00:40:01
Será aquí donde yo empezaré a crear 00:40:04
los objetos personas, 00:40:06
luego los asocio con los objetos casa, 00:40:08
luego los asocio con los objetos coche, 00:40:10
y voy creando mi sistema y hacer cosas. 00:40:12
Si tuviera un menú que dice 00:40:15
crea un nuevo coche, 00:40:17
crea una nueva casa, 00:40:18
crea una nueva persona, 00:40:19
asocia persona con casa, 00:40:20
pues el menú sería aquí. 00:40:21
Y este main no necesariamente 00:40:25
está en todas las clases, 00:40:27
que es también una cosa nueva. 00:40:28
Hasta ahora una clase tiene un main, 00:40:30
una clase tiene un main. 00:40:32
Ahora, si yo tengo tres clases, 00:40:33
tengo dos clases, 00:40:35
tengo persona y coche, 00:40:36
para asociar luego personas y coches, 00:40:38
tengo que elegir 00:40:40
si el main está en persona 00:40:42
o si el main está en coche. 00:40:44
O me creo una tercera persona, 00:40:46
que es una tercera clase, 00:40:48
que es mi clase, 00:40:50
ejecutar ejemplo persona coche, 00:40:51
¿vale? 00:40:56
Y lo que hago es que en esta clase aquí 00:40:57
no es una clase destinada a crear objetos, 00:40:59
es una clase estática, 00:41:01
que sustancialmente lo que hace 00:41:06
es tener solo el main. 00:41:07
Entonces, yo tengo aquí mi persona 00:41:09
con la cosa de persona, 00:41:11
mi coche con la cosa de coche, 00:41:12
y cuando quiero ejecutar, 00:41:13
trabajar con ellos, 00:41:15
pues ejecuto esta tercera clase, 00:41:16
la clase ejecutar. 00:41:18
Y la clase ejecutar, 00:41:21
pues lo que hace 00:41:22
es empezar a crear persona, 00:41:23
crear coches 00:41:24
y asociarlo entre ellos. 00:41:25
¿Dudas? 00:41:28
Esto es semi nuevo, 00:41:33
casi nuevo, 00:41:35
porque con Raquel 00:41:37
algunos de vosotros lo han visto, 00:41:38
pero nosotros en la vida 00:41:40
hemos escrito aquí. 00:41:42
Nosotros estas cosas de aquí 00:41:43
las hacemos en el main. 00:41:45
Y ahora en vez, 00:41:47
las sacamos del main. 00:41:49
Es más, 00:41:50
las sacamos de todos los métodos. 00:41:51
Las variables que se ponen aquí, 00:41:56
fuera de cualquier método posible, 00:41:59
son lo que son los atributos. 00:42:01
Las variables propias 00:42:04
que luego utilizaré 00:42:08
dentro de la persona 00:42:10
para hacer objetos. 00:42:11
Cuando yo creo un objeto persona, 00:42:13
pues tendrá un string de nombre 00:42:15
y un int de data. 00:42:17
Oye, pero este es nombre, 00:42:19
este es data, 00:42:20
¿cuáles son? 00:42:21
¿Cómo se llama esta persona? 00:42:22
No lo sé. 00:42:23
Este es el molde. 00:42:24
Esto me está diciendo 00:42:25
que tendrá un nombre, 00:42:26
tendrá una edad. 00:42:27
Luego a partir de allí 00:42:29
vamos a ver 00:42:31
cómo se le da 00:42:32
y qué persona es. 00:42:33
A partir de este molde de aquí 00:42:34
yo puedo crear 00:42:37
cuántas personas quiero. 00:42:38
¿Dudas? 00:42:42
¿Preguntas? 00:42:44
Pregunta para vosotros entonces. 00:42:50
¿Esta variable nombre? 00:42:52
¿Qué visibilidad tiene? 00:42:54
¿Qué ámbito tiene? 00:42:56
¿Qué scope tiene? 00:42:58
¿Dónde la puedo usar? 00:42:59
¿Recuerdas cuál era el ámbito 00:43:11
de una variable? 00:43:12
¿Dónde existe una variable? 00:43:13
Si yo creo una variable 00:43:18
en algún lado, 00:43:19
¿hasta dónde existe esa variable? 00:43:20
Dentro de su bloque. 00:43:24
Y aquí empieza un bloque 00:43:28
que acaba al final. 00:43:30
Es decir, 00:43:32
que esta variable nombre 00:43:33
la puedo usar 00:43:35
en cualquier lado de esta clase. 00:43:36
En cualquiera 00:43:38
de los métodos de la clase. 00:43:39
Cualquier método de la clase 00:43:41
puede acceder a ese nombre. 00:43:43
Lo puedo usar aquí dentro, 00:43:45
como lo puedo usar aquí dentro, 00:43:47
como lo puedo usar en otro método. 00:43:48
Como estos son los parámetros, 00:43:50
los atributos, 00:43:52
las características de esta clase, 00:43:54
y los métodos, 00:43:56
aquí lo que van a hacer 00:43:58
es modificar estos atributos, 00:43:59
pues estos atributos 00:44:01
son accesibles 00:44:02
desde cualquier punto de la clase. 00:44:03
Veremos que, 00:44:10
si son públicos, 00:44:11
son hasta accesibles 00:44:13
desde fuera de esta clase. 00:44:14
Si son privados, 00:44:16
solo esta clase 00:44:18
los puede modificar. 00:44:21
Eso dependerá de mí, 00:44:23
cuando veremos ahora los modificadores, 00:44:24
lo veremos más. 00:44:26
Pero si yo tengo aquí 00:44:27
un dato especial, 00:44:28
que no quiero que alguien fuera cambie, 00:44:30
a menos que no pase 00:44:32
por un método mío, 00:44:34
que lo que va a hacer 00:44:36
es comprobar 00:44:37
que los datos que me has dado 00:44:38
son correctos, 00:44:39
imaginaos que aquí 00:44:40
hay un string DNI. 00:44:41
Y yo cuando tú 00:44:43
configuras el DNI, 00:44:44
no quiero que tú puedas poner gato, 00:44:46
porque gato no es un DNI, 00:44:48
un DNI tiene que ser 00:44:50
ocho números y una letra. 00:44:51
Entonces a lo mejor yo me digo, 00:44:53
oye mira, 00:44:55
este DNI es privado, 00:44:56
y te doy un metodito aquí 00:44:58
que puede ser 00:45:00
configuraDNI, 00:45:01
y dentro del metodito 00:45:03
configuraDNI, 00:45:04
tú cuando accedes allí 00:45:05
me comprueba 00:45:06
antes de asignarlo 00:45:07
que es efectivamente 00:45:08
ocho números más una letra. 00:45:09
Pero bueno, 00:45:12
me estoy adelantando. 00:45:13
Lo que sacamos de aquí es, 00:45:15
creo una clase, 00:45:17
la clase es un molde, 00:45:19
tiene los atributos aquí, 00:45:21
y tiene los métodos aquí, 00:45:23
¿vale? 00:45:25
Puede o no tener un main, 00:45:26
si tiene el main 00:45:28
es el punto de acceso 00:45:29
de mi programa, 00:45:30
si no tiene el main, 00:45:31
no. 00:45:32
Pregunta para vosotros, 00:45:33
¿puede haber un programa 00:45:35
sin main? 00:45:36
Programa sin main 00:45:42
no sería ejecutable, 00:45:45
no sé de dónde empezar. 00:45:47
Entonces en un sistema, 00:45:49
por algún lado 00:45:51
un main tiene que estar. 00:45:52
¿Puedo tener 00:45:54
tres clases y tres main? 00:45:56
¿Puedo tener persona con su main, 00:46:03
coche con su main, 00:46:05
o casa con su main? 00:46:07
Lo puedo tener, ¿vale? 00:46:12
Pero normalmente, 00:46:14
la idea es que haya uno de estos 00:46:16
que sea mi sistema, 00:46:18
este es un main 00:46:20
que cuando lo lanzo 00:46:22
empieza mi sistema 00:46:23
de gestión de cosas y casas 00:46:24
de personas, ¿sí? 00:46:25
Mientras que en cada clase 00:46:27
hay un main 00:46:29
que hace pruebas 00:46:30
sobre esta clase. 00:46:32
Cuando ya he creado la clase persona 00:46:34
para probar la clase persona 00:46:35
y crear tres, cuatro personas 00:46:37
y hacerle hacer algo, 00:46:38
pues me he creado un main 00:46:39
para ver de utilizar las personas, 00:46:40
los objetos personas, ¿vale? 00:46:43
Y que se lanza esto, 00:46:45
hace algo, 00:46:46
pero no es mi sistema, 00:46:47
es una prueba concreta de este. 00:46:48
¿Sí? 00:46:51
En general, 00:46:52
lo que debería haber 00:46:53
es un main 00:46:54
y las clases que quiero 00:46:55
y que necesito. 00:46:57
¿Dudas? 00:46:59
¿Sí? 00:47:01
Una variable existe 00:47:09
solo dentro de su bloque. 00:47:11
Cuando tú haces for, int, 00:47:13
no sé qué, 00:47:14
dentro que hagas int aux 00:47:15
y la usas, 00:47:19
cuando sale del for, 00:47:20
aux no existe, 00:47:21
no la puedes usar fuera del for. 00:47:22
Porque el ámbito de una variable 00:47:24
es el bloque en el que crea. 00:47:26
Ahora, nosotros normalmente 00:47:28
creamos las variables 00:47:29
dentro de este bloque. 00:47:30
Entonces, 00:47:31
solo existen en el main, 00:47:32
pero no existen, 00:47:33
por ejemplo, 00:47:34
en escribir, 00:47:35
porque la he creado aquí dentro. 00:47:36
Ahora, 00:47:38
lo que he hecho es 00:47:39
sacar estas variables aquí fuera. 00:47:40
Al sacarlas aquí fuera, 00:47:43
existen en el bloque persona. 00:47:44
Por lo tanto, 00:47:48
existen tanto en escribir 00:47:49
como en main. 00:47:50
Por lo tanto, 00:47:52
las puedo utilizar 00:47:53
tanto en escribir 00:47:54
como en main, 00:47:55
como en cambia nombre, 00:47:56
como en saluda, 00:47:57
como en todos los métodos 00:47:58
que están aquí. 00:48:00
Aquí hay como 00:48:02
tres niveles de variables, 00:48:05
digamos así. 00:48:07
Hay las variables locales, 00:48:08
que son locales a un método. 00:48:10
Las variables atributos, 00:48:13
que son comunes a toda la clase, 00:48:16
las puedo usar en todos los métodos. 00:48:18
Y luego veremos 00:48:20
que hay las variables estáticas 00:48:21
o globales, 00:48:24
que prácticamente no dependen 00:48:25
del objeto, 00:48:27
pero son las mismas 00:48:28
en todos los objetos. 00:48:29
Pero digo, 00:48:31
si no se supone que cada, 00:48:32
por ejemplo, 00:48:34
persona y escribir 00:48:35
son clases que van... 00:48:36
Escribir no es una clase. 00:48:39
Es un método de la clase persona. 00:48:41
Si se supone que persona es una clase 00:48:44
que existe en un lado 00:48:46
y luego lo tengo que utilizar 00:48:49
en el main, por ejemplo... 00:48:51
Persona es una clase. 00:48:53
Nombre lo puedes usar aquí. 00:48:57
Si quieres crear una persona, 00:49:03
aquí en el main o en otro main 00:49:05
puedes crear una persona. 00:49:07
No hemos visto todavía 00:49:08
cómo creamos los objetos. 00:49:09
Ahora simplemente 00:49:12
estamos hablando del molde. 00:49:13
Estamos hablando de la clase. 00:49:15
Aquí yo estoy haciendo 00:49:17
una descripción 00:49:18
de cómo es una persona. 00:49:19
De cómo es y lo que hace. 00:49:21
El cuerpo de uno de estos... 00:49:24
es cómo lo hace. 00:49:27
No sé si veis las tres preguntas. 00:49:29
¿Qué tiene la persona? 00:49:33
Sus atributos. 00:49:35
¿Qué hace la persona? 00:49:36
Sus métodos. 00:49:38
¿Cómo hace las cosas? 00:49:39
Pues la descripción 00:49:41
de la implementación del método. 00:49:42
Yo puedo tener escribir 00:49:45
y aquí dentro 00:49:47
tener implementaciones distintas. 00:49:48
Si la haces tú, 00:49:50
haces una implementación. 00:49:51
Si la haces tú, 00:49:52
haces una implementación. 00:49:53
Hacen la misma cosa 00:49:54
porque los dos sabrán escribir 00:49:55
sea lo que sea 00:49:56
lo que quiere decir escribir, 00:49:57
pero el tuyo lo hace 00:49:58
de una forma 00:49:59
y el tuyo lo hace de otra. 00:50:00
El cómo lo hacen 00:50:01
son de formas distintas. 00:50:02
A lo mejor una es más eficiente 00:50:03
y otra no. 00:50:05
Como cuando yo daba los ejercicios 00:50:07
y uno lo resolvía 00:50:08
de una forma 00:50:09
y uno de otra. 00:50:10
Los dos ejercicios 00:50:11
hacen lo mismo 00:50:12
y son correctos 00:50:13
pero uno tarda un segundo 00:50:14
y uno tarda diez horas. 00:50:15
Lo están haciendo 00:50:17
de formas distintas 00:50:18
pero lo están haciendo a mí. 00:50:19
Eso depende 00:50:20
de la implementación. 00:50:21
Siempre clases. 00:50:25
En un archivo 00:50:26
solo puede haber 00:50:27
una clase public. 00:50:28
Puede haber más clases 00:50:30
pero public una clase solo. 00:50:31
Puede haber 00:50:34
otras contenidas 00:50:35
pero no accesibles 00:50:36
desde el exterior. 00:50:37
Cuando yo no pongo public 00:50:38
quiere decir que 00:50:40
fuera de este fichero 00:50:41
código escrito 00:50:42
fuera de este fichero 00:50:43
no puede acceder 00:50:44
a estas clases. 00:50:46
Están como protegidas. 00:50:47
En realidad 00:50:49
hay cuatro niveles 00:50:50
de protección 00:50:51
desde público a privado. 00:50:53
La privada es la más estricta. 00:50:56
La pública es la menos estricta. 00:50:58
Y luego hay en el medio 00:51:02
cosas que son 00:51:04
a nivel de package 00:51:05
o a nivel de herencia. 00:51:06
Como no sabemos 00:51:08
que son estas cosas 00:51:09
por ahora no lo sabemos. 00:51:10
Los atributos de una clase 00:51:12
son propios de la misma 00:51:13
y se podrán consultar 00:51:15
internamente 00:51:16
por parte 00:51:17
de los métodos de la misma. 00:51:18
O sea, todos los métodos 00:51:19
pueden toquetear 00:51:20
pueden modificar 00:51:22
y leer 00:51:23
todos los atributos 00:51:24
dentro de una misma clase. 00:51:26
Subido por:
Stefano C.
Licencia:
Reconocimiento
Visualizaciones:
10
Fecha:
20 de diciembre de 2023 - 12:00
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
51′ 37″
Relación de aspecto:
4:3 Hasta 2009 fue el estándar utilizado en la televisión PAL; muchas pantallas de ordenador y televisores usan este estándar, erróneamente llamado cuadrado, cuando en la realidad es rectangular o wide.
Resolución:
960x720 píxeles
Tamaño:
130.20 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid