Saltar navegación

20251215 AppClientesPedidos_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 15 de diciembre de 2025 por Raquel G.

9 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues esto sería lo primero parecido a una aplicación ya un poquito más grande, 00:00:00
no solo un programa que hace una cosa ya, sino una aplicación para desarrollar 00:00:10
toda una serie de funcionalidades sobre un modelo de datos, que en nuestro caso 00:00:15
es para gestionar el qué, los clientes y pedidos, que es la solución, el ejemplo más sencillo. 00:00:20
vale, pues entonces una aplicación 00:00:26
yo tengo clientes 00:00:29
que me piden cosas de mi almacén 00:00:30
y vamos a gestionar 00:00:32
esos pedidos y esos clientes que tengo 00:00:34
para facilitarme tareas 00:00:36
como emitir facturas 00:00:38
comprobar de un cliente si ha pagado 00:00:40
o no ha pagado, lo que fuera 00:00:42
a partir de ahí puedo añadir ya un montón de funcionalidades 00:00:43
venga, vamos a hacer 00:00:47
esto que plantea aquí 00:00:48
a ver que sacamos de aquí 00:00:50
se supone que 00:00:53
nos habríamos entrevistado con el cliente 00:00:56
y él nos habría explicado 00:00:58
lo que quiere conseguir 00:00:59
con esa aplicación, pues yo quiero 00:01:02
como tengo un montón de clientes así, pues quiero 00:01:04
en los clientes poder ver su ficha cuando quiera 00:01:06
quiero no sé cuánto, entonces después de esa entrevista 00:01:08
de tomar notas de muchas cosas 00:01:10
nosotros ya decidimos 00:01:12
cuáles son las entidades necesarias 00:01:14
¿vale? 00:01:16
en este caso ya han decidido 00:01:18
por nosotros un cliente 00:01:20
un pedido, una entidad 00:01:22
pedido, porque hay que gestionar cosas con pedidos 00:01:24
y una entidad 00:01:26
cliente 00:01:28
¿vale? 00:01:29
entonces, las entidades tienen datos 00:01:31
dentro, son cosas complejas 00:01:34
claro, porque si 00:01:36
el tío me dice, yo tengo que gestionar 00:01:38
mensajes 00:01:40
vale, el mensaje es un string, eso no es una 00:01:41
entidad que yo tenga que hacer, cuando necesito 00:01:44
un mensaje, instancia un string y ya está 00:01:46
pero el pedido, si es algo complejo 00:01:48
pues tiene un montón de cosas dentro, y el cliente 00:01:50
también tiene un montón de cosas dentro, entonces cada una 00:01:52
de ellas es una entidad, como si fuera 00:01:54
una tabla de la base de datos 00:01:56
como si fuera una entidad de un modelo 00:01:58
entidad relación, exactamente igual 00:02:00
bueno 00:02:02
pues después de haber hecho 00:02:04
reuniones con el cliente y todo eso 00:02:06
hemos llegado a la conclusión de que lo que 00:02:08
nos interesa en los pedidos 00:02:10
es solamente 00:02:12
lo que se ha gastado 00:02:13
de que va el pedido y el código 00:02:15
único 00:02:18
y en la clase cliente lo que nos 00:02:19
interesa es el nombre y el NIF 00:02:22
y todos los pedidos que tenga ese 00:02:24
cliente, todos los que tenga, ¿vale? 00:02:26
Solamente nos interesa eso. 00:02:28
Pues entonces vamos a hacer esas dos 00:02:31
clases. 00:02:32
Entonces, aquí 00:02:34
en un caso real, se haría 00:02:36
un paquete modelo 00:02:38
con el modelo de datos. 00:02:40
Otro paquete, pues con la 00:02:42
lógica o con 00:02:44
funcionalidades lógicas o lo que sea. 00:02:46
Ahora lo vamos a ir engordando. Otro con el 00:02:48
main, ¿vale? Entonces, como 00:02:50
yo lo tengo todo en un proyecto 00:02:51
todo en un proyecto para luego subirlo más fácilmente 00:02:55
a la aula virtual 00:02:57
pues lo que voy a hacer va a ser 00:02:58
paquete ejer22.model 00:03:00
ejer22.no se que 00:03:03
pero en un caso real 00:03:04
esta aplicación sería un proyecto 00:03:05
esa aplicación sería un proyecto 00:03:09
dentro de ese proyecto tendría 00:03:12
un paquete por cada conjunto 00:03:14
de clases que tienen una especie 00:03:17
de significado común 00:03:18
por ejemplo las entidades tienen como significado 00:03:20
pues ser entidades que representan 00:03:23
mi realidad, habrá otras 00:03:25
clases que sean utilidades matemáticas 00:03:26
pues en el paquete utilidades, lo que sea 00:03:28
entonces como yo no tengo 00:03:30
un único proyecto para mi clase 00:03:32
pues lo voy a hacer en 00:03:34
para que se vea que va en diferentes paquetes 00:03:36
pues voy a hacer un paquete ger22.modelo 00:03:38
ger22.no se que 00:03:41
entonces 00:03:43
me voy a crear 00:03:44
un paquete para el modelo de esta 00:03:46
aplicación 00:03:48
y lo voy a llamar 00:03:49
ejer22.model 00:03:53
en el paquete ejer22.model 00:03:56
este de aquí, ahora ya si hacemos 00:04:02
las entidades 00:04:04
que son cliente y pedido 00:04:06
pues venga, empezamos por pedido 00:04:08
las entidades 00:04:10
es el modelo de datos 00:04:16
¿eh? 00:04:17
¿dónde? 00:04:21
ya veremos 00:04:22
en función del diseño 00:04:24
de paquetes que hagamos de nuestra aplicación 00:04:28
por ahora lo que sí que sabemos es que un paquete 00:04:29
modelo con las entidades 00:04:31
necesitamos, pues ahí va 00:04:33
vale 00:04:35
pues bueno 00:04:36
lógicamente le dejamos 00:04:39
el public 00:04:41
porque esas entidades están en un paquete 00:04:42
para ellas solitas, el paquete modelo 00:04:45
entonces desde otros paquetes 00:04:47
habrá que poder acceder, entonces ahora 00:04:49
ya el public hay que dejarlo, ya no lo podemos quitar 00:04:51
lógicamente, porque estas clases 00:04:53
van a ser accesibles desde otro paquete 00:04:55
desde el que sea 00:04:57
¿qué nos han dicho que necesita 00:04:58
el pedido? pues el código 00:05:03
un entero 00:05:05
por ejemplo 00:05:07
la descripción 00:05:08
un string 00:05:13
y la cantidad 00:05:14
el precio del pedido 00:05:20
lo que sea, solo interesa 00:05:22
eso, es lo único que quiere gestionar este 00:05:27
luego ya esto se podría ampliar 00:05:29
claro 00:05:31
y la programación orientada a objetos 00:05:31
precisamente nos hace que la aplicación 00:05:35
se pueda ampliar fácilmente 00:05:38
si esto lo hiciéramos 00:05:39
con un programa antiguo 00:05:41
de los estructurados, de los antiguos 00:05:43
de operación estructurada punto pelota 00:05:45
esto sería un programa muy grande 00:05:46
en el cual tendríamos un montón de variables 00:05:49
precio del pedido, no se que del pedido 00:05:51
nombre del cliente 00:05:54
un montón de variables, hay luego un montón 00:05:55
de if, while 00:05:57
para hacer las cosas 00:05:59
entonces cualquier modificación que quisiéramos hacer 00:06:00
sería un lío meterse en ese programa con tantas líneas 00:06:03
hasta encontrar que es lo que tenemos que añadir 00:06:06
sin embargo aquí, oye mi aplicación ya está hecha 00:06:09
pero la quiero ampliar porque ahora además del precio 00:06:13
del pedido, quiero gestionar si está 00:06:15
pagado o no, que es algo que no tenía en la versión 1 00:06:18
de mi aplicación, ah vale pues rápidamente 00:06:21
eso implica que tú abres la entidad pedido 00:06:24
y pones aquí un boolean 00:06:27
pagado, por ejemplo 00:06:29
entonces la ampliación de la aplicación 00:06:30
es muchísimo más sencilla si está 00:06:32
organizada como una aplicación orientada a objetos 00:06:35
con diferentes clases 00:06:37
que si fuera un programa estructurado 00:06:39
con todos los datos en variables ahí puestas 00:06:40
un montón de variables 00:06:42
y luego las operaciones 00:06:44
bueno, en nuestro caso, por ahora dejamos 00:06:45
la versión básica con estas tres propiedades 00:06:48
y ya está 00:06:50
ahora 00:06:51
le ponemos un constructor 00:06:53
con parámetros que siempre va a ser útil 00:06:56
y es lo habitual 00:07:00
le ponemos los get y los set 00:07:01
para permitir desde fuera acceder a las propiedades 00:07:10
porque si no se lo ponemos 00:07:14
imposible desde fuera acceder al contenido del pedido 00:07:15
imposible 00:07:19
pues ponemos los get y set 00:07:20
y ya que lo conocemos 00:07:25
del otro día 00:07:29
vamos a aprovechar para poner el método 00:07:31
toString 00:07:34
que ya explicamos el otro día 00:07:35
que es un método que los que nos usen 00:07:38
de otras aplicaciones 00:07:40
de otros paquetes 00:07:42
los que nos usen van a asumir 00:07:43
que yo voy a tener implementado 00:07:47
un toString, porque cuando ellos 00:07:48
necesiten ver mi descripción 00:07:50
ellos van a llamar a ese toString 00:07:51
lo van a llamar 00:07:54
entonces está bien que yo 00:07:55
lo ofrezca 00:07:58
para si los demás 00:07:59
llaman a ese método porque 00:08:01
asumen que yo lo he hecho 00:08:03
pues que tengan respuesta 00:08:05
¿vale? entonces siempre nos tenemos que adaptar 00:08:07
de alguna manera 00:08:12
a estándares 00:08:13
pues venga 00:08:15
generamos tu string 00:08:18
¿qué descripción quieres poner 00:08:19
en el string? pues las tres propiedades 00:08:22
código, descripción y precio 00:08:24
venga, me gusta el overwrite 00:08:25
lo podéis quitar si queréis porque no sabemos 00:08:28
lo que significa todavía 00:08:30
medio lo apuntamos el otro día para lo que 00:08:31
sirve para hacer una validación en 00:08:34
tiempo de compilación, pero 00:08:36
ahora mismo nos olvidamos de 00:08:38
anotaciones y de 00:08:40
todo eso, nos olvidamos 00:08:42
vale, pues este método toString 00:08:44
cuando alguien lo llame, desde donde 00:08:46
sea, que podrá hacerlo porque es público 00:08:48
claro, cuando alguien lo llame 00:08:50
desde donde sea 00:08:52
me va a devolver este string 00:08:53
entonces es 00:08:55
útil si alguien quiere visualizar 00:08:58
el contenido en una cadena 00:09:00
para ponerlo en un emergente 00:09:02
Para lo que sea 00:09:03
Vale, entonces ahora mismo 00:09:05
Así se quedan 00:09:10
Estos 00:09:12
Estos 00:09:13
Esta clase, pedido, vale 00:09:15
Cliente 00:09:18
La otra entidad 00:09:21
De cliente hemos quedado 00:09:22
Con el que nos pidió el software 00:09:34
Que lo que le interesa es 00:09:36
El NIF, el nombre 00:09:38
Y los pedidos que me ha hecho 00:09:40
Es lo único que me interesa 00:09:44
Los pedidos que me ha hecho 00:09:46
Los pedidos que me ha hecho 00:09:47
Como son muchos pedidos 00:09:50
Los tendré que guardar 00:09:52
En un array, no hay otra 00:09:54
Los tendré que guardar en un array 00:09:55
Pues aquí están 00:09:58
¿Vale? 00:10:01
Entonces, esto ya sabemos lo que significa 00:10:07
Significa que cuando exista un cliente 00:10:09
Que ahora mismo no existe ninguno 00:10:12
Porque no hay ningún programa ejecutándose 00:10:14
Y no hay un main 00:10:16
Cuando exista un cliente 00:10:17
ese cliente tendrá 00:10:19
un nif concreto 00:10:20
un nombre concreto 00:10:22
y un array de pedidos concreto 00:10:24
ya está 00:10:26
aquí no instanciamos nada 00:10:28
no tenemos que instanciar nada 00:10:30
aquí lo único que estamos diciendo es que cuando un cliente 00:10:32
exista, ese cliente 00:10:34
va a tener dentro un array de pedidos 00:10:36
¿de cuántos pedidos? ¿qué tamaño tendrá 00:10:38
ese array? es que nos da igual, solamente estamos 00:10:40
diciendo el tipo de dato que va a 00:10:42
tener esa variable 00:10:44
pues esa variable va a tener este tipo 00:10:45
de dato 00:10:48
en concreto que array va a ser, que pedidos 00:10:49
va a tener, cuantos, pues hombre cuando exista 00:10:52
un cliente ya veremos, ahora mismo 00:10:54
solamente decimos que cuando exista 00:10:56
va a tener un need 00:10:58
string, un nombre string 00:11:00
y unos pedidos que son array de pedido 00:11:02
ya está, es lo único que decimos ahí 00:11:04
y lo mismo 00:11:05
vamos a hacer el constructor get set 00:11:08
vale, constructor get set 00:11:10
y vamos a hacer un to string también 00:11:28
por si alguien 00:11:30
quiere tener un mensaje 00:11:32
con la descripción de como somos 00:11:34
pues venga 00:11:36
generamos toString 00:11:37
aquí 00:11:39
el toString si incluimos las 00:11:45
tres propiedades 00:11:49
pues luego ya veremos que lo va a 00:11:50
mostrar raro, porque el nif lo va a 00:11:55
mostrar sin problema 00:11:56
el nombre lo va a mostrar sin problema 00:11:57
vale, y aquí lo que 00:12:00
él me ha hecho es, y pedidos como es un 00:12:02
array, me va a 00:12:04
llamar al método 00:12:06
toString de esta clase, que no sabemos 00:12:08
muy bien lo que significa el método toString 00:12:10
de esta clase, al que le 00:12:12
pasa esto, y este método 00:12:16
debe ser, si él no lo ha metido aquí 00:12:18
debe ser que este 00:12:20
método me muestra una 00:12:22
descripción de lo que tiene ese array 00:12:24
pero yo puedo cambiar y ponerme 00:12:25
aquí en el toString lo que quiera, él me ofrece esto 00:12:30
por defecto 00:12:32
lo que suponemos 00:12:33
que hará, será eso 00:12:40
es lo que suponemos que hará, vale 00:12:41
pero nos viene bien como ejemplo 00:12:43
para que veáis lo estándar 00:12:45
que es este método 00:12:47
esta clase de aquí que no hemos 00:12:48
hecho nosotros 00:12:51
tiene un método toString 00:12:52
tiene un método toString cuya utilidad 00:12:54
va a ser 00:12:57
darme un string con la descripción de lo que hay 00:12:58
dentro, en este caso va a ser 00:13:01
pedidos, ¿vale? para que veáis lo estándar que puede 00:13:03
ser este nombre, ahora mismo 00:13:05
esto no sabemos ni lo que hace 00:13:07
intuimos que efectivamente 00:13:08
coge el array que hay aquí 00:13:11
y concatena 00:13:13
el contenido del pedido 00:13:15
lo asumimos 00:13:18
pero bueno, podemos cambiar nuestro otro string 00:13:18
y aquí que nos muestre otra cosa 00:13:22
o lo que sea 00:13:23
vale, pues ya tenemos 00:13:24
este override de nuevo 00:13:31
como no sabemos lo que significa 00:13:34
y no lo necesitamos tampoco 00:13:36
que exista, que esté ahí 00:13:38
Lo quitamos 00:13:39
Pues ya tenemos las dos entidades 00:13:41
Por ahora no tenemos que añadir nada más 00:13:43
Luego otra cosa es que 00:13:45
Vayamos necesitando añadir cosas 00:13:47
Vamos a ver 00:13:49
Sí 00:13:51
Sí, yo lo he hecho mediante source todo el rato 00:13:51
Source, generate constructor 00:13:59
Using fields 00:14:01
¿Eh? 00:14:02
No, no, no 00:14:09
No, no los he dejado tal y como me los ha generado él. 00:14:10
No los he tocado. 00:14:13
Vale. 00:14:16
Bueno, pues ya tenemos estas dos entidades. 00:14:17
¿Vale? 00:14:21
Entonces. 00:14:21
Ahora, cuando exista un main, ya con clientes y pedidos, 00:14:29
entonces vamos a ir haciendo en paralelo el main, 00:14:34
un main, para irlo entendiendo mejor. 00:14:36
El main nuestro va a ser 00:14:39
Un menú 00:14:44
Primero solicita datos para crear objetos pedido 00:14:47
Almacenar estos pedidos en un array con espacio máximo para 100 pedidos 00:14:55
Y luego crea un array con espacio para 100 clientes 00:14:59
Esta primera parte sería como crear 00:15:03
Donde van a ir los datos 00:15:06
¿Vale? 00:15:09
Entonces vamos a hacer ahora nosotros en paralelo el main 00:15:11
El main es esto 00:15:13
Lo que viene a ser la aplicación 00:15:15
Pues venga, vamos a hacer el main 00:15:16
Vale, lo ha generado 00:15:19
Solo él 00:15:25
Claro 00:15:26
Lo ha generado 00:15:28
El eclipse lo ha generado solo 00:15:34
Pero podríamos quitarlo 00:15:36
Porque no queremos mostrar esto 00:15:39
Por ejemplo, yo no quiero mostrar todos los pedidos 00:15:40
En este toString 00:15:42
Quiero mostrar solo el tamaño 00:15:44
Pues podría quitarlo 00:15:46
Y poner aquí 00:15:48
Pedidos.length 00:15:49
Y poner aquí numPedidos 00:15:52
Por ejemplo, entonces este toString 00:15:56
Me saca el nif 00:15:58
El nombre y el número de pedidos 00:16:00
Sería otra variante de toString 00:16:02
Lo que pasa es que él me ha ofrecido esa 00:16:04
Porque esa sentencia rara 00:16:07
Raíz.toString, que era mismo 00:16:10
Podemos intuir lo que hace 00:16:11
Aunque no la entendemos 00:16:13
Pues esa sentencia rara 00:16:14
Coge el array de pedidos 00:16:17
Y me va haciendo un string 00:16:19
Donde va concatenando 00:16:21
Todos los tuestrins a su vez 00:16:23
De cada pedido 00:16:25
Pero lo podemos quitar 00:16:26
Y dejarlo así 00:16:29
Si total este tuestrin es solo para una descripción 00:16:30
Un mensajito 00:16:33
Nada para nada más 00:16:36
Poned este y así no nos liamos con cosas 00:16:37
que no, número 00:16:42
pedidos 00:16:57
vale, no, no, no, no 00:16:57
no, no he hecho, vale 00:17:00
voy a hacer el main, voy a empezar a hacer el main 00:17:11
y luego ya vamos haciendo los métodos, pero vamos a 00:17:13
ir haciendo el main en paralelo 00:17:15
para ir entendiendo quizá un poquito más la 00:17:17
estructura de la aplicación, vale, pues nuestro 00:17:19
main, nuestro main 00:17:21
lo vamos a meter en este 00:17:23
paquete que se ha quedado ahí solo abandonado 00:17:25
en ejer 22 00:17:27
ahí 00:17:29
vamos a meter nuestra clase 00:17:30
main, esta tiene 00:17:33
el método main que se va a ejecutar 00:17:37
este es el punto de arranque 00:17:39
de la aplicación, este 00:17:43
bueno pues lo que 00:17:44
ocurre a partir de aquí ya es 00:17:57
lo real, el funcionamiento 00:17:59
lo que se está ejecutando, lo real 00:18:02
vale, pues a partir de 00:18:03
aquí que es donde arranca la aplicación 00:18:05
aquí ya tiene que haber pedidos 00:18:07
los pedidos 00:18:09
ya tienen que existir, se supone 00:18:11
que mi aplicación es para 00:18:13
una tienda mía donde 00:18:15
pues yo tengo 00:18:17
mis 00:18:20
lo que pasa es que bueno, aquí no están 00:18:21
los ítems de pedido, vale, aquí es donde 00:18:24
realmente ya empiezan a aparecer los pedidos 00:18:26
y los clientes, aquí tiene que haber pedidos y clientes 00:18:28
vale, pues lo que me dice 00:18:31
la aplicación es que antes de hacer 00:18:32
nada los haga aparecer, venga 00:18:34
pues dice 00:18:36
vamos a hacer una cosa 00:18:38
yo creo que lo vamos a cambiar un pelinín 00:18:47
vamos a hacer una cosa 00:18:49
para que la aplicación sea más clara, 00:18:58
tenga más sentido. 00:19:00
Esta aplicación lo que va a manejar son clientes 00:19:02
y los clientes tienen dentro sus pedidos, ¿verdad? 00:19:05
Va a manejar clientes 00:19:08
y los clientes son los que tienen dentro sus pedidos. 00:19:09
Pues entonces, 00:19:12
los clientes van a tener que estar en algún sitio. 00:19:13
En condiciones normales, 00:19:16
será en la tabla de una base de datos. 00:19:17
Yo tendré una tabla en mi base de datos cliente, 00:19:20
en principio con líneas vacías, 00:19:23
porque no hay ningún cliente. 00:19:25
luego ya la aplicación 00:19:27
me ofrecerá un menú para insertar cliente 00:19:29
eliminar cliente, lo que sea 00:19:32
y ahí ya irán apareciendo 00:19:33
pero esa tabla tendría que estar 00:19:34
con el espacio físico 00:19:38
para ir metiendo los clientes 00:19:40
o irlos eliminando según los voy dando 00:19:41
de baja de mi base de datos 00:19:44
nosotros no podemos trabajar 00:19:45
con los clientes en la tabla 00:19:47
en la base de datos porque no sabemos 00:19:50
todavía recoger de la base de datos 00:19:52
ni volcar a la base de datos 00:19:54
entonces nuestros clientes donde van a estar 00:19:56
pues en la única estructura 00:19:58
en la que sabemos meter un montón de cosas 00:20:00
que es en el array 00:20:02
pues entonces nuestros clientes 00:20:03
según vayan apareciendo 00:20:05
desapareciendo van a estar 00:20:08
en mi array de clientes 00:20:10
que sería el equivalente 00:20:12
a mi tabla de clientes 00:20:14
la que en un caso real existiría realmente 00:20:15
mi tabla con los clientes y mi aplicación 00:20:18
pues recoge uno 00:20:20
lo quita, lo que sea 00:20:22
¿Vale? Como yo no creo la tabla 00:20:23
Porque no sé hacerlo 00:20:26
Pues mis clientes van a estar aquí 00:20:27
Aquí van a estar 00:20:30
Mis clientes 00:20:32
¿Vale? Entonces yo aquí 00:20:33
O hago el import 00:20:37
O le pongo su nombre completo 00:20:39
¿Verdad? 00:20:41
¿Cuál es el nombre completo de la clase cliente? 00:20:44
El nombre completo 00:20:48
De la clase cliente es 00:20:49
Ejer22.model.cliente 00:20:51
Ese es el nombre completo 00:20:53
entonces si yo quiero hacer un array de clientes 00:20:54
pues tengo que poner aquí el nombre de la clase 00:20:59
pero como ya sabemos 00:21:01
como esto deja el código muy feo 00:21:05
y pierdo yo un poco porque imaginaos que el paquete 00:21:08
es larguísimo el nombre, pues me quedan ahí unas líneas 00:21:11
como esto es un poco feo 00:21:14
pues ponemos el import y ya está 00:21:16
entonces al poner el import decimos 00:21:19
oye, usa cliente 00:21:24
por su nombre corto, no por el largo 00:21:26
vale, pues ya está, más bonito 00:21:28
aquí van a estar mis clientes 00:21:29
esta es mi caja 00:21:32
de clientes, pero bueno 00:21:34
la caja ahora mismo no tiene 00:21:36
ni los cartones de los lados, con lo cual no la puedo usar 00:21:37
es imposible 00:21:40
recordad que lo primero que tenemos que hacer es instanciar 00:21:41
el array 00:21:44
instanciar el array, que es ya poner los cartoncitos 00:21:44
vale 00:21:48
pues venga, vamos a instanciar el array 00:21:49
aquí nos viene 00:21:51
el primer problema 00:21:57
y único 00:21:59
de los arrays 00:22:00
porque además son todos maravillosos 00:22:03
pero este problema da mucha guerra 00:22:04
por eso es por lo que luego se usan colecciones de datos 00:22:07
como veremos más adelante 00:22:09
pues aquí nos damos de golpe de nuevo con el 00:22:10
único problema de los arrays 00:22:12
que es, desde el momento en que tú 00:22:14
instancias una caja array para meter 00:22:17
cosas, me tienes que dar el tamaño 00:22:19
y ese tamaño va a ser fijo 00:22:21
que me dices crear una caja 00:22:22
de un metro cuadrado y luego solamente 00:22:25
vas a usar un imperdible 00:22:27
pues lo siento 00:22:29
no vas a poder cambiar de caja nunca 00:22:30
una caja de un metro cuadrado con un imperdible 00:22:33
ese es el problema de los arrays 00:22:35
vale, pues aquí tenemos que tomar una decisión 00:22:36
que es, voy a hacerla 00:22:39
lo suficientemente grande 00:22:41
para que quepa el número máximo 00:22:43
de clientes que yo aspiro a tener 00:22:45
que yo aspiro a tener 00:22:47
el anunciado me dice que asuma que como 00:22:48
mucho voy a tener 100 00:22:51
que luego resulta que 00:22:52
tengo más de 100 clientes 00:23:00
pues esta aplicación no me va a funcionar 00:23:01
y voy a tener que irme al código 00:23:04
a cambiarla 00:23:06
lo cual querríamos evitar 00:23:07
siempre 00:23:10
una aplicación no tiene sentido que cuando 00:23:11
pasen cosas en la vida real 00:23:14
yo tenga que ir al código a cambiarla 00:23:15
recompilarla, volverla a desplegar en los 00:23:18
servidores, pues no 00:23:20
tendría que poder adaptarse sin necesidad 00:23:21
de escribirla de nuevo 00:23:24
pues esta, como yo pase de 100 clientes 00:23:25
no se va a poder adaptar 00:23:28
a menos que hagamos alguna cosa extraña 00:23:30
aquí dentro para intentar apañarlo 00:23:33
que la haremos también 00:23:35
claro, tendríamos que 00:23:36
cada vez que 00:23:39
se inserta el cliente 00:23:41
decir 00:23:43
si tengo 00:23:44
más de 100 clientes 00:23:48
pues en ese momento hacer un array nuevo 00:23:49
¿vale? 00:23:51
venga, pues la caja está 00:23:53
y ahora ya viene mi aplicación 00:23:54
con las funcionalidades que quiero hacer 00:23:57
esta aplicación va 00:23:59
va a ser pues mostrar un menú con las cosas que yo quiero hacer 00:24:00
entonces, pues mientras 00:24:04
la opción sea distinta de la de salir 00:24:15
y la opción de salir 00:24:19
pues es esta, entonces ya hacemos lo que haya que hacer 00:24:23
aquí tendré yo el resto de opciones del menú 00:24:30
que ahora las decidimos, las acordamos, pero ya sabemos que la estructura del menú 00:24:34
Será esta, leo la opción 00:24:38
Con lo cual me falta el escáner 00:24:40
Por aquí, vale 00:24:47
Y ahora ya en función de la opción 00:25:04
Pues ya hago una cosa 00:25:08
O hago otra 00:25:13
Aquí, ¿que os gustan los break? 00:25:14
Pues dos puntos 00:25:23
¿Que no os gustan? 00:25:25
Flechita 00:25:31
Vale 00:25:32
En el caso cero, será en el que 00:25:44
Decimos adiós y ya está 00:25:49
O volcamos en la 00:25:50
Aquí en el caso 0 salir 00:25:54
Volcaríamos los datos en la base de datos 00:25:56
Para no perderlos 00:25:58
Pero claro, eso no lo sabemos hacer 00:26:00
Así que volcaríamos en base de datos 00:26:01
Los datos de la aplicación 00:26:06
Pero esta parte 00:26:10
Pues no la podemos hacer 00:26:16
Con lo cual los datos se van a perder 00:26:17
En cuanto le demos a salir los datos se van a perder 00:26:18
Al menos pues nada 00:26:20
Ya está 00:26:22
Caso 0 00:26:27
vale, pues vamos a ver 00:26:29
una opción 00:26:32
imprescindible, lógicamente 00:26:34
es insertar cliente 00:26:36
porque la aplicación 00:26:38
cuando arranque, va a arrancar 00:26:43
sin clientes 00:26:46
va a arrancar sin clientes 00:26:47
claro, si nosotros ya supiéramos 00:26:48
volcar de una base de datos, al arrancar 00:26:52
la aplicación, podríamos leer de la base de datos 00:26:54
llevarlo a la RAI, pero no sabemos 00:26:56
con lo cual la aplicación va a arrancar sin clientes 00:26:57
Luego lo primero que vamos a hacer 00:27:00
Va a ser insertar un cliente 00:27:02
Vale, insertar un cliente 00:27:04
Que sería el caso 1 00:27:06
Aunque no sé exactamente lo que dice aquí 00:27:07
La vamos a ir orientando 00:27:12
Para que sea un poquito más 00:27:14
Más didáctica 00:27:15
Vale, pues en el caso 1 00:27:18
Insertar cliente 00:27:20
Habrá que pedir los datos 00:27:22
Y meterlo en el array 00:27:23
Venga, nif 00:27:27
Aquí 00:27:31
guardaremos el nif del cliente 00:27:35
y lo mismo con el nombre 00:27:41
vale, el cliente 00:27:51
la primera vez cuando lo metemos 00:28:06
en la base de datos 00:28:08
cuando digo base de datos me estoy refiriendo 00:28:10
a nuestro array, claro, pero no hay base de datos 00:28:12
cuando lo metemos es un cliente que estamos 00:28:14
dando de alta, por ahora 00:28:16
ni tiene pedidos ni tiene nada 00:28:18
luego ya haremos una 00:28:19
funcionalidad que sea 00:28:22
hacer un pedido para un cliente 00:28:23
que ya existe, pero con esta 00:28:26
es insertar un cliente, dar de alta un cliente 00:28:28
nuevo, sin pedidos y sin nada 00:28:30
¿vale? sin pedidos y sin nada 00:28:32
entonces no hago 00:28:34
pedidos, ¿vale? repito 00:28:36
ya haremos opciones del menú más 00:28:38
adelante para insertar 00:28:40
un pedido para un cliente que ya 00:28:42
existe, entonces de hecho 00:28:44
lo podemos llamar a esto más que 00:28:46
insertar, pues registrar cliente 00:28:48
por si así lo entendemos mejor 00:28:50
registrar cliente 00:28:51
vale, pues entonces 00:28:53
nuestro cliente nuevo 00:28:56
Tiene el constructor que hemos hecho 00:28:57
Que es el único que yo puedo usar 00:29:02
Porque es el único que he hecho 00:29:04
Le pasamos el nif 00:29:06
Le pasamos el nombre 00:29:08
Y me pide también el array de pedidos 00:29:10
¿Verdad? 00:29:13
Porque el constructor 00:29:13
El constructor de cliente 00:29:14
Yo lo tengo hecho 00:29:18
Para pedirle las tres cosas 00:29:20
¿Vale? 00:29:22
Entonces puedo usar este mismo constructor 00:29:25
Y aquí pasarle null 00:29:27
por ejemplo, y ya está ahora mismo 00:29:30
cliente sin pedidos 00:29:31
su array null 00:29:33
¿vale? por ejemplo 00:29:35
que este null queda muy feo 00:29:37
me puedo 00:29:46
hacer otro constructor, recordad que 00:29:48
constructores 00:29:50
ya vimos que podíamos tener muchos 00:29:51
pero tenían que distinguirse 00:29:54
por los argumentos 00:29:56
que había aquí, entonces podemos 00:29:58
hacernos otro constructor 00:30:02
otro constructor que me 00:30:03
pida solamente el nif y el nombre 00:30:08
Valor a mi clase cliente tiene dos 00:30:10
Yo cada vez que creo un cliente 00:30:24
Elijo cual de los dos uso 00:30:26
Ahora en este uso 00:30:28
Que estoy haciendo me interesa este 00:30:30
Porque yo solo tengo los datos 00:30:31
Nif y nombre, array no lo inicializo 00:30:34
No lo inicializo, el array de pedidos 00:30:36
Ni lo inicializo porque no lo tengo 00:30:38
Con lo cual se quedará 00:30:40
Con el valor por defecto de un array 00:30:44
Que es null porque es un objeto 00:30:46
Null, su valor por defecto 00:30:47
Entonces este constructor se distingue de este 00:30:48
porque a este solo se le pasan 00:30:52
dos cosas, sin embargo 00:30:54
a este se le pasan tres 00:30:56
son perfectamente distinguibles 00:30:57
entonces, si uso el de abajo 00:31:00
pues entonces 00:31:04
este null ya no hace 00:31:06
falta que se lo pase 00:31:08
y queda como más bonito el código 00:31:09
solo porque quede bonito, da igual 00:31:12
da igual que lo haga de una manera o de otra, estoy haciendo lo mismo 00:31:14
pero así como que queda más bonito 00:31:16
porque poner un null ahí 00:31:18
es un logo como metido así a calzador 00:31:19
Bueno, es que hay que meterlo en el array 00:31:21
Hemos terminado 00:31:34
Claro, esto es como un objeto temporal 00:31:35
Lo que importa es que ahora va al array 00:31:37
¿Vale? 00:31:39
Vale, por ahora hemos creado este objeto cliente 00:31:42
Pero no hemos terminado todavía 00:31:44
De hacer esta opción 00:31:46
Vale, entonces repito 00:31:47
Vale, repito 00:31:49
Usando el otro constructor y poniendo null 00:31:58
Estaría haciendo lo mismo 00:32:01
pero así mejor 00:32:02
ahora, este cliente que hemos creado 00:32:04
yo no lo puedo dejar ahí suelto 00:32:08
primero, porque 00:32:10
sería una variable local 00:32:12
a este bloque 00:32:14
con lo cual en cuanto este bloque ha terminado de ejecutarse 00:32:15
ese cliente ha desaparecido 00:32:18
¿para qué lo creo ahí? 00:32:19
y segundo, porque mis clientes no van a estar como variables 00:32:21
sueltas, si estuvieran como variables 00:32:24
sueltas serían inmanejables 00:32:26
mis clientes tienen que estar metidos 00:32:28
en esta caja, que para eso la he creado 00:32:30
tienen que estar metidos ahí 00:32:32
inicialmente esta caja tiene sus 100 posiciones 00:32:33
pero hay nul en cada una de ellas 00:32:37
pues entonces cada cliente tendrá que ir 00:32:39
a la primera que quede libre 00:32:43
entonces, ¿cuál es la primera que queda libre? 00:32:45
pues no lo sé, vamos a necesitar una variable adicional 00:32:49
que me vaya informando de eso 00:32:52
es decir, voy a necesitar una variable 00:32:53
por ejemplo, siguiente posición libre 00:32:58
inicialmente es cero, verdad 00:33:02
cuando mi aplicación 00:33:04
arranca, este array 00:33:07
tiene sus huecos 00:33:09
pero no tiene ningún objeto en ninguna de ellas 00:33:10
luego la siguiente posición 00:33:13
libre inicialmente es cero 00:33:14
inicialmente es cero 00:33:16
y ahora 00:33:18
este cliente de aquí 00:33:19
este cliente de aquí 00:33:22
¿dónde se tiene que colocar? 00:33:24
pues se tiene que colocar en la siguiente 00:33:27
posición libre 00:33:29
Ahí se tiene que colocar 00:33:30
Ese cliente 00:33:33
¿Vale? 00:33:34
Claro, ¿y qué me faltaría por hacer? 00:33:37
Incrementarla 00:33:40
Que la puede incrementar 00:33:41
Aquí aparte 00:33:43
O si quiero ahorrar una línea de código 00:33:44
Pues la incremento aquí 00:33:51
Que ya sabemos lo que significa esto 00:33:52
Que es primero usa la variable para lo que sea 00:33:56
En este caso para darme la posición 00:33:58
Y luego después 00:34:00
Y luego después déjala incrementada 00:34:01
No, porque primero coloco en la que toque 00:34:03
Y luego lo dejo incrementada para la siguiente 00:34:10
Es que 00:34:12
Si lo pusieras antes 00:34:15
Te daría primero 00:34:18
Menos uno y trataría de colocarlo en la menos uno 00:34:20
Claro, porque está en cero 00:34:22
No, menos uno no, perdón 00:34:25
Primero te incrementaría, te colocaría en la uno 00:34:29
Con lo cual la cero se la saltaría 00:34:31
vale, te coloca en la que toca 00:34:32
y te lo deja incrementado para la siguiente 00:34:37
vale, pues insertar cliente 00:34:39
ya está 00:34:43
entonces hombre, siempre si uno hace una aplicación 00:34:43
mínimamente decente, debería dar el 00:34:46
ok, cliente 00:34:48
registrado 00:34:52
ala, ya está 00:34:53
cliente registrado 00:34:56
este objeto 00:35:00
o sea, esta referencia 00:35:03
desaparece porque es una variable local 00:35:05
Pero no pasa nada porque el cliente 00:35:08
Se ha quedado apuntado por el array 00:35:10
Se ha quedado apuntado 00:35:12
Entonces no pasa nada 00:35:13
¿Vale? 00:35:14
¿Vale? 00:35:26
Entender lo que 00:35:32
Hacemos en cada momento 00:35:32
Vale, con esto 00:35:34
Con esta sentencia de aquí 00:35:44
Hemos creado el objeto cliente 00:35:46
Con sus dos datos, nif, nombre 00:35:50
Y el array de pedidos, null 00:35:52
no tiene nada, hemos creado nif, nombre 00:35:54
y array de pedidos, esto hemos 00:35:56
creado, array de pedidos a null, aquí hay un 00:35:58
null, porque no hay ningún array 00:36:00
hemos creado esto, esto 00:36:01
apuntado 00:36:04
por c 00:36:05
por c, vale, ahora 00:36:07
¿qué tenemos? tenemos 00:36:10
este array con posiciones 00:36:12
con 100 posiciones 00:36:14
en particular, aunque 00:36:16
por ahora, todas apuntando a null 00:36:18
todas apuntando a null inicialmente 00:36:20
vale, pues con esta sentencia de aquí 00:36:22
con esta sentencia 00:36:25
lo que hemos hecho es 00:36:28
oye tú, posición 0 00:36:30
que es la que tocaba en este caso 00:36:32
si hemos hecho registrar clientes 00:36:34
7 veces después, pues estaremos en esta 00:36:37
pero bueno, la primera vez que hemos entrado 00:36:39
oye tú, posición 0 00:36:40
de clientes, posición 0 00:36:42
deja de apuntar a null 00:36:44
y empieza a apuntar a este 00:36:47
eso es lo que hemos hecho con esta sentencia 00:36:50
¿verdad? hemos dicho 00:36:53
oye tú, posición 0 de clientes 00:36:55
deja de apuntar al null que estabas apuntando 00:36:57
y empieza a apuntar 00:36:59
a lo que apunta C 00:37:01
es lo que estamos diciendo, empieza a apuntar a lo que apunta 00:37:02
C, a magnífico 00:37:05
ahora ya el objeto 00:37:07
cliente, el objeto que hay que conservar 00:37:08
el objeto verdadero y real 00:37:11
se ha quedado apuntado por 2, por C 00:37:12
y por el array, que es el que importa 00:37:15
pero también se ha quedado por C 00:37:17
ahora ya cuando este bloque termina de ejecutarse 00:37:19
cuando ya sacamos el system out 00:37:23
y el bloque termina de ejecutarse 00:37:24
esta c como es variable local 00:37:26
desaparece, pero es que no pasa nada 00:37:28
esta desaparece 00:37:30
pero nos da igual, el cliente no ha desaparecido 00:37:32
el cliente se queda 00:37:34
apuntado por esta 00:37:36
lo único que ha desaparecido es la variable c 00:37:37
pero es que esta no nos importa que desaparezca 00:37:40
la siguiente vez que 00:37:42
demos a registrar 00:37:44
volverá a aparecer otro c para otro 00:37:45
bueno, está claro lo que hemos hecho con esta 00:37:49
con registrar cliente, ¿verdad? 00:37:57
fundamental esta variable 00:38:02
fundamental que esta variable exista, porque es la que me va a decir 00:38:05
en qué posición de la RAI coloco cada vez, venga, vamos a parar unos minutos 00:38:09
... 00:38:13
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
9
Fecha:
15 de diciembre de 2025 - 17:19
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
38′ 24″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
324.15 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid