1
00:00:00,000 --> 00:00:05,000
Bueno, habréis hecho algo parecido a esto que es lo de siempre, ¿no?

2
00:00:05,000 --> 00:00:12,000
Crear una raya auxiliar con una posición más que el de referencia,

3
00:00:12,000 --> 00:00:15,000
que el que queremos ampliar, una raya auxiliar.

4
00:00:15,000 --> 00:00:23,000
Ese array auxiliar le damos los mismos valores que tiene el otro

5
00:00:23,000 --> 00:00:27,000
y en la extra, en la posición extra que hemos creado,

6
00:00:27,000 --> 00:00:31,000
en la extra, en la posición extra metemos el nuevo

7
00:00:31,000 --> 00:00:35,000
y el nuevo es el que ha llegado por parámetro, ¿vale?

8
00:00:35,000 --> 00:00:40,000
El nuevo es el que ha llegado por parámetro, le damos el nuevo

9
00:00:40,000 --> 00:00:44,000
y ahora ya aux es nuestro array definitivo, el bueno,

10
00:00:44,000 --> 00:00:50,000
el que tiene los pedidos anteriores más el nuevo en la posición adicional.

11
00:00:50,000 --> 00:00:55,000
Pues entonces sobrescribo mi propiedad, ítems pedido,

12
00:00:55,000 --> 00:00:59,000
mi propiedad la sobrescribo con mi array bueno ya, definitivo,

13
00:00:59,000 --> 00:01:01,000
la sobrescribo, ¿vale?

14
00:01:01,000 --> 00:01:05,000
Y entonces ya mi array ítems pedido, que es éste,

15
00:01:05,000 --> 00:01:08,000
mi propiedad, éste, que es éste,

16
00:01:08,000 --> 00:01:11,000
mi propiedad ya se queda con el valor bueno,

17
00:01:11,000 --> 00:01:17,000
ésta es mi propiedad, es ésta, que es la que he ampliado.

18
00:01:17,000 --> 00:01:20,000
Como si ponemos aquí dis, es lo mismo, ¿vale?

19
00:01:20,000 --> 00:01:22,000
Me da igual, en este caso el dis no hace falta

20
00:01:22,000 --> 00:01:28,000
porque solo hay una cosa que se llama ítems pedido en este método, ¿vale?

21
00:01:28,000 --> 00:01:31,000
Me da igual poner el dis que no ponerlo, ¿vale?

22
00:01:31,000 --> 00:01:34,000
Está claro lo que hemos hecho, ¿no?

23
00:01:34,000 --> 00:01:37,000
A ver, primero recordar dos matices,

24
00:01:37,000 --> 00:01:44,000
aquí tengo un problema cuando pasa que,

25
00:01:44,000 --> 00:01:54,000
¿en qué situación este método me daría un error y cuál sería?

26
00:01:54,000 --> 00:01:57,000
Cuando añado el primero,

27
00:01:57,000 --> 00:02:00,000
cuando llamo por primera vez a addItem,

28
00:02:00,000 --> 00:02:02,000
porque cuando llamo por primera vez a addItem,

29
00:02:02,000 --> 00:02:05,000
ítems pedido de arriba es nul,

30
00:02:05,000 --> 00:02:07,000
estas inicializar es nul,

31
00:02:07,000 --> 00:02:09,000
entonces cuando lo llamo por primera vez,

32
00:02:09,000 --> 00:02:13,000
ya aquí directamente al tratar de acceder a su tamaño,

33
00:02:13,000 --> 00:02:15,000
para darle uno más al otro,

34
00:02:15,000 --> 00:02:17,000
me va a decir nul, pointer exception,

35
00:02:17,000 --> 00:02:21,000
pa, a lo bestia, ¿vale?

36
00:02:21,000 --> 00:02:24,000
Entonces, esa es primera cosa que tendríamos que arreglar,

37
00:02:24,000 --> 00:02:27,000
que la primera vez que se llame addItem,

38
00:02:27,000 --> 00:02:30,000
la primera vez esto es nul,

39
00:02:30,000 --> 00:02:32,000
entonces podríamos arreglarlo de varias maneras,

40
00:02:32,000 --> 00:02:35,000
una más larga, otra más corta, una más fea,

41
00:02:35,000 --> 00:02:37,000
una más bonita, depende,

42
00:02:37,000 --> 00:02:39,000
una distinguir aquí con un if, ¿no?

43
00:02:39,000 --> 00:02:42,000
y poner if items pedido igual a nul,

44
00:02:42,000 --> 00:02:44,000
entonces no hagas todo esto,

45
00:02:44,000 --> 00:02:46,000
te voy a ver la que le voy a hacer,

46
00:02:46,000 --> 00:02:49,000
si ítems pedido, ha sonado, pero no,

47
00:02:49,000 --> 00:02:51,000
si ítems pedido es igual a nul,

48
00:02:51,000 --> 00:02:53,000
entonces no hagas todo este chorizo,

49
00:02:53,000 --> 00:02:56,000
simplemente ítems pedido igual a newItem1

50
00:02:56,000 --> 00:02:59,000
y mete ahí el nuevo, ¿verdad?

51
00:02:59,000 --> 00:03:01,000
Si es igual a nul,

52
00:03:01,000 --> 00:03:03,000
lo creas con una pollina y metes el nuevo,

53
00:03:03,000 --> 00:03:06,000
o, o, se puede hacer otra cosa,

54
00:03:06,000 --> 00:03:10,000
que es, oye,

55
00:03:10,000 --> 00:03:12,000
créala desde el principio,

56
00:03:12,000 --> 00:03:15,000
en el momento de crear el objeto,

57
00:03:15,000 --> 00:03:17,000
recordad que mencionamos

58
00:03:17,000 --> 00:03:20,000
que uno puede inicializar las propiedades también,

59
00:03:20,000 --> 00:03:23,000
si quiere, ahí, si quiere,

60
00:03:23,000 --> 00:03:26,000
entonces podríamos hacer esto, ¿verdad?

61
00:03:26,000 --> 00:03:28,000
Lo peor es que esto es más feo,

62
00:03:28,000 --> 00:03:30,000
yo lo he visto menos y me gusta menos,

63
00:03:30,000 --> 00:03:36,000
pero, como, con Estefano,

64
00:03:36,000 --> 00:03:38,000
esta es una forma cómoda de arreglar ese problema

65
00:03:38,000 --> 00:03:43,000
y creo que con él lo, os lo planteo así, ¿vale?

66
00:03:43,000 --> 00:03:46,000
Entonces, de aquí,

67
00:03:46,000 --> 00:03:48,000
¿qué me interesa de aquí sobre todo?

68
00:03:48,000 --> 00:03:51,000
El recordar que cuando uno declara propiedades,

69
00:03:51,000 --> 00:03:55,000
puede a la vez inicializarlas si le da la gana,

70
00:03:55,000 --> 00:03:57,000
¿eso qué significa?

71
00:03:57,000 --> 00:03:59,000
¿eso qué significa?

72
00:03:59,000 --> 00:04:01,000
Que en el momento de instanciar el objeto,

73
00:04:01,000 --> 00:04:05,000
la propiedad se inicializa con lo que se pone aquí, ¿vale?

74
00:04:05,000 --> 00:04:07,000
Lo que pasa es que luego, es una tontería,

75
00:04:07,000 --> 00:04:11,000
porque se va a pisar con lo que yo ya he puesto en el constructor,

76
00:04:11,000 --> 00:04:12,000
¿vale?

77
00:04:12,000 --> 00:04:15,000
Se va a pisar con lo que yo ya he puesto.

78
00:04:15,000 --> 00:04:17,000
Entonces, esto tiene sentido

79
00:04:17,000 --> 00:04:19,000
cuando no usas el constructor con parámetros,

80
00:04:19,000 --> 00:04:20,000
¿vale?

81
00:04:20,000 --> 00:04:23,000
Pero recordemos, quiero recordar aquí,

82
00:04:23,000 --> 00:04:26,000
que uno puede inicializar una propiedad,

83
00:04:26,000 --> 00:04:29,000
que es el valor que va a recibir esa propiedad

84
00:04:29,000 --> 00:04:31,000
en el momento de instanciar el objeto,

85
00:04:31,000 --> 00:04:32,000
pero si luego tienes,

86
00:04:32,000 --> 00:04:34,000
si le estás instanciando el objeto

87
00:04:34,000 --> 00:04:36,000
a través de un constructor con parámetros,

88
00:04:36,000 --> 00:04:38,000
eso luego se va a pisar con lo que tú le pongas aquí,

89
00:04:38,000 --> 00:04:40,000
se va a pisar con eso, ¿vale?

90
00:04:40,000 --> 00:04:42,000
Entonces, esta inicialización

91
00:04:42,000 --> 00:04:44,000
solo tiene sentido

92
00:04:44,000 --> 00:04:46,000
cuando tú estás instanciando con este,

93
00:04:46,000 --> 00:04:47,000
por ejemplo,

94
00:04:47,000 --> 00:04:48,000
con el que no tiene parámetros,

95
00:04:48,000 --> 00:04:49,000
con este,

96
00:04:49,000 --> 00:04:50,000
entonces sí,

97
00:04:50,000 --> 00:04:52,000
si tú estás instanciando con este,

98
00:04:52,000 --> 00:04:54,000
las propiedades se quedan inicializadas

99
00:04:54,000 --> 00:04:56,000
con lo que tú hayas puesto aquí,

100
00:04:56,000 --> 00:04:57,000
¿vale?

101
00:04:57,000 --> 00:04:59,000
Estás instanciando con este.

102
00:04:59,000 --> 00:05:00,000
Bueno, en este caso,

103
00:05:00,000 --> 00:05:02,000
si nosotros instanciamos

104
00:05:02,000 --> 00:05:03,000
con un constructor,

105
00:05:03,000 --> 00:05:04,000
con este de aquí,

106
00:05:04,000 --> 00:05:05,000
que es con el que lo vamos a hacer,

107
00:05:05,000 --> 00:05:08,000
que hace el pedido sin parámetros,

108
00:05:08,000 --> 00:05:09,000
entonces el pedido

109
00:05:09,000 --> 00:05:11,000
se queda inicializado a un array

110
00:05:11,000 --> 00:05:13,000
sin posiciones,

111
00:05:13,000 --> 00:05:14,000
pero que ya no es null,

112
00:05:14,000 --> 00:05:15,000
no es lo mismo

113
00:05:15,000 --> 00:05:17,000
un objeto null

114
00:05:17,000 --> 00:05:18,000
que no existe un null

115
00:05:18,000 --> 00:05:20,000
que un array de cero posiciones,

116
00:05:20,000 --> 00:05:21,000
no es lo mismo,

117
00:05:21,000 --> 00:05:22,000
no es lo mismo.

118
00:05:22,000 --> 00:05:23,000
Entonces,

119
00:05:23,000 --> 00:05:25,000
si lo inicializamos a newItemCero,

120
00:05:25,000 --> 00:05:28,000
pues ya podemos dejar este código aquí sin tocar,

121
00:05:28,000 --> 00:05:31,000
porque ahora ya esto no me dará nullPointerException,

122
00:05:31,000 --> 00:05:33,000
esto me dará cero,

123
00:05:33,000 --> 00:05:35,000
y ahora ya el nuevo array será uno,

124
00:05:35,000 --> 00:05:37,000
entonces eso como más os guste.

125
00:05:37,000 --> 00:05:39,000
O no se lo inicializa

126
00:05:39,000 --> 00:05:43,000
y se distingue aquí si es null,

127
00:05:43,000 --> 00:05:45,000
actúa de otra manera,

128
00:05:45,000 --> 00:05:47,000
o se inicializa longitud cero,

129
00:05:47,000 --> 00:05:49,000
¿vale?

130
00:05:49,000 --> 00:05:51,000
Podéis encontrar las dos cosas.

131
00:05:51,000 --> 00:05:53,000
Vale, bueno,

132
00:05:53,000 --> 00:05:55,000
pues vamos a parar aquí.