Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 12-12-23 - 1 - Contenido educativo

Ajuste de pantalla

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

Subido el 18 de diciembre de 2023 por Raquel G.

4 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues entonces, que no se duerma nadie. 00:00:00
A ver, pues entonces tenemos ahora la oportunidad, magnífica, de resetear un poquito, 00:00:15
porque ahora empezamos con una filosofía nueva de programación. 00:00:24
No es que cambie tanto, porque vamos a utilizar todo lo anterior. 00:00:31
Pero tenemos la oportunidad de resetear, más o menos, todos los conceptos que hemos visto hasta ahora, 00:00:34
en más o menos medida, más o menos, a todos os suenan, unos los manejáis muy bien, otros menos bien, 00:00:39
pero los conocimientos de programación estructurada, que es cómo construir programas con variables, 00:00:47
sean sencillas o a raíz, y luego decisiones y bucles para que hagan lo que nosotros queremos hacer, 00:00:55
más o menos tenemos esa idea, y esa es la programación estructurada, ¿verdad? 00:01:03
La programación estructurada se basa en, yo tengo un problema para resolver, 00:01:07
un problema, entonces tengo ahora que descomponerlo en una secuencia de pasos, 00:01:13
en una secuencia de pasos, y ahora ya, esa secuencia de pasos tiene que constar exclusivamente 00:01:18
de entrada y salida de datos, leer variables, mostrar variables, entrada y salida de datos, 00:01:26
decisiones y bucles, ya está, esa es la programación estructurada. 00:01:33
La programación estructurada es una serie de sentencias, una tras otra, que yo he diseñado, 00:01:38
he diseñado para que consigan hacer lo que yo quería hacer, y esas sentencias, 00:01:43
con que sean decisiones, if, switch case, o bucles, while, for, es suficiente, 00:01:50
y luego por supuesto en asignación de datos a las variables y demás, 00:01:58
esa es la programación estructurada, más o menos, pues ya, mejor o peor, 00:02:02
todos la manejamos. 00:02:08
Pues ahora toda esa base la vamos a meter dentro de otra filosofía de programación, 00:02:10
que es la programación orientada a objetos. 00:02:19
Bueno, pues este es el punto, repito, de resetear y reconectar, 00:02:33
el que esté un poco más perdido, o el que haya desconectado desde hace unas cuantas semanas, 00:02:40
este es el momento de resetear y reconectar. 00:02:46
Vale, pues ¿por qué es necesario incorporar la programación dentro de objetos? 00:02:49
¿O por qué apareció? 00:02:56
¿O por qué de repente empezó a programarse así? 00:02:58
Nosotros hemos dicho ya que cualquier problema, cualquier problema que a uno se le plantee, 00:03:03
que sea resoluble por un ordenador, cualquiera, 00:03:09
con las sentencias de programación estructurada lo puede hacer, 00:03:14
y eso sigue siendo verdad. 00:03:17
Cualquier tarea se puede realizar mediante un algoritmo 00:03:19
que incorpore asignaciones a variables, decisiones y bucles, cualquiera, 00:03:24
siempre y cuando yo organice bien esas sentencias, 00:03:28
que ahí las diseñe bien y decida, ah, vale, tengo que hacer esto, eso. 00:03:31
Pues si las diseño bien, cualquier cosa que a mí se me ocurra, 00:03:35
la puedo resolver combinando decisiones, bucles y asignaciones a variables. 00:03:38
Y eso sigue siendo verdad, eso es verdad, y es inamovible. 00:03:43
Bueno, pues ¿qué necesidad tenemos entonces de programar de otra manera? 00:03:47
Pues tenemos la necesidad de entender nuestros programas un poquito mejor. 00:03:51
Cuando hace 50 o 60 años había que resolver tareas pequeñas, 00:03:58
pues ya está, yo me hago mi programa de 50 líneas seguidas y se acabó, 00:04:03
y 50 líneas seguidas cualquiera lo entiende. 00:04:08
Pero luego ya empiezan a venir volúmenes de datos enormes. 00:04:11
Empieza a venir programas con interfaces gráficas, 00:04:15
empiezan a venir programas distribuidos, 00:04:18
que parte del programa se hace aquí, 00:04:20
pero otra parte del programa se hace aquí y se tienen que comunicar. 00:04:22
Empieza a venir ya las complejidades derivadas de que la tecnología se desarrolla. 00:04:25
Pues entonces yo puedo seguir programando con programación estructural, 00:04:30
claro que puedo, pero mi programa que era antes de 50 líneas, 00:04:33
ahora se convierte en un programa de 357.000 líneas. 00:04:36
Entonces desarrollar 357.000 líneas es una locura, 00:04:41
porque si yo tengo un error, madre mía, ¿dónde lo encuentro? 00:04:45
Y si lo he encontrado, a lo mejor ese ya me encabe en un error aquí, 00:04:50
pues es una locura. 00:04:53
Entonces la aprobación de entradas de objetos, sobre todo, 00:04:55
surge por estos motivos que estamos diciendo. 00:04:58
El primero que he dicho, organizar el código un poquito mejor, 00:05:02
por Dios, no tener 50.000 líneas todas seguidas. 00:05:05
Vamos a organizar el código de otra manera. 00:05:09
La realidad viene esencialmente de ahí. 00:05:12
Vamos a organizar el código de otra manera. 00:05:15
Entonces la idea es la idea de la programación, 00:05:17
lo que antiguamente se llamaba la programación modular, 00:05:21
que era, uy, voy a dividir este código enorme en módulos, 00:05:25
que eran cachos de programa. 00:05:28
Entonces, bueno, la programación modular, algo nos arreglaba, 00:05:32
algo nos arreglaba el galimatías ese de 300.000 líneas, 00:05:37
algo nos lo arreglaba. 00:05:40
Pero esto luego ya se fue depurando, se fue depurando, 00:05:43
se fue depurando, y ya además se persiguió conseguir otros objetivos, 00:05:46
que es, hombre, vale, organizar el código, 00:05:51
vamos a dividirlo en partes, organizar el código, 00:05:54
organizar el código, vamos a llamarlo dividir el código. 00:05:58
Bueno, pues la programación estructurada divide el código 00:06:03
en cosas que se llaman clases. 00:06:07
¿Vale? 00:06:13
¿Qué es lo que veremos más en detalle en este tema? 00:06:14
¿Qué es una clase? 00:06:16
Pues una clase es un cacho de mi aplicación. 00:06:18
Cualquier aplicación construida en Java 00:06:20
y por extensión en cualquier otro lenguaje 00:06:24
que va a tener cada objeto, 00:06:27
pues la filosofía es la misma. 00:06:28
Es un montón de clases. 00:06:30
Ya está. 00:06:32
Y nada más que eso, un montón de clases. 00:06:33
Y cada clase es un trozo de esa aplicación. 00:06:35
Hasta ahora nuestras aplicaciones eran una sola, solo una. 00:06:38
¿No? 00:06:43
Nuestras aplicaciones empezaban con este aquí, 00:06:44
que ponía clas, pa, pa, pa, y luego ya las llaves. 00:06:47
¿Vale? 00:06:50
Pues esto es un trozo de aplicación. 00:06:51
Esto es una clase. 00:06:53
Lo que hemos hecho nosotros hasta ahora es eso. 00:06:54
Esto es una clase. 00:06:57
Lo que hemos hecho nosotros hasta ahora es eso, una clase. 00:06:58
¿Vale? 00:07:02
Pero nuestras aplicaciones tenían solo una. 00:07:03
Porque eran aplicaciones, bueno, pequeñitas, manejables 00:07:05
y no merecía la pena empezar a dividirlo en clases diferentes. 00:07:08
Solo tenían una. 00:07:11
Pero una aplicación Java mínima, cualquiera, 00:07:14
pues tendrá muchas clases. 00:07:17
Tendrá un montón de clases. 00:07:20
Porque ya empezar a hacer diferentes cosas 00:07:22
y el código se va alargando, 00:07:24
tengo que tirar por aquí, tirar por acá. 00:07:25
Bueno, pues la operación de entradas de objetos, 00:07:27
uno de los objetivos es organizar el código 00:07:29
dividiéndolo en estos trocitos que se llaman clases. 00:07:33
Y luego estas clases se pensaron también, 00:07:38
cuando ya se dijo, vale, ¿cómo las vamos a hacer estas clases? 00:07:40
¿Cuál va a ser su sintaxis? 00:07:43
¿Cómo las vamos a construir? 00:07:44
Pues se pensó también eso, 00:07:46
que además se alcanzó un segundo objetivo, 00:07:48
que ahora en realidad es casi el más importante. 00:07:50
Y es el de la reutilización. 00:07:53
Si yo ya tengo mi aplicación 00:08:01
y la tengo muy bien divididas en clases, 00:08:03
por ejemplo, tengo una aplicación que 00:08:05
gestiona los pedidos de una empresa. 00:08:07
Esa aplicación es enorme. 00:08:10
Tengo que hacer, introduzca datos del pedido. 00:08:12
Ahora, pues introduzca datos del cliente. 00:08:14
Hacer un pedido nuevo. 00:08:17
Hacer una reserva, eliminar. 00:08:18
Si tengo una aplicación enorme, 00:08:20
yo entonces ahora digo, uy, esta es muy grande. 00:08:22
Voy a dividirla en clases. 00:08:24
Vale, pues entonces ahora viene la parte del diseño, 00:08:26
que es decir, ¿y qué clases hago? 00:08:29
¿Cada una qué hace? 00:08:31
¿De qué parte se encarga? 00:08:32
Cada aplicación tiene 200.000 diseños posibles. 00:08:34
Unos serán buenos, otros serán malos. 00:08:37
Pero no hay único diseño posible. 00:08:41
Hay tantos diseños como divisiones uno quiera hacer. 00:08:44
Uno puede dividir la aplicación como lo quiera. 00:08:47
Bueno, pues una vez que ha decidido esta división, 00:08:50
por ejemplo, voy a hacer una clase 00:08:53
que es la que se va a encargar de todo lo relacionado 00:08:56
con insertar pedidos nuevos. 00:08:59
Vale, pues yo tengo ahí mi clase para insertar pedidos. 00:09:01
Ahora voy a hacer otra clase que va a hacer 00:09:03
todo lo relacionado con insertar clientes nuevos. 00:09:05
Estupendo, tengo aquí mi clase para insertar clientes. 00:09:09
Ahora voy a hacer otra clase que tenga 00:09:12
todo lo relacionado con hacer las ventanitas gráficas 00:09:14
para comunicarse con el usuario. 00:09:17
Estupendo, tengo mi clase de interfaz gráfica. 00:09:19
Pues una vez que uno tiene ya las clases decididas 00:09:22
y las va haciendo para construir la aplicación, 00:09:25
¿de repente qué ocurre? 00:09:28
Que ahora esa aplicación ya está hecha. 00:09:30
Y ahora vamos a hacer otra aplicación completamente distinta 00:09:32
que va a gestionar otra cosa, 00:09:34
pero que también tiene pedidos. 00:09:36
Estupendo, me cojo la clase que hacía todo relacionado 00:09:38
con los pedidos, me cojo esa clase 00:09:42
y me la llevo también a esta aplicación mía 00:09:44
porque este trocito me vale. 00:09:46
Pues entonces reutilizar esos trozos en otras aplicaciones 00:09:49
o reutilizar las clases 00:09:53
es precisamente la ventaja añadida 00:09:55
y la más importante en realidad 00:09:58
de la aprobación de entrada de objetos. 00:10:00
El poder reutilizar las clases que ya están hechas. 00:10:02
El poder reutilizarlas. 00:10:06
Por ejemplo, yo tengo una aplicación en un solo fichero 00:10:08
con 100.000 líneas. 00:10:11
Reutilizar eso es una locura. 00:10:13
Hasta que encuentre yo el trocito que me vale 00:10:15
y luego adaptar ese trocito a mi código, 00:10:17
meterlo donde toque, es una barbaridad. 00:10:19
Pero con esta filosofía de hacerlo en diferentes clases 00:10:22
ya veremos cuando veamos cómo funciona 00:10:25
que la reutilización es inmediata 00:10:27
porque se adapta automáticamente. 00:10:29
Entonces, este objetivo en realidad 00:10:31
es ahora mismo el más importante 00:10:35
y el que ha hecho que esto triunfe. 00:10:37
Todas las aplicaciones que se hacen 00:10:40
uno no las puede construir todas. 00:10:42
Es imposible. 00:10:44
Entonces, cuando me hace una aplicación de cero 00:10:45
¿Veis que le estás durmiendo? 00:10:47
No. 00:10:49
¿Cómo que no? 00:10:50
Estaba descansando los ojos. 00:10:51
Me duelen los párpados. 00:10:53
¡Ah! ¡Qué estupido que te duelen los párpados! 00:10:54
Sí, porque cuando duermo poco 00:10:56
me duelen los párpados al pestañero. 00:10:58
¿Qué cosas más grandes me pasan? 00:11:00
Me pasa algo muy largo. 00:11:02
Bueno, bueno. 00:11:04
Hay que dormir, sí. 00:11:05
Eh... 00:11:08
Vale, entonces 00:11:11
lo de la reutilización ahora es imprescindible. 00:11:12
Cuando uno ya se plantea hacer una aplicación en condiciones 00:11:14
parte de las clases las programa uno. 00:11:18
Obviamente, parte las programa uno. 00:11:21
Pero el 90% restante 00:11:23
son clases que usamos que ya están hechas. 00:11:26
De paquetes de clases que descargamos, 00:11:29
que miramos en el repositorio, 00:11:32
todo eso, toda esa filosofía de programación, 00:11:34
reutilizando clases, llenando clases, 00:11:36
es la que vamos a ir construyendo aquí. 00:11:38
Que descargamos del mar, que no sé qué. 00:11:40
Cualquier aplicación necesita clases que hemos hecho nosotros. 00:11:43
Cualquiera. 00:11:48
¿Vale? 00:11:49
Bueno, pues esta es 00:11:51
la motivación para que exista esto. 00:11:55
Organizar el código de manera que mi aplicación 00:11:59
sea un poquito más legible. 00:12:01
Y si yo tengo que hacer una modificación, 00:12:03
no sea una locura, 00:12:05
porque me voy al trozo correspondiente y modifico, 00:12:07
y tengo que buscar en mil líneas, 00:12:09
para organizarlo y que quede más claro, 00:12:11
y poder reutilizarlo. 00:12:13
Estas son las dos motivaciones 00:12:16
de la aplicación entre dos objetos. 00:12:20
Y claro, ahora ya lo que hay dentro de estas clases 00:12:22
ya es programación estructurada. 00:12:28
Lo que hemos visto. 00:12:31
Lo que hay dentro de estos trozos 00:12:33
ya es lo que hemos visto. 00:12:35
Los while, los for, las variables, 00:12:37
eso ya está dentro de los trocitos. 00:12:42
¿Vale? 00:12:44
¿Vale? 00:13:02
¿Vale? 00:13:14
¿Está claro? 00:13:15
Bueno, pues entonces, 00:13:18
vamos a ver si a través de algún ejemplo 00:13:19
entendemos un poquito mejor cómo funciona. 00:13:21
A ver. 00:13:24
Las aplicaciones están 00:13:26
íntimamente relacionadas con una realidad 00:13:28
que es con la que estamos trabajando. 00:13:32
¿Verdad? 00:13:35
Uno hace una aplicación para facturas, 00:13:36
para las matrículas de secretaría, 00:13:40
para los pedidos de mi tienda de ropa. 00:13:42
Las aplicaciones están para resolver o ayudarnos 00:13:45
en la gestión de un problema real. 00:13:49
¿Verdad? 00:13:51
Nunca lo olvidemos. 00:13:52
Están para eso las aplicaciones. 00:13:53
¿Vale? 00:13:54
Una aplicación matemática. 00:13:55
Pues nos está ayudando en resolver un problema real 00:13:56
de sumas-restas al fin y al cabo. 00:13:59
Entonces, 00:14:02
cuando ya tenemos la posibilidad 00:14:03
de hacer una aplicación con diferentes trozos, 00:14:05
viene una parte 00:14:09
que es la parte que a nosotros nos compete menos 00:14:11
porque esta parte se ocupa más de ella, 00:14:15
los analistas, diseñadores, pues, 00:14:19
que no va a ser vuestro trabajo. 00:14:22
El trabajo va a ser sobre todo 00:14:24
ya directamente escribir código, modificar código. 00:14:26
Pero bueno, 00:14:30
cuando uno empieza una aplicación de cero 00:14:31
para gestionar su empresa de pantalones vaqueros, 00:14:33
sus libros de biblioteca, 00:14:38
cuando uno empieza una aplicación, 00:14:40
como ahora ya tiene la posibilidad 00:14:42
de hacer esa aplicación bien, 00:14:44
dividiéndola en clases para que sea organizada, 00:14:46
pues antes de nada le viene una primera parte 00:14:49
que es ¿vale? 00:14:52
¿Y en qué trozos divido? 00:14:53
¿En qué trozos divido? 00:14:55
¿En qué trozos divido? 00:14:57
¿Qué clases hago? 00:14:58
Esa es la parte de diseño. 00:15:00
Esa es la parte de diseño. 00:15:02
Vamos a diseñar en qué trozos divido 00:15:04
y luego ya le pongo a programar esos trocitos. 00:15:06
Entonces, como he dicho antes, 00:15:09
esa primera parte de diseño 00:15:11
hay muchos posibles en realidad. 00:15:13
Si yo consigo un diseño que sea muy claro 00:15:16
y la aplicación sea mantenible, 00:15:19
me ha acertado, es un diseño bueno. 00:15:21
Si hago un diseño y otro viene mi aplicación 00:15:23
y me dice no entiendo nada, 00:15:25
no entiendo nada de estos trozos, 00:15:27
pues entonces igual mi diseño es malo. 00:15:29
Es una cuestión de práctica sobre todo. 00:15:31
Pero hay una serie de pautas básicas 00:15:33
en las que nosotros no nos centramos muchos. 00:15:36
Quizás la asignatura... 00:15:39
¿Habéis empezado ya WML con Vanessa? 00:15:41
Con Marina, ¿verdad? 00:15:45
¿Qué nos da entornos de desarrollo? 00:15:52
¿Entornos o son de AVEA? 00:15:55
Vale, ¿habéis visto diagramas de clases? 00:15:57
Bueno, pues cada diagramita que habéis visto de clases 00:16:01
es un diseño y cada una de esas clases 00:16:04
es un trozo de una aplicación. 00:16:07
Entonces, ahí habréis de alguna manera intuido o visto 00:16:09
que cada una de esas clases 00:16:13
suele estar asociada, como pauta de diseño natural, 00:16:17
a un concepto de la realidad que yo estoy representando. 00:16:22
Por ejemplo, es como cuando hacéis un modelo 00:16:26
de entidad-relación en bases de datos. 00:16:29
Diseñar las clases es lo mismo 00:16:31
que hacer un modelo de entidad-relación. 00:16:34
Es exactamente el mismo problema. 00:16:37
Vosotros, pues no sé exactamente 00:16:39
pero tenéis que gestionar a lo mejor 00:16:41
pues eso, una empresa que lleva pedidos de cosas. 00:16:50
Entonces, los dos ahí tendréis que haber decidido 00:16:54
a ver, ¿cuáles son mis entidades? 00:16:57
Entonces, de forma natural os habrá salido. 00:17:02
A ver, mi empresa va a hacer pedidos. 00:17:05
De forma natural, una de las entidades 00:17:08
de mi modelo de datos será el pedido. 00:17:11
Porque si mi empresa trabaja con pedidos, 00:17:14
de forma natural una de mis entidades es un pedido. 00:17:17
O sea, cada entidad es un concepto real 00:17:20
que existe en la realidad que yo estoy tratando de modelar. 00:17:24
Entonces, ¿cómo verifica uno que esa entidad 00:17:30
que ha elegido está bien elegida 00:17:33
desde un criterio de diseño? 00:17:35
Pues porque la puede caracterizar con propiedades. 00:17:37
¿A un pedido se le puede caracterizar? 00:17:40
Sí, a un pedido se le puede decir. 00:17:43
El pedido se le puede caracterizar 00:17:45
por lo que cuesta, la fecha. 00:17:47
Entonces, si tú has identificado un concepto 00:17:49
y lo puedes caracterizar con propiedades 00:17:51
como fecha, cantidad, seguramente 00:17:54
hayas elegido bien la entidad. 00:17:57
Si has elegido otro concepto 00:17:59
y no le encuentras propiedades, 00:18:01
pues seguramente sea un concepto 00:18:04
que no está bien pensado 00:18:07
para asociarlo a una entidad. 00:18:09
Que no es un concepto real 00:18:11
que tú puedes tocar o identificar. 00:18:13
Pues más o menos, 00:18:15
cuando habéis hecho poderes de entidad de relación, 00:18:17
las entidades que os han salido 00:18:19
son efectivamente conceptos caracterizables 00:18:21
de la realidad que modeláis. 00:18:23
Y cada una de esas características 00:18:25
era cada uno de los campos de la tabla. 00:18:27
Cada uno de los campos. 00:18:30
Una clase es igual que una entidad 00:18:32
en un modelo de interrelación. 00:18:34
Es lo mismo. 00:18:36
Cuando uno diseña una aplicación 00:18:37
para una empresa que trabaja 00:18:39
con pedidos y clientes, 00:18:41
dice, vale, tiene sentido que haya un pedido. 00:18:43
Pues ala, ya tenemos una clase. 00:18:45
Mi aplicación. 00:18:50
Voy a hacer un ejemplito así muy por encima 00:18:53
para que lo entendamos 00:18:55
antes de programar ya más en faena. 00:18:57
Aplicación para gestionar 00:19:00
pedidos de clientes. 00:19:04
Vale, entonces. 00:19:11
Pues si va a gestionar los pedidos 00:19:13
de clientes, rápidamente 00:19:15
se nos ocurrirá. 00:19:17
Pues hombre, el concepto pedido 00:19:19
tiene importancia, el concepto pedido. 00:19:21
Ah, estupendo, pues ya tenemos 00:19:23
una clase o entidad 00:19:25
que en pronunciamiento de objetos se suele usar 00:19:27
como sinónimo clase y entidad 00:19:29
que sea pedido. Fenomenal. 00:19:31
Ala, guay. 00:19:33
Tengo ya una clase pedida. Ya veremos cómo la programamos 00:19:35
y qué hago con ella. Ya veremos. Pero tiene sentido que exista. 00:19:37
Vale, mi aplicación 00:19:39
con qué más va a trabajar. 00:19:41
Pues con clientes. Porque mi aplicación 00:19:43
se va a autenticar a un cliente, el cliente va a hacer un pedido. 00:19:45
Ah, pues tiene sentido 00:19:47
que haya también una entidad cliente. 00:19:49
Y además caracterizable por su DNI, 00:19:51
su fecha de alta, lo que sea. 00:19:53
Ah, tiene sentido. Ah, genial. Pues decido yo 00:19:55
que haya una clase cliente. 00:19:57
Vale, entonces en una aplicación 00:20:01
y entidad objetos tenemos que hacer un diseño 00:20:03
previo de cuáles son 00:20:05
los trozos o las clases que me interesan. 00:20:07
como pauta, que repito 00:20:11
no es nuestro problema ni lo que nosotros 00:20:13
evaluamos en este módulo, porque este módulo es formación 00:20:15
no es análisis, ni vais a ser analistas. 00:20:17
Como pauta 00:20:19
las clases que uno 00:20:21
elige tienen que 00:20:23
corresponderse a conceptos y entidades 00:20:25
de la realidad 00:20:27
que estoy yo modelando. 00:20:29
En este caso es evidente, si es una aplicación de pedidos clientes 00:20:31
un pedido 00:20:33
y una entidad cliente. 00:20:35
Habrá aplicaciones en las cuales 00:20:37
decidir las clases no es tan evidente. 00:20:39
Bueno, pues por eso está tan bien 00:20:41
pagado el trabajo del analista. 00:20:43
Porque esto es lo que hace y lo tienen que hacer bien. 00:20:45
Analista diseñador. 00:20:47
Porque si lo hacen mal y luego uno se pone 00:20:49
a programar ya una aplicación 00:20:51
con unas clases mal decididas 00:20:53
después hay un caos de aplicación 00:20:55
que al final puede que funcione, pero es un caos 00:20:57
y luego eso ya se va a abandonar, no va a tener recorrido 00:20:59
porque va a ser imposible mantenerlo. 00:21:01
Bueno, pues en nuestra aplicación de clientes pedidos 00:21:05
hemos decidido que haya 00:21:07
esas dos entidades. 00:21:09
Vale, pues vamos a programar una de ellas 00:21:11
para ver cómo se programa una clase. 00:21:13
Muy por encima, solamente para ver 00:21:15
cómo es el funcionamiento. 00:21:17
Hay que meterse ya, que ese ya es lo más rollo 00:21:19
en todos los detalles ya técnicos 00:21:21
de qué puede haber dentro de una clase. 00:21:23
Pero eso ya sí que es un chorizo. 00:21:25
Métodos estáticos para ti y para tan. 00:21:27
Antes vamos a ver 00:21:29
pues un panorama de cómo funciona esto 00:21:31
como funciona la aplicación de entrada de objetos. 00:21:33
Bueno, pues venga, hemos decidido que haya 00:21:35
estas dos clases, pedido y cliente. 00:21:37
Vale, pues ahora ya uno va 00:21:39
cada una, una por una, caracterizándolas. 00:21:41
Vamos a suponer que vamos a 00:21:43
programar la clase pedido. 00:21:45
Venga, empezamos con esta. 00:21:47
Pues si uno ha hecho su diagramita UML 00:21:51
los que hacéis en entornos 00:21:53
ya tendrá aquí un diagramita 00:21:55
estupendo que le habrá dado 00:21:57
el analista, diseñador, quien sea, 00:21:59
le habrá dicho, oye clase pedido y de pedido 00:22:01
te interesa la propiedad 00:22:03
pues código 00:22:05
que va a ser un entero 00:22:07
y además de pedido 00:22:09
te va a interesar 00:22:11
la descripción del pedido, que va a ser 00:22:13
una cadena de texto. Pongo ahí texto 00:22:15
aunque bueno, no se pone así, pero bueno. 00:22:17
Descripción. 00:22:19
A lo mejor resulta que sólo nos interesan 00:22:21
esas dos cosas del pedido. Bueno, vamos a 00:22:23
simplificar, nos interesan esas dos. 00:22:25
Nos interesa el código y la descripción. 00:22:27
Nada más, sólo esas dos. 00:22:29
¿Vale? Esa es la siguiente 00:22:31
fase, cuando uno ya ha identificado 00:22:33
una de las entidades 00:22:35
que le interesan en su aplicación 00:22:37
tiene que caracterizarla, es decir, ¿por qué se va a 00:22:39
caracterizar? Por el código 00:22:41
y por la descripción. 00:22:43
Si se caracteriza por más, pues por más, por las que sean. 00:22:45
Bueno, pues vamos a 00:22:47
programar ya esta clase. 00:22:49
Vamos a programarla. 00:22:51
Pues ¿cómo se programa ya una clase 00:22:53
de estas? 00:22:55
Vale, empezamos 00:22:57
con la palabra reservada 00:22:59
CLASS, sí o sí. 00:23:01
Vale, empezamos con esta palabra reservada 00:23:03
CLASS. 00:23:05
¿Qué se pone 00:23:07
después? El nombre 00:23:09
que yo decido, el que a mí me da la gana. 00:23:11
Lo normal es que sea un nombre, obviamente, 00:23:13
que represente esa realidad, 00:23:15
ese concepto. Pues en 00:23:17
este caso, pedido, es lo que más lo 00:23:19
representa a la pedido. 00:23:21
Que es un nombre muy largo, no pasa nada. 00:23:25
Que sea todo lo largo que sea. Hay 00:23:27
clases que tienen hasta 100 caracteres de nombre. 00:23:29
Pero que se entienda. 00:23:31
Porque si luego alguien va a reutilizar 00:23:33
su código, 00:23:35
ya veremos 00:23:37
por qué razones, por qué irá surgiendo. 00:23:39
Pues va a necesitar 00:23:41
información sobre qué representa eso. 00:23:43
Y la información en primera instancia 00:23:45
va a venir con el nombre. Entonces si el nombre lo describe 00:23:47
bien, maravilloso. Si no, no. Dime. 00:23:49
Descripción. 00:23:51
Vamos. 00:23:53
Bueno, pues así empieza. ¿Y ahora qué? 00:23:55
Pues ahora unas llaves que 00:23:57
abren y cierran donde está todo 00:23:59
el código de la clase. Todo el código. 00:24:01
Bueno, pues esta sería 00:24:05
una clase. 00:24:07
Que ahora vamos a ver qué metemos dentro. 00:24:11
A ver, siguiente cosa. 00:24:13
No es que sea obligatorio, 00:24:17
pero de nuevo, 00:24:19
es una regla de programación convenida 00:24:21
un poco por todos, 00:24:23
para clarificar y entendernos 00:24:25
entre nosotros. 00:24:27
Que los nombres de las 00:24:29
clases empiecen en letra 00:24:31
mayúscula. 00:24:33
¿Recordáis cuando estábamos viendo 00:24:35
declaración de variables que yo os decía? 00:24:37
Cuando declaráis una variable 00:24:39
así, 00:24:41
pauta en general 00:24:43
no obligatoria, 00:24:45
pero sí recomendable. 00:24:47
Que las variables empiecen 00:24:49
siempre con minúscula. 00:24:51
Lo dijimos en su momento. 00:24:53
Dije, eso tiene una explicación y es para 00:24:55
dejar muy claro 00:24:57
que es una variable y no una clase. 00:24:59
¿Vale? Porque las clases tienen 00:25:01
la otra pauta. Recomendable 00:25:03
que empiecen con letra mayúscula. 00:25:05
Recomendable. 00:25:07
Y así, cuando uno ve un código por ahí, 00:25:09
rápidamente, 00:25:11
si es mayúscula el identificador 00:25:13
o si es minúscula, 00:25:15
rápidamente ve, ah, esto es una clase. 00:25:17
Ah, no, esto es una variable. Entonces, esa información 00:25:19
ya le orienta muchísimo sobre 00:25:21
el funcionamiento del código. 00:25:23
Entonces, recomendable seguir esas 00:25:25
pautas de trabajo. 00:25:27
Bueno, pues entonces. 00:25:29
¡Hala! 00:25:33
Clase pedido. 00:25:35
Vale. 00:25:47
A ver, ¿queréis que ponamos unos minutos? 00:25:49
Vale, venga. 00:25:53
Venga, dos 00:25:55
minutillos, sí. 00:25:57
Tengo que subir los vídeos de ayer que no he tenido 00:25:59
tiempo a subirlos. 00:26:01
No, no, no. 00:27:01
No, no, no. 00:27:31
Y nada. 00:28:01
¿Qué dices? 00:28:31
¿Qué dices? 00:29:01
¿Qué dices? 00:29:31
¿Qué dices? 00:30:01
¿Qué dices? 00:30:03
¿Qué dices? 00:30:13
¿Qué dices? 00:30:15
¡Uy! 00:30:23
¿Qué dices? 00:30:25
¿Qué dices? 00:30:31
¿Qué dices? 00:30:41
¿Qué dices? 00:30:51
¿Qué dices? 00:30:55
¿Qué dices? 00:30:57
¿Qué dices? 00:31:05
¿Qué dices? 00:31:09
¿Qué dices? 00:31:21
¿Qué dices? 00:31:27
¿Qué dices? 00:31:31
¿Qué dices? 00:31:37
¿Qué dices? 00:31:41
¿Qué dices? 00:31:45
¿Qué dices? 00:31:51
¿Qué dices? 00:31:53
¿Qué dices? 00:31:57
¿Qué dices? 00:32:01
¿Qué dices? 00:32:03
¿Qué dices? 00:32:07
¿Qué dices? 00:32:11
Para minitando 00:32:19
¿you want to sit down? 00:32:23
Ya estoy 00:32:27
Pues dejámoslo 00:32:37
Vámonos 00:32:39
Óscar... 00:32:45
Ya están aquí 00:32:49
¿No? 00:32:53
Ya está 00:32:55
Ya está 00:33:15
Ya estás haciendo las caritas 00:33:19
Ya está 00:33:23
Ya está 00:33:41
Por el movimiento que tiene 00:33:43
Ya está 00:33:47
Vamos con la virta 00:33:49
Otra virta 00:33:51
Ya está 00:33:53
Voy a hacer cuatro 00:33:57
Esta hacer 00:34:00
Yo cierto 00:34:05
Pero sube a la parte 00:34:07
Ya va a cambiar el número 00:34:09
Eso sí, es como va subiendo el número 00:34:21
Pero no hay nada seguramente 00:34:29
Aquí también hay 00:34:33
No hay nada seguro 00:34:39
Estás tú 00:34:53
Sí, eso es una virta 00:34:59
Sí 00:35:05
Sí 00:35:09
Ya está, eso es como se encuentra 00:35:15
Claro 00:35:17
No me lo puedo creer, no pare esto 00:35:27
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
4
Fecha:
18 de diciembre de 2023 - 13:53
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
676.24 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid