1
00:00:01,260 --> 00:00:13,900
Ya estamos en marcha, pues como decíamos antes, feliz año a todos y bueno, pues vamos a arrancar. En un poco más de un mes o en un mes más o menos tenemos el examen este de prueba.

2
00:00:13,900 --> 00:00:23,839
comentaros el examen acordaros que bueno pues en realidad ni quita contenidos para el examen final

3
00:00:23,839 --> 00:00:30,519
cosa que al final sería un poquito lo que estamos viendo hasta ahora es necesario en todo programa

4
00:00:30,519 --> 00:00:34,380
de java con lo cual el quitar contenidos o no quitar contenido no llevaría a ningún sitio pero

5
00:00:34,380 --> 00:00:39,520
bueno no es el caso no quita no quita ningún tipo de materia pero sí que creo que es bastante

6
00:00:39,520 --> 00:00:41,460
interesante, si podéis sacar

7
00:00:41,460 --> 00:00:43,679
el ratito con vuestros trabajos, que sé que

8
00:00:43,679 --> 00:00:45,539
todos estáis, bueno, pues lleváis

9
00:00:45,539 --> 00:00:47,619
vidas atareadas, ¿no? Y con vuestros

10
00:00:47,619 --> 00:00:49,539
trabajos y en muchos casos

11
00:00:49,539 --> 00:00:51,640
con cargas familiares y todo.

12
00:00:52,500 --> 00:00:53,700
Pero si tenéis el ratito

13
00:00:53,700 --> 00:00:55,659
para venir a hacer el examen, creo que es interesante

14
00:00:55,659 --> 00:00:57,759
porque el esquema

15
00:00:57,759 --> 00:00:59,500
del examen es, claro,

16
00:01:00,079 --> 00:01:01,140
cuando hagamos en

17
00:01:01,140 --> 00:01:03,240
para la ordinaria el examen, luego hacía

18
00:01:03,240 --> 00:01:05,099
cerca de junio, finales de mayo

19
00:01:05,099 --> 00:01:07,439
o principios de junio, ya estaban las fechas por ahí

20
00:01:07,439 --> 00:01:08,420
puestas, no las recuerdo.

21
00:01:09,519 --> 00:01:24,200
Habrá más contenidos, pero el modelo del examen es prácticamente igual en cuanto a la estructura y en cuanto al tipo de preguntas, digamos, para que os podáis hacer una idea. Entonces creo que resulta útil el que vengáis a hacerlo.

22
00:01:24,200 --> 00:01:46,090
Si tenéis el ratillo, interesante que os paséis. Y nada, pues el examen abre un tema ahora el día 21 en una semana, abre un tema nuevo, pues hasta el siguiente tema. Nos entrarán los contenidos de los cuales sacaremos las preguntas para el examen.

23
00:01:46,090 --> 00:02:10,830
¿Cómo suele ser? Pues suele tener, lo anticipo un poco, pues algunas preguntas tipo test, algunas que tengáis que responder verdadero o falso, alguna que tenga opciones para resolverlo y luego pues os pedirá un enunciado en el cual tendréis que hacer algunos pequeños programas, no muy grandes, pero bueno, o de algún programa, a lo mejor os lo pedimos por apartados.

24
00:02:10,830 --> 00:02:14,050
aquí haz un constructor copia, aquí haz

25
00:02:14,050 --> 00:02:16,990
un método que se llame

26
00:02:16,990 --> 00:02:19,669
no sé qué, que reciba tal y de como resultado

27
00:02:19,669 --> 00:02:22,969
pues otra cosa. Entonces bueno, pues hay que

28
00:02:22,969 --> 00:02:25,789
darle un poquillo a la cabeza para ver cómo podría ser el algoritmo que

29
00:02:25,789 --> 00:02:28,069
resuelva ese problema que se plantea

30
00:02:28,069 --> 00:02:31,849
y bueno, pues implementarlo con las cosas

31
00:02:31,849 --> 00:02:34,949
que estamos viendo, en principio

32
00:02:34,949 --> 00:02:37,650
lógicamente basado en el lenguaje Java

33
00:02:37,650 --> 00:02:40,110
que es el que estamos utilizando en la asignatura.

34
00:02:44,000 --> 00:02:48,860
Y dicho esto, pues nada, preguntaros si tenéis alguna duda o alguna consulta que me queráis hacer

35
00:02:48,860 --> 00:02:53,599
antes de arrancar yo a contaros algunas cosas. Por ahí están dos horitas que tenemos por delante.

36
00:02:57,939 --> 00:03:02,120
Se me escucha bien, eso sí, ¿verdad? Vale.

37
00:03:08,409 --> 00:03:12,490
¿Alguna cosita por ahí queréis que comentemos o arranco por aquí?

38
00:03:12,490 --> 00:03:20,669
Y tengo el último día de clase, que tuvimos solamente una hora, estuvimos resolviendo la tarea del tema 4.

39
00:03:21,250 --> 00:03:26,770
Recuerdo que quedó un poco... bueno, pues no nos dio tiempo a probarlo.

40
00:03:26,909 --> 00:03:32,870
Al final habíamos metido todo el código, hicimos una prueba y tenía algún fallo, me parece, que no nos dio tiempo a depurar.

41
00:03:33,610 --> 00:03:38,909
Yo creo que en principio, si no me lo pedís de forma explícita, pues lo dejamos ya parado aquello,

42
00:03:38,909 --> 00:03:47,169
porque digamos que la vuelta teórica ya la había mordado y arrancamos con cosas relacionadas con lo que tenéis en la teoría del tema 5.

43
00:03:47,870 --> 00:03:54,639
¿Os parece? Vale, pues ahora, pues venga, pues vamos ahí al ataque.

44
00:03:55,580 --> 00:04:05,800
El tema 5 todavía continúa siendo, bueno y el tema 6 incluso, continúa haciéndonos aterrizar en la programación orientada a objetos

45
00:04:05,800 --> 00:04:10,219
y claro, como desde el primer día para hacer programas

46
00:04:10,219 --> 00:04:14,300
hemos venido utilizando programas en Java, que es un lenguaje como ya hemos comentado

47
00:04:14,300 --> 00:04:18,500
orientado a objetos, pues poco a poco, sin querer o a propósito

48
00:04:18,500 --> 00:04:22,100
hemos ido adelantando muchos de los conceptos, entonces aquí digamos que

49
00:04:22,100 --> 00:04:25,860
formalmente en este tema 5, pues asentamos algunos de ellos

50
00:04:25,860 --> 00:04:29,540
Bueno, como repaso para los que no hayamos

51
00:04:29,540 --> 00:04:33,300
para aquellos que no hayamos visto y para los que sí que hemos visto

52
00:04:33,300 --> 00:04:39,420
pues ir asentándolos, pues vamos a dedicar un par de tutorías, la de esta y la de la semana que viene

53
00:04:39,420 --> 00:04:47,180
y luego ya la semana que viene, el martes, arranca ya el siguiente tema, ya lo concluimos entre estas dos semanas

54
00:04:47,180 --> 00:04:53,540
y repasamos cositas. Y para repasar los conceptos, pues como siempre, me parece que lo más útil es ir haciéndolo

55
00:04:53,540 --> 00:05:02,839
con Eclipse, pues vamos con ello. Vamos a arrancar un proyecto, aquí, que podemos llamar por ejemplo

56
00:05:02,839 --> 00:05:16,879
lo tema 5. En este tema, bueno, pues habla, creo recordar, lo estuve leyendo justo a principio de

57
00:05:16,879 --> 00:05:21,959
navidades repasando los contenidos de este tema, pues bueno, hablaba de las clases y los objetos,

58
00:05:22,839 --> 00:05:28,560
un poco lo que los diferenciaba, las clases, yo lo cuento más o menos bien al ser lo mismo, pero bueno,

59
00:05:28,620 --> 00:05:33,519
lo cuento un poco con mis palabras o como yo lo veo, que quizás no coincida al 100% con lo que

60
00:05:33,519 --> 00:05:41,740
ponga ahí en los apuntes, aunque claro no es muy lejanos, las clases vienen a ser el esquema en el

61
00:05:41,740 --> 00:05:48,980
cual definimos las características o atributos que tienen los objetos de esa clase que luego

62
00:05:48,980 --> 00:05:55,990
vamos a ir instanciando y los métodos como formas de comportamiento. Ese esquema yo siempre digo lo

63
00:05:55,990 --> 00:05:59,810
colgamos ahí como un cuadro por ejemplo en la pizarra, lo dibujamos en la pizarra, lo colgamos

64
00:05:59,810 --> 00:06:04,730
en la pared y normalmente una clase no es la que está interactuando y la que está poniendo en

65
00:06:04,730 --> 00:06:08,230
marcha el programa, sino que son objetos de esa clase que vamos creando

66
00:06:08,230 --> 00:06:12,689
según vayamos necesitándolos. No doy muchas más vueltas al

67
00:06:12,689 --> 00:06:15,730
concepto de clase y objetos porque ya hemos hablado de ellos.

68
00:06:16,670 --> 00:06:20,709
Y luego también creo recordar que en el tema se habla

69
00:06:20,709 --> 00:06:24,870
algo de métodos y parámetros. Los métodos son aquellas acciones

70
00:06:24,870 --> 00:06:28,769
que hacen los objetos de una clase y que vienen definidos

71
00:06:28,769 --> 00:06:32,730
en la clase como esquema base del comportamiento

72
00:06:32,730 --> 00:06:35,990
de esa clase y de los objetos que luego vayamos instanciando

73
00:06:35,990 --> 00:06:38,810
de ellos. Y los parámetros, pues esa información

74
00:06:38,810 --> 00:06:41,750
que dentro del método se va a comportar como variables

75
00:06:41,750 --> 00:06:44,810
locales que ponemos entre los paréntesis

76
00:06:44,810 --> 00:06:47,569
en la definición con el tipo

77
00:06:47,569 --> 00:06:50,769
y cuando hacemos llamadas ponemos los valores que se copian

78
00:06:50,769 --> 00:06:52,689
directamente para la ejecución del método.

79
00:06:53,889 --> 00:06:55,470
Lo tenemos súper trabajado esto.

80
00:06:56,730 --> 00:06:59,810
Y luego, no sé si es exactamente en este

81
00:07:00,550 --> 00:07:02,610
orden en el que lo va contando en el tema, pero

82
00:07:02,610 --> 00:07:10,110
sí en el guión del tema que me he hecho yo, tengo apuntado a hablaros de un poquito del ámbito de

83
00:07:10,110 --> 00:07:18,389
alcance de las clases. Bueno, hay diferentes tipos de etiquetas y una de las cosas que nos aparecen

84
00:07:18,389 --> 00:07:24,629
es el ámbito de alcance dentro de un proyecto, es decir, que sean públicos, que sean protective, que

85
00:07:24,629 --> 00:07:31,170
sean friendly o package, que viene a ser aquellos en los cuales no definimos el tipo de alcance o

86
00:07:31,170 --> 00:07:39,410
que sean privados. Vamos aquí en el tema 5 a crear un paquete. Normalmente sabéis que no suelo

87
00:07:39,410 --> 00:07:44,670
trabajar utilizando paquetes porque como son programas muy pequeños pues directamente

88
00:07:44,670 --> 00:07:50,629
utilizo el paquete por defecto pero en este caso sí que lo vamos a hacer acá. Vamos a definirlos

89
00:07:50,629 --> 00:07:57,269
porque tiene que ver con el alcance de desde dónde podemos llegar a métodos de otras clases

90
00:07:57,269 --> 00:08:05,269
diferentes. Vamos a definir un primer paquete, paquete 1, package 1 lo he llamado, y vamos a definir un segundo

91
00:08:05,269 --> 00:08:17,720
paquete por aquí, package 2. Recordad que al final podríamos tener todo el código en un solo paquete,

92
00:08:17,720 --> 00:08:25,699
que la forma de que esté distribuido en el sistema de archivos sería en un solo directorio del proyecto,

93
00:08:25,699 --> 00:08:33,360
mirad aquí en el directorio home del usuario Debian en Eclipse

94
00:08:33,360 --> 00:08:36,240
tenemos el directorio Eclipse Workspace

95
00:08:36,240 --> 00:08:40,659
que está asociado a Eclipse para ir guardando los diferentes proyectos

96
00:08:40,659 --> 00:08:47,159
y aquí si hacemos un ls vemos todos los proyectos que tenemos dados de alta dentro de Eclipse

97
00:08:47,159 --> 00:08:51,580
en este caso estamos en el proyecto tema 5

98
00:08:51,580 --> 00:08:54,919
tenemos un directorio colgando el Workspace completo

99
00:08:54,919 --> 00:09:17,549
Y aquí tenemos el código fuente, aquí y por aquí en el bin tendríamos los ficheros .class. Dentro de los ficheros .class fijaros como nos han aparecido de repente dos directorios aquí que corresponde cada uno a cada uno de los dos paquetes que tenemos.

100
00:09:17,549 --> 00:09:34,129
¿Para qué nos resultan útiles los paquetes? Volviendo a ejemplos que hemos utilizado en otras ocasiones, imaginaos que tenemos un proyecto que estamos haciendo de un banco y podríamos tener todo el código en un directorio, en un único paquete, todo el código ahí puesto.

101
00:09:34,129 --> 00:09:48,129
En el momento en el que el proyecto ya es un proyecto con cierta envergadura, nos saldrían un montón de ficheros. Todos estos ficheros estarían dando funcionalidades al banco probablemente en diferentes ámbitos.

102
00:09:48,129 --> 00:10:10,250
Pues unos pertenecerían a la parte de líneas de crédito, otros pertenecerían al pago de nóminas, bueno, vete tú a saber, ¿no? Otro al banco, pero en su sección de recursos humanos. Pues si tenemos código para todos estos campos y muchos otros, todos ellos en un único paquete, pues seguramente su mantenimiento nos resulte más costoso.

103
00:10:10,250 --> 00:10:16,190
entonces que podemos hacer para proyectos así grandes pues crear diferentes paquetes y uno de

104
00:10:16,190 --> 00:10:20,389
los paquetes que aquí lo llamado yo para cada uno y para cada dos pues podría ser recursos humanos

105
00:10:20,389 --> 00:10:27,049
y otro nóminas y de esta forma el código de cada uno de ellos meterlo dentro de su paquete con lo

106
00:10:27,049 --> 00:10:34,049
cual queda todo mucho más ordenado como si tenemos un armario sin cajones en casa y ponemos toda la

107
00:10:34,049 --> 00:10:39,309
ropa y a granel o de repente tenemos cajoneras y perchas y las chaquetas y los abrigos los ponemos

108
00:10:39,309 --> 00:10:43,610
en las perchas y la ropa interior y los calcetines en unos cajones separados.

109
00:10:43,789 --> 00:10:45,490
Entonces todo está como más organizadito.

110
00:10:47,659 --> 00:10:52,360
Además nos resulta útil los paquetes no solo por tener un cierto orden

111
00:10:52,360 --> 00:10:57,200
que cuando vayamos a hacer un mantenimiento es más fácil localizar las zonas de código.

112
00:10:57,340 --> 00:11:00,159
Si tenemos un error de repente o tenemos que hacer una actualización

113
00:11:00,159 --> 00:11:04,419
en el software de recursos humanos, pues seguramente si lo tenemos en un paquete

114
00:11:04,419 --> 00:11:08,200
que sea recursos humanos, la actualización la vamos a tener que hacer en código

115
00:11:08,200 --> 00:11:13,080
que cuelga de ahí. Y si ahí tenemos 10 ficheros, pues sabemos que tendremos que tocar en esos 10 ficheros.

116
00:11:13,220 --> 00:11:19,960
No va a resultar más fácil hacer un análisis y un desarrollo nuevo para actualizarlo que si esos 10 ficheros

117
00:11:19,960 --> 00:11:24,740
los tenemos mezclados con otros 200 del resto de funcionalidades que pudiera tener el banco.

118
00:11:26,620 --> 00:11:33,799
Y una tercera ventaja que se me ocurre es que imaginaros que hemos hecho para un determinado banco un desarrollo

119
00:11:33,799 --> 00:11:37,039
y nos funciona todo, lo tenemos muy bien probadito,

120
00:11:37,120 --> 00:11:38,659
estamos muy contentos con ese software

121
00:11:38,659 --> 00:11:40,419
y de repente nos contrata otro banco,

122
00:11:41,080 --> 00:11:42,860
nos pide su desarrollo, pero bueno,

123
00:11:42,940 --> 00:11:46,200
para ciertas funcionalidades no le interesa nuestro código

124
00:11:46,200 --> 00:11:49,580
porque es muy particular para el desarrollo anterior,

125
00:11:49,759 --> 00:11:51,279
pero en cambio la parte de recursos humanos

126
00:11:51,279 --> 00:11:53,620
es que está clavada como ellos también la querrían.

127
00:11:54,419 --> 00:11:56,519
Pues bueno, resulta muy sencillo coger

128
00:11:56,519 --> 00:11:59,159
el paquete de recursos humanos tal cual

129
00:11:59,159 --> 00:12:02,580
y portar de un proyecto a otro ese paquete.

130
00:12:02,580 --> 00:12:25,590
Entonces, directamente no necesitamos andar entre todo el código intentando localizar qué trocitos de código cogeríamos de un sitio o de otro para obtener esa misma funcionalidad en el segundo error. Esto un poco en cuanto al nivel funcional de los paquetes y un poquito en cómo Eclipse organiza esos paquetes en el sistema de archivos.

131
00:12:25,590 --> 00:12:30,690
paquete de recursos humanos que pudiera ser el paquete 1 pues fijaros tiene un directorio que

132
00:12:30,690 --> 00:12:35,070
me interesa para otro proyecto cojo este directorio con todo su contenido interno y traslado este

133
00:12:35,070 --> 00:12:43,889
directorio al segundo de los proyectos mirad aquí en el paquete aquí en el paquete 1 vamos a crear

134
00:12:43,889 --> 00:13:00,570
una nueva clase que la vamos a llamar vamos a llamarle clase clase 1 del paquete 1 fijaros

135
00:13:00,570 --> 00:13:07,049
que por el hecho de pertenecer al paquete 1 esta clase pone en la cabecera la etiqueta

136
00:13:07,049 --> 00:13:17,139
package identifica en qué paquete se encuentra vamos a crear una segunda clase aquí bueno por

137
00:13:17,139 --> 00:13:27,840
seguir un poco con la misma nomenclatura se llamaría clase 2 del paquete 1 y aquí en el

138
00:13:27,840 --> 00:13:36,559
paquete 2 vamos a crear otra clase más que sería la clase 1 del paquete 2

139
00:13:36,559 --> 00:13:56,379
Y ahora vamos a crear ciertas variables para intentar, digamos, justificar los ámbitos que nos dice la teoría respecto a las etiquetas public, protected, si no está especificado que sería ámbito de paquete o private.

140
00:13:56,379 --> 00:14:26,360
Entonces, si venimos, por ejemplo, aquí a la clase 1 del paquete 1, aquí vamos a definir cuatro variables, una que sea una variable public, da igual el tipo, para ver el ámbito en sí, bueno, pues el tipo que sea sería indiferente, tendrá sentido que sea un enter, un string o lo que sea, en función de la información que pueda recoger, pero para ver el ámbito de alcance, lo que nos fijamos es en esta etiqueta anterior, con lo cual, bueno, es indiferente utilizar un tipo de variable public.

141
00:14:26,379 --> 00:14:42,539
o otro entonces vamos a poner y entero público este pub como hemos definido aquí la variable

142
00:14:42,539 --> 00:14:50,720
de tipo público para saber manejarla vamos a definir una que sea mantener esta pública

143
00:14:50,720 --> 00:15:02,059
vamos a poner esta como private de la variable la podríamos llamar priv tenemos la privada vamos

144
00:15:02,059 --> 00:15:25,049
a definir una que sea protegida, protective, y vamos a definir una que no tenga definición

145
00:15:25,049 --> 00:15:34,409
ninguna. Estas variables, si no se pone por defecto ninguna, tienen alcance package. Creo

146
00:15:34,409 --> 00:15:43,580
que recordar que se podría definir como package de forma explícita. Bueno, dice que lo borremos.

147
00:15:43,580 --> 00:15:49,460
bueno si no lo ponemos ninguna la de por defecto es de alcance package o también no sé si en esta

148
00:15:49,460 --> 00:15:56,080
en nuestra teoría pero hay ciertos sitios donde la llaman también friendly de amigable friendly

149
00:15:56,080 --> 00:16:09,750
o package son este tipo de variables bueno le gusta la etiqueta package si no ponemos nada

150
00:16:09,750 --> 00:16:20,299
son la frente o package y vamos a ver los diferentes alcances que tiene esta public

151
00:16:20,299 --> 00:16:37,340
protective me falta la private ahora de fijaros en esta clase hemos definido cuatro atributos una de

152
00:16:37,340 --> 00:16:48,360
cada tipo las las variables que son privadas están variables o métodos esto esto es equivalente para

153
00:16:48,360 --> 00:16:53,340
métodos y variables que en los cuales definamos estas etiquetas tienen su alcance dentro de la

154
00:16:53,340 --> 00:17:01,750
propia clásica única única y exclusivamente de si nosotros cogemos bueno dentro de un método en la

155
00:17:01,750 --> 00:17:14,259
misma clase vamos a definir que un método vamos a poner un método public void mi método permite

156
00:17:14,259 --> 00:17:19,599
acceso a cualquier variable dentro de la clase las que tienen un acceso más restringido son las

157
00:17:19,599 --> 00:17:24,859
privadas que solamente estarán disponibles dentro de la clase propia donde están definidas pero

158
00:17:24,859 --> 00:17:29,119
cualquier otra también está disponible. Es decir, dentro de la misma clase, cualquier variable

159
00:17:29,119 --> 00:17:32,859
está al alcance. De hecho, fijaros cómo

160
00:17:32,859 --> 00:17:54,579
vamos a poner un valor aquí. Dentro de un método

161
00:17:54,579 --> 00:17:59,140
que pertenezca a la clase donde están definidas, cualquiera

162
00:17:59,140 --> 00:18:03,200
de las etiquetas están disponibles. Es el ámbito más cercano, parece que

163
00:18:03,200 --> 00:18:06,519
tiene sentido. Una variable que no estuviera disponible dentro de la misma clase

164
00:18:06,519 --> 00:18:15,779
no tendría en realidad ninguna utilidad. Si nos vamos

165
00:18:15,779 --> 00:18:23,599
a una clase que esté en el mismo paquete la clase 2 del paquete 1 pues podríamos venir aquí y definir

166
00:18:23,599 --> 00:18:32,900
un objeto de esa clase entonces decimos clase 1 en la clase 1 recordad que es donde hemos definido

167
00:18:32,900 --> 00:18:37,660
estas cuatro variables que son las que vamos a ir haciendo comprobaciones en función de la etiqueta

168
00:18:37,660 --> 00:18:52,779
Vamos a definir un objeto de esta clase aquí dentro. Clase1, mi objeto de clase1 igual a new clase1.

169
00:18:52,779 --> 00:19:28,500
Entonces si yo ahora cojo aquí, voy a hacer un copy para no tener que escribir tanto, defino un método, public void mi método y ahí intento acceder a los atributos de esta clase, vamos a ver a cuáles me deja y a cuáles no.

170
00:19:28,500 --> 00:19:38,440
mirad, en una segunda clase, la clase 2

171
00:19:38,440 --> 00:19:42,900
que está en el mismo paquete que la clase 1

172
00:19:42,900 --> 00:19:47,119
pero es una clase distinta, clase 1 que tiene las 4 variables

173
00:19:47,119 --> 00:19:50,420
y clase 2 que está en el mismo paquete que la clase 1

174
00:19:50,420 --> 00:19:55,019
podríamos acceder a cualquier tipo de variable, a la pública, a la protegida

175
00:19:55,019 --> 00:19:58,259
y a la paquete, pero no podríamos a la privada

176
00:19:58,259 --> 00:20:00,400
es decir, la privada no podemos

177
00:20:00,400 --> 00:20:07,000
en una clase, aunque comparta el mismo paquete.

178
00:20:10,680 --> 00:20:11,299
Al resto sí.

179
00:20:11,799 --> 00:20:14,799
En una clase propia tenemos acceso, sea cual sea la etiqueta.

180
00:20:15,640 --> 00:20:19,099
Si queremos que el acceso a una determinada variable

181
00:20:19,099 --> 00:20:21,299
no esté disponible en ninguna otra clase,

182
00:20:21,680 --> 00:20:24,579
esté donde esté del proyecto, la definimos como privada

183
00:20:24,579 --> 00:20:28,480
y ya no tendrá nunca acceso desde ningún sitio,

184
00:20:29,000 --> 00:20:30,640
nada más que desde la propia clase.

185
00:20:32,869 --> 00:20:34,130
Vamos a ponernos en situaciones.

186
00:20:35,369 --> 00:20:53,849
Imaginaos que es una persona, está la clase persona, tenemos un getter y un setter que luego los volvemos a repasar para asignarle una edad y en mi proyecto esa edad va de 0 a 100 años para la persona o a 200 años, de 0 a 200 años.

187
00:20:53,849 --> 00:21:18,309
Vamos a darle un poquito más margen de los 100. Si nosotros queremos tener certeza que la variable edad, que sería la equivalente a esta, no se modifica fuera de la clase persona que estoy programando yo en ningún otro sitio del proyecto y creo yo un getter y un setter para modificar ese valor haciendo un control de que la edad no sea ni mayor ni menor de 0 ni mayor de 200.

188
00:21:18,309 --> 00:21:33,910
Si no me fío, no me fío entre comillas, ¿vale? Porque el proyecto lo está realizando mucha gente y a lo mejor incluso dentro de mi paquete este, una clase diferente la puede programar otra persona, no quiero que tengan acceso directamente, pues la pondría privada.

189
00:21:33,910 --> 00:21:43,869
si al contrario de esto todo el paquete 1 por ejemplo lo voy a desarrollar yo y bueno pues no

190
00:21:43,869 --> 00:21:50,769
me importa que modificar la edad de forma directa desde otras clases diferentes pero sólo desde mi

191
00:21:50,769 --> 00:21:54,809
paquete porque este otro paquete sí que lo está desarrollando otra gente y no tengo la certeza de

192
00:21:54,809 --> 00:22:00,230
que vaya a tener esa precaución de no darle una edad menor de 0 ni mayor de 200 pues podría

193
00:22:00,230 --> 00:22:05,690
utilizar tendría que utilizar una etiqueta diferente de privada que me dé acceso en todo

194
00:22:05,690 --> 00:22:11,230
el paquete por ejemplo no ponerla que me da acceso a todo el paquete pero con la package me da acceso

195
00:22:11,230 --> 00:22:18,150
dentro de todo el paquete pero no en otros paquetes que pudiera tener el proyecto privada que está

196
00:22:18,150 --> 00:22:23,630
privado que está pensado para el acceso desde solamente esta clase ya incluso desde una clase

197
00:22:23,630 --> 00:22:33,440
diferente pero incluso dentro del mismo paquete ya no me lo permite ya no compila y vamos a hacer

198
00:22:33,440 --> 00:22:42,299
esta misma jugada pero nos vamos a venir a la clase del paquete 2 a ver privada lógicamente no

199
00:22:42,299 --> 00:22:46,740
me va a dejar porque ya está encerrado simplemente a esta clase pero todavía va a tener alguna

200
00:22:46,740 --> 00:22:52,599
restricción más al paquete 2 al ya que la clase paquete 2 no pertenece a la misma clase que la

201
00:22:52,599 --> 00:22:58,980
clase 2 de que la clase 1 del paquete 1 donde tenemos definidas las variables entonces si nos

202
00:22:58,980 --> 00:23:21,920
venimos por aquí, si intentamos poner, fijaros, voy a definir un objeto de esta clase aquí, entonces me vengo por aquí y yo digo mi objeto 1, vamos a poner aquí, igual a new y no me compila, ¿por qué no me compila?

203
00:23:21,920 --> 00:23:30,519
porque para que esta clase esté disponible dentro de este para que la clase 1 del paquete 1 esté

204
00:23:30,519 --> 00:23:35,519
disponible dentro de la clase 1 del paquete 2 es necesario importarla al no pertenecer al

205
00:23:35,519 --> 00:23:42,680
mismo paquete aquí no había sido necesaria necesario hacerlo porque ambas clases tanto

206
00:23:42,680 --> 00:23:48,740
ésta como ésta pertenecían al mismo paquete entonces no es necesario importarlo ya lo estamos

207
00:23:48,740 --> 00:23:55,619
indicando aquí que pertenece al paquete 1. En cambio, en este caso, como la clase 1 del paquete 2

208
00:23:55,619 --> 00:24:00,660
es una clase que está en un paquete diferente a la clase donde están las variables,

209
00:24:00,880 --> 00:24:04,059
si intento instanciar un objeto de ella, es necesario hacer un import.

210
00:24:04,599 --> 00:24:11,799
Algo parecido a lo que nos sucede cuando importamos para escáner algunas librerías de las que están en Eclipse.

211
00:24:13,380 --> 00:24:17,859
Eclipse nos ayuda un poquito aquí, nos dice importalo, vamos a ponerlo aquí directamente,

212
00:24:17,859 --> 00:24:34,220
Ella me dice importamos desde el paquete 1 la clase 1 y entonces ya está disponible dentro de esta clase que está en el paquete 2 y ya podemos instanciar un objeto.

213
00:24:34,220 --> 00:25:12,579
Entonces si ahora nos venimos y hacemos un copy y pega de esto, cambiamos el nombre, lo hemos llamado de forma diferente, fijaros que en una clase que se encuentra en otro paquete diferente, lo único que está disponible en principio es la variable que hemos definido como pública.

214
00:25:12,579 --> 00:25:21,039
Ni la protected, ni la package por defecto, ni la privada.

215
00:25:22,140 --> 00:25:23,140
Aquí ya no me deja.

216
00:25:28,720 --> 00:25:36,559
Si definimos una clase como, fijaros, el resto, en realidad,

217
00:25:37,339 --> 00:25:39,799
bueno, pues tienen que ver un poquito con, bueno,

218
00:25:39,880 --> 00:25:44,519
la package está muy identificada al propio paquete donde nos encontramos.

219
00:25:44,519 --> 00:26:02,059
La privada está directamente relacionada con la clase donde está definida. Las públicas están disponibles en cualquier sitio del proyecto, me da igual, donde esté, en un paquete, en otro, con unas condiciones o con otras.

220
00:26:02,059 --> 00:26:14,960
Y luego tenemos el tema de las subclases. Os cuento cómo va esto. Una de las características de la programación orientada a objetos es la herencia.

221
00:26:14,960 --> 00:26:25,200
mira si yo cojo y vamos a definir otra incluso aquí aunque esté en otro

222
00:26:25,200 --> 00:26:33,140
para que otro paquete diferente voy a comentar esto para que compile vamos a

223
00:26:33,140 --> 00:26:37,460
definir una clase que sea que herede de otra

224
00:26:37,460 --> 00:26:41,420
y ahora os cuento para qué sirve la herencia yo creo ya lo hemos hablado en

225
00:26:41,420 --> 00:26:48,599
algún momento vamos a definir aquí dentro del paquete 1 incluso una clase

226
00:26:48,599 --> 00:27:01,000
esta clase pertenece al paquete 2 y podrá tener sus parámetros y sus atributos propios cuando

227
00:27:01,000 --> 00:27:04,940
cuando estamos definiendo la característica de herencia lo veremos también en el siguiente tema

228
00:27:04,940 --> 00:27:11,720
y damos otra vuelta justo a este concepto lo que hacemos es que una determinada clase coge

229
00:27:11,720 --> 00:27:19,720
características de otra que digamos tiene un rango más más cerrado imaginaos que tenemos en un pro en

230
00:27:19,720 --> 00:27:26,180
un programa la clase alumno y la clase profesor. Tanto los alumnos como los profesores, si definimos

231
00:27:26,180 --> 00:27:31,380
dos clases por separado, porque es lo que nos está demandando el ejercicio, ambos dos tendrán

232
00:27:31,380 --> 00:27:38,200
un nombre y ambos dos tendrán una edad. En cambio, el alumno tendrá un número de matrícula y el

233
00:27:38,200 --> 00:27:44,380
profesor tendrá un número de taquilla, si los profesores tienen taquilla. Los alumnos no tienen

234
00:27:44,380 --> 00:27:50,880
taquilla los profesores no tienen número de matrícula. Cuando estamos definiendo cada una

235
00:27:50,880 --> 00:27:58,319
de esas dos clases, si esto fuese la clase alumno, pues pondríamos aquí private o como sea,

236
00:27:58,319 --> 00:28:09,319
con el ámbito que nos interese, int, string, ese nombre, si lo hacemos private estaría solamente

237
00:28:09,319 --> 00:28:19,680
accesible desde la propia clase, estas variables, int y edad, y por ejemplo tendríamos private, int y num matrícula.

238
00:28:23,119 --> 00:28:29,319
Si esta es la clase alumno, pues tendríamos estos tres parámetros. En la clase profesor, que tendríamos en otro

239
00:28:29,319 --> 00:28:37,359
ficherito, probablemente estos dos nombres volverían a existir y este no existiría, en cambio existiría el del

240
00:28:37,359 --> 00:28:43,019
número de taquilla en lugar de número de más. ¿Qué sucede? Que estos dos son comunes.

241
00:28:43,319 --> 00:28:46,960
Una forma de implementar esto, lo que podríamos hacer es definir

242
00:28:46,960 --> 00:28:51,140
una clase que sea persona y todas las

243
00:28:51,140 --> 00:28:55,000
personas, tanto si finalmente termina siendo un alumno o termina siendo

244
00:28:55,000 --> 00:28:58,900
un profesor, tendrán un nombre y una edad. Con lo cual estos dos parámetros los

245
00:28:58,900 --> 00:29:02,640
podríamos poner atributos, los podríamos poner en la clase

246
00:29:02,640 --> 00:29:06,880
persona. Este no lo podríamos poner en la clase persona porque solamente lo tendrían

247
00:29:06,880 --> 00:29:12,960
aquellas personas que terminen siendo alumnos. De la misma forma que el número de taquilla no

248
00:29:12,960 --> 00:29:16,200
podríamos poner en la clase persona porque solamente lo terminarían teniendo aquellos

249
00:29:16,200 --> 00:29:22,200
que sean profesores, pero estos dos sí que lo tienen disponibles. Entonces estos dos los

250
00:29:22,200 --> 00:29:29,119
podríamos derivar a la clase persona y cuando estamos definiendo la clase alumno, aquí lo he

251
00:29:29,119 --> 00:29:35,059
llamado clase herencia, lo que podríamos hacer es definir en esta misma clase única y exclusivamente

252
00:29:35,059 --> 00:29:55,920
el número de matrícula y aquí decir que hereda Stance, en la etiqueta que se utiliza en Java para hablar de la herencia, Stance de la clase, en aquí pondríamos de la clase persona, que la tendríamos definida con los atributos de nombre y edad.

253
00:29:55,920 --> 00:29:59,680
en particular como la clase personal no existe en este proyecto

254
00:29:59,680 --> 00:30:02,079
pues podríamos decir que hereda de la clase

255
00:30:02,079 --> 00:30:09,640
clase 1, ¿por qué no le gusta esto?

256
00:30:09,759 --> 00:30:12,700
pues porque no reconoce esta clase

257
00:30:12,700 --> 00:30:15,220
fijaros que la clase herencia la hemos definido en el paquete 2

258
00:30:15,220 --> 00:30:18,099
nos vuelve a pasar lo mismo que aquí, necesitamos importarla

259
00:30:18,099 --> 00:30:23,819
para que la reconozca, entonces

260
00:30:23,819 --> 00:30:26,980
en el ejemplo este ahora vemos a nivel

261
00:30:26,980 --> 00:30:30,200
práctico con el desarrollo que estamos haciendo

262
00:30:30,200 --> 00:30:32,559
la clase herencia tendría este atributo

263
00:30:32,559 --> 00:30:44,579
el número de matrícula y la clase alumno, por heredar de la clase persona, en el ejemplo que estábamos hablando, también tendría el nombre y tendría la edad.

264
00:30:44,960 --> 00:30:59,269
En particular, ¿qué atributos tiene aparte de esta clase herencia al heredar de clase 1P1? Pues tiene estos. Esos cuatro los tiene heredados.

265
00:30:59,470 --> 00:31:08,200
Ahora, ¿va a poder acceder a todos ellos según la etiqueta que tengamos aquí? Pues vamos a comprobar. ¿Se entiende un poco el concepto de herencia?

266
00:31:08,380 --> 00:31:15,119
En el tema siguiente creo que es, volvemos a hablar de él, si no ahora después lo repasamos un poquito más.

267
00:31:16,559 --> 00:31:39,829
Entonces si nos venimos y hacemos copy-paste de un método de este tipo, ahora necesitamos instanciar un objeto porque realmente él tiene ya estos parámetros heredados.

268
00:31:46,380 --> 00:31:55,480
Fijaros cómo nos cambia el ámbito de acceso respecto a la clase 1-2.

269
00:31:55,480 --> 00:32:13,920
De partida, la clase 1, P2 y la clase herencia, ambos dos están definidos en el paquete 2 y estamos intentando acceder a atributos, estos cuatro, que están definidos en una clase del paquete 1.

270
00:32:14,920 --> 00:32:28,380
En una clase normal del paquete 2, la única etiqueta que permite que estén accesibles sus atributos son las públicas, ¿veis? Ni la protectiz, ni la paques, ni la privada.

271
00:32:28,380 --> 00:32:32,539
están accesibles. En cambio, si resulta

272
00:32:32,539 --> 00:32:36,359
que la clase es hija de la clase

273
00:32:36,359 --> 00:32:39,980
de la cual va a utilizar los atributos, están disponibles

274
00:32:39,980 --> 00:32:43,660
tanto los públicos como los protective. Ahí es la diferencia entre

275
00:32:43,660 --> 00:32:48,059
si es una clase hija de donde está definido el parámetro

276
00:32:48,059 --> 00:32:52,619
o una clase donde no está definido el parámetro, la protective.

277
00:32:56,880 --> 00:32:59,700
Y no sé si con esto tenemos ya toda la casuística de las etiquetas.

278
00:32:59,700 --> 00:33:21,759
Mira, si hacemos una tabla más o menos, podríamos decir public, protected, no especificado, que sería el package, o friendly, y la private, que vienen a ser estas cuatro que tenemos definidas en el ejercicio.

279
00:33:22,980 --> 00:33:33,380
Las publicas, ¿dónde están accesibles? Están accesibles desde cualquier clase en todo el proyecto.

280
00:33:37,029 --> 00:33:44,190
Las packets, yo creo que estas dos son como más entendibles,

281
00:33:44,349 --> 00:33:48,190
porque si es packets o no he dicho nada, pues está claro que es desde el paquete.

282
00:33:48,190 --> 00:33:53,930
Entonces estas están accesibles desde su mismo paquete.

283
00:33:56,309 --> 00:34:10,329
Fijaros cómo aquí la packets no está, esta clase pertenece a un paquete diferente

284
00:34:10,329 --> 00:34:14,809
donde están definidas, en la clase herencia la packets tampoco está,

285
00:34:14,809 --> 00:34:19,329
en la clase 1 que es la misma clase, la clase Package está

286
00:34:19,329 --> 00:34:26,309
y en la clase 2, perdón, clase 2 del paquete 1

287
00:34:26,309 --> 00:34:30,449
la Package está disponible porque pertenece al mismo paquete donde está definida

288
00:34:30,449 --> 00:34:33,989
y en su misma clase también lo está. La pública

289
00:34:33,989 --> 00:34:36,289
que es esta otra que hemos indicado aquí

290
00:34:36,289 --> 00:34:42,329
que está accesible desde cualquier sitio

291
00:34:42,329 --> 00:34:46,349
vamos a verificarlo, accesible desde la misma clase

292
00:34:46,349 --> 00:34:54,849
donde está definida, accesible desde otra clase en el mismo paquete, aquí lo tenéis, en otro paquete

293
00:34:54,849 --> 00:35:07,179
también está accesible, da igual que sea una clase que hereda o que no hereda. La protective lo que

294
00:35:07,179 --> 00:35:29,929
tiene es que está disponible en el propio paquete y también está disponible si es una clase hija de

295
00:35:29,929 --> 00:35:39,460
donde está definida. Mirad, la clase herencia acepta la protective. ¿Por qué la clase herencia

296
00:35:39,460 --> 00:35:45,820
si le vale el acceso a la variable de tipo protective? Porque la clase herencia es hija

297
00:35:45,820 --> 00:35:53,219
de la clase donde está definida esa variable. En cambio, si nos vamos aquí a clase 1 del paquete 2,

298
00:35:53,880 --> 00:35:59,719
está en un paquete diferente, pero fijaros como no es hija, no tiene el extens, la protective

299
00:35:59,719 --> 00:36:09,179
tampoco está disponible. Y luego la tercera etiqueta que nos queda es la privada, que esta me da igual herencia,

300
00:36:09,360 --> 00:36:22,829
me da igual cualquier cosa, está solo accesible en la propia clase, la privada. Y si nos venimos por aquí,

301
00:36:23,650 --> 00:36:28,369
fijaros como aquí la privada está accesible, que es justo la clase donde está definida, privada,

302
00:36:28,369 --> 00:36:33,610
pero ya no vayamos donde no vayamos, incluso teniendo en consideración

303
00:36:33,610 --> 00:36:37,409
que puede ser una clase del mismo paquete, la privada ya no compila

304
00:36:37,409 --> 00:36:40,170
aquí la privada no compila

305
00:36:40,170 --> 00:36:45,610
y aquí la privada, a pesar de que es una clase

306
00:36:45,610 --> 00:36:49,130
hija de esta otra, sigue sin compilar

307
00:36:49,130 --> 00:36:54,099
y estas etiquetas que definimos como público-privada

308
00:36:54,099 --> 00:36:58,420
sin etiqueta, o sea, público-protegida sin etiqueta

309
00:36:58,420 --> 00:37:05,440
para que sea package o friendly o private estas más etiquetas son aplicables a los métodos los

310
00:37:05,440 --> 00:37:10,780
métodos están accesibles en el mismo ámbito que los que los para que los atributos según

311
00:37:10,780 --> 00:37:27,559
la etiqueta está que pongamos en unas y otras clases si se entiende más o menos seguís por

312
00:37:27,559 --> 00:37:37,900
ahí verdad vale vale pues bien una vez visto que bueno que esto nos permite gestionar hasta

313
00:37:37,900 --> 00:37:45,840
donde queremos que estén accesibles nuestras variables, puede resultar que el hecho de que no estén accesibles

314
00:37:45,840 --> 00:37:52,760
no sea porque no queramos que se modifique esta variable, sino que puede ser porque queremos tener un control

315
00:37:52,760 --> 00:37:56,519
sobre cómo se modifican estas variables, lo que os hablaba antes de la edad.

316
00:37:57,079 --> 00:38:02,309
Vamos a poner aquí un private, int y edad.

317
00:38:03,369 --> 00:38:09,309
Resulta que la edad, si esto fuese la clase persona, igual tenía que haber utilizado otros nombres desde el principio,

318
00:38:09,309 --> 00:38:17,070
que fuesen estos pero bueno tampoco importa mucho la edad quiero que vaya entre 0 y 200 años yo lo

319
00:38:17,070 --> 00:38:21,929
pongo privado porque yo está esta clase la estoy programando yo y yo voy aquí voy a tener mucha

320
00:38:21,929 --> 00:38:29,130
precaución de que esta variable nunca tenga un valor diferente de entre 0 y 200 si os resulta

321
00:38:29,130 --> 00:38:38,369
que yo esto lo dejo como público cuando lo estoy definiendo yo puedo decir esta variable tiene que

322
00:38:38,369 --> 00:38:48,059
entre 0 y 200 pero el momento que yo he hecho esto público igual en esta zona de código que

323
00:38:48,059 --> 00:39:01,570
no estoy con la que yo no estoy trabajando pues alguien me coge y me dice y 1.1 edad es igual a

324
00:39:01,570 --> 00:39:08,570
300 y ya la mucha fao y tú tienes control si es otro grupo de trabajo el que está haciendo esto

325
00:39:08,570 --> 00:39:25,670
Pues no. ¿Estás saltándote el requisito de que esta edad iba entre 0 y 200? Pues sí. Si yo cojo aquí y esto lo pongo como privado, como os decía, yo ahora me vengo aquí y ya no me permite hacer este cambio.

326
00:39:26,849 --> 00:39:33,650
Directamente yo tengo un control, ya que toda modificación sobre ese atributo y edad se tiene que hacer por ser privado dentro de mi clase.

327
00:39:33,650 --> 00:39:59,690
Sí, bueno, si me fío un poco más, porque a lo mejor está, imaginaos que el trabajo lo estamos haciendo entre dos empresas y digo el paquete uno me lo han contratado a mí y el paquete dos lo han contratado a otra empresa y digo, mira, seguramente sean unos créditos de la otra empresa, pero yo me fío de los de mi empresa y todo este desarrollo lo estamos haciendo diferentes personas, pero me fío que van a tener cuidado, pues entonces podría coger y definir aquí esto en lugar de private, definirlo como package.

328
00:39:59,690 --> 00:40:04,829
desde mi paquete está accesible, pero desde este otro paquete que está en otra

329
00:40:04,829 --> 00:40:09,150
empresa desarrollándolo, pues no lo está. Esto quiere decir

330
00:40:09,150 --> 00:40:12,829
que si yo le defino esto como privado, este

331
00:40:12,829 --> 00:40:16,989
atributo ya solamente es útil dentro de esta clase

332
00:40:16,989 --> 00:40:20,989
y nunca nadie va a poder modificar la edad de esta

333
00:40:20,989 --> 00:40:24,730
clase que estamos haciendo el supuesto que podría ser la clase persona, pues no,

334
00:40:24,849 --> 00:40:28,130
porque la edad en realidad se puede modificar desde cualquier sitio del proyecto.

335
00:40:28,130 --> 00:40:42,429
Pero para tener este control, lo pongo privado y ahora lo que hago yo es crearme unos métodos de acceso al atributo. ¿Y qué métodos de acceso son? Pues los que se llaman getters y setters, que también los hemos hablado ya en algún momento.

336
00:40:42,429 --> 00:40:57,769
Entonces, para este atributo, por ejemplo, yo cojo y me hago, voy a utilizar la ayuda del IDE, digo, génerame los getters y los setters. Pues, ¿para quién? Me ofrece por aquí diferentes, pues, digo, para la edad. Get y edad, lo digo, géneramelos.

337
00:40:57,769 --> 00:41:20,750
Y estos me los define como públicos. Es decir, a estos métodos sí que puedo acceder yo desde cualquier sitio. ¿Por qué? Porque tienen etiqueta pública. Fijaros como si yo me vengo aquí, digo mi oj1.set y edad.

338
00:41:20,750 --> 00:41:35,150
¿Veis? Este sí me compila. ¿Por qué me compila el acceso a ese método? Pues porque lo he definido público. ¿Esta clase está en un paquete distinto? Sí. Lo público, habíamos dicho que estaba accesible desde cualquier sitio en todo el proyecto.

339
00:41:35,150 --> 00:41:37,849
entonces yo aquí puedo coger y puedo modificar la edad

340
00:41:37,849 --> 00:41:39,650
es cierto que yo puedo poner aquí un 300

341
00:41:39,650 --> 00:41:43,510
que vendría a ser el equivalente de poner este 300 aquí

342
00:41:43,510 --> 00:41:44,309
que no es válido

343
00:41:44,309 --> 00:41:47,250
pero yo ahora aquí tengo

344
00:41:47,250 --> 00:41:51,829
y este setter que me ha generado

345
00:41:51,829 --> 00:41:53,409
de forma pragmática de Clisse

346
00:41:53,409 --> 00:41:55,329
lo que hace es esta variable

347
00:41:55,329 --> 00:41:57,849
que recibe como parámetro el método

348
00:41:57,849 --> 00:42:00,750
se lo asigna a la misma variable

349
00:42:00,750 --> 00:42:02,570
que tiene como atributo

350
00:42:02,570 --> 00:42:03,969
el yedad este

351
00:42:03,969 --> 00:42:26,869
Con lo cual, en este caso, estaría aplicándole el 300. Pero ahora resulta que este método está dentro de la clase que estoy yo programando. Aunque aquí sí que tiene la posibilidad abierta de meter un valor que esté en el rango de los enteros, 300 o un millón incluso, o 10 millones de años, sí que es cierto que para que llegue a este atributo tengo que asignárselo yo aquí.

352
00:42:26,869 --> 00:42:31,570
¿qué podría hacer? pues en alguna ocasión ya lo hemos hecho, podríamos decir

353
00:42:31,570 --> 00:42:35,789
sí, el valor, fijaros, aquí tengo yo el control para gestionar

354
00:42:35,789 --> 00:42:39,769
que ese atributo tenga la información que a mí me interesa, si es menor que 0

355
00:42:39,769 --> 00:42:43,190
pues lo que voy a hacer va a ser

356
00:42:43,190 --> 00:42:47,929
asignar un 0, si le paso

357
00:42:47,929 --> 00:42:51,309
una edad de menos 30 años, pues al final lo estoy fijando a 0

358
00:42:51,309 --> 00:42:55,369
el shift, así la edad

359
00:42:55,369 --> 00:42:59,849
aquí me fijo en el margen superior que habíamos dicho

360
00:42:59,849 --> 00:43:04,869
si es mayor que 200, pues le voy a decir que mira, que tenga la edad de 200

361
00:43:04,869 --> 00:43:10,809
y solamente en caso de que no sea ninguna de esas

362
00:43:10,809 --> 00:43:17,920
es decir, que esté entre 0 y 200, pues entonces digo dis y edad

363
00:43:17,920 --> 00:43:23,840
que sea igual a y edad. Aquí me ha asegurado

364
00:43:23,840 --> 00:43:25,860
con este setter que

365
00:43:25,860 --> 00:43:30,500
este atributo nunca va a tener un valor diferente

366
00:43:30,500 --> 00:43:37,760
que no es que esté fuera del rango de 0 y 200 este método lo tengo bajo mi control porque soy

367
00:43:37,760 --> 00:43:42,239
yo quien estoy haciendo la programación y ya garantizo que en todo el proyecto sí o sí si

368
00:43:42,239 --> 00:43:46,539
alguien quiere asignar una edad como lo tiene que hacer a través del setter no se puede saltar esa

369
00:43:46,539 --> 00:43:56,820
norma que teníamos definido el getter pues qué sentido te podría tener pues bueno lo que nos da

370
00:43:56,820 --> 00:44:02,880
la posibilidad el getter es de no acceder de forma directa a la edad porque bueno porque igual interesa

371
00:44:02,880 --> 00:44:05,119
hacer aquí una algoritmia antes

372
00:44:05,119 --> 00:44:06,599
de devolver esa edad.

373
00:44:06,860 --> 00:44:08,900
Que no interesa, pues pon un return y edad

374
00:44:08,900 --> 00:44:10,340
directamente y me devuelve la edad.

375
00:44:11,179 --> 00:44:12,840
Pero bueno, pensad, yo que sé,

376
00:44:12,920 --> 00:44:14,679
por poner un contexto, pensad que

377
00:44:14,679 --> 00:44:16,840
en mi empresa, como

378
00:44:16,840 --> 00:44:18,739
queremos ganar clientes y queremos parecer

379
00:44:18,739 --> 00:44:20,519
que somos todos muy jóvenes

380
00:44:20,519 --> 00:44:23,019
y la lucidez de la juventud la tenemos

381
00:44:23,019 --> 00:44:24,900
a tope, ¿no? Pues

382
00:44:24,900 --> 00:44:26,900
si de repente nos preguntan por la edad,

383
00:44:26,900 --> 00:44:29,019
pues podría resultar que, aunque seamos

384
00:44:29,019 --> 00:44:30,880
un poco mentirosillos, nos gusta decir que

385
00:44:30,880 --> 00:44:32,480
tenemos 5 años menos, ¿no?

386
00:44:32,880 --> 00:44:38,820
pues aquí podríamos tener asignada la edad de verdad y cuando me llame ya a la edad directamente

387
00:44:38,820 --> 00:44:43,960
no puedo acceder desde fuera de mi clase porque está privado lo tengo que hacer obligatoriamente

388
00:44:43,960 --> 00:44:48,760
a través de un getter pues aquí podría coger y decir que lo que devuelvo es la edad que tengo

389
00:44:48,760 --> 00:44:56,480
menos 5 entonces bueno pues al resto del mundo poco mentirosillos aquí pero bueno le estamos

390
00:44:56,480 --> 00:45:03,280
diciendo que la edad que tenemos es siempre menor de 5 para que no quede muy feo si tenemos dos años

391
00:45:03,280 --> 00:45:14,199
pues podríamos poner aquí que solamente que si vamos a poner aquí un int y edad aus y decir que

392
00:45:14,199 --> 00:45:36,780
si y edad es mayor de 5 entonces y edad aus que sea igual a y edad else y edad menor 5 perdón

393
00:45:37,360 --> 00:45:46,900
y si no que y edad aus sea igual a edad para evitar que me devuelva una edad menor que la

394
00:45:46,900 --> 00:45:52,420
que menos de cero vamos que entonces me pillarían con la mentira que estoy intentando lanzar o sea

395
00:45:52,420 --> 00:45:57,699
que aquí en el get era antes de hacer el return me da la posibilidad de implementar una cierta

396
00:45:57,699 --> 00:46:03,699
algoritmia que tenga yo pensada pensado antes de devolver el valor que tenga esa variable

397
00:46:03,699 --> 00:46:06,860
entonces estos son los getter y los setter

398
00:46:06,860 --> 00:46:10,159
¿tienen sentido los getter y los setter para

399
00:46:10,159 --> 00:46:13,239
las variables privadas? pues bueno lo tienen

400
00:46:13,239 --> 00:46:14,940
en el caso en el que

401
00:46:14,940 --> 00:46:19,119
queramos que se pueda modificar este valor fuera de mi clase

402
00:46:19,119 --> 00:46:22,280
porque al haberla definido como privada no sería posible

403
00:46:22,280 --> 00:46:25,239
¿tiene sentido un getter y un setter en el caso

404
00:46:25,239 --> 00:46:28,159
de que sea por defecto

405
00:46:28,159 --> 00:46:31,099
package of friendly? pues bueno también tiene

406
00:46:31,099 --> 00:46:34,360
sentido, porque yo si es package

407
00:46:34,360 --> 00:46:37,219
de todo el código que haya por aquí, por ejemplo

408
00:46:37,219 --> 00:46:40,480
mi equipo de trabajo, pues me fío de que directamente modifiquen

409
00:46:40,480 --> 00:46:43,500
este atributo asignándole un valor

410
00:46:43,500 --> 00:46:46,599
pero como no me fío de que lo puedan hacer correctamente

411
00:46:46,599 --> 00:46:48,980
desde otros equipos de trabajo, desde otros paquetes

412
00:46:48,980 --> 00:46:52,440
pues entonces dejo el ámbito como

413
00:46:52,440 --> 00:46:55,559
friendly package. Pero quiero

414
00:46:55,559 --> 00:46:58,380
que en estos otros sitios se puedan modificar, pues sí, pues entonces

415
00:46:58,380 --> 00:47:05,159
para que estos de estos otros paquetes sean capaces de modificar mi edad, pues hago un getter y un setter.

416
00:47:10,599 --> 00:47:15,380
Bueno, pues esto sería el getter y el setter. También lo habíamos hablado en algún momento.

417
00:47:15,940 --> 00:47:21,960
No sé si tenéis alguna duda que queréis consultarme del getter y el setter.

418
00:47:24,869 --> 00:47:27,690
Si no, pues bueno, os cuento, os sigo contando más cosas.

419
00:47:29,030 --> 00:47:33,550
Otra de las etiquetas que hemos utilizado ya en algún momento es la etiqueta final.

420
00:47:33,550 --> 00:47:37,550
la etiqueta final

421
00:47:37,550 --> 00:47:42,510
se puede utilizar en diferentes ámbitos

422
00:47:42,510 --> 00:47:45,730
y esta etiqueta sí que tiene diferentes significados

423
00:47:45,730 --> 00:47:47,849
dependiendo de donde la vayamos a utilizar

424
00:47:47,849 --> 00:47:54,829
el sitio donde lo hemos utilizado

425
00:47:54,829 --> 00:47:57,010
inicialmente ha sido

426
00:47:57,010 --> 00:48:00,750
para atributos de clase

427
00:48:00,750 --> 00:48:02,150
entonces si yo pongo aquí int

428
00:48:02,150 --> 00:48:09,820
y IVA, digo que el IVA sea igual al 12%

429
00:48:09,820 --> 00:48:16,239
por ejemplo, para el sector en el que yo trabajo, aquí estoy definiendo

430
00:48:16,239 --> 00:48:19,219
una variable, en particular lo estoy definiendo

431
00:48:19,219 --> 00:48:24,079
con ámbito package, indiferente, solamente mencionarlo

432
00:48:24,079 --> 00:48:27,860
como hemos estado antes hablando de ello, vamos a ponerlo por ejemplo privado

433
00:48:27,860 --> 00:48:31,800
con lo cual solo estaría accesible desde mi propia clase, desde cualquier método

434
00:48:31,800 --> 00:48:35,900
de mi propia clase, y por ser una variable yo podría poner aquí

435
00:48:35,900 --> 00:48:59,260
Y iba, si me interesa, que es una variable, pues que de 12 pase a valer 5. Y esto compila y va perfectamente. Si le añado la etiqueta final, lo que estoy haciendo es convertir esto que ha estado en una variable de tipo entero y de ámbito de alcance privado, lo estoy convirtiendo en una constante.

436
00:48:59,260 --> 00:49:13,000
Entonces, como ahora es una constante, lo que estoy fijando es el valor 12 y ya es inamovible de este valor 12 en todo el proyecto. Con lo cual, fijaros, como ahora ya no me compila. Es decir, convertimos una variable en una constante.

437
00:49:13,000 --> 00:49:32,679
Lo que sí que es cierto es que las constantes suelen aparecer en el código con todo mayúsculas. Bueno, suelen. Digamos que es un convenio ahí de acuerdo de, vamos a poner las constantes con mayúsculas para que si vemos una palabra IVA aplicado, por ejemplo.

438
00:49:32,679 --> 00:49:39,039
pues ahí va aplicado a aparecer así esto que no lo que nos permite pues que si de repente aparece

439
00:49:39,039 --> 00:49:44,860
un iva aplicado por ahí en alguna parte del código vemos que todo es mayúsculas nos hace ya ir

440
00:49:44,860 --> 00:49:51,420
teniendo una idea de que se trata de una constante a cambiarle el valor como es una constante no lo

441
00:49:51,420 --> 00:49:59,440
permite pero si utilizarlo por ejemplo podríamos utilizarlo para sacar su valor para lectura no

442
00:49:59,440 --> 00:50:05,440
para modificación pero sí para lectura lectura y escribirlo por pantalla aquí sí que me compré

443
00:50:05,440 --> 00:50:10,449
le iba bien. ¿Sí? ¿Sí?

444
00:50:10,869 --> 00:50:11,409
¿No me oís?

445
00:50:12,929 --> 00:50:14,510
Buenas tardes. Ah,

446
00:50:14,610 --> 00:50:16,630
vale, bien, bien. No, como decías se escucha,

447
00:50:16,690 --> 00:50:18,630
pensaba que me decías que no se me escuchaba. Sí, se me

448
00:50:18,630 --> 00:50:20,469
escucha bien, ¿no? Ah, sí, dime,

449
00:50:20,590 --> 00:50:35,139
dime. ¿Los atributos?

450
00:50:36,320 --> 00:50:36,599
Sí.

451
00:50:48,380 --> 00:50:49,239
Claro, sí.

452
00:50:50,340 --> 00:50:52,000
Sí, sí, sí, sí, perfectamente.

453
00:50:52,599 --> 00:50:53,440
Bueno, el

454
00:50:53,440 --> 00:50:56,659
hecho de definirlo como privado

455
00:50:56,659 --> 00:50:58,239
permite que solamente

456
00:50:58,239 --> 00:51:00,219
lo puedas acceder desde tu clase, correcto,

457
00:51:00,219 --> 00:51:02,139
como bien decías. Pero a lo mejor

458
00:51:02,139 --> 00:51:08,320
funcionalmente sí que quieres cambiar ese valor tú, como la edad que hablábamos antes, desde otras partes

459
00:51:08,320 --> 00:51:16,420
del código. Lo que no quieres es que mediante código lo puedan cambiar. A ver, funcionalmente queremos

460
00:51:16,420 --> 00:51:22,860
que exista la posibilidad de cambiar la edad, que una persona tenga una determinada edad y se le aplique

461
00:51:22,860 --> 00:51:28,579
desde este código, pero que no se pueda acceder directamente a la variable Java que está definida

462
00:51:28,579 --> 00:51:32,559
como privada. Y para eso es para lo que hacemos, utilizamos los getter

463
00:51:32,559 --> 00:51:36,420
y los setters. Como lo hemos definido de forma privada, digamos

464
00:51:36,420 --> 00:51:40,539
que técnicamente no está accesible desde aquí, desde este

465
00:51:40,539 --> 00:51:44,400
código, pero funcionalmente conseguimos poder modificar

466
00:51:44,400 --> 00:51:48,360
este valor a través del setter. Y en el setter, como

467
00:51:48,360 --> 00:51:52,300
metemos, podríamos decir, pues si quieres

468
00:51:52,300 --> 00:51:56,139
que esté accesible su modificación desde esta clase, pues directamente

469
00:51:56,139 --> 00:51:58,340
ponla pública, ¿no? Podría ser

470
00:51:58,340 --> 00:52:00,420
la pregunta que nos planteásemos.

471
00:52:01,840 --> 00:52:02,079
Claro,

472
00:52:07,309 --> 00:52:08,550
claro, es que en realidad

473
00:52:08,550 --> 00:52:10,670
funcionalmente sí que quiero modificarla

474
00:52:10,670 --> 00:52:12,670
desde otro sitio, pero quiero

475
00:52:12,670 --> 00:52:14,949
acceder a ella teniendo

476
00:52:14,949 --> 00:52:16,630
yo el control de cómo se modifica.

477
00:52:16,969 --> 00:52:18,469
Como en este ejemplo hemos puesto

478
00:52:18,469 --> 00:52:20,510
que la edad vaya entre

479
00:52:20,510 --> 00:52:22,610
0 y 200 años, si yo esto

480
00:52:22,610 --> 00:52:23,469
lo pongo público,

481
00:52:24,849 --> 00:52:26,630
desde aquí yo podría poner

482
00:52:26,630 --> 00:52:30,219
y edad y decir

483
00:52:30,219 --> 00:52:31,760
que tenga un millón de años.

484
00:52:32,219 --> 00:52:38,800
¿Por qué? Porque la única condición que me haría que esto no compilase sería el rango de valores que tiene un entero.

485
00:52:39,699 --> 00:52:44,320
Entonces, podría ser que esta zona de código no la estuviera desarrollando yo, por ejemplo.

486
00:52:45,320 --> 00:52:50,679
Entonces, alguien que está desarrollando esta zona de código podría poner este valor a la edad,

487
00:52:51,059 --> 00:52:56,880
sabiendo que estamos incumpliendo un requisito de las edades que pueden tener las personas que participan en este programa,

488
00:52:56,880 --> 00:52:58,679
que es que vaya entre 0 y 200.

489
00:52:59,480 --> 00:53:04,480
¿Cómo evito yo que una persona ajena al código que estoy desarrollando yo

490
00:53:04,480 --> 00:53:07,519
nunca pueda meter un valor entre 0 y 200?

491
00:53:07,699 --> 00:53:10,320
Pues le digo, mira, aunque la edad funcionalmente

492
00:53:10,320 --> 00:53:12,719
voy a permitirte que la modifiques entre 0 y 200,

493
00:53:13,340 --> 00:53:17,320
no te voy a dar acceso directo a esta variable de tipo entero.

494
00:53:17,559 --> 00:53:19,239
Y eso lo hago poniéndolo esto como privado.

495
00:53:21,449 --> 00:53:23,650
Y sí que te permito modificar este parámetro,

496
00:53:23,650 --> 00:53:27,590
pero te obligo a que lo hagas a través de la llamada un método.

497
00:53:27,590 --> 00:53:32,170
este método lo defino público que sí que está alcanzable

498
00:53:32,170 --> 00:53:36,989
es alcanzable desde aquí y ya pongas lo que pongas

499
00:53:36,989 --> 00:53:40,769
como yo aquí pongo cierto código que me controla que el valor

500
00:53:40,769 --> 00:53:44,489
no sea nunca mayor de 0 y 200 garantizo que esta variable

501
00:53:44,489 --> 00:53:47,489
accesible desde todo el programa a través de

502
00:53:47,489 --> 00:53:52,829
funcionalmente accesible a través del set y edad tenga este

503
00:53:52,829 --> 00:53:56,710
rango y garantizo que esta variable directamente nadie

504
00:53:56,710 --> 00:54:04,530
me la va a modificar a no ser que sea a través de este método del setter bueno si podría podríamos

505
00:54:04,530 --> 00:54:20,030
llamarlo un encriptado sí o sea digamos que sí sí sí mira mira ya verás mira tú imagínate que

506
00:54:20,030 --> 00:54:29,289
a una persona yo cojo y le digo quiero aplicarle la edad de 50 por digo y edad si pongo y edad

507
00:54:29,289 --> 00:54:41,679
igual a 50 no me compila porque porque la tengo definida como privada esto me asegura que no soy

508
00:54:41,679 --> 00:54:46,159
capaz de poner un millón porque como no puedo hacer allá directamente mira si yo pongo aquí

509
00:54:46,159 --> 00:55:03,929
set y edad como se llama el setter bajamos un segundito aquí set y edad incluso una edad que

510
00:55:03,929 --> 00:55:07,849
no vale, voy a asignarle a esa persona 500 y luego aquí

511
00:55:07,849 --> 00:55:12,429
un system.out.println

512
00:55:12,429 --> 00:55:15,269
y aquí hago un get

513
00:55:15,269 --> 00:55:19,889
y edad, aquí cojo el valor que tiene la variable

514
00:55:19,889 --> 00:55:23,550
y la muestro a través de system.out.println y previamente

515
00:55:23,550 --> 00:55:27,690
he asignado una edad de 500, bueno esto tendría que estar

516
00:55:27,690 --> 00:55:30,690
en un main para que nos permita ejecutarlo

517
00:55:30,690 --> 00:55:38,130
public static voice main

518
00:55:38,130 --> 00:56:00,179
bueno, ahora ha dejado de compilarme

519
00:56:00,179 --> 00:56:02,079
porque estoy intentando acceder

520
00:56:02,079 --> 00:56:05,099
a través del main a una variable

521
00:56:05,099 --> 00:56:09,000
el main es static, estoy intentando acceder

522
00:56:09,000 --> 00:56:11,199
a métodos que no son static

523
00:56:11,199 --> 00:56:15,059
entonces aquí vamos a necesitar definir una variable

524
00:56:15,059 --> 00:56:21,579
de ese tipo, ahora retomamos tu pregunta

525
00:56:21,579 --> 00:56:22,440
si no

526
00:56:22,440 --> 00:56:51,820
si no te queda claro mira vamos a poner en lugar de a ver uno mira aquí estamos dando de alta ahora

527
00:56:51,820 --> 00:56:58,940
a ver si somos capaces de ejecutar el programa desde aquí estamos dando de alta bueno llamó

528
00:56:58,940 --> 00:57:04,480
clase 1 vamos a suponer que es una la clase persona vale una determinada persona hacemos

529
00:57:04,480 --> 00:57:13,400
su new y podemos coger y decir mira ahora mismo muéstrame a ver qué edad tiene esa persona aquí

530
00:57:13,400 --> 00:57:20,679
es previsible que salga a cero porque es un entero inicialmente su valor es cero mira vamos a poner

531
00:57:20,679 --> 00:57:29,150
aquí vamos a poner tres casos vamos a ponerle que tenga una edad de 20 aquí es previsible que salga

532
00:57:29,150 --> 00:57:38,960
20 y ahora intentamos asignar una edad de 500 y aquí es previsible ahora lo ejecutamos a ver si

533
00:57:38,960 --> 00:57:40,579
de verdad es así, que salga

534
00:57:40,579 --> 00:57:42,880
200, no

535
00:57:42,880 --> 00:57:44,840
500, ¿por qué no 500?

536
00:57:45,000 --> 00:57:45,519
Porque este

537
00:57:45,519 --> 00:57:48,400
set y edad

538
00:57:48,400 --> 00:57:50,340
lo hemos bloqueado aquí, ¿ves?

539
00:57:51,400 --> 00:57:52,820
Estamos modificando la edad

540
00:57:52,820 --> 00:57:54,960
en el fondo, pero gracias

541
00:57:54,960 --> 00:57:56,960
a no permitir que

542
00:57:56,960 --> 00:57:58,679
se acceda directamente a la edad

543
00:57:58,679 --> 00:58:00,920
por ser privada, estamos

544
00:58:00,920 --> 00:58:02,860
garantizando que a través de este setter

545
00:58:02,860 --> 00:58:04,760
nunca nos puedan meter que la persona

546
00:58:04,760 --> 00:58:05,980
tiene un millón de años,

547
00:58:06,579 --> 00:58:08,460
desde una zona de código que es

548
00:58:08,460 --> 00:58:13,139
que está en un paquete diferente a donde tengo ya definida la supuesta

549
00:58:13,139 --> 00:58:17,380
clase persona, que es donde tengo identificado el atributo

550
00:58:17,380 --> 00:58:20,960
y edad. Entonces, mira, si yo cojo

551
00:58:20,960 --> 00:58:24,719
a ver si soy capaz de ejecutarlo desde aquí, voy a darle

552
00:58:24,719 --> 00:58:34,900
a ejecutar por aquí, no sé si me... run as, por aquí

553
00:58:34,900 --> 00:58:41,409
java application, mira. Bueno, resulta que con el

554
00:58:41,409 --> 00:58:45,349
getter me estás mostrando, ¿os acordáis que habíamos dicho que pusiera 5 de menos?

555
00:58:45,349 --> 00:58:48,730
bueno, me está mostrando menos 5, esto habíamos intentado evitarlo, ahora si queréis

556
00:58:48,730 --> 00:58:52,929
reemplazamos el getter, aquí 10 y aquí 190

557
00:58:52,929 --> 00:58:56,710
¿por qué aquí tiene restado 10? porque en cada una de las veces con el getter estamos

558
00:58:56,710 --> 00:59:16,260
restándole 5, no, no, no estamos llamando al atributo, estamos llamando

559
00:59:16,260 --> 00:59:20,420
a estos métodos, al set y edad

560
00:59:20,420 --> 00:59:34,690
y al get y edad, no, bueno, si estás trabajando

561
00:59:34,690 --> 00:59:37,829
aquí, aquí estás asignando edades y modificándolas

562
00:59:37,829 --> 00:59:41,190
voy a quitar un momentito esto para que no nos confunda

563
00:59:41,190 --> 00:59:46,110
voy a decir que devuelva la edad exactamente

564
00:59:46,110 --> 00:59:51,260
pero tú funcionalmente sí que estás trabajando

565
00:59:51,260 --> 00:59:55,139
con la edad de la persona

566
00:59:55,139 --> 01:00:05,639
mira

567
01:00:05,639 --> 01:00:07,820
tú imagínate que tienes

568
01:00:07,820 --> 01:00:12,800
en esta zona de código tú quieres modificar la edad de una persona

569
01:00:12,800 --> 01:00:14,960
y quieres leer su edad

570
01:00:14,960 --> 01:00:17,840
¿estás modificándola aquí?

571
01:00:18,260 --> 01:00:20,940
¿con este set? ¿estás modificando la edad?

572
01:00:20,980 --> 01:00:52,780
Mira, si ejecutamos, claro, pues entonces sí que puedes, funcionalmente sí puedes modificar la edad de la persona. Lo que no puede, no, porque es privada, pero el servicio de dar edades y de recuperarlas, funcionalmente lo tienes.

573
01:00:52,780 --> 01:01:04,260
¿Por qué? Porque puedes dar edades a través de set y edad y puedes leerlas a través de get y edad. Entonces, funcionalmente sí que tienes ahí un acceso a una variable entero que está reflejando la edad de la persona.

574
01:01:04,260 --> 01:01:26,380
Lo que te estás garantizando es evitar, porque es uno de los requisitos que tiene tu programa, el hacer que la edad valga más de 200 o menos de cero, de forma inadecuada.

575
01:01:26,380 --> 01:01:57,969
Es decir, tú das un servicio, mira, bueno, no a mala leche, por equivocación, ¿sabes? A lo mejor, yo que sé, alguien nos ha leído los requisitos de que esa variable no pueda, mira, permíteme, sí, claro, por cerrar, mira, sí, por cerrar un poco te voy a hacer una analogía de estas con un ejemplo que a veces pongo, que a veces, pues a lo mejor pueden parecer un poco tontos,

576
01:01:58,269 --> 01:02:07,530
Imagínate que tú estás en una frutería y resulta que no tienen guantes de plástico para dejarnos a todos para coger las frutas.

577
01:02:07,889 --> 01:02:22,929
Tú quieres comprar una manzana y puede ser que te digan, mira, si llegas a la frutería yo no te dejo que toques la manzana. Para coger la manzana se la tienes que pedir al cajero, que él sí que tiene unos guantes, te coge la manzana y te la da.

578
01:02:23,690 --> 01:02:27,530
Pero está prohibido que tú cojas la manzana con tus manos.

579
01:02:28,489 --> 01:02:33,570
¿Cuando salgas de la frutería te vas a llevar una manzana a casa que es funcionalmente lo que quieres?

580
01:02:33,789 --> 01:02:34,070
Sí.

581
01:02:34,530 --> 01:02:39,449
¿Has bloqueado de alguna forma que todo el mundo llegue y toque la manzana con la mano?

582
01:02:39,949 --> 01:02:42,369
La ha bloqueado con esa norma.

583
01:02:42,769 --> 01:02:47,710
Pues es un poco esto, para evitar que la edad la toquemos con la mano como la manzana,

584
01:02:47,710 --> 01:02:51,030
es decir, que asignemos un valor que sea menor o mayor de 200,

585
01:02:51,030 --> 01:02:53,969
asegurarnos que quien toca la manzana

586
01:02:53,969 --> 01:02:56,630
tiene puestos los guantes, es decir, lleva la edad

587
01:02:56,630 --> 01:02:59,989
un valor entre 0 y 200, no te permito

588
01:02:59,989 --> 01:03:02,989
que toques directamente la manzana, no te permito que modifiques

589
01:03:02,989 --> 01:03:06,090
directamente la edad, para hacerlo tienes que

590
01:03:06,090 --> 01:03:08,929
pero vas a poder llevarte una manzana a casa, sí

591
01:03:08,929 --> 01:03:12,050
vas a poder consultar la edad, sí, vas a poder actualizarla

592
01:03:12,050 --> 01:03:15,269
sí, pero tendrás que hacerlo a través de los setters y los getters

593
01:03:15,269 --> 01:03:17,969
que es pedirle al dependiente

594
01:03:17,969 --> 01:03:20,750
oye, cógeme tú la manzana que eres el único que tiene los guantes

595
01:03:20,750 --> 01:03:23,909
es un poco la idea

596
01:03:23,909 --> 01:03:26,369
no sé si la equivalencia

597
01:03:26,369 --> 01:03:28,030
un poco aclara algo

598
01:03:28,030 --> 01:03:28,929
o hace que se entienda

599
01:03:28,929 --> 01:03:34,309
directamente no

600
01:03:34,309 --> 01:03:36,070
pero no puedes

601
01:03:36,070 --> 01:03:37,909
pero es tu decisión de diseño

602
01:03:37,909 --> 01:03:41,210
cuando estás implementando esta clase

603
01:03:41,210 --> 01:03:42,909
esta etiqueta la pones tú

604
01:03:42,909 --> 01:03:45,090
entonces si tú lo que quieres es

605
01:03:45,090 --> 01:03:47,230
que la manzana siempre se coja con guantes

606
01:03:47,230 --> 01:03:49,250
desde alguien que sea ajeno

607
01:03:49,250 --> 01:03:50,150
aquí a la clase

608
01:03:50,150 --> 01:03:53,550
es decir, que nadie pueda modificar el valor de la edad

609
01:03:53,550 --> 01:03:56,329
desde alguien que sea ajeno a la clase, pues le pones privado.

610
01:03:57,010 --> 01:04:01,289
Si te fías porque todos los que trabajan en tu tienda,

611
01:04:01,829 --> 01:04:04,150
que son los que pertenecen a tu propio paquete,

612
01:04:04,650 --> 01:04:08,369
se lavan las manos antes de pasar a trabajar y te fías de ellos,

613
01:04:08,769 --> 01:04:10,570
pues puedes definirlo esto como package,

614
01:04:10,710 --> 01:04:12,969
porque de todos los que trabajan en esta zona,

615
01:04:12,969 --> 01:04:15,530
yo me fío para que modifiquen directamente este valor,

616
01:04:16,110 --> 01:04:20,469
porque todos conocen que ese valor no puede ir más allá de 200

617
01:04:20,469 --> 01:04:21,409
ni menor de cero.

618
01:04:21,409 --> 01:04:23,949
y si no te fías de los de tu

619
01:04:23,949 --> 01:04:25,949
de los de tu tienda, porque dices

620
01:04:25,949 --> 01:04:27,949
es que algunos no se lavan las manos por la de fines

621
01:04:27,949 --> 01:04:29,489
privada para solamente hacerlo tú

622
01:04:29,489 --> 01:04:31,869
y si te fías de todo el mundo, dices, pues bueno

623
01:04:31,869 --> 01:04:33,610
es que no es una manzana total

624
01:04:33,610 --> 01:04:36,050
son unas tijeras

625
01:04:36,050 --> 01:04:38,150
pues ya está, que eso me da un poquito más igual

626
01:04:38,150 --> 01:04:40,090
pues entonces la de fines pública y todo el mundo

627
01:04:40,090 --> 01:04:42,230
llega y directamente compra las tijeras

628
01:04:42,230 --> 01:04:45,170
¿sí? vale

629
01:04:45,170 --> 01:04:46,750
bueno, pues esto era, sí

630
01:04:46,750 --> 01:04:49,349
vale, pues nada

631
01:04:49,349 --> 01:04:51,449
retomamos, continuamos con el

632
01:04:51,449 --> 01:04:59,050
tema de lo de final, final para los atributos lo convierte en una constante, como hemos hecho con,

633
01:05:00,190 --> 01:05:10,050
no me acuerdo en qué clase ha sido, por aquí, esta final. Cuando la etiqueta final está identificada

634
01:05:10,050 --> 01:05:17,829
en una clase, lo que no permite es que esa clase tenga hijos. Esto está relacionado de nuevo con

635
01:05:17,829 --> 01:05:23,949
la herencia. ¿Os acordáis aquí que hemos hablado un poquito de la herencia? La herencia, repasaremos

636
01:05:23,949 --> 01:05:30,670
esto y volveremos a hablar de ello en otra tutoría cuando cuando lo veamos formalmente pero bueno

637
01:05:30,670 --> 01:05:37,210
para explicar la etiqueta final es necesario relacionado con una clase fijaros hemos dicho

638
01:05:37,210 --> 01:05:47,250
que la clase herencia es hija de la clase 1p1 y el hecho de que sea hija implica que tiene

639
01:05:47,250 --> 01:05:55,590
disponibles los atributos que tiene esta clase y tiene disponibles los métodos que tiene esta clase

640
01:05:55,590 --> 01:06:01,110
también luego podrá acceder a ellos si no son privados cuidados y son privados por mucho que

641
01:06:01,110 --> 01:06:09,190
sea una clase hija no poder no tendría acceso a ellos pues mirad cuando una clase la ponen a una

642
01:06:09,190 --> 01:06:16,969
clase ponemos la etiqueta final este final lo que significa es que es una clase que ya no admite

643
01:06:16,969 --> 01:06:19,070
herencias, es decir, si tenemos un

644
01:06:19,070 --> 01:06:20,849
árbol de herencias, este fuese la clase

645
01:06:20,849 --> 01:06:23,170
persona, de la clase

646
01:06:23,170 --> 01:06:24,989
persona ya no sería posible

647
01:06:24,989 --> 01:06:26,670
hacer que hereden

648
01:06:26,670 --> 01:06:29,070
nuevos hijos. ¿Os acordáis? Antes decíamos

649
01:06:29,070 --> 01:06:30,570
esta es la clase alumno

650
01:06:30,570 --> 01:06:32,889
que hereda de la clase persona.

651
01:06:33,230 --> 01:06:34,969
La clase alumno tiene sus características

652
01:06:34,969 --> 01:06:36,690
y por herencia

653
01:06:36,690 --> 01:06:39,289
los atributos

654
01:06:39,289 --> 01:06:41,210
y métodos de la clase persona.

655
01:06:42,070 --> 01:06:43,070
Hay una posibilidad

656
01:06:43,070 --> 01:06:45,130
cuando tú estás implementando

657
01:06:45,130 --> 01:06:46,230
una clase, es decir,

658
01:06:46,969 --> 01:06:49,849
Este es el punto final en un posible árbol de herencias.

659
01:06:50,230 --> 01:06:53,389
Ya de esta clase no hay clase que herede.

660
01:06:53,670 --> 01:06:57,230
Imaginaos que está la clase persona y decimos, si alguien quiere implementar una clase alumno,

661
01:06:57,329 --> 01:07:02,670
que la implemente de forma completa y no apoyándose en lo que yo tengo definido como atributos y métodos.

662
01:07:03,670 --> 01:07:05,829
¿Cómo lo puedo bloquear en la clase persona?

663
01:07:06,409 --> 01:07:10,190
Para que la clase alumno no herede la clase persona,

664
01:07:10,650 --> 01:07:13,670
indicando la etiqueta final relacionada con una clase.

665
01:07:17,179 --> 01:07:18,820
Fijaros cómo ahora ya este no me compila.

666
01:07:19,239 --> 01:07:38,320
La supuesta clase alumno que heredaba la clase persona ahora ya no me compila. ¿Por qué? Porque en la clase supuesta clase persona, que es la clase 1P1, hemos puesto aquí la etiqueta final. Si quito aquí la etiqueta final de nuevo, si me vengo aquí, pues ya me deja.

667
01:07:38,320 --> 01:07:44,920
en atributos lo convierte una variable en una constante

668
01:07:44,920 --> 01:07:49,199
la etiqueta final relacionada con clases hace que

669
01:07:49,199 --> 01:07:54,000
sea posible ya la herencia, no tenga clases hijas

670
01:07:54,000 --> 01:07:57,619
y luego tenemos también

671
01:07:57,619 --> 01:08:01,519
la posibilidad de poner la etiqueta final en métodos

672
01:08:01,519 --> 01:08:04,159
que tiene nuevamente un significado diferente

673
01:08:04,159 --> 01:08:09,679
esta es la clase hija de esta clase

674
01:08:09,679 --> 01:08:13,099
¿verdad? de la supuesta clase persona

675
01:08:13,099 --> 01:08:15,619
entonces vamos a poner aquí, vamos a crear aquí un método

676
01:08:15,619 --> 01:08:16,760
public

677
01:08:16,760 --> 01:08:22,449
void

678
01:08:22,449 --> 01:08:29,359
saludar, vamos a llamarlo, mirad, este

679
01:08:29,359 --> 01:08:33,380
método, saco un system.out.println

680
01:08:33,380 --> 01:08:47,989
saludando desde la clase padre, fijaros

681
01:08:47,989 --> 01:08:51,369
la clase 1p1

682
01:08:51,369 --> 01:08:55,069
que sea clase persona, ya la podría haber llamado así desde el principio

683
01:08:55,069 --> 01:08:58,149
cuando instanciemos objetos de esta clase

684
01:08:58,149 --> 01:08:59,949
podríamos llamar al método saludar

685
01:08:59,949 --> 01:09:02,130
y nos diría saludando

686
01:09:02,130 --> 01:09:03,050
el de la clase padre

687
01:09:03,050 --> 01:09:05,729
la clase herencia

688
01:09:05,729 --> 01:09:09,680
tiene sus propios

689
01:09:09,680 --> 01:09:11,300
métodos, tiene el main, podría tener

690
01:09:11,300 --> 01:09:13,319
otros métodos más definidos por aquí

691
01:09:13,319 --> 01:09:15,199
tiene sus propios

692
01:09:15,199 --> 01:09:17,699
atributos y como

693
01:09:17,699 --> 01:09:19,720
clase hija

694
01:09:19,720 --> 01:09:21,880
de la clase persona

695
01:09:21,880 --> 01:09:23,199
de la clase 1P1

696
01:09:23,199 --> 01:09:25,760
tiene aquellos atributos definidos

697
01:09:25,760 --> 01:09:31,460
en la clase padre, los que no sean privados, y aquellos métodos

698
01:09:31,460 --> 01:09:35,300
definidos en la clase padre. Con lo cual, si yo pongo aquí

699
01:09:35,300 --> 01:09:40,640
en el main, por ejemplo, para el objeto de la clase

700
01:09:40,640 --> 01:09:49,079
P1, 1P1, voy a comentar esto

701
01:09:49,079 --> 01:09:52,760
y hacemos código por aquí, nuevo, arriba.

702
01:09:57,420 --> 01:10:00,979
Si yo cojo y digo, mira, quiero definir un objeto de la clase herencia.

703
01:10:11,220 --> 01:10:14,060
Este objeto de la clase herencia es

704
01:10:14,060 --> 01:10:18,479
tendrá, lógicamente acceso, tendrá sus atributos

705
01:10:18,479 --> 01:10:24,479
entonces mioj.inunmat

706
01:10:24,479 --> 01:10:32,090
está disponible, un atributo suyo, faltaría más

707
01:10:32,090 --> 01:10:35,649
tengo la posibilidad de acceder a mis propios

708
01:10:35,649 --> 01:10:39,289
métodos, vamos a poner aquí un public void

709
01:10:39,289 --> 01:10:45,449
salu, vamos a llamarlo de momento, luego lo

710
01:10:45,449 --> 01:11:05,909
renombraremos, ponemos aquí un system.out.println, saludo desde el hijo, pues podrá acceder a sus

711
01:11:05,909 --> 01:11:27,340
métodos, podríamos llamar meof.salud, voy a ponerlo bien, voy a ponerlo en minúsculas que los métodos

712
01:11:27,340 --> 01:11:36,319
tienen que empezar con minúsculas, hace a sus atributos y a sus métodos como es lógico, podemos

713
01:11:36,319 --> 01:11:37,659
poner mi

714
01:11:37,659 --> 01:11:42,319
oj.saludar

715
01:11:42,319 --> 01:11:44,199
Este saludar, ¿por qué lo tiene disponible?

716
01:11:44,699 --> 01:11:47,520
Si no lo he definido aquí, pues lo tiene disponible porque

717
01:11:47,520 --> 01:11:52,930
clase herencia es hija de clase 1p1

718
01:11:52,930 --> 01:11:56,130
y en clase 1p1 tenemos definido

719
01:11:56,130 --> 01:11:58,649
el método saludar. Por herencia lo ha recibido.

720
01:11:59,649 --> 01:12:02,170
Y luego, fijaros que aquí tenemos una serie de

721
01:12:02,170 --> 01:12:04,890
atributos también y entero

722
01:12:04,890 --> 01:12:07,270
que también están disponibles aquí por herencia.

723
01:12:08,010 --> 01:12:22,199
y off punto y entero es decir tiene acceso a atributos de la propia clase métodos de la

724
01:12:22,199 --> 01:12:30,039
propia clase atrib un método heredado de la clase padre un atributo heredado de la clase padre claro

725
01:12:30,039 --> 01:12:49,750
si yo ejecutó esto vamos a ver qué resultado nos da estamos en la clase herencia aquí este

726
01:12:49,750 --> 01:12:56,779
es el otro no me lo permitía porque no tenía un mail bueno me dice saludos de fijaros bueno

727
01:12:56,779 --> 01:13:02,939
asigna este valor, miog saludo, dice saludo desde la clase hijo,

728
01:13:04,220 --> 01:13:09,399
que es lo que hemos puesto aquí, y luego si pongo, llamo al método saludar,

729
01:13:09,979 --> 01:13:13,439
como consecuencia de haber llamado este, dice saludando desde la clase padre,

730
01:13:15,810 --> 01:13:16,710
que es este otro.

731
01:13:20,539 --> 01:13:26,760
En las cuestiones de herencia, nosotros tenemos la posibilidad de ejecutar métodos

732
01:13:26,760 --> 01:13:30,819
que sigan el comportamiento de lo definido en la clase padre,

733
01:13:30,819 --> 01:13:33,420
como acabamos de ver ahora mismo, el método saludando.

734
01:13:33,880 --> 01:13:45,100
Pero resulta que si esta es la clase persona y está resultando ser clase padre de una clase alumno

735
01:13:45,100 --> 01:13:50,100
y de una clase profesor, podría ser que los profesores y los alumnos saludásemos de forma diferente.

736
01:13:51,199 --> 01:13:57,260
Si tenemos definido el método saludar aquí en la clase padre,

737
01:13:57,260 --> 01:14:01,699
diciendo saludando es de la clase padre, tanto si ejecutamos

738
01:14:01,699 --> 01:14:05,539
el método saludar por parte de un alumno como por parte de un profesor

739
01:14:05,539 --> 01:14:09,479
si está utilizando ese método, pues saludará de la misma

740
01:14:09,479 --> 01:14:13,220
forma en todos los casos. Pero podría darse el caso

741
01:14:13,220 --> 01:14:17,399
que quisiéramos que los alumnos y los profesores saludaran de forma

742
01:14:17,399 --> 01:14:21,520
distinta. Entonces, a pesar de tenerlo disponible por herencia

743
01:14:21,520 --> 01:14:25,739
es posible en esta clase sobre escribir ese método para que justo

744
01:14:25,739 --> 01:14:35,739
se comporte de una forma diferente y sobre escribir el método lo que implica es hacer definir también este método en la clase hija.

745
01:14:40,899 --> 01:14:53,180
Entonces yo cojo y digo aquí el método saludar, aquí podría poner saludando desde la clase alumno.

746
01:14:55,079 --> 01:15:02,140
Ahora esta clase que estamos haciendo el supuesto de que es la clase alumno tendría sus propios atributos,

747
01:15:02,140 --> 01:15:08,979
atributos, tendría por herencia un método saludar, que si lo llamamos, si no existe

748
01:15:08,979 --> 01:15:15,119
en su propia clase, utilizaría este, pero como lo hemos sobrescrito aquí, el que va

749
01:15:15,119 --> 01:15:21,100
a utilizar va a ser el propio. Entonces, si en la clase alumno y profesor resulta que

750
01:15:21,100 --> 01:15:27,460
decimos que heredan de la clase persona, que sería esta, heredaría los atributos

751
01:15:27,460 --> 01:15:34,319
de edad, de nombre, la posibilidad de utilizar su saludar, pero como queremos que saluden

752
01:15:34,319 --> 01:15:39,319
de forma distinta uno y otro, lo sobreescribimos en ambas clases y en ambas clases tenemos

753
01:15:39,319 --> 01:15:43,899
la posibilidad de poner un código diferente y así no utiliza el código que está disponible

754
01:15:43,899 --> 01:15:44,760
en la clase padre.

755
01:15:45,119 --> 01:15:53,779
Si yo cojo ahora aquí y ejecuto, ahora ya no pone saludando desde la clase padre, sino

756
01:15:53,779 --> 01:15:56,119
que pone saludando desde la clase alumno.

757
01:15:56,119 --> 01:16:03,090
entendiendo que está la clase alumno mira vamos a crear un momento la una clase profesora aquí

758
01:16:03,090 --> 01:16:17,180
la clase profesor queremos también que herede de la supuesta clase persona que era la clase 1

759
01:16:17,180 --> 01:16:31,000
es que le hacemos a la clase profesor le decimos también que herede desde esta lo tenemos si me

760
01:16:31,000 --> 01:16:36,340
vengo al main fijaros que la clase herencia y profesor está en el mismo paquete pues ahora

761
01:16:36,340 --> 01:16:38,140
aquí en el mail, yo podría coger y decir

762
01:16:38,140 --> 01:16:39,939
profesor

763
01:16:39,939 --> 01:16:43,699
prof1

764
01:16:43,699 --> 01:16:45,960
Igual, crear un objeto de la clase

765
01:16:45,960 --> 01:16:50,689
profesor. Fijaros, este objeto

766
01:16:50,689 --> 01:16:51,970
de la clase profesor tendrás

767
01:16:51,970 --> 01:17:02,060
Bueno, a ver

768
01:17:02,060 --> 01:17:03,680
porque

769
01:17:03,680 --> 01:17:06,079
estamos utilizando Eclipse y es muy listo

770
01:17:06,079 --> 01:17:07,779
Eclipse, claro, los ides. O sea,

771
01:17:08,079 --> 01:17:10,060
me lo ha metido, se ha dado cuenta

772
01:17:10,060 --> 01:17:11,960
Eclipse de que me hacía falta.

773
01:17:12,300 --> 01:17:13,300
Entonces ha cogido y lo ha puesto.

774
01:17:14,520 --> 01:17:16,060
Pero, o sea, si tú lo estás

775
01:17:16,060 --> 01:17:17,880
haciendo en un editor de texto que

776
01:17:17,880 --> 01:17:31,729
no sea un IDE, claro, pues lo tienes que poner, sí, sí, claro, sí, sí, fijaros que la clase

777
01:17:31,729 --> 01:17:37,890
profesor la he definido abierta, no he definido ningún método, ni ningún atributo, ni nada, pero

778
01:17:37,890 --> 01:17:44,729
directamente tiene disponibles algunos por herencia desde la clase 1P1, que es la que estamos

779
01:17:44,729 --> 01:17:48,869
suponiendo clase como clase persona. Entonces, si yo me vengo aquí

780
01:17:48,869 --> 01:17:52,590
y digo que prof1.

781
01:17:53,210 --> 01:17:56,970
Fijaros cómo tiene disponible saludar. ¿Cómo saludará

782
01:17:56,970 --> 01:18:00,489
el profesor? Pues el profesor dirá, voy a

783
01:18:00,489 --> 01:18:04,550
buscar un código que me dé respuesta al método saludar. ¿Lo tengo aquí?

784
01:18:04,810 --> 01:18:09,029
No lo tengo aquí. Voy a utilizar el que tengo disponible como herencia

785
01:18:09,029 --> 01:18:13,109
desde aquí. Con lo cual el profesor utilizará este saludar

786
01:18:13,109 --> 01:18:16,050
y me saldrá un saludando de la clase padre.

787
01:18:16,909 --> 01:18:21,510
En el caso de este otro objeto, que es la clase herencia,

788
01:18:21,609 --> 01:18:24,210
la que estábamos haciendo el supuesto que fuese la clase alumno,

789
01:18:25,050 --> 01:18:26,710
dirá, me piden que salude.

790
01:18:27,149 --> 01:18:27,750
¿Veis? Por aquí.

791
01:18:28,310 --> 01:18:30,710
Este saludar, ¿tengo yo implementado un saludar?

792
01:18:31,050 --> 01:18:31,350
Sí.

793
01:18:31,789 --> 01:18:33,569
Pues voy a utilizar el que tengo yo implementado.

794
01:18:34,229 --> 01:18:36,850
En realidad, anteriormente, si no lo tuviera aquí implementado,

795
01:18:36,850 --> 01:18:40,590
tendría uno por herencia de la clase persona.

796
01:18:40,590 --> 01:18:58,010
Pero como lo tengo sobrescrito, en términos de la programación orientada a objetos, utilizo el propio. El profesor que también hereda de la clase persona, ¿lo tiene sobrescrito o no? Pues como no lo tiene sobrescrito, utiliza el que tiene disponible, que es el que está en la clase persona.

797
01:18:58,010 --> 01:19:31,859
Entonces, si ahora ejecutamos de nuevo la clase herencia, fijaros cómo me dice, bueno, me dice primero un saludo desde la clase hijo, bueno, pues porque hacemos una llamada a un método propio, este ni estaba heredado ni nada, luego dice saludando desde la clase padre, desde la clase alumno, este saludar de un objeto perteneciente a la clase herencia, clase alumno de la que estábamos hablando, tiene disponible dos saludar, uno, heredado desde la clase padre, pero es que resulta que lo tiene que hacer.

798
01:19:31,880 --> 01:19:37,979
aquí sobre escrito no tiene aquí sobre escrito me muestra el saludando el de la clase alumno y luego

799
01:19:39,319 --> 01:19:44,659
otro objeto en este caso de la clase profesor llama al método saludar resulta que el profesor

800
01:19:44,659 --> 01:19:50,359
no tiene sobre escrito el método saludar cuál va a utilizar el que sí que tiene disponible como

801
01:19:50,359 --> 01:19:56,000
herencia es de la clase persona entonces este coge y me muestra el saludando el de la clase

802
01:19:56,000 --> 01:20:02,439
padre bueno todo esto que ya os digo cuando hablemos de la herencia lo vamos a repasar de

803
01:20:02,439 --> 01:20:07,359
nuevo pero explicar la etiqueta final relacionada con un método no tiene sentido si no entendéis

804
01:20:07,359 --> 01:20:14,619
este contexto pues si aún hemos dicho si a un atributo le ponemos final se convierte en una

805
01:20:14,619 --> 01:20:20,260
constante si a una clase le ponemos final no permite ya herencia de esa clase y si a un

806
01:20:20,260 --> 01:20:29,350
método le ponemos final fijaros el método saludar lo que estás bloqueando es la posibilidad de

807
01:20:29,350 --> 01:20:34,229
sobrescribir ese método en clases hijas es que ahora ya no me compila aquí

808
01:20:34,229 --> 01:20:42,569
etiqueta final en una clase que resulta ser padre de otras lo que hace es

809
01:20:42,569 --> 01:20:47,909
bloquear la posibilidad de sobre escribir ese método de las clases hijas

810
01:20:47,909 --> 01:20:53,729
el método la etiqueta final en una clase evita que se puede utilizar esa clase

811
01:20:53,729 --> 01:21:00,090
como padres en todo su conjunto en este caso lo único para el método evita que

812
01:21:00,090 --> 01:21:01,010
se sobreescriba.

813
01:21:02,050 --> 01:21:04,090
Ambar2 en el contexto de la herencia.

814
01:21:04,609 --> 01:21:06,130
Matices distintos, pero en el contexto

815
01:21:06,130 --> 01:21:08,090
de la herencia. Y etiqueta final en un

816
01:21:08,090 --> 01:21:09,829
atributo convierte una variable

817
01:21:09,829 --> 01:21:10,930
en

818
01:21:10,930 --> 01:21:13,550
una constante.

819
01:21:18,869 --> 01:21:19,689
¿Se entiende?

820
01:21:27,439 --> 01:21:28,079
Vale.

821
01:21:29,920 --> 01:21:31,479
Bueno, pues algunas

822
01:21:31,479 --> 01:21:33,359
cosillas más de las que voy teniendo por aquí

823
01:21:33,359 --> 01:21:34,079
apuntadas.

824
01:21:36,239 --> 01:21:39,949
Bueno, hablo...

825
01:21:40,590 --> 01:21:41,850
Tengo aquí apuntado que

826
01:21:41,850 --> 01:21:43,789
en algún sitio o de algún sitio

827
01:21:43,789 --> 01:21:46,670
deducido que podría ser interesante hablar del ámbito

828
01:21:46,670 --> 01:21:48,949
de las variables.

829
01:21:49,689 --> 01:21:51,649
Esto sí que lo hemos hablado más veces también.

830
01:21:54,010 --> 01:21:58,710
En Java, digamos que el código se va definiendo por bloques

831
01:21:58,710 --> 01:22:01,750
y estos bloques se van identificando con llaves.

832
01:22:02,670 --> 01:22:05,069
Tenemos la clase, aquí definiendo una clase,

833
01:22:05,270 --> 01:22:07,970
esta clase va de aquí hasta esta llave.

834
01:22:08,369 --> 01:22:10,090
Todo lo que hay entre la llave de apertura y cierre

835
01:22:10,090 --> 01:22:11,109
pertenece a esa clase.

836
01:22:11,109 --> 01:22:15,369
un método, pues lo tenemos aquí, entonces todo lo que tenemos aquí

837
01:22:15,369 --> 01:22:19,289
pues va entre, eso es el código que tiene que ver

838
01:22:19,289 --> 01:22:23,229
con el método saludar, entonces las variables tienen

839
01:22:23,229 --> 01:22:26,689
un acceso en unos determinados ámbitos

840
01:22:26,689 --> 01:22:31,210
entonces el ámbito es en el que están definidos

841
01:22:31,210 --> 01:22:34,989
entonces estas variables están definidas para poderse utilizar

842
01:22:34,989 --> 01:22:38,489
en el ámbito de la clase en su conjunto

843
01:22:38,489 --> 01:23:02,729
Si tú defines aquí una variable, está definida en el ámbito de este método. En este método, si ponemos inti entero puff, aquí en el ámbito del método saludar resulta que hemos definido una variable que se llama i entero puff.

844
01:23:02,729 --> 01:23:20,579
Y resulta que este nombre coincide con este. Si yo, aquí defino la variable, si yo cojo aquí y asigno un valor a esa variable, ¿a cuál me estoy refiriendo? Pues al del ámbito más cercano, a esta variable y no a esta.

845
01:23:20,579 --> 01:23:34,479
A efectos funcionales, digamos, o a efectos de recursos en el ordenador, cada una de las variables tendrá una zona de memoria RAM diferente que será donde se guardará su valor.

846
01:23:34,479 --> 01:23:53,119
He estado muy pesado durante muchas semanas hablando de la RAM, pues cuando construimos, definimos una instancia de esta clase y creamos un objeto con new, se creará una variable para sus atributos, entonces se cogerá un espacio de memoria RAM para esta variable.

847
01:23:53,119 --> 01:24:19,500
¿En qué momento se liberará esta memoria RAM? Pues habrá un momento en el que dejará de ser útil, que será el momento en el que salga del ámbito el objeto ese donde lo hayamos definido y luego una vez que ya no es útil para nuestro programa porque ya no está disponible el objeto para el que se había definido esa variable, pues el recolector de basura terminará liberando la memoria RAM.

848
01:24:23,119 --> 01:24:47,399
A ver, el método finalice, si intentas localizarlo en código Java, pues si miras un millón de líneas de código lo vas a ver en un sitio o en ninguno.

849
01:24:47,399 --> 01:25:05,119
Yo creo que no se llama nunca. En Java siempre se deriva a que eso suceda cuando el recolector de basura, que es un código que está por ahí detrás, del cual nosotros no nos preocupemos, se ejecute.

850
01:25:05,119 --> 01:25:28,880
¿En qué casos podría ser muy interesante llamar al método finalice? Cuando se llama al método finalice es lo contrario al constructor. El constructor sí resulta muy útil porque cuando vamos a querer empezar a utilizar un objeto nos puede interesar que tenga ciertos valores subparámetros o para que pasen ciertas cosas.

851
01:25:28,880 --> 01:25:32,739
imagínate que es un estadio

852
01:25:32,739 --> 01:25:33,960
y está entrando gente

853
01:25:33,960 --> 01:25:36,100
y dices, pues mira, me interesa

854
01:25:36,100 --> 01:25:38,920
no tanto dar un valor a uno de sus atributos

855
01:25:38,920 --> 01:25:42,039
de esta instancia del espectador

856
01:25:42,039 --> 01:25:43,260
que acaba de pasar al estadio

857
01:25:43,260 --> 01:25:44,960
sino que me interesa que cada vez

858
01:25:44,960 --> 01:25:46,359
que acceda una nueva persona

859
01:25:46,359 --> 01:25:49,619
se escriba en una base de datos

860
01:25:49,619 --> 01:25:51,460
nueva persona accedido

861
01:25:51,460 --> 01:25:52,560
en un fichero de un log

862
01:25:52,560 --> 01:25:55,460
o sea, cuando queremos que al crear un nuevo objeto

863
01:25:55,460 --> 01:25:57,500
suceda algo, inicializar sus atributos

864
01:25:57,500 --> 01:26:00,439
o hacer ciertas acciones, utilizas el constructor.

865
01:26:01,159 --> 01:26:05,539
Y el finalice podría entenderse como un método que fuese el destructor.

866
01:26:05,899 --> 01:26:10,600
Cuando deja de existir un determinado objeto, pues que pasen ciertas cosas.

867
01:26:12,560 --> 01:26:16,140
En tanto en cuanto inicializar variables, pues ya no tiene sentido,

868
01:26:16,279 --> 01:26:18,079
porque justo ya está desapareciendo ese objeto,

869
01:26:18,220 --> 01:26:20,439
¿para qué quieres tener variables inicializadas?

870
01:26:21,420 --> 01:26:25,000
Si quieres que pase algo muy particular de un código que pongas,

871
01:26:25,000 --> 01:26:26,739
pues bueno, podrías intentar llamar al método

872
01:26:26,739 --> 01:26:28,600
finalice en ese caso, o

873
01:26:28,600 --> 01:26:30,819
en el momento que lo vas a cerrar, llamar a un método

874
01:26:30,819 --> 01:26:33,100
que haces tú, método finalice

875
01:26:33,100 --> 01:26:34,760
no se suele programar nunca

876
01:26:34,760 --> 01:26:37,119
pero existe y bueno, por eso aparece por ahí

877
01:26:37,119 --> 01:26:39,020
digamos que lo podrías entender como

878
01:26:39,020 --> 01:26:40,979
un destructor, igual que el otro es el

879
01:26:40,979 --> 01:26:42,739
constructor, como un destructor del objeto

880
01:26:42,739 --> 01:27:16,359
cuando llamabas

881
01:27:16,359 --> 01:27:17,300
al método finalice

882
01:27:17,300 --> 01:27:20,119
estaba terminando ya el programa, porque igual

883
01:27:20,119 --> 01:27:22,020
termina el programa antes de que el recolector

884
01:27:22,020 --> 01:27:24,000
de basura, estás como forzando que se llame

885
01:27:24,000 --> 01:27:25,640
pero igual termina hasta antes el programa

886
01:27:25,640 --> 01:27:27,800
ponme, ponme, de tal forma

887
01:27:27,800 --> 01:27:30,199
yo te tengo que decir

888
01:27:30,199 --> 01:27:32,079
que no estoy, o sea, para coger y hacer un ejercicio

889
01:27:32,079 --> 01:27:34,159
aquí directamente, como es algo que no se usa prácticamente

890
01:27:34,159 --> 01:27:36,300
nunca, no estoy muy familiarizado

891
01:27:36,300 --> 01:27:37,619
con trabajar con él

892
01:27:37,619 --> 01:27:38,520
de tal forma

893
01:27:38,520 --> 01:27:42,199
no sé si tienes localizado

894
01:27:42,199 --> 01:27:43,439
justo el ejercicio que es

895
01:27:43,439 --> 01:27:45,859
o me lo pones en el foro

896
01:27:45,859 --> 01:27:47,640
e intento echarle un ojo yo y lo ejecuto

897
01:27:47,640 --> 01:27:48,460
a ver si doy con ello

898
01:27:48,460 --> 01:27:55,699
vale, pues

899
01:27:55,699 --> 01:27:58,800
bueno, en cualquier caso lo he hecho yo luego un ojillo

900
01:27:58,800 --> 01:28:02,140
y os digo, a ver si lo hago

901
01:28:02,140 --> 01:28:05,140
funcionar. Ya te digo que

902
01:28:05,140 --> 01:28:08,159
luego en el mundo real no vas a ver el finalice

903
01:28:08,159 --> 01:28:12,630
ese prácticamente nunca, con que

904
01:28:12,630 --> 01:28:16,270
de cara aquí a este curso, con que entiendas

905
01:28:16,270 --> 01:28:18,729
que se podría considerar como un destructor

906
01:28:18,729 --> 01:28:22,289
pensando en esa idea

907
01:28:22,289 --> 01:28:25,390
en un momento dado podría plantearse el finalice

908
01:28:25,390 --> 01:28:28,250
como eso, está desapareciendo el objeto, pues es el momento

909
01:28:28,250 --> 01:28:53,600
Podría ser el momento de restar uno al número de personas que están en el estadio o al número de objetos que se han creado. Nada, no se suele implementar nunca. De todas formas, lo he hecho yo durante estos días un ojillo y si llego a una conclusión clara de una buena forma de utilizarlo, os lo comento.

910
01:28:53,600 --> 01:29:33,380
O bien en la próxima tutorial os escribo una entrada en el foro. Vale. Vale, pues lo miro, ¿vale? Y os pongo una entrada ahí en el foro. Vale, estábamos hablando de, ah, vale, de los ámbitos. Pues nada, esto es lo que os decía entonces de cuando tú creas un nuevo objeto, pues lógicamente necesitas para sus atributos un espacio de memoria RAM.

911
01:29:33,380 --> 01:29:37,279
y esta variable la estamos definiendo en el ámbito de la clase

912
01:29:37,279 --> 01:29:41,640
cuando quedará para liberarse

913
01:29:41,640 --> 01:29:45,960
quedará ese espacio de memoria RAM para liberarse en el momento

914
01:29:45,960 --> 01:29:49,979
en el que desaparezca el objeto, que básicamente por un objeto

915
01:29:49,979 --> 01:29:52,560
su ámbito podríamos decir que es la clase completa

916
01:29:52,560 --> 01:29:57,840
si de vez en cuando en ciertos sitios del código

917
01:29:57,840 --> 01:30:01,939
se llama al método saludar, pues justo este método tiene este otro

918
01:30:01,939 --> 01:30:05,979
ámbito. Entonces, si yo cojo y defino aquí unas variables, en el momento

919
01:30:05,979 --> 01:30:10,140
en el que estoy definiendo estas variables, se reservará espacio de memoria

920
01:30:10,140 --> 01:30:13,220
para estas variables también, igual que para los atributos antes

921
01:30:13,220 --> 01:30:18,100
cuando definíamos un nuevo objeto. ¿Y cuándo dejan de ser útiles

922
01:30:18,100 --> 01:30:21,899
estas variables? Pues si esta variable está definida en este ámbito, que es el

923
01:30:21,899 --> 01:30:26,000
del método saludar, estará disponible esa variable entre la

924
01:30:26,000 --> 01:30:29,819
apertura y el cierre de las llaves. Una vez llegado aquí, esa variable ya no tiene

925
01:30:29,819 --> 01:30:34,439
uso ninguno, con lo cual el recolector de basura terminaría también

926
01:30:34,439 --> 01:30:40,699
liberando ese espacio. Si definimos con un mismo nombre en diferentes

927
01:30:40,699 --> 01:30:45,739
ámbitos que uno recoge al otro una variable con el mismo nombre, pues

928
01:30:45,739 --> 01:30:50,539
se hace referencia a la variable que es más cercana. En este caso, fijaros

929
01:30:50,539 --> 01:30:55,859
como Ecclesia al ponerme sobre esta variable me está poniendo un poquito

930
01:30:55,859 --> 01:31:00,119
oscurecida la que está definiendo. Y si a pesar

931
01:31:00,119 --> 01:31:03,979
de todo, dentro de este método, quiero hacer referencia a esta otra, pues como

932
01:31:03,979 --> 01:31:07,960
hacemos habitualmente los constructores para pasar la información, podemos

933
01:31:07,960 --> 01:31:11,659
utilizar la etiqueta dis, que quiere decir yo mismo,

934
01:31:11,920 --> 01:31:15,760
mi propia clase, entonces yo pongo aquí el nombre de la variable

935
01:31:15,760 --> 01:31:21,659
precedido por dis

936
01:31:21,659 --> 01:31:24,779
y entonces ahora si me pongo sobre esta, fijaros como Eclipse

937
01:31:24,779 --> 01:31:32,149
hacer que compile, si me pongo sobre esta variable

938
01:31:32,149 --> 01:31:35,810
fijaros como Eclipse ahora la que me pone en negrita es esta y hace

939
01:31:35,810 --> 01:31:39,630
considera que es esta y no la del ámbito más cercano porque le he puesto el dis

940
01:31:39,630 --> 01:31:43,989
y esta otra, pues como no le he puesto el dis, pues considera

941
01:31:43,989 --> 01:31:53,229
que es esta, no me lo pone ahí en negrita

942
01:31:53,229 --> 01:32:00,390
pero bueno, esta se refiere a esta la más cercana, no, es que se llaman diferentes

943
01:32:00,390 --> 01:32:05,800
las variables, hacerla coincidir, bien, ahora ya

944
01:32:05,800 --> 01:32:09,680
se llaman igual, entonces si me pongo en esta se refiere a esta y si me pongo sobre esta se refiere a la

945
01:32:09,680 --> 01:32:15,520
local. Bueno, eso respecto a los ámbitos. Fijaros que un ámbito

946
01:32:15,520 --> 01:32:19,100
al final es algo que está encerrado entre unas llaves.

947
01:32:20,020 --> 01:32:23,619
Para la clase es esto, desde aquí hasta el final, para el método saludar es este.

948
01:32:24,300 --> 01:32:27,520
Aunque es una cosa que tampoco se utiliza mucho, existe la posibilidad de

949
01:32:27,520 --> 01:32:31,539
definir ámbitos que no estén relacionados con nada y se definen

950
01:32:31,539 --> 01:32:35,659
con unas llaves. A ver, creo recordar, a ver, si yo hago esto

951
01:32:35,659 --> 01:32:56,279
Fijaros, dentro de un método, como he abierto aquí unas llaves, vamos a tabularlo para verlo más claro con estas llaves, si yo ahora intento acceder a esta variable y le pongo un valor de 9, me compila, pero fijaros a qué variable se refiere, se refiere a la de clase.

952
01:32:56,279 --> 01:33:00,199
no se refiere a esta, ¿por qué? porque esta variable

953
01:33:00,199 --> 01:33:04,039
a pesar de que estas llaves no están asociadas a un método ni a una clase

954
01:33:04,039 --> 01:33:11,140
están definiendo un ámbito, no sé si lo veis, que me pongo aquí y no se refiere

955
01:33:11,140 --> 01:33:14,239
a esta variable, aunque a pesar de que comparten

956
01:33:14,239 --> 01:33:19,319
código en el mismo método, sino que se refiere a la variable de clase

957
01:33:19,319 --> 01:33:23,579
¿por qué? porque ya os digo, esta está definida en el ámbito

958
01:33:23,579 --> 01:33:26,319
de estas llaves, es decir, existe esta posibilidad

959
01:33:26,319 --> 01:33:40,939
Pero bueno, no se suelen poner así llaves, a no ser que sea para identificar bloques SIF o para bucles o métodos o bien identificar clases en su conjunto.

960
01:33:46,479 --> 01:33:48,380
Bueno, esto os puedo contar más o menos de los ámbitos.

961
01:33:51,020 --> 01:33:57,140
Otra cosa de la que habíamos estado hablando otro día es de los constructores copia.

962
01:33:57,140 --> 01:34:32,310
No sé si os acordáis de ellos. Los constructores copia son los que definimos en una clase. Haciendo un mini repaso de los constructores, los constructores son métodos que se llaman igual que la clase, suelen ser públicos, son los únicos métodos que no devuelven nada, no tienen una instrucción return, pero no lo indicamos aquí en los constructores.

963
01:34:36,710 --> 01:34:46,000
Y pueden estar sobrecargados, os acordáis de la sobrecarga de métodos que también hemos hablado en algún momento de ella y volveremos a repasarlo.

964
01:34:46,920 --> 01:34:56,659
Si yo cogiese y definiese dos métodos, los constructores como cualquier otro método de la clase también lo aceptan, dos métodos así,

965
01:34:56,659 --> 01:35:01,140
que no nos permitiría, si hacemos una llamada

966
01:35:01,140 --> 01:35:05,159
a este constructor, a un constructor sin parámetros, no nos permitiría identificar

967
01:35:05,159 --> 01:35:09,159
si nos estamos refiriendo al código que está implementado

968
01:35:09,159 --> 01:35:13,100
aquí, en este método o en este otro. Entonces, como hay una

969
01:35:13,100 --> 01:35:16,819
discrepancia, no es posible identificar a cuál nos referimos

970
01:35:16,819 --> 01:35:23,460
si hacemos, por ejemplo, este profesor

971
01:35:23,460 --> 01:35:27,520
aquí estamos llamando al constructor, fijaros, llamada a un método

972
01:35:27,520 --> 01:35:31,739
constructor sin pasarle parámetro ninguno, pues se vendría aquí al código y diría

973
01:35:31,739 --> 01:35:35,520
¿cuál quieres que ejecute? ¿este o este? Si aquí me has puesto un código que puede ser

974
01:35:35,520 --> 01:35:39,180
diferente del que me has puesto aquí. Entonces, esto no lo acepta.

975
01:35:39,680 --> 01:35:42,800
Es igual que si tenemos una variable con...

976
01:35:42,800 --> 01:35:47,380
Intentamos poner a dos variables el mismo nombre. Entonces, lo que sí que nos acepta es

977
01:35:47,380 --> 01:35:53,720
si ponemos... Hacemos que tengan

978
01:35:53,720 --> 01:35:57,739
alguna diferencia. Entonces, aquí este no recibe ningún

979
01:35:57,739 --> 01:36:04,159
parámetro y este recibe uno aquí si nos venimos en este constructor está claro que no le estamos

980
01:36:04,159 --> 01:36:08,539
pasando parámetro alguno no hay lugar a dudas entre estos dos cual tendría que ejecutar el

981
01:36:08,539 --> 01:36:15,500
que no recibe ningún parámetro y si le ponemos que como parámetro reciba una cadena de caracteres

982
01:36:15,500 --> 01:36:28,079
pues esto me seguiría con compilando por aquí ve como veis y cuando se viniese aquí a buscar

983
01:36:28,079 --> 01:36:31,640
el constructor, diría, ¿cuál de ellos tengo que ejecutar? ¿Este o este?

984
01:36:31,819 --> 01:36:36,439
Pues oye, si me has pasado como parámetro una cadena de caracteres,

985
01:36:36,579 --> 01:36:39,659
este no recibe ninguna, pues querrás que se ejecute este código.

986
01:36:39,960 --> 01:36:44,000
Entonces esto me compila porque no hay discrepancia, no hay lugar a dudas

987
01:36:44,000 --> 01:36:50,340
cuál de los dos tiene que ejecutar. Esto, el hecho de tener diferentes métodos,

988
01:36:50,859 --> 01:36:55,439
en este caso el método constructor, con el mismo nombre que los diferencia

989
01:36:55,439 --> 01:36:59,279
el número de parámetros, el tipo, el número de parámetros que tienen disponibles

990
01:36:59,279 --> 01:37:03,600
y nos garantiza que no hay lugar a dudas cuál de los dos se tiene que ejecutar cuando lo llamemos

991
01:37:03,600 --> 01:37:06,720
es lo que se llama sobrecarga de métodos, ¿vale?

992
01:37:08,260 --> 01:37:11,859
No sobre escritura, que era lo que hablábamos antes de la herencia, sobrecarga.

993
01:37:13,460 --> 01:37:20,520
Entonces, el constructor copia, que es otra de las cosas que tengo por aquí apuntadas,

994
01:37:20,520 --> 01:37:22,939
es un constructor, con lo cual

995
01:37:22,939 --> 01:37:25,199
será public, se llamará

996
01:37:25,199 --> 01:37:26,760
como la clase, profesor

997
01:37:26,760 --> 01:37:29,239
su utilidad típicamente será

998
01:37:29,239 --> 01:37:30,920
el momento en el que estamos haciendo un

999
01:37:30,920 --> 01:37:31,840
nuevo objeto

1000
01:37:31,840 --> 01:37:38,689
por aquí, verdad, no sé si alguien

1001
01:37:38,689 --> 01:37:40,710
ha levantado por ahí la mano, cuando me queráis

1002
01:37:40,710 --> 01:37:42,670
decir algo, decídmelo a la bravas

1003
01:37:42,670 --> 01:37:44,109
no levantéis la mano porque

1004
01:37:44,109 --> 01:37:46,149
porque no estoy muy pendiente

1005
01:37:46,149 --> 01:37:48,069
de si me las andáis levantando

1006
01:37:48,069 --> 01:37:49,729
igual alguien la está levantando hace rato

1007
01:37:49,729 --> 01:37:51,810
y está esperando a que le dé paso

1008
01:37:51,810 --> 01:37:53,689
y no me estoy ni enterando

1009
01:37:53,689 --> 01:38:07,710
Si queréis decirme algo, me avisáis. Entonces, el constructor copia puede ser un constructor que sobrecarga a otros y que el parámetro que recibe es una referencia a un objeto de la misma clase.

1010
01:38:14,600 --> 01:38:25,960
¿Y para qué utilizamos esto? Pues mirad, si queremos tener varios objetos que sean exactamente igual, que cada uno estará situado en una zona diferente de memoria,

1011
01:38:25,960 --> 01:38:29,520
porque son objetos distintos, pero puede ser que todos sus atributos

1012
01:38:29,520 --> 01:38:33,979
queramos que tengan el mismo valor, pues podemos utilizar el constructor.

1013
01:38:34,159 --> 01:38:36,460
Lo normal será utilizar el constructor copia.

1014
01:38:38,000 --> 01:38:43,380
Mirad, si aquí cogemos y definimos, ponemos string ese nombre

1015
01:38:43,380 --> 01:38:50,119
para el profesor, int y edad, estos dos atributos,

1016
01:38:50,119 --> 01:38:56,619
aquí podemos crear un primer profesor con este constructor, por ejemplo,

1017
01:38:56,619 --> 01:39:07,439
que no recibe ningún atributo, y a este profesor podemos coger y decirle

1018
01:39:07,439 --> 01:39:12,140
prof1, punto, y aplicarle valores a sus atributos.

1019
01:39:12,380 --> 01:39:28,449
Es decir, que su nombre sea Valeria y que su edad sea 13 años, por ejemplo.

1020
01:39:30,289 --> 01:39:34,609
Entonces, prof1 resulta que tiene, es un objeto de la clase profesor

1021
01:39:34,609 --> 01:39:38,689
al cual hemos asignado un nombre de Valeria y una edad de 13 años.

1022
01:39:38,689 --> 01:39:57,729
Y ahora resulta que podríamos querer tener una segunda persona, un segundo profesor, un profesor con 13 años, igual lo estamos sobreexplotando, pero bueno, ahora que me di cuenta, podríamos tener un segundo profesor que queremos que de partida tenga los mismos datos que el profesor 1.

1023
01:39:57,729 --> 01:40:21,510
Bueno, pues así nos está exigiendo el programa. Podríamos coger y hacer esto, construir un segundo profesor y asignarle sus valores, en este caso sería prof2, o lo que podemos hacer es utilizar el constructor copia, que sería hacer esto y llamar al new del profesor utilizando el constructor y pasándole una persona.

1024
01:40:21,510 --> 01:40:23,710
en este caso el prof.1

1025
01:40:23,710 --> 01:40:25,829
y aquí que es lo que vamos a hacer

1026
01:40:25,829 --> 01:40:27,170
lo que vamos a hacer va a ser

1027
01:40:27,170 --> 01:40:29,850
en el constructor copia

1028
01:40:29,850 --> 01:40:31,409
decir que

1029
01:40:31,409 --> 01:40:33,670
dis de este el ese nombre

1030
01:40:33,670 --> 01:40:35,609
es decir

1031
01:40:35,609 --> 01:40:36,670
la variable

1032
01:40:36,670 --> 01:40:39,569
de el objeto que está

1033
01:40:39,569 --> 01:40:41,270
llamando al constructor, fijaros

1034
01:40:41,270 --> 01:40:43,550
el que está llamando al constructor es el

1035
01:40:43,550 --> 01:40:44,270
profesor2

1036
01:40:44,270 --> 01:40:47,550
su nombre queremos que sea

1037
01:40:47,550 --> 01:40:49,310
igual a un

1038
01:40:49,310 --> 01:40:54,449
prof. ese nombre. Aquí, en este profesor

1039
01:40:54,449 --> 01:40:57,409
que ha recibido como parámetro, resulta que le estamos aplicando

1040
01:40:57,409 --> 01:41:01,810
estamos pasando el profesor 1. Entonces, ¿qué estamos haciendo?

1041
01:41:02,289 --> 01:41:06,369
Esta posición de memoria para el profesor 1, habíamos asignado a su nombre

1042
01:41:06,369 --> 01:41:10,409
Valeria, y esta posición de memoria se está copiando como parámetro

1043
01:41:10,409 --> 01:41:14,090
en esta posición de memoria, con lo cual esto está apuntando en memoria RAM

1044
01:41:14,090 --> 01:41:18,430
al mismo sitio donde está apuntando prof1. Y resulta que prof1, su variable ese nombre

1045
01:41:18,430 --> 01:41:20,390
es Valeria, entonces

1046
01:41:20,390 --> 01:41:22,470
un prof. ese nombre que tendrá

1047
01:41:22,470 --> 01:41:24,409
Valeria, y aquí se lo estamos asignando

1048
01:41:24,409 --> 01:41:26,189
al objeto

1049
01:41:26,189 --> 01:41:28,489
con el dis, al atributo del

1050
01:41:28,489 --> 01:41:28,949
objeto

1051
01:41:28,949 --> 01:41:32,630
de quien está ejecutando en este momento el constructor

1052
01:41:32,630 --> 01:41:33,310
que es

1053
01:41:33,310 --> 01:41:36,430
este otro, el profesor

1054
01:41:36,430 --> 01:41:38,890
2, entonces estamos copiando los atributos

1055
01:41:38,890 --> 01:41:40,750
de un profesor

1056
01:41:40,750 --> 01:41:42,510
que estamos pasando al constructor

1057
01:41:42,510 --> 01:41:44,430
como parámetro

1058
01:41:44,430 --> 01:41:46,489
a los atributos

1059
01:41:46,489 --> 01:41:50,229
de este otro. Este es el constructor copia. Entonces haríamos esto

1060
01:41:50,229 --> 01:41:57,960
de igual forma para la edad. Y ahí tenemos el constructor copia.

1061
01:42:00,460 --> 01:42:04,359
En realidad, aquí como no tenemos como un parámetro

1062
01:42:04,359 --> 01:42:07,840
ni ese nombre ni edad, si

1063
01:42:07,840 --> 01:42:11,899
quitamos el dis, se mantendría

1064
01:42:11,899 --> 01:42:15,859
que las variables a las que hace referencia este constructor

1065
01:42:15,859 --> 01:42:20,159
siguen siendo las de la clase. Dice que es el nombre

1066
01:42:20,159 --> 01:42:24,479
Si utilizamos el dis, también sigue diciendo que son estos atributos.

1067
01:42:32,729 --> 01:42:36,289
¿Alguna dudilla por ahí tenéis? ¿Alguna cosilla queréis preguntarme?

1068
01:42:37,890 --> 01:42:40,890
Hemos hablado de unas cuantas cosas hoy, la verdad.

1069
01:42:41,789 --> 01:42:45,390
Unas cuantas etiquetas. No sé si os han quedado más o menos claras.

1070
01:42:49,760 --> 01:42:52,079
Todavía tengo unas cuantas cosas más apuntadas por aquí.

1071
01:42:53,979 --> 01:42:57,100
Yo creo que para el lunes que viene. Me parece que lo vamos a ir dejando ya por aquí.

1072
01:42:57,100 --> 01:42:59,899
Si no tenéis alguna duda, hasta donde hemos visto.

1073
01:43:05,359 --> 01:43:29,409
Nada nuevo, miro lo del finalice, de todas formas, a ver si, ya digo que no, que con este método no he trabajado mucho, pero lo miro para ver si lo concretamos, y yo bien en la siguiente tutoría os cuento, os pongo una entrada en el foro, y si no tenéis nada, pues aquí paramos, el lunes que viene ya continuamos con el resto de cosas de este tema.

1074
01:43:29,409 --> 01:43:35,390
Y si tenéis dudas durante la semana, ya sabéis, me ponéis entradas en el foro. Estoy bastante pendiente de él.

1075
01:43:39,199 --> 01:43:43,939
Pues venga, pues nada, a vosotros. Que tengáis buena semana. Hasta luego.