Saltar navegación

20260112 Refactorizar_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 12 de enero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues esta aplicación ya era una aplicación un poquitín más real en cuanto a que gestionaba una situación que se correspondía con un modelo de datos, en nuestro caso clientes y pedidos. 00:00:00
los clientes podían tener uno, muchos pedidos teniendo un NIF y un nombre 00:00:21
y cada pedido podía tener un código, una descripción y un precio 00:00:27
y luego además como había un dato general para toda la aplicación 00:00:32
que es este, pero también variable 00:00:37
pues en una variable estática donde creemos que más pegaba 00:00:39
que como el IVA afecta el precio de los pedidos 00:00:43
pues pega mejor ponerlo ahí 00:00:47
¿Vale? Es lo más parecido a una variable global, pero no es global porque está dentro del contexto de una aplicación, siempre, no hay variables fuera de una clase, perdón, no hay variables fuera de las clases, todo está metido dentro en clases, lo más que podemos decidir es si es particular de cada instancia o común para todas, es lo más que podemos decidir, pero todos los datos están siempre dentro del ámbito de una clase. 00:00:49
que hay muchas posibilidades de diseño 00:01:17
y podemos colocar las cosas de muchas maneras 00:01:20
sí, pero bueno 00:01:21
siempre tenemos que intentar que se corresponda 00:01:23
lo más posible con su significado 00:01:26
real 00:01:28
vale, pues esta es nuestra clase pedido que se caracterizaba 00:01:28
por todo esto, con sus métodos 00:01:32
get y set, que entendemos y sabemos 00:01:33
por qué 00:01:36
os lo pregunté el otro día 00:01:37
además, para 00:01:39
que los hacemos, etc 00:01:41
y luego esta aplicación 00:01:43
tenía unas funcionalidades 00:01:46
que metimos aquí en el main 00:01:49
¿vale? 00:01:52
entonces 00:01:55
en esta aplicación ya empezamos a 00:01:56
usar 00:01:58
la posibilidad de los métodos estáticos 00:01:59
para que no nos quedaran métodos tan horriblemente 00:02:02
largos ¿vale? 00:02:04
porque hay muchos principios 00:02:06
generales 00:02:08
muchos de esos se 00:02:10
concretan en una cosa que se llama patrones de diseño 00:02:12
que son formas de programar 00:02:14
las aplicaciones del año que viene, pues ya sí que tenemos 00:02:16
que respetar un poco más los patrones de diseño 00:02:18
porque si no se convierten en algo inmanejable 00:02:21
pero ahora mismo como son aplicaciones 00:02:22
de un ámbito pequeñito 00:02:24
los patrones de diseño no nos importan tanto 00:02:26
cuando hablo de patrones de diseño 00:02:28
hablo de reglas concretas 00:02:30
¿vale? 00:02:32
pero aparte de esos patrones 00:02:35
de diseño hay unos principios generales 00:02:36
básicos a los que uno se tiene que ir adaptando 00:02:38
muchos de ellos muy sencillos 00:02:41
los hemos mencionado, nombres de variables 00:02:42
lo más explicativos posibles 00:02:45
¿vale? 00:02:47
por muy largos que sean 00:02:49
cuando las variables son datos 00:02:50
estáticos, perdón, son propiedades 00:02:53
estáticas 00:02:55
es buena idea 00:02:56
que su nombre esté 00:02:59
en mayúscula, ¿vale? 00:03:02
no son cosas obligatorias pero son como ciertas 00:03:04
reglas de diseño que luego van a facilitar 00:03:06
entender los códigos 00:03:09
de otros 00:03:11
¿vale? 00:03:11
¿Lo de mayúsculas solo para la variable? 00:03:13
¿O también si un método es estático también? 00:03:16
No, no, no, no, no, no, para las propiedades estáticas 00:03:18
¿Vale? 00:03:20
Nombres de métodos lo más largo y explicativo 00:03:22
posible 00:03:25
¿Vale? Cosas que más o menos hemos ido mencionando 00:03:25
siempre. Bueno, pues otro principio 00:03:28
básico, nada de métodos 00:03:30
así, de bordos con mil líneas 00:03:32
No, eso es muy difícil 00:03:34
luego de mantener 00:03:37
porque si tenemos que hacer cualquier cambio 00:03:38
¿Cómo lo encuentra uno en un 00:03:40
método de 100 líneas 00:03:42
¿vale? se trata de la medida 00:03:43
de lo posible refactorizar 00:03:46
¿qué significa la 00:03:48
palabra refactorizar? 00:03:50
que si el entorno de 00:03:53
desarrollo está a tiempo, pues bueno, refactorizar 00:03:54
en realidad no es más que 00:03:56
yo ya tengo un código que funciona 00:03:58
perfectamente, hace lo que tiene que hacer, mi aplicación 00:04:00
está estupenda, ha pasado toda 00:04:03
la batería de test, todos los casos de prueba 00:04:04
pero 00:04:06
este código está muy 00:04:08
feo, no quiero 00:04:10
cambiar la funcionalidad de la aplicación 00:04:12
está perfecta, no quiero corregir 00:04:14
errores, no quiero corregir errores 00:04:16
lo que quiero es 00:04:18
cambiar el estilo del código para que quede 00:04:20
más bonito, eso es lo que se llama refactorizar 00:04:22
vale, pues 00:04:25
cuando nos damos cuenta, cuando vemos una aplicación 00:04:26
aunque funcione, está estupenda, tiene unos métodos así 00:04:28
de gordos, pues deberíamos 00:04:30
refactorizarla 00:04:32
una de las refactorizaciones 00:04:33
consiste en, voy 00:04:37
sacando partes de ese método 00:04:38
las voy sacando a métodos 00:04:40
independientes 00:04:42
y así tengo 00:04:44
cada funcionalidad la tengo recogida 00:04:47
bajo un nombre 00:04:49
esa es la idea, tener cada funcionalidad 00:04:50
recogida bajo un nombre 00:04:53
entonces si tenemos que tocar algo, retocar algo 00:04:54
modificar algo, yo ya me voy 00:04:57
directamente a la parte 00:04:59
donde tengo que hacer esa modificación 00:05:01
que es traer recogidita en un método con un nombre 00:05:02
si el método, si el nombre 00:05:04
es explicativo, mucho mejor, por supuesto 00:05:07
si no me va a costar más encontrarlo 00:05:08
Bueno, pues aquí, por ejemplo, esa regla general la seguíamos, por ejemplo, aquí dijimos en nuestro main, dijimos aquí mostrar menú, jolín, pues mostrar todo el menú, el system out, todos los system out, qué rollo meterlo aquí en este main y que me quede larguísimo. 00:05:10
vale, pues vamos a hacernos un método mostrarMenu 00:05:29
este método por definición es que va a ser estático 00:05:32
vale, porque mostrarMenu te hace un system.out 00:05:36
te lee por teclado y te devuelve un valor 00:05:39
o sea, no depende de que exista ningún objeto 00:05:41
no está asociado a la realidad de ningún objeto, no 00:05:43
te hace una cosa de librería muy básica 00:05:46
bueno, entonces este método mostrarMenu 00:05:49
lo declarábamos en esta misma clase, aquí 00:05:51
con el modificador static 00:05:55
como se iba a usar solo desde esta clase 00:05:58
es un método auxiliar de la clase 00:06:01
¿vale? esto es lo que se llama 00:06:03
un método auxiliar 00:06:05
un método en el que yo he sacado 00:06:05
he sacado esta parte 00:06:14
de aquí que era un rollete 00:06:16
de mostrarme, ¿no? la he sacado ahí fuera 00:06:17
no lo he puesto 00:06:23
en otra clase, ¿por qué? porque eso 00:06:24
no tiene nada que ver con 00:06:26
ni objetos del modelo, ni con clientes 00:06:28
ni con pedidos, no tiene que ver con nada 00:06:30
tiene que ver con una cosa muy concreta 00:06:32
Del main que es mostrar el menú 00:06:35
Pues lo puedo poner aquí mismo como método auxiliar 00:06:37
Y ya está, no hace falta que lo ubique en otra clase 00:06:39
Podría 00:06:41
Podría ponerlo en otra clase 00:06:42
Que 00:06:45
Tenga simplemente métodos static 00:06:47
Pero bueno, aquí lo he puesto aquí 00:06:49
Le puedo poner el modificador privado 00:06:51
En este caso es el que tendría que tener 00:06:53
Porque este método 00:06:55
Solo va a ser llamado por esta clase main 00:06:56
Solo va a ser llamado por esta 00:06:59
Entonces le pongo el modificador privado 00:07:00
Porque solo va a ser llamado por esta 00:07:03
estático porque lógicamente no depende de la existencia 00:07:04
del propio objeto en el que está, de hecho 00:07:09
la clase en la que está es la clase main que ni tiene propiedades ni tiene 00:07:13
nada, vale 00:07:17
entonces pues este era mi método auxiliar que servía solamente 00:07:20
para mostrar el menú, hacer todo este rollo 00:07:25
leer el entero, en este caso 00:07:29
además leerlo con esa clase teclado 00:07:33
de librería que habíamos hecho para olvidarnos del escáner y de todo esto 00:07:37
y gracias a eso pues yo ya me he podido olvidar del escáner y de todo 00:07:41
ya ni había escáner ni había nada y me lo devuelve y ya está 00:07:45
entonces este trocito de código lo he sacado fuera mucho mejor 00:07:51
y ahora aquí ya mi aplicación de clientes pedidos 00:07:55
mostraba el menú, como llamábamos al método 00:07:59
pues como era estático, lo llamábamos con el nombre de la clase 00:08:03
claro, con el nombre de la clase que es main 00:08:06
en este caso, como el método está en esta misma clase 00:08:10
en esta misma, este main es opcional 00:08:16
¿vale? esto lo podría quitar 00:08:19
y no pasa nada 00:08:22
pero porque el método está en esta misma clase 00:08:25
entonces, si un método 00:08:29
no tiene nada delante 00:08:31
que lo llame con un puntito, 00:08:35
no tiene nada delante, 00:08:37
el compilador lo busca en la propia clase. 00:08:38
¿Vale? Lo busca. 00:08:42
Y ahí lo encuentra, ahí debajo está. 00:08:43
¿Vale? 00:08:46
Bueno, pues ahora ya sí, 00:08:50
hacíamos el switch case con todas las funcionalidades. 00:08:51
Pues la funcionalidad uno, 00:08:54
que no sé lo que era, 00:08:56
entiendo que insertar cliente nuevo. 00:08:57
Insertábamos un cliente nuevo, 00:09:02
pedíamos los datos, de nuevo todo podríamos sacarlo 00:09:04
a métodos auxiliares, podríamos sacar a un método auxiliar esta parte 00:09:08
de leer cliente, por ejemplo 00:09:12
podríamos sacar esta parte, leer cliente y asignárselo así 00:09:14
asignárselo aquí, entonces vamos a sacar este 00:09:19
trocito de código a un método auxiliar, que me devuelva directamente 00:09:26
un cliente con los datos que se pidan por teclado, leer cliente 00:09:30
Pues entonces podríamos hacernos aquí 00:09:34
Nuestro método 00:09:37
¿Qué me va a devolver este método? 00:09:39
Un objeto cliente 00:09:46
Leer cliente 00:09:48
¿Necesita que le pasemos algo? No 00:09:51
Y ahora 00:09:53
¿Qué metemos aquí? 00:09:54
Pues esta parte 00:09:57
Metemos aquí 00:09:59
Todo esto 00:10:03
Todo esto de leer cliente 00:10:05
Se va aquí a mi método auxiliar 00:10:12
Creo el cliente y lo devuelvo 00:10:15
Retún C 00:10:21
Tengo un método que encapsula 00:10:22
Que oculta la complejidad de pedir los datos 00:10:28
Instanciar un objeto cliente y devolverlo como valor de retorno 00:10:33
Una clase puede tener 200.000 métodos auxiliares 00:10:36
No pasa nada 00:10:41
Una clase con un montonazo, muchos métodos cortitos 00:10:41
No tiene ningún problema 00:10:47
Una clase con dos métodos enormes cada uno 00:10:49
Sí lo va a tener 00:10:52
Hombre, si una clase tiene un montón de métodos cortos 00:10:52
Nos sirve como alerta, semáforo naranja 00:10:58
De que, hombre, a lo mejor el diseño de clases 00:11:03
Igual no está muy bien hecho 00:11:06
Igual nos ha faltado darnos cuenta de alguna otra clase 00:11:08
Porque pocas clases con un montón de métodos 00:11:10
No lo sé, a lo mejor 00:11:13
Pero bueno, eso ya son cuestiones más avanzadas 00:11:15
vale, pues si tengo yo este método auxiliar 00:11:20
ahora ya 00:11:22
fijaos que bien 00:11:23
este switch del main 00:11:25
se queda mucho más bonito 00:11:28
porque se queda 00:11:33
así 00:11:35
y ya está, así se queda 00:11:35
y magnífico, el caso 1 00:11:42
queda mucho más claro 00:11:45
vale, yo antes 00:11:46
cuando yo estoy viendo la aplicación 00:11:49
yo quiero 00:11:51
con un vistazo por encima ver rápidamente 00:11:53
qué hace, por si tengo que hacer alguna 00:11:55
modificación, decidir dónde hacerla, etc. 00:11:57
En este rápido vistazo 00:11:59
veo mucho antes 00:12:01
lo que hace que cuando tenía el otro código, 00:12:03
cuando tenía el otro código, tenía que, hasta que 00:12:05
he entendido qué hacía ese caso, 00:12:07
pues me ha costado más. Si yo hubiera 00:12:09
visto esto, ah, pues está claro lo que hace. 00:12:11
Me lee un cliente y lo guarda 00:12:14
en el array, ya está. Aquí lo veo mucho 00:12:15
mejor. Y así en el resto 00:12:17
de los casos. ¿Qué hacía 00:12:22
el caso 2? El caso 2 00:12:24
mostraba los datos de un cliente 00:12:26
¿verdad? 00:12:29
entonces este caso 2, pues bueno, solo tenía 00:12:31
un for y ya está 00:12:33
recuperaba al cliente 00:12:33
de nuevo, incluso esto 00:12:44
meter aquí 00:12:46
un for directamente en el case 00:12:48
pues incluso esto ya queda feo 00:12:51
podríamos hacer un método 00:12:53
recuperaCliente 00:12:56
recuperaCliente 00:12:57
al que se le pasa 00:12:59
una posición y te lo recupera 00:13:01
¿vale? entonces vamos a hacerlo 00:13:03
aquí nos gustaría 00:13:05
hacer simplemente 00:13:09
esto 00:13:11
un siso que haga 00:13:12
recupera 00:13:15
cliente 00:13:18
ah no, es que 00:13:20
esto lo mostraba a todos, perdón, perdón 00:13:21
esto lo mostraba a todos, no te buscaba 00:13:23
por, vale, bueno pues incluso 00:13:25
así, esto sería mucho más bonito 00:13:27
Si fuera un 00:13:29
Mostrar clientes 00:13:31
Muchísimo mejor 00:13:33
Si fuera un mostrar clientes 00:13:34
¿Vale? 00:13:39
Exacto 00:13:43
Representa mucho mejor la lógica 00:13:44
Y aparte nos va a permitir 00:13:47
Ahora hacer un pequeño cambio de diseño 00:13:48
Que es mucho más aproximado 00:13:51
A cuando ya 00:13:53
Tengamos una estructura en la que hay una base de datos 00:13:54
Todo eso, o sea, esto mucho mejor 00:13:57
Caso 2, mostrar clientes 00:13:58
Tú ves aquí de golpe y porrazo. Vale, entonces todo esto te lo ahorras. Pero claro, hay que hacer el mostrar clientes aquí abajo. Bueno, me vais siguiendo, ¿no? No se va perdiendo nadie con las subidas y bajadas porque esto, sobre todo, estamos haciendo cuestiones de diseño que son mucho más importantes en realidad. 00:14:00
Entonces no quiero que nadie se pierda 00:14:18
Con las subidas y bajadas 00:14:20
Vale, aquí 00:14:21
Lo ideal sería hacer un mostrar clientes y punto pelota 00:14:23
Eso haría que tuviéramos que sacar 00:14:26
Esto a otro método 00:14:30
¿Vale? Vamos a sacarlo a otro método 00:14:31
Mostrar clientes 00:14:33
Vale, y aquí querría 00:14:49
Uy, private void 00:14:51
Porque este 00:14:52
Me lo muestra por consola y ya está 00:14:54
y aquí ya nos encontramos el problema 00:14:57
este 00:15:00
en el propio main 00:15:01
cuando ya ha acabado 00:15:09
aquí acaba el main, son métodos auxiliares 00:15:10
ahora esto lo voy a cambiar 00:15:13
claro, claro, claro 00:15:14
este corchete será el método main 00:15:18
y a partir del método main 00:15:19
vienen más métodos 00:15:22
que son auxiliares que a su vez son llamados 00:15:24
Desde dentro del main 00:15:26
¿Vale? 00:15:27
Sí 00:15:35
Lo estoy haciendo fuera del 00:15:36
Este es un método 00:15:38
Esto es una clase main 00:15:39
Normal y corriente 00:15:41
Lo que pasa es que esta clase main 00:15:42
Tiene un método main 00:15:44
Que es el que la máquina virtual va a ejecutar 00:15:47
Vale, entonces uno se pone a hacer el método main 00:15:49
Entonces, ¿aquí en qué situación estamos? 00:15:51
En la situación de que 00:15:54
Este método main hace un montón de cosas 00:15:55
Un montón de líneas de código y queda muy feo 00:15:57
Entonces yo parte de ese código 00:15:59
Lo quiero meter en otro sitio 00:16:01
Mediante un método para llamarlo 00:16:03
Bueno, pues ¿dónde lo estoy metiendo? 00:16:05
Pues en esta misma clase main 00:16:07
Me estoy haciendo más métodos 00:16:09
¿Vale? Además de este main 00:16:11
Que se abre aquí 00:16:13
Y se cierra aquí 00:16:14
Aquí se ha cerrado 00:16:17
Pues además de este método main voy a hacer más 00:16:20
Todos dentro de la clase 00:16:23
Lo que no puedo hacer 00:16:26
es un método dentro de otro, eso no 00:16:28
existe, eso no tiene sentido, un método 00:16:30
dentro de otro no tiene sentido 00:16:31
¿vale? entonces son 00:16:33
métodos dentro de la clase, bueno, pues este 00:16:35
método, mostrar menú, es 00:16:38
un método estático 00:16:40
está claro que es estático porque 00:16:41
es que no utiliza ninguna propiedad 00:16:44
de la clase, absolutamente 00:16:46
ninguna utiliza 00:16:48
porque de hecho la clase no tiene propiedades 00:16:49
no tiene ninguna, esto está 00:16:52
comentado, que era de pruebas que hicimos 00:16:56
entonces este método es estático 00:16:57
con lo cual 00:16:59
este método lo puedo llamar 00:17:00
desde donde me dé la gana 00:17:03
con nombre de la clase 00:17:04
que es main.mostrarMenu 00:17:06
desde donde me dé la gana 00:17:08
desde cualquier sitio, desde cualquier parte 00:17:09
desde cualquier otra clase que haya por ahí 00:17:12
lo puedo llamar con main.mostrarMenu 00:17:13
vale, en particular desde donde me interesa 00:17:15
llamarlo, hombre pues lo he hecho 00:17:18
para llamarlo desde aquí 00:17:20
lo he hecho justo para llamarlo desde aquí 00:17:21
desde el main 00:17:24
desde otro método de esa clase 00:17:25
bueno pues desde aquí lo llamo 00:17:27
y ya está, como podría llamarlo 00:17:29
desde cualquier sitio, pero me interesa 00:17:32
llamarlo desde ahí, vale 00:17:33
lo que pasa es 00:17:35
un segundito, para completar 00:17:38
la revisión, lo que pasa 00:17:39
es que como en este caso en particular 00:17:42
el método mostrar menú está dentro 00:17:43
de esta misma clase, no está 00:17:45
en otra 00:17:47
pues este main es opcional 00:17:48
lo puedo quitar 00:17:51
lo puedo quitar, vale, esto es como 00:17:52
lo del disk que también vimos en su momento 00:17:55
si yo lo quito 00:17:57
cuando el compilador vea 00:17:59
un mostrar menú sin nadie 00:18:01
que lo llame, que eso no puede ser 00:18:03
a los métodos siempre los tiene que llamar algo 00:18:05
o alguien, pues cuando vea 00:18:07
que nadie lo llama, dirá, ah pues debe ser 00:18:09
la opción por defecto, y la opción 00:18:11
por defecto es debe ser que te está llamando 00:18:13
la propia clase en la que estoy 00:18:15
voy a ver si hay algún 00:18:17
método que se llame así en esta clase 00:18:19
entonces va bajando, va bajando 00:18:21
dice, uy, sí 00:18:23
sí que lo hay 00:18:24
Si no hubiera un método mostrar menú en esta clase, aquí tendríamos un error porque nos diría, pero ¿esto qué es? 00:18:27
Bueno, entonces el main lo podéis poner si os hacéis lío en el caso de no ponerlo, que es método estático mostrar menú de la clase main. 00:18:38
¿De dónde quiero llamarlo? Desde aquí, como podéis llamarlo desde cualquier sitio. 00:18:47
Jimmy, tu pregunta. 00:18:53
Porque estaba, exacto 00:18:54
Porque lo teníamos aquí dentro 00:19:01
¿Cómo que lo volvías a crear? ¿Dónde? 00:19:03
Dentro del otro, del método filial 00:19:07
Entonces como local 00:19:09
Entonces sí, como no te va a funcionar 00:19:11
O sea, tú pones aquí un escáner, dices 00:19:13
Pero no te va, ¿a qué te refieres? 00:19:14
Escáner canovirus 00:19:20
¿Pero lo has puesto en el import? 00:19:21
Sí, lo he puesto en el import 00:19:28
Ah, vale 00:19:28
Cierto, cierto 00:19:32
Vale 00:19:34
Vale, pues entonces 00:19:34
Perdón, perdón, perdón 00:19:37
Te perdonamos 00:19:40
Pero que sea la última 00:19:41
Vale, entonces seguíamos 00:19:43
Con esta misma idea 00:19:46
Con esta misma idea 00:19:49
Estábamos arreglando o refactorizando 00:19:50
El resto del código de esta aplicación 00:19:53
Que nos había quedado bien, funcionaba 00:19:54
La habíamos probado, funcionaba perfecta 00:19:56
nos había quedado muy feo, muy horrible, pues con esta misma idea estábamos refactorizando el resto 00:19:58
que es, caso 1, leer datos de cliente 00:20:02
pues hombre, me voy a hacer yo, vamos a poner aquí esto si queremos para no 00:20:05
hasta que cojamos altura, pues me voy a hacer un método 00:20:09
estático dentro de esta misma clase, que es el que tenemos hecho ahí abajo 00:20:13
que me pida los datos, me devuelva como 00:20:17
valor de retorno un objeto, y ese objeto lo guardo yo 00:20:22
aquí, en la posición 00:20:26
del array que queda libre 00:20:27
y la dejo incrementada 00:20:29
para 00:20:32
que se quede apuntando a la 00:20:33
siguiente libre, y aviso 00:20:35
vale, pues así 00:20:38
muchísimo mejor el case así 00:20:39
vale, cuando ya se hacen 00:20:41
un montón de llamadas, por si no 00:20:43
sabéis este truco 00:20:45
si uno quiere irse directamente al código 00:20:47
de un método para ver que es lo que hace 00:20:49
pues si pulsáis control 00:20:51
y ponéis el cursor 00:20:53
Pues te dice, a ver, ¿dónde te quieres ir? 00:20:55
Quiero irme a la implementación de leer cliente 00:20:58
Y pum 00:21:00
Pulsas y se va a la implementación 00:21:02
Y así puedes navegar 00:21:04
En tu editor más rápido 00:21:06
Lo que no sé es volver atrás 00:21:07
No sé si hay atajo 00:21:09
Control y luego acercas el cursor 00:21:11
Lo depositas 00:21:24
Y se te habla este 00:21:25
Pulsas control sin más 00:21:27
Vale, pues el caso 1 00:21:29
Ahora ahí vamos con el caso 2 00:21:32
que nos permite hacer un siguiente salto un poco 00:21:33
vale, el caso 2 00:21:36
mostraba clientes 00:21:38
pues entonces, voy a quitar 00:21:39
yo todo esto que lo tenía antes 00:21:42
aquí puesto, voy a quitar yo todo esto 00:21:44
y voy a hacerme un método mostrar 00:21:46
clientes y ya está, me va a quedar 00:21:48
mucho más claro el switch case, un método 00:21:50
mostrar clientes, lo voy a llamar 00:21:51
también así con main 00:21:54
vale 00:21:55
no hace falta 00:21:56
pero lo digo bueno para si 00:22:01
quien se sienta más cómodo 00:22:03
todavía porque vea más claro 00:22:06
que es un método estático 00:22:08
de esta misma clase main 00:22:09
vale, pues mostrar clientes 00:22:10
pues vamos a hacer mostrar clientes 00:22:13
entonces mostrar clientes 00:22:15
habíamos empezado a hacerlo 00:22:16
por aquí abajo 00:22:17
public static 00:22:19
y ahora aquí es donde tenemos un problema 00:22:21
y es que este método 00:22:25
necesita acceder a la raíz de clientes 00:22:28
Para mostrarlos todos 00:22:32
Y te accede al array de clientes 00:22:33
Vale, ¿dónde está mi array de clientes? 00:22:35
Pues aquí viene el problema 00:22:38
Que mi array de clientes 00:22:39
Es local al método main 00:22:41
Entonces como mi array de clientes 00:22:44
Que está aquí es local al método main 00:22:47
Pues este no tiene acceso a él 00:22:49
No tiene acceso 00:22:54
Para recorrerlo y mostrarlo 00:22:55
Luego, soluciones que se os ocurren 00:22:57
Venga, solución una 00:22:59
Perfecto, una 00:23:00
Se lo paso por parámetro 00:23:03
¿Vale? Es una solución 00:23:05
¿Alguna otra solución 00:23:08
Que se os ocurra? 00:23:10
O en la misma 00:23:14
Sacarlo 00:23:15
Sacarlo aquí fuera 00:23:16
¿Vale? 00:23:20
Y si lo saco aquí fuera 00:23:25
Ya lo ven todos los métodos 00:23:27
Ya lo ven todos los métodos 00:23:31
Pero claro, ahora tenemos que, claro, lo ven todos los métodos, pero es que todos mis métodos tienen que ser estáticos, porque están hechos todos para ser llamados desde el main, y el main es static, luego solamente puede llamar a cosas static. 00:23:33
Entonces, para que realmente mi método este de mostrar datos pueda acceder a ese array de clientes que acabo de sacar, que acabo de sacar y he quitado de ahí, tiene que ser static. 00:23:48
y la pregunta es 00:24:01
¿es grave que sea static? 00:24:03
poniendo static para arreglar 00:24:08
errores de compilación la estoy liando 00:24:09
par de generando un problema enorme porque hay veces 00:24:11
que ponemos un static para arreglar un error de compilación 00:24:13
y hemos cambiado el sentido 00:24:16
de la aplicación completamente 00:24:18
aquí ese 00:24:19
eso es un problema, haberlo puesto static 00:24:21
es un problema 00:24:24
no es un problema porque 00:24:24
claro 00:24:28
mi aplicación trabaja con un 00:24:29
único array de clientes, ya está 00:24:32
no necesito 00:24:33
esta clase, de esta no va a haber 00:24:35
muchas instancias, cada una con su array 00:24:37
de clientes, no, esta es mi clase 00:24:39
main, que es la que va a instanciar 00:24:41
la máquina virtual para arrancar el main 00:24:43
solo va a haber una instancia, solo va a haber 00:24:45
un array de clientes para mi 00:24:47
aplicación, no hay muchos arrays de clientes 00:24:49
luego por aquí el static, no solo 00:24:51
no lo estropea, sino que 00:24:53
describe 00:24:55
mucho mejor la situación, que es que 00:24:57
solo tengo un array de clientes en toda la aplicación 00:24:59
entonces mucho mejor 00:25:02
meterlo aquí, vale 00:25:04
bueno, pues ahora ya sí 00:25:09
mi método mostrar clientes 00:25:11
pues lo tiene muy fácil 00:25:15
porque ya sí que puede hacer eso 00:25:17
para 00:25:19
cada cliente 00:25:21
C en clientes 00:25:23
muéstrame 00:25:26
y ya está 00:25:30
vale 00:25:33
y claro dirás tú 00:25:39
y dirías tú y decías tú 00:25:42
jolín, por dos líneas 00:25:44
sacar un método 00:25:47
por dos líneas y aquí 00:25:48
solamente estoy poniendo una 00:25:51
claro, pero es que esta es mi versión de ahora 00:25:52
pero ahora esta versión, a lo mejor 00:25:54
hay que cambiarla y me dicen, no, que ya no vas 00:25:56
por consola, que ahora vas por 00:25:59
una interfaz gráfica o mandas a base de datos 00:26:01
pues hombre 00:26:03
ah, vale, es mostrar clientes 00:26:04
lo que ha cambiado, pues tú te vas 00:26:07
a este método 00:26:08
y aquí haces el cambio 00:26:09
Y a lo mejor ese cambio implica añadir 20 líneas más, porque ahora ya no mandas la salida con un siso, sino que la mandas con una interfaz gráfica. Pues bueno, amplías este método, pero eso se mantiene completamente independiente del main, completamente. 00:26:12
que es lo que importa 00:26:30
lo importante es separar 00:26:31
lo más posible, lo que se llama 00:26:33
desacoplar, vamos a desacoplarlo 00:26:35
todo, entonces 00:26:38
esto está separado del main 00:26:39
que yo tengo que tocar la forma 00:26:41
de mostrar los clientes, me vengo 00:26:44
aquí a mostrar cliente y la toco 00:26:45
y al main le da igual, el main ya va a mostrar 00:26:47
al cliente y se acabó 00:26:50
¿vale? esa es la diferencia entre una 00:26:51
aplicación que esté bien hecha 00:26:53
y pueda tener un buen recorrido y que esté mal hecha 00:26:55
porque si yo he metido aquí 00:26:58
toda la complejidad de mostrar clientes 00:26:59
y ahora me dicen, oye, que he cambiado 00:27:02
y ahora voy por inteligencia gráfica 00:27:04
pues me tengo que ir a mi main 00:27:05
ir buscando en todas las partes donde accedo 00:27:07
a los clientes 00:27:09
ir retocando en todos lados, pues no 00:27:11
si lo tengo agrupadito en métodos 00:27:13
no voy al método que toque y el main 00:27:16
no tengo ni que tocarlo 00:27:17
bueno, con el main 00:27:22
al método main 00:27:26
vale 00:27:27
Vale, y con el resto 00:27:29
Pues podríamos ir haciendo un poco lo mismo 00:27:32
Vale, vamos a 00:27:33
Antes de meternos con el resto 00:27:35
Bueno, de mirarlo por encima 00:27:37
Vamos a recordar lo del toString, si os acordáis 00:27:38
Vale, acordaos 00:27:42
De que 00:27:44
Al system.out este de aquí 00:27:45
Le estábamos pasando 00:27:48
Directamente un objeto 00:27:50
Entero 00:27:52
Al system.out normalmente 00:27:53
Le pasábamos variables 00:27:55
Primitivas 00:27:57
o cadenas de texto 00:27:58
directamente, cuando le pasábamos variables 00:28:00
primitivas pues él las convertía 00:28:02
a la representación 00:28:04
ASCII, si le pasábamos 00:28:07
la variable entera 17 00:28:08
pues él la transformaba al 1 7 00:28:10
y no había ningún problema 00:28:12
pero que pasaba cuando le pasábamos un objeto 00:28:13
pues un objeto es una 00:28:16
dirección de memoria en realidad 00:28:18
entonces si yo 00:28:20
sin haber hecho nada en la clase clientea 00:28:22
hacía esto 00:28:24
este sistema me mostraba una cosa muy rara 00:28:25
¿Vale? 00:28:28
Que con la herencia entenderemos un poco mejor 00:28:30
Por qué me mostraba esa clase tan rara 00:28:31
Entonces, lo que yo os decía 00:28:33
O avanzaba de herencia 00:28:36
Es, vale, lo que realmente 00:28:38
El system out está haciendo 00:28:40
Cuando tú le pasas un objeto 00:28:41
Es, como el objeto no lo entiende 00:28:42
Llama a un método de esa clase 00:28:45
Que se llama toString para convertir 00:28:48
Para que se lo den string 00:28:50
Eso es lo que decía, oye, pues voy a llamar a un toString para que te lo den string 00:28:51
Entonces 00:28:54
Nosotros nos íbamos a cliente 00:28:55
y hacíamos ese toString 00:28:58
que sabemos que es 00:28:59
el método al que 00:29:02
el System.out va a llamar cuando le pasamos 00:29:04
el objeto. Es decir, oye, me das 00:29:06
un objeto que esto es una disminución de memoria, es una mierda, 00:29:08
esto yo no lo quiero. Voy a llamar a un toString 00:29:10
para que me lo cambie a string. 00:29:12
Pues nosotros lo hacíamos 00:29:14
para que lo convirtiera exactamente 00:29:15
como nosotros queríamos. 00:29:18
Porque podíamos no hacerlo, 00:29:21
pero si no lo hacemos, 00:29:23
entonces aparece un toString 00:29:24
por defecto, así de la nada. 00:29:26
aunque no lo veamos físicamente. 00:29:28
Y ese toString por defecto que aparece de la nada 00:29:30
hacía una cosa muy fea. 00:29:32
¿Vale? 00:29:35
De hecho, si dejamos comentado este método, 00:29:38
lo dejamos comentado así 00:29:42
y ejecutábamos esta aplicación 00:29:44
que es esta. 00:29:48
Bueno, primero nos pedía, pues eso, 00:29:59
él iba para configurar 00:30:01
y ahora vamos a hacer un cliente, 00:30:03
Al menos para que me lo muestre 00:30:04
Vale, ya teníamos un primer cliente 00:30:06
Y ahora listado de clientes 00:30:13
Ah, vale, vale, perdón 00:30:14
Mi método lo he hecho 00:30:18
Listado de clientes 00:30:19
Aquí no tenía nada en el array, por eso me ha mostrado nul 00:30:22
Eso lo cambiamos ahora 00:30:25
Me mostraba esto 00:30:25
Esto es una información que no me vale para nada 00:30:27
Porque este es 00:30:30
El toStream por defecto 00:30:32
Yo no quiero el toStream por defecto 00:30:34
Por eso hemos hecho uno específico para nosotros 00:30:36
vale, entonces el toString 00:30:38
que habíamos hecho nosotros era este 00:30:42
y ahora voy a cambiar en el cliente 00:30:44
en el main este, he sido yo muy chula aquí 00:30:49
lo he hecho con un for each 00:30:51
y recordáis que el for each que hacía 00:30:52
recorría la raya entero 00:30:55
y no queremos recorrer la raya entero 00:30:57
queremos recorrer solo hasta donde haya clientes 00:31:00
y hasta donde hay clientes 00:31:02
Hasta donde indique la variable 00:31:05
Siguiente posición libre 00:31:07
Por esto esto lo hacíamos con un 00:31:08
For de índice 00:31:11
Que no se debe llamar así 00:31:12
Porque se llama 00:31:22
ST pos libre 00:31:27
Ah, si se llama así 00:31:31
Vale, de posición libre 00:31:34
CDI 00:31:37
Clientes 00:31:38
De I, vale 00:31:45
Vale 00:31:46
Ahora ya si me llegaría solo 00:31:50
Este for hasta el que estuviera 00:31:53
Pero claro, ¿por qué me sale este error de compilación? 00:31:55
Claro, de nuevo por el mismo problema de antes 00:32:00
Porque los datos 00:32:02
Que le interesan al conjunto 00:32:04
De la aplicación 00:32:06
No es solo el array entero 00:32:07
Los datos también son 00:32:09
Oye, ¿cuál es la siguiente posición que tienes? 00:32:11
Entonces esto 00:32:14
También tenemos que sacarlo fuera 00:32:14
Esto nos pasa porque no tenemos colecciones de datos todavía 00:32:17
Y el array tiene este pequeño problemilla 00:32:24
Entonces 00:32:26
Ahora ya sí 00:32:35
la siguiente posición libre es un dato que puede necesitar 00:32:36
cualquier método 00:32:40
y sigue quedando un error 00:32:40
en algún sitio 00:32:45
aquí esto 00:32:46
y en el resto de 00:32:48
métodos podríamos ir haciendo lo mismo 00:33:02
podéis ir haciendo 00:33:04
vosotros lo mismo 00:33:06
o ponerlo en práctica en el resto de aplicaciones 00:33:07
pues el caso 3 00:33:10
es hacer un pedido nuevo 00:33:12
este en particular 00:33:14
si que hay que 00:33:16
Refactorizarlo, porque esto es un rollo 00:33:18
Entonces 00:33:20
Este que es, para leer un pedido 00:33:21
¿Vale? Generando el código 00:33:25
Todo eso se puede sacar a otro método 00:33:28
Todo 00:33:30
¿Vale? 00:33:32
A ese método 00:33:34
Ya está 00:33:35
Se sacaría todo un método que haga esto 00:33:39
Y se acabó 00:33:43
Esto sería, vamos a hacer el copia y pega 00:33:44
Esto sería, agregar pedido 00:33:49
Agregar pedido 00:34:01
Vale, pues este agregar pedido 00:34:10
En este agregar pedido 00:34:12
De aquí 00:34:19
Quiero yo 00:34:19
En principio hacer todo eso 00:34:23
Que es 00:34:27
Dame una descripción 00:34:29
Dame un precio 00:34:30
Generar código de pedido para que sea único 00:34:32
Vale 00:34:40
Todo este rollo que hicimos 00:34:43
De aquí 00:34:47
Nos íbamos 00:34:48
al cliente con ese nif 00:34:50
una vez que 00:34:53
encontrábamos el cliente con ese nif 00:34:55
le agregábamos el pedido 00:34:57
y ya está 00:34:58
con esta refactorización lo único es que 00:35:02
el código de pedido de nuevo 00:35:07
nos damos cuenta de que el código de pedido es una 00:35:09
información común para todos 00:35:11
el código de pedido 00:35:13
¿verdad? pues el código 00:35:14
de pedido aquí también 00:35:17
y el main se va quedando cada vez 00:35:19
más vacío, más claro, más limpio 00:35:33
¿vale? 00:35:35
Bueno, vamos a parar aquí un momento 00:35:38
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:
1
Fecha:
12 de enero de 2026 - 20:59
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
35′ 47″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
176.04 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid