1
00:00:00,370 --> 00:00:01,490
Aquí y aquí.

2
00:00:10,900 --> 00:00:13,820
Y estáis viendo la pantalla, ¿verdad?

3
00:00:13,980 --> 00:00:17,539
¿Veis el aula virtual, verdad?

4
00:00:18,320 --> 00:00:19,140
Con el temario.

5
00:00:22,679 --> 00:00:23,280
Sí, ¿no? Vale.

6
00:00:25,539 --> 00:00:27,059
¿Alguien me puede decir por dónde me quedé?

7
00:00:27,760 --> 00:00:28,579
Más o menos.

8
00:00:30,500 --> 00:00:33,179
Yo creo que me quedé por la programación declarativa e imperativa.

9
00:00:33,399 --> 00:00:34,060
¿Alguien recuerda?

10
00:00:41,259 --> 00:00:41,659
Vale.

11
00:00:42,240 --> 00:00:45,579
Antes de empezar con la teoría, esto es lo que vamos a ver hoy.

12
00:00:45,579 --> 00:00:46,460
¿Vale? De Java.

13
00:00:46,759 --> 00:00:47,600
¿Qué vamos a ver hoy?

14
00:00:48,000 --> 00:00:51,500
vamos a ver un poquito los tipos de datos

15
00:00:51,500 --> 00:00:54,140
solo que sepáis el tipo double

16
00:00:54,140 --> 00:00:57,859
vamos a hacer un programa sencillo que es calcular la nota media

17
00:00:57,859 --> 00:01:01,700
de tres notas que vamos a introducir por teclado

18
00:01:01,700 --> 00:01:04,599
tendremos que saber cómo crear un objeto

19
00:01:04,599 --> 00:01:09,659
y ya vamos viendo el operador

20
00:01:09,659 --> 00:01:14,040
y vamos a ver cómo crear un método

21
00:01:14,040 --> 00:01:17,900
muy sencillo y la diferencia entre llamar un método estático

22
00:01:17,900 --> 00:01:22,060
y uno no estático. La clase escáner y el ejercicio para calcular

23
00:01:22,060 --> 00:01:25,840
la nota media de tres letras. Esto es lo que vamos a ver luego

24
00:01:25,840 --> 00:01:29,579
con, nos meteremos ya, tengo ya instalado aquí el

25
00:01:29,579 --> 00:01:33,480
NetBeans y lo haremos aquí. Entonces el programa que vamos a hacer

26
00:01:33,480 --> 00:01:35,959
se puede hacer de tres maneras. Entonces voy a hacer con las tres.

27
00:01:39,140 --> 00:01:41,280
Esto sería por una parte lo que vamos a ver después.

28
00:01:41,980 --> 00:01:44,359
En principio voy a hablar un poquito de la teoría.

29
00:01:44,359 --> 00:01:48,340
esto sigue siendo teoría pura y dura

30
00:01:48,340 --> 00:01:51,620
pero que es necesario que sepáis

31
00:01:51,620 --> 00:01:54,140
si vimos la diferencia entre algoritmo y programa

32
00:01:54,140 --> 00:01:55,640
vimos que un algoritmo

33
00:01:55,640 --> 00:01:57,340
nosotros teníamos un

34
00:01:57,340 --> 00:02:00,400
cuando tengáis alguna duda o lo que sea

35
00:02:00,400 --> 00:02:01,040
me interrumpís

36
00:02:01,040 --> 00:02:04,760
un algoritmo realmente

37
00:02:04,760 --> 00:02:06,640
a ti te van a proponer un problema

38
00:02:06,640 --> 00:02:09,319
y ese problema necesita ser resuelto

39
00:02:09,319 --> 00:02:10,379
por medio de un algoritmo

40
00:02:10,379 --> 00:02:13,740
entonces, diferencia entre el algoritmo y el programa

41
00:02:14,400 --> 00:02:20,479
El algoritmo es un medio que vamos a utilizar para resolver un problema.

42
00:02:21,819 --> 00:02:24,840
¿Cómo tiene que ser? Tiene que caracterizarse por tres cosas.

43
00:02:24,979 --> 00:02:33,680
Una, que tiene que ser preciso. Si no es preciso, indicando paso a paso cómo se tiene que realizar.

44
00:02:34,599 --> 00:02:38,360
Si no es preciso, tenemos un problema, aparte del que ya nos han propuesto.

45
00:02:38,680 --> 00:02:41,219
Tiene que ser preciso. Tiene que estar definido.

46
00:02:41,219 --> 00:03:00,080
O sea, si tú lo ejecutas más de una vez y con los mismos valores, tiene que siempre dar el mismo resultado y debe ser finito. Todo algoritmo va a tener una serie de pasos y tienen que ser finitos, no puede ser algo infinito, sino que tiene que tener un número de pasos finito.

47
00:03:00,080 --> 00:03:16,699
O sea que con un comienzo no fina. Y luego todos los pasos intermedios en primeros. En cambio, un programa que es un conjunto de instrucciones que se codifica en un lenguaje de programación y que lo que hace es permitir que ese algoritmo se pueda ejecutar en un ordenador.

48
00:03:16,699 --> 00:03:31,099
Básicamente es eso. Con respecto a cómo representar los algoritmos, pues tenemos aquí tres métodos. Uno que sería con los diagramas de flujo, que si un diagrama de flujo,

49
00:03:31,099 --> 00:03:32,960
mirad, para que veáis un diagrama de flujo

50
00:03:32,960 --> 00:03:34,240
os voy a poner aquí PSEN

51
00:03:34,240 --> 00:03:37,039
este es un programa sencillito

52
00:03:37,039 --> 00:03:38,879
en el que se programa

53
00:03:38,879 --> 00:03:40,300
el pseudocódigo, ¿vale?

54
00:03:40,379 --> 00:03:41,740
entonces, si yo le pongo

55
00:03:41,740 --> 00:03:42,960
vamos a ponerle

56
00:03:42,960 --> 00:03:47,960
salud

57
00:03:47,960 --> 00:03:50,680
esto nos define aquí un algoritmo

58
00:03:50,680 --> 00:03:52,919
esto no tenéis que saberlo, pero es para que veáis

59
00:03:52,919 --> 00:03:54,919
esto lo doy

60
00:03:54,919 --> 00:03:56,120
en un fundamento de programación

61
00:03:56,120 --> 00:03:56,979
solo es para que veáis

62
00:03:56,979 --> 00:04:00,419
el pseudocódigo, como se representa

63
00:04:00,419 --> 00:04:01,560
en un programa

64
00:04:01,560 --> 00:04:12,139
A ver, tenéis que diferenciar lo que es el diseño del algoritmo, que lo podéis hacer con cualquiera de estas tres cosas, con diagrama de flujo, con una tabla de decisión y con un pseudocódigo.

65
00:04:12,219 --> 00:04:20,439
Con tabla de decisión no me voy a meter, que lo sepáis, que hay una serie de posibles condiciones del problema con sus respectivas acciones, que sepáis eso.

66
00:04:20,819 --> 00:04:22,879
Pero con diagrama de flujo y pseudocódigo, sí.

67
00:04:22,879 --> 00:04:27,879
Y pseudocódigo, este programa nos permite crear programas en pseudocódigo.

68
00:04:27,879 --> 00:04:33,600
otro código. Entonces nosotros le podemos poner aquí, ¿veis? Yo le pongo escribir y

69
00:04:33,600 --> 00:04:45,939
le digo que me escriba hola, ¿cómo te llamas? Y luego después le digo leer, ¿vale? Para

70
00:04:45,939 --> 00:04:52,100
que el usuario pueda poner su propio nombre, ¿vale? Con el teclado. Entonces leer y le

71
00:04:52,100 --> 00:04:57,000
ponemos una variable que le va a llamar nombre. Todo lo que pongas por teclado lo va a meter

72
00:04:57,000 --> 00:05:01,819
dentro de esta variable que se llama nombre. Después, le damos a la vez a escribir y le

73
00:05:01,819 --> 00:05:17,500
decimos el saludo. Hola, ¿cómo estás? Vamos a ponerlo por aquí, coma, nombre. ¿Qué

74
00:05:17,500 --> 00:05:22,160
he hecho aquí? Lo que he hecho es, primero, he escrito una cadena de texto en el que escribir,

75
00:05:22,160 --> 00:05:25,220
Lo que nos va a permitir es leer una cadena de texto en la pantalla.

76
00:05:25,879 --> 00:05:30,040
Leer nos permite leer, el usuario puede escribir, le hacen una pregunta,

77
00:05:30,199 --> 00:05:34,759
se aparece un cursor parpadeando y lo que escriba se va a almacenar en esta variable que se llama nombre.

78
00:05:35,180 --> 00:05:39,759
Acordaos que una variable es una opción de cajón con un nombre donde ahí podemos guardar algo.

79
00:05:40,259 --> 00:05:43,279
¿Qué guardaremos? Pues en función de qué tipo sea la variable.

80
00:05:43,500 --> 00:05:45,800
Si es tipo entera, guardaremos números enteros.

81
00:05:45,800 --> 00:05:50,220
Si es tipo decimal, guardaremos números decimales.

82
00:05:50,220 --> 00:05:52,319
y es tipo cadena, guardaremos

83
00:05:52,319 --> 00:05:54,279
cadenas de texto

84
00:05:54,279 --> 00:05:56,339
después digo que

85
00:05:56,339 --> 00:05:58,519
escriba hola, ¿cómo estás? y a continuación

86
00:05:58,519 --> 00:06:00,220
lo que ha escrito el usuario

87
00:06:00,220 --> 00:06:01,220
en la variable nombre, ¿vale?

88
00:06:01,279 --> 00:06:03,500
y veis

89
00:06:03,500 --> 00:06:06,279
lo primero que me hace es poner hola, ¿cómo estás?

90
00:06:06,740 --> 00:06:07,680
pongo Paco

91
00:06:07,680 --> 00:06:09,779
y me saluda, ¿veis?

92
00:06:09,879 --> 00:06:12,100
hola, ¿cómo estás Paco? ¿veis? este es el algoritmo

93
00:06:12,100 --> 00:06:13,800
me han pedido este algoritmo y lo resuelve

94
00:06:13,800 --> 00:06:15,000
aquí tiene

95
00:06:15,000 --> 00:06:17,439
¿por qué he querido que veáis esto?

96
00:06:17,600 --> 00:06:19,980
no porque quiera que aprendáis este programa

97
00:06:19,980 --> 00:06:25,019
sino porque aquí tiene la oportunidad de que veamos lo que es un diagrama de flujo.

98
00:06:25,459 --> 00:06:32,220
Este programa lo convierte luego en un diagrama de flujo y veis, este algoritmo, como hemos visto, es finito.

99
00:06:32,519 --> 00:06:36,199
Tiene un comienzo y un final con una serie de pasos que van en una única dirección.

100
00:06:36,399 --> 00:06:37,620
Siempre es unidireccional.

101
00:06:38,199 --> 00:06:44,800
Podría ser bidireccional, pero luego, aunque sea bidireccional, el algoritmo seguirá una sola línea.

102
00:06:44,800 --> 00:06:49,720
que lo que hace primero lo representa el inicio y el final del algoritmo

103
00:06:49,720 --> 00:06:53,560
en diagramas de flujo lo representa a través de elipses

104
00:06:53,560 --> 00:06:58,500
y cuando haces una operación de escritura en pantalla

105
00:06:58,500 --> 00:07:02,199
lo representa con este paralelepípedo o rectángulo inclinado

106
00:07:02,199 --> 00:07:04,519
en el que veis que la flecha está hacia arriba

107
00:07:04,519 --> 00:07:06,879
que aquí quiere decir que escribe en pantalla

108
00:07:06,879 --> 00:07:10,199
a continuación pasa a la siguiente línea que es nombre

109
00:07:10,199 --> 00:07:12,519
y lo que hace es otro paralelepípedo

110
00:07:12,519 --> 00:07:18,120
Tanto las operaciones de entrada y salida en el ordenador

111
00:07:18,120 --> 00:07:21,199
Las va a ejecutar y las representa a través de un parámetro

112
00:07:21,199 --> 00:07:27,639
Pero ahora el mismo lo representa como una flecha hacia la variable que yo he puesto

113
00:07:27,639 --> 00:07:30,519
O sea, que lo que escriba irá aquí dentro

114
00:07:30,519 --> 00:07:33,560
A continuación, la siguiente sigue con la flecha

115
00:07:33,560 --> 00:07:36,360
Y sigue a otra operación en la que sería escribir

116
00:07:36,360 --> 00:07:38,240
Y veis, es otro parámetro en el que pone

117
00:07:38,240 --> 00:07:38,899
Hola, ¿cómo estás?

118
00:07:39,040 --> 00:07:42,019
Y esta sería la flecha que indica que es de salida

119
00:07:42,019 --> 00:07:44,019
Aquí terminaría el algoritmo

120
00:07:44,019 --> 00:07:45,660
Esta es la manera

121
00:07:45,660 --> 00:07:48,459
La segunda manera de poder representar

122
00:07:48,459 --> 00:07:49,500
Un

123
00:07:49,500 --> 00:07:51,060
Un

124
00:07:51,060 --> 00:07:52,879
Un algoritmo

125
00:07:52,879 --> 00:07:56,019
Bien con pseudocódigo, que sería esto

126
00:07:56,019 --> 00:07:57,180
O bien con

127
00:07:57,180 --> 00:08:00,240
Con diagrama de flujo

128
00:08:00,240 --> 00:08:02,019
Una vez que tenemos resuelto el problema

129
00:08:02,019 --> 00:08:04,319
Bien con esta vía, bien con esta otra vía

130
00:08:04,319 --> 00:08:06,279
Pasaremos a codificar esto

131
00:08:06,279 --> 00:08:07,480
En algún lenguaje de programación

132
00:08:07,480 --> 00:08:09,259
Y haremos lo que se llama el programa

133
00:08:09,259 --> 00:08:11,160
¿Veis la diferencia entre una cosa y la otra?

134
00:08:11,639 --> 00:08:11,800
¿Vale?

135
00:08:12,019 --> 00:08:27,990
Y aquí tenéis un vídeo con el DGD, que es un programa para principiantes y que nos permite crear diagramas de flujo como el que he hecho yo.

136
00:08:29,170 --> 00:08:38,610
También nos habla de PESAIN, que es un programa que nos permite ejecutar código, vamos, realizar pseudocódigo.

137
00:08:38,610 --> 00:08:43,490
Está muy bien porque es en castellano y es muy sencillo

138
00:08:43,490 --> 00:08:49,629
Y nos permite meter aquí condicionales, bucles, etc. solo dándole con un botón

139
00:08:49,629 --> 00:08:54,820
Paradigma de programación

140
00:08:54,820 --> 00:08:56,779
¿Qué es un paradigma de programación?

141
00:08:57,220 --> 00:09:00,200
Es un modelo básico para el diseño e implementación de programas

142
00:09:00,200 --> 00:09:05,419
Es como si dijéramos una serie de características que va a tener ese lenguaje de programación

143
00:09:05,419 --> 00:09:07,960
A la hora de diseñarlo

144
00:09:07,960 --> 00:09:13,100
que las personas que han diseñado cada uno de los lenguajes de programación se basan en un paradigma.

145
00:09:13,399 --> 00:09:16,460
Eso es lo que compete a esto que aparece aquí.

146
00:09:16,659 --> 00:09:19,080
Es un modelo básico para el diseño e implementación de programas.

147
00:09:19,740 --> 00:09:26,019
Hay una subdivisión en dos, que serían la programación declarativa y la imperativa.

148
00:09:26,559 --> 00:09:32,980
La declarativa no nos importa, es muy diferente a la programación imperativa.

149
00:09:32,980 --> 00:09:37,600
Una programación imperativa es un desarrollo de un algoritmo detallado, como lo que hemos hecho, de arriba a abajo.

150
00:09:37,600 --> 00:09:59,399
A base de una serie de instrucciones que se van ejecutando una detrás de otra. Esto son ejemplos de lenguajes, Python, Java, C++, pero la declarativa se basa en una serie de condiciones o proposiciones y aquí ya no nos importa el resultado, sino en cómo se hace, sino en qué es lo que quiere que haga.

151
00:09:59,399 --> 00:10:22,379
Algunos detalles de la programación declarativa que son, ahora estamos hablando de una programación lo que se llama lógica, en el que se va a solucionar, o sea, el problema que se quiere solucionar lo va a describir, pero no las instrucciones necesarias para generar esa solución.

152
00:10:22,379 --> 00:10:33,879
No sé si me explico. En cambio, en la imperativa sí necesitamos esas instrucciones que necesitas para generar la solución. Aquí no se preocupa por eso, sino por lo que se quiere solucionar.

153
00:10:33,980 --> 00:10:48,220
Un ejemplo de este sería el lenguaje SQL. Este es de indicar que dentro de las generaciones de lenguajes de programación, por ejemplo, la programación imperativa con Java, estos son lenguajes de tercera generación,

154
00:10:48,220 --> 00:11:08,139
Pero en la declarativa serían ya lenguajes de cuarta generación. Dentro de la primera generación estaba el código máquina, ensamblador, etc. Pero el código máquina sería la primera generación, la segunda generación sería el ensamblador y luego la tercera generación serían todos estos lenguajes que hay aquí.

155
00:11:08,139 --> 00:11:13,059
en cuarta generación tendríamos la programación declarativa

156
00:11:13,059 --> 00:11:13,980
como por ejemplo ese

157
00:11:13,980 --> 00:11:18,899
Fases de la programación, creo que esto lo hablamos

158
00:11:18,899 --> 00:11:20,159
pero bueno, hay tres fases

159
00:11:20,159 --> 00:11:22,879
primero, fase de resolución del problema

160
00:11:22,879 --> 00:11:26,419
a ver, aquí te proponen un problema

161
00:11:26,419 --> 00:11:31,919
ese problema, lo primero que vas a hacer es analizar ese problema

162
00:11:31,919 --> 00:11:35,720
si a ti te dan un problema y no entiendes el problema

163
00:11:35,720 --> 00:11:39,000
porque no lo has analizado, es muy difícil que lo vayas a resolver

164
00:11:39,000 --> 00:12:05,860
Entonces esa primera fase sería la de resolución del problema. Para resolverlo lo primero que tienes que saber es entender el problema. Una vez que has entendido el problema, porque has hecho un análisis de ese problema, se encarga de que, por medio de estos métodos que hemos visto aquí arriba, o bien por pseudocódigo o bien por diagrama de flujo, resolver ese problema, resolver el algoritmo que va a resolver el problema.

165
00:12:05,860 --> 00:12:17,580
Esto sería una fase como de diseño. Una vez que ya lo ha resuelto, vas a codificarlo, vas a pasar a la fase de implementación y a testearlo a través de pruebas.

166
00:12:18,220 --> 00:12:25,379
Y luego una última fase sería la fase de explotación y mantenimiento. Es ya cuando el programa está en ejecución en un entorno,

167
00:12:25,559 --> 00:12:32,200
o en un programa empresarial o donde sea, donde se está ejecutando, donde se está utilizando y donde el cliente puede encontrar algún bug

168
00:12:32,200 --> 00:12:44,860
o encontrar algún problema, o incluso pueden sugerir algunas mejoras que puedan llevar otra vez hacia atrás en estas tres fases

169
00:12:44,860 --> 00:12:50,379
y establecer una nueva versión de ese programa. Esa sería la fase de explotación y de mantenimiento.

170
00:12:51,700 --> 00:12:56,740
Fijaos, aquí la fase de resolución del problema habla de un análisis y de un diseño.

171
00:12:57,299 --> 00:13:00,720
El análisis es lo que he dicho yo, que tienes que hacer preguntas sobre ese problema.

172
00:13:00,720 --> 00:13:03,700
Imaginaos, este problema es muy sencillo

173
00:13:03,700 --> 00:13:08,080
Fijaos, me están diciendo que haga un algoritmo

174
00:13:08,080 --> 00:13:11,639
Que permita saludar a un usuario

175
00:13:11,639 --> 00:13:13,919
Escribir su nombre y que el programa le salude

176
00:13:13,919 --> 00:13:16,179
El programa es muy sencillo

177
00:13:16,179 --> 00:13:19,879
Pero primero, imaginaos un algoritmo que os pidan

178
00:13:19,879 --> 00:13:21,220
Que sea muy complejo

179
00:13:21,220 --> 00:13:27,820
A lo mejor el que os solicita que resolváis ese problema

180
00:13:27,820 --> 00:13:29,379
Lo tiene muy claro él

181
00:13:29,379 --> 00:13:47,700
Pero a lo mejor nosotros, que tenemos que codificar, que tenemos que diseñar previamente ese algoritmo, pues no lo tenemos tan claro. Entonces, ¿qué es lo que haríamos lo primero? Es un análisis, realizar preguntas al cliente, ver cuál es la información que tiene ese problema, qué datos son necesarios, bueno, muchas cosas que nos van a permitir entender el problema.

182
00:13:47,700 --> 00:13:49,700
entonces esa sería la fase de análisis

183
00:13:49,700 --> 00:13:52,480
una vez que hemos hecho la fase de análisis

184
00:13:52,480 --> 00:13:54,360
aquí ya se supone

185
00:13:54,360 --> 00:13:56,080
a partir de esta línea

186
00:13:56,080 --> 00:13:57,919
se supone que ya entendemos el problema

187
00:13:57,919 --> 00:14:00,440
como lo entendemos, podemos diseñar

188
00:14:00,440 --> 00:14:02,159
un algoritmo, ¿cómo se diseñaba?

189
00:14:02,460 --> 00:14:04,679
con diálogo de fujo, con tabla de decisiones

190
00:14:04,679 --> 00:14:05,980
con pseudocódigo

191
00:14:05,980 --> 00:14:07,919
hay más métodos, pero bueno, esos serían

192
00:14:07,919 --> 00:14:10,460
principalmente los que os voy a poner aquí en el aula

193
00:14:10,460 --> 00:14:13,340
se diseñaría

194
00:14:13,340 --> 00:14:16,279
¿qué sucede cuando ya se ha diseñado?

195
00:14:16,360 --> 00:14:17,539
pues ya pasamos a la siguiente fase

196
00:14:17,539 --> 00:14:22,440
que es la fase de implementación. Esa fase de implementación también tiene dos subfases.

197
00:14:22,899 --> 00:14:29,940
Una primera fase sería la de codificación. Ahora ya no estamos hablando de algoritmo, problema, diseño.

198
00:14:30,200 --> 00:14:37,740
Estamos hablando de codificación o construcción de un programa, que es diferente con lo que hemos visto como algoritmo.

199
00:14:38,200 --> 00:14:43,519
Y ahora tenemos que codificar ese programa y en esta fase incluso podemos elegir o llegar a un acuerdo

200
00:14:43,519 --> 00:14:48,419
sobre qué lenguaje de programación elegir, porque luego todos los lenguajes de programación

201
00:14:48,419 --> 00:14:50,980
nos sirven para solucionar todos los problemas.

202
00:14:51,299 --> 00:14:53,799
Hay lenguajes de programación que son más aptos para una serie de problemas

203
00:14:53,799 --> 00:14:56,440
y otros lenguajes de programación más aptos para otros problemas.

204
00:14:56,879 --> 00:15:00,600
Entonces, incluso en esta fase podríamos elegir qué lenguaje de programación usar

205
00:15:00,600 --> 00:15:04,360
y para codificar ese algoritmo que ya hemos diseñado.

206
00:15:05,200 --> 00:15:11,120
Lo construimos, lo compilamos, bien a través de un compilador o bien a través de un intérprete.

207
00:15:11,179 --> 00:15:11,960
¿De qué depende esto?

208
00:15:11,960 --> 00:15:29,960
Esto dependerá del lenguaje de programación que utilicemos. Si utilizamos un compilador, serán lenguajes como C, C++, Java, en el que lo que va a hacer, Java sería más a través de un intermedio bytecoded, pero no sería a través de un intérprete.

209
00:15:29,960 --> 00:15:33,879
Bueno, sí, sería una máquina virtual, pero bueno, pongamos C, C++.

210
00:15:34,100 --> 00:15:39,860
Entonces, a través de un compilador que nos va a pasar a transformar el código

211
00:15:39,860 --> 00:15:46,220
escrito en C o C++, nos va a transformar en un ejecutable en código macro.

212
00:15:47,460 --> 00:15:53,080
Por tanto, un compilador es mucho más rápido que lo que puede ser un intérprete.

213
00:15:53,080 --> 00:15:56,980
Bueno, y el compilador en Java estaría en Java C, en el que también nos compilaría,

214
00:15:57,059 --> 00:15:58,019
que nos generaría el bytecode.

215
00:15:58,019 --> 00:16:00,580
En cambio, un intérprete ¿qué hace?

216
00:16:02,580 --> 00:16:05,220
Ya digo, esto dependerá de la elección de uno o de otro

217
00:16:05,220 --> 00:16:07,519
Dependerá del lenguaje de la programación que hayas elegido

218
00:16:07,519 --> 00:16:10,039
Un intérprete, por ejemplo, como puede ser en PHP

219
00:16:10,039 --> 00:16:11,960
¿Qué es lo que hace?

220
00:16:12,080 --> 00:16:15,320
Va leyendo línea a línea cuando está en ejecución

221
00:16:15,320 --> 00:16:19,179
Y va a ejecutar esas líneas

222
00:16:19,179 --> 00:16:21,580
Las va traduciendo y ejecutando línea a línea

223
00:16:21,580 --> 00:16:25,580
Por lo tanto, será más lento que lo que puede ser a través de un compilado

224
00:16:26,580 --> 00:16:47,019
Una vez que ya hemos elegido el lenguaje de programación, hemos elegido si va a ser un concepto de lenguaje de programación, si va a ser a través de un compilador, a través de un intérprete y hemos codificado el programa y lo hemos compilado o lo hemos ejecutado, mejor dicho, pues tenemos que pasar a otra subfase dentro de la implementación que serán las pruebas de ejecución y validación.

225
00:16:47,019 --> 00:17:10,440
Estas pruebas son indispensables a la hora de realizar un programa porque nos va a permitir, dentro del dominio de posibilidades que puede tener ese programa, generar una serie de pruebas que, siempre que se realizan pruebas a un programa, no queda exento al 100% que no tenga un error.

226
00:17:10,440 --> 00:17:23,200
Eso nunca es así. Lo que pasa es que cuando nosotros hacemos una serie de pruebas, esas pruebas las ejecutamos con respecto a lo que queremos probar, a lo que realmente queremos que no falle,

227
00:17:23,559 --> 00:17:36,339
sus valores límite, un montón de pruebas que se pueden realizar y cuantas más pruebas y más vayan enfocadas a lo que nos importa del programa, pues mayor seguridad tendremos de que ese programa funcione de manera correcta y no genera errores.

228
00:17:36,339 --> 00:17:45,279
Pero ningún tipo de pruebas nos da un 100% absoluto de que un programa no tenga error.

229
00:17:45,279 --> 00:17:49,279
Luego ya nos pasa a la tercera fase que sería la explotación

230
00:17:49,279 --> 00:17:53,460
que es la que he dicho antes, aquí se van viendo si hay nuevas necesidades

231
00:17:53,460 --> 00:17:56,480
que va a requerir

232
00:17:56,480 --> 00:18:01,220
introducir cambios en el programa

233
00:18:01,220 --> 00:18:04,619
o si tiene algún error que se detecta a posteriori

234
00:18:04,619 --> 00:18:06,839
que hay que modificar

235
00:18:06,839 --> 00:18:11,759
¿Qué más? Tenemos el ciclo de vida del software

236
00:18:11,759 --> 00:18:16,220
El ciclo de vida del software es una serie de fases

237
00:18:16,220 --> 00:18:17,980
En las cuales pasa el software

238
00:18:17,980 --> 00:18:20,779
Donde pasa a través del software

239
00:18:20,779 --> 00:18:24,259
Digamos, como si

240
00:18:24,259 --> 00:18:26,339
¿Cómo explicarlo?

241
00:18:26,880 --> 00:18:29,980
A lo largo de toda la creación del software

242
00:18:29,980 --> 00:18:30,880
Hay una serie de fases

243
00:18:30,880 --> 00:18:32,920
Y eso se le llama el ciclo de vida

244
00:18:32,920 --> 00:18:38,079
Ese ciclo de vida pasa por estas distintas fases que aparecen aquí

245
00:18:38,079 --> 00:18:41,180
Una de las primeras y la segunda ya nos suena

246
00:18:41,180 --> 00:18:44,839
de lo que hemos dicho antes. Una es la especificación y análisis de requisitos.

247
00:18:45,299 --> 00:18:49,339
El análisis de requisitos sea tanto de requisitos funcionales como de requisitos no funcionales.

248
00:18:51,000 --> 00:18:53,059
Esos análisis de requisitos se hace

249
00:18:53,059 --> 00:18:56,980
con el cliente y se determina qué es lo que necesita

250
00:18:56,980 --> 00:18:58,460
la aplicación, qué es lo fundamental

251
00:18:58,460 --> 00:19:05,160
para su funcionamiento y luego, aparte, también requisitos

252
00:19:05,160 --> 00:19:07,980
no funcionales, pero que pueden implicar

253
00:19:07,980 --> 00:19:13,240
tenga un gran rendimiento en la aplicación

254
00:19:13,240 --> 00:19:16,019
o que tenga una gran seguridad

255
00:19:16,019 --> 00:19:18,440
o ya serían requisitos no funcionales.

256
00:19:18,500 --> 00:19:22,259
Pero todo eso antes de comenzar

257
00:19:22,259 --> 00:19:24,759
tiene que estar detallado

258
00:19:24,759 --> 00:19:27,920
para luego pasar a la fase de diseño.

259
00:19:28,400 --> 00:19:30,160
La fase de diseño es la que hemos visto antes.

260
00:19:30,279 --> 00:19:33,660
Es la fase de diseño de la aplicación

261
00:19:33,660 --> 00:19:36,619
del algoritmo que vayamos a resolver.

262
00:19:37,200 --> 00:19:43,980
Esa fase de diseño se puede realizar tanto en pseudocódigo, se puede realizar en diagramas de flujo, lo que queráis.

263
00:19:44,779 --> 00:19:48,420
Y ya pasa la fase de codificación, que era la fase de implementación que veíamos antes.

264
00:19:48,420 --> 00:19:57,240
Esa fase de codificación es la codificación en lenguaje que uno quiera utilizar o que más se adapte a nuestro problema.

265
00:19:58,500 --> 00:20:03,680
A continuación, una vez en la codificación, hay ciclos de vida donde las pruebas las ponen antes que la codificación.

266
00:20:03,680 --> 00:20:06,900
hay veces en el que en función del problema

267
00:20:06,900 --> 00:20:09,599
crean las pruebas previas incluso a la codificación

268
00:20:09,599 --> 00:20:11,180
eso es en programación extrema

269
00:20:11,180 --> 00:20:16,019
en el que se utiliza primero las pruebas

270
00:20:16,019 --> 00:20:17,220
y luego la codificación

271
00:20:17,220 --> 00:20:19,559
eso da una gran seguridad

272
00:20:19,559 --> 00:20:22,019
pero que sepáis que cuando uno codifica algo

273
00:20:22,019 --> 00:20:25,000
tiene que ir añadido con pruebas

274
00:20:25,000 --> 00:20:28,859
pruebas que cubran el mayor margen de posibilidad

275
00:20:28,859 --> 00:20:31,799
de errores que pueda tener nuestra aplicación

276
00:20:32,700 --> 00:20:37,740
Luego ya pasa la instalación en el lugar donde se vaya a ejecutar y el paso a producir.

277
00:20:38,420 --> 00:20:44,660
Luego queda el mantenimiento, que es lo que hablaba antes de si necesita mejoras, si hay algún error que a posteriori pueda salir, etc.

278
00:20:45,200 --> 00:20:57,859
Con lo cual, si hubiera que realizar alguna mejora o algo, tendríamos que ir otra vez hacia atrás en ese ciclo de vida para poder sacar la nueva versión de la vida.

279
00:20:57,859 --> 00:21:11,049
Pasamos a los lenguajes de programación. Un lenguaje de programación es como un idioma, tiene una serie de reglas léxicas, sintácticas y semánticas.

280
00:21:11,049 --> 00:21:29,289
Es igual, va a estar definido con unas reglas léxicas, o sea, va a tener una serie de palabras reservadas, es el lenguaje, eso se llama la regla léxica, también sintácticas, como uno de esas palabras para formar una frase, esto es igual, podría ser por nuestro idioma.

281
00:21:29,289 --> 00:21:37,369
Y semántica, una vez que ya he unido ese conjunto de palabras en una frase, saber si realmente tiene sentido o no.

282
00:21:38,109 --> 00:21:42,210
Entonces, un compilador que pasa a través de estas tres reglas.

283
00:21:42,650 --> 00:21:49,589
Primero comprueba léxicas, comprueba si esas palabras que aparecen en ese lenguaje son las correctas o no.

284
00:21:50,029 --> 00:21:53,730
Luego, sintácticas, si se han construido bien las frases.

285
00:21:53,890 --> 00:21:56,349
Y semánticas, si luego realmente eso tiene sentido.

286
00:21:56,349 --> 00:22:06,410
Una regla semántica podría ser si un tipo, por ejemplo, una variable tiene el tipo adecuado a la inicialización de la misma.

287
00:22:07,589 --> 00:22:16,170
Bien, ya sabemos lo que es un lenguaje de programación. La gramática del lenguaje serán todas las reglas aplicadas a ese conjunto de símbolos y parábolas especiales de ese lenguaje.

288
00:22:16,730 --> 00:22:20,950
Y aquí tenemos la gramática, está definida por un léxico, una sintaxis y una sema.

289
00:22:20,950 --> 00:22:24,930
El primer lenguaje que surgió fue el lenguaje máquina

290
00:22:24,930 --> 00:22:27,329
que es un lenguaje de primera generación

291
00:22:27,329 --> 00:22:31,369
en el que era un lenguaje lo que se llama de bajo nivel

292
00:22:31,369 --> 00:22:34,950
No sé si lo dije otra vez, pero los lenguajes de bajo nivel

293
00:22:34,950 --> 00:22:37,829
son aquellos que están muy cercanos a la máquina

294
00:22:37,829 --> 00:22:41,230
Los lenguajes de alto nivel son los que están más cercanos a la persona

295
00:22:41,230 --> 00:22:43,869
¿Cómo distingo yo eso?

296
00:22:43,869 --> 00:22:49,890
Un lenguaje muy cercano a la máquina es el que está en un lenguaje que solo entiende el ordenador

297
00:22:49,890 --> 00:22:52,930
Un ordenador solo entiende de ceros y unos

298
00:22:52,930 --> 00:22:54,690
Tensión, no tensión

299
00:22:54,690 --> 00:22:56,450
Un uno, un cero

300
00:22:56,450 --> 00:22:57,670
No entiendo otra cosa

301
00:22:57,670 --> 00:23:00,589
Entonces, lógicamente, si tú le pones un programa

302
00:23:00,589 --> 00:23:01,569
Con ceros y unos

303
00:23:01,569 --> 00:23:04,509
El lenguaje es de bajo nivel

304
00:23:04,509 --> 00:23:05,970
Está muy cercano a la máquina

305
00:23:05,970 --> 00:23:07,009
La máquina lo entiende

306
00:23:07,009 --> 00:23:10,009
Ponte tú a programar

307
00:23:10,009 --> 00:23:11,369
Lenguaje a máquina

308
00:23:11,369 --> 00:23:14,490
Para programas muy sencillos

309
00:23:14,490 --> 00:23:15,230
Pues vale, pero

310
00:23:15,230 --> 00:23:18,890
La cantidad de ceros y unos que se te puede convertir

311
00:23:18,890 --> 00:23:32,089
Es inviable. Entonces, con ello surgieron nuevos lenguajes a partir del lenguaje máquina, que se alejaban un poquito de la máquina y se acercaban un poquito hacia nosotros. ¿Para qué? Para que tuviéramos una mayor facilidad de poderlos programar.

312
00:23:32,089 --> 00:23:47,750
Entonces, los lenguajes de programación vienen de inglés. ¿Por qué? Porque fueron creados por personas americanas o inglesas, entonces por eso aparecen los lenguajes de programación en inglés.

313
00:23:48,890 --> 00:24:08,609
El lenguaje asamblador fue el primero en el que utilizaba reglas memotécnicas, ya introducía estas palabras que aparecen aquí para dividir, para multiplicar, para mover y ya lo que hacía es que se alejaba un poquito del lenguaje de programación, exactamente código máquina y se acercaba un poquito a nosotros, a las personas.

314
00:24:08,609 --> 00:24:12,650
Ya teníamos alguna palabra que podíamos entender para poder programar.

315
00:24:12,869 --> 00:24:19,630
Aún así, el código máquina también es un lenguaje en el que es difícil de programar,

316
00:24:19,730 --> 00:24:23,849
pero siempre es mucho más sencillo que programar, por ejemplo, un código máquina.

317
00:24:25,930 --> 00:24:30,869
Después surgieron ya los lenguajes compilados, que son ya los lenguajes de alto nivel.

318
00:24:31,470 --> 00:24:36,730
Pascal, Fortran, CET y demás lenguajes que se parecen mucho más,

319
00:24:36,730 --> 00:24:41,650
O sea, que el ser humano es capaz de interpretar mucho mejor que una máquina.

320
00:24:42,089 --> 00:24:44,369
¿Por qué? Porque ya parece como lo que hablábamos arriba,

321
00:24:44,529 --> 00:24:50,250
con una serie de palabras, unas reglas léxicas, unas sintácticas y semánticas,

322
00:24:50,369 --> 00:24:52,210
que es como nuestro idioma en castellano.

323
00:24:53,009 --> 00:24:56,009
Tiene un léxico, una serie de palabras, una sintaxis,

324
00:24:56,190 --> 00:24:59,150
y es muy parecido a lo que es un lenguaje humano.

325
00:24:59,750 --> 00:25:02,269
De ahí que sean los llamados lenguajes de Aldo.

326
00:25:02,269 --> 00:25:05,670
aquí viene como lo que es un compilador

327
00:25:05,670 --> 00:25:07,230
como genera el código fuente

328
00:25:07,230 --> 00:25:09,650
no me voy a meter mucho en eso

329
00:25:09,650 --> 00:25:12,130
y luego los lenguajes interpretados

330
00:25:12,130 --> 00:25:13,250
ya lo he dicho

331
00:25:13,250 --> 00:25:16,069
Perl, Python, PHP, Javascript

332
00:25:16,069 --> 00:25:17,910
todos estos son lenguajes en el que en vez de

333
00:25:17,910 --> 00:25:20,009
compilar, establecer

334
00:25:20,009 --> 00:25:21,609
y generar el código objeto

335
00:25:21,609 --> 00:25:23,410
con un código

336
00:25:23,410 --> 00:25:25,430
que sería el código fuente

337
00:25:25,430 --> 00:25:28,109
y lo que va a realizar a través de

338
00:25:28,109 --> 00:25:29,650
fijaos, aquí hay una tabla

339
00:25:29,650 --> 00:25:31,930
aquí hay una tabla

340
00:25:31,930 --> 00:25:34,130
en el que el compilador

341
00:25:34,130 --> 00:25:36,049
¿qué es lo que hace? Fijaos lo que hace el compilador

342
00:25:36,049 --> 00:25:37,730
un compilador lo que hace es

343
00:25:37,730 --> 00:25:40,029
analiza el léxico, ve si las

344
00:25:40,029 --> 00:25:41,549
palabras que tú has escrito

345
00:25:41,549 --> 00:25:44,289
en ese código fuente se corresponden

346
00:25:44,289 --> 00:25:45,930
con el lenguaje de programación

347
00:25:45,930 --> 00:25:47,569
que está compilando

348
00:25:47,569 --> 00:25:50,190
luego analiza

349
00:25:50,190 --> 00:25:52,190
a nivel sintáctico si las frases

350
00:25:52,190 --> 00:25:53,710
que has creado en el lenguaje

351
00:25:53,710 --> 00:25:56,130
imaginaos si yo le he creado

352
00:25:56,130 --> 00:25:58,569
fijaos aquí en

353
00:25:58,569 --> 00:26:00,430
Java, pues lo primero que va a hacer

354
00:26:00,430 --> 00:26:02,390
es el lenguaje léxico

355
00:26:02,390 --> 00:26:03,630
el compilador lo primero que va a hacer es

356
00:26:03,630 --> 00:26:05,450
primero coge la palabra public

357
00:26:05,450 --> 00:26:07,130
bueno, empezaría por aquí

358
00:26:07,130 --> 00:26:09,089
coge la palabra public

359
00:26:09,089 --> 00:26:12,569
y hace un análisis léxico, mira a ver si esa palabra existe

360
00:26:12,569 --> 00:26:14,210
mientras las palabras reservadas las dejaba

361
00:26:14,210 --> 00:26:15,769
y ve que sí, que existe

362
00:26:15,769 --> 00:26:18,589
luego coge class y también ve que también existe

363
00:26:18,589 --> 00:26:20,630
a nivel léxico eso no está cumpliendo

364
00:26:20,630 --> 00:26:21,710
luego ve que esto

365
00:26:21,710 --> 00:26:23,910
no existe

366
00:26:23,910 --> 00:26:25,990
pero debe ser

367
00:26:25,990 --> 00:26:27,890
algún literal, algún nombre

368
00:26:27,890 --> 00:26:29,730
que el propio programador ha puesto

369
00:26:29,730 --> 00:26:46,329
A continuación, hace un análisis de esta frase, hace un análisis sintáctico. Ve si todo esto encaja o no. Si poniendo public, class y luego un nombre o un literal, esto encaja o no a nivel sintáctico.

370
00:26:46,329 --> 00:26:48,730
llegar a la conclusión

371
00:26:48,730 --> 00:26:50,109
que sí, está bien escrito

372
00:26:50,109 --> 00:26:52,089
y luego a nivel semántico

373
00:26:52,089 --> 00:26:54,450
a nivel semántico es un poco más complejo

374
00:26:54,450 --> 00:26:56,250
pero es ver si tiene sentido

375
00:26:56,250 --> 00:26:58,170
lo que ha escrito aquí

376
00:26:58,170 --> 00:26:59,789
si este método está dentro de esta clase

377
00:26:59,789 --> 00:27:01,549
pues eso es lo que hace

378
00:27:01,549 --> 00:27:03,890
lo que haría

379
00:27:03,890 --> 00:27:05,269
tanto en C, C++

380
00:27:05,269 --> 00:27:07,349
como lo haría en Java cuando compila

381
00:27:07,349 --> 00:27:08,970
para formar el bytecode

382
00:27:08,970 --> 00:27:11,670
una vez que ha pasado por esas tres

383
00:27:11,670 --> 00:27:13,730
genera un código intermedio

384
00:27:13,730 --> 00:27:15,410
hay un optimizador de código

385
00:27:15,410 --> 00:27:17,049
aquí, lo optimiza

386
00:27:17,049 --> 00:27:19,430
y a continuación genera el código objeto

387
00:27:19,430 --> 00:27:21,289
y aquí ya tenemos que esto ya es el código

388
00:27:21,289 --> 00:27:23,369
máquina, o sea, los ceros y unos

389
00:27:23,369 --> 00:27:24,750
que va a entender ordenar

390
00:27:24,750 --> 00:27:27,410
eso sería en cuanto a un compilado

391
00:27:27,410 --> 00:27:31,089
en cambio el intérprete que lo pone

392
00:27:31,089 --> 00:27:32,950
aquí, que serían estos lenguajes

393
00:27:32,950 --> 00:27:34,769
de programación, ahora lo que está haciendo

394
00:27:34,769 --> 00:27:36,970
él se pone en ejecución y coge la primera línea

395
00:27:36,970 --> 00:27:39,230
y hace todo eso, pero lo va interpretando

396
00:27:39,230 --> 00:27:40,450
una a una

397
00:27:40,450 --> 00:27:42,690
la intérprete también que es correcto

398
00:27:42,690 --> 00:27:43,569
sigue con la siguiente

399
00:27:43,569 --> 00:27:46,869
no genera un programa ejecutable

400
00:27:46,869 --> 00:27:48,309
como pasaba con el compilado

401
00:27:48,309 --> 00:27:51,710
lógicamente, estos lenguajes de programación

402
00:27:51,710 --> 00:27:53,029
van a ser más lentos

403
00:27:53,029 --> 00:27:54,950
que lo que puede ser un lenguaje en C11

404
00:27:54,950 --> 00:27:57,029
por eso, por ejemplo

405
00:27:57,029 --> 00:27:59,390
cuando tú quieres hacer lo que hablaba antes

406
00:27:59,390 --> 00:28:01,730
en función del problema

407
00:28:01,730 --> 00:28:03,430
¿qué lenguaje de programación

408
00:28:03,430 --> 00:28:04,230
voy a utilizar?

409
00:28:05,029 --> 00:28:07,210
pues fijaos, si yo tengo que hacer

410
00:28:07,210 --> 00:28:09,250
una aplicación que va a

411
00:28:09,250 --> 00:28:10,569
funcionar en tiempo real

412
00:28:10,569 --> 00:28:13,490
¿qué elegiríais? ¿un intérprete o elegiríais un compilado?

413
00:28:13,869 --> 00:28:15,470
yo elegiría C o C++

414
00:28:15,470 --> 00:28:20,750
¿Por qué? Porque es muy rápido y necesitamos que las respuestas sean en tiempo real.

415
00:28:21,130 --> 00:28:27,609
Entonces, lo realizaría con C o con C++, pero no lo realizaría con Javascript o con Perl.

416
00:28:31,279 --> 00:28:33,880
Y pasamos ya al lenguaje de programación Java.

417
00:28:34,259 --> 00:28:43,299
El lenguaje de programación Java es un lenguaje que tiene una sintaxis muy parecida a C++.

418
00:28:43,299 --> 00:28:50,599
Bueno, en teoría, C++ es un lenguaje de programación que tiene la posibilidad de los punteros.

419
00:28:50,700 --> 00:28:54,319
Cosa que los punteros, un puntero es un acceso directo a memoria.

420
00:28:54,980 --> 00:28:56,759
C y C++ tenían un problema.

421
00:28:57,299 --> 00:29:01,440
Primero, para programar es más complejo debido a los punteros.

422
00:29:01,779 --> 00:29:11,440
Y además, la puedes generar una muy buena accediendo a accesos a memoria y provocando problemas.

423
00:29:11,440 --> 00:29:26,539
¿Qué sucede? Que Java los punteros los tiene camuflados, son de esos dividendos a memoria y veremos cómo los tiene camuflados Java con respecto a hace marcas, pero que sepáis que en Java no hay punteros.

424
00:29:26,539 --> 00:29:30,440
Acordaos que

425
00:29:30,440 --> 00:29:32,980
Necesita Java, que era independiente de la plataforma

426
00:29:32,980 --> 00:29:33,799
Y necesitaba una

427
00:29:33,799 --> 00:29:36,740
Una máquina virtual de Java

428
00:29:36,740 --> 00:29:39,039
Esa máquina virtual de Java lo que hacía era

429
00:29:39,039 --> 00:29:41,299
Ejecutar el bytecode

430
00:29:41,299 --> 00:29:42,539
Que generabas al compilar

431
00:29:42,539 --> 00:29:45,259
Por eso se le llama el byte once

432
00:29:45,259 --> 00:29:46,380
O runner

433
00:29:46,380 --> 00:29:49,500
Se puede hacer

434
00:29:49,500 --> 00:29:51,960
En cualquier lugar, independiente de la plataforma

435
00:29:51,960 --> 00:29:53,180
Si allí tiene una

436
00:29:53,180 --> 00:29:55,319
Máquina virtual, se va a poder ejecutar

437
00:29:55,319 --> 00:30:12,599
También está basado, aparte de, acordaos, en cuanto a los paradigmas, habíamos visto que había dos tipos de paradigmas en declarativo imperativo.

438
00:30:12,599 --> 00:30:18,920
Java es un lenguaje imperativo, pero además también es un lenguaje orientado a objetos.

439
00:30:18,920 --> 00:30:21,619
hay lenguajes en el que tienen varios paradigmas

440
00:30:21,619 --> 00:30:23,440
no solo uno, entonces Java

441
00:30:23,440 --> 00:30:25,559
es un lenguaje orientado a objetos

442
00:30:25,559 --> 00:30:27,680
¿qué quiere decir? que interpreta

443
00:30:27,680 --> 00:30:29,299
tú puedes utilizar también Java

444
00:30:29,299 --> 00:30:30,579
como vamos a hacer aquí

445
00:30:30,579 --> 00:30:33,579
luego lo veremos en un ejemplo de lo de las tres

446
00:30:33,579 --> 00:30:35,339
notas, puedes utilizarlo a través de esta aplicación

447
00:30:35,339 --> 00:30:37,079
como un lenguaje imperativo

448
00:30:37,079 --> 00:30:39,500
sin necesidad de crear, de utilizar

449
00:30:39,500 --> 00:30:41,160
herencia, ni polimorfismo

450
00:30:41,160 --> 00:30:42,539
ni encasulación, etc.

451
00:30:43,480 --> 00:30:45,299
pero Java está

452
00:30:45,299 --> 00:30:46,799
diseñado ¿para qué? para

453
00:30:46,799 --> 00:30:50,200
ser un programa orientado a objetos

454
00:30:50,200 --> 00:30:52,319
para interpretar el mundo real

455
00:30:52,319 --> 00:30:54,319
que tiene a su alrededor todo como un objeto

456
00:30:54,319 --> 00:30:56,299
con una serie de atributos y una serie de

457
00:30:56,299 --> 00:30:57,779
métodos que ya veremos más adelante

458
00:30:57,779 --> 00:31:01,680
esta es una breve historia de

459
00:31:01,680 --> 00:31:03,440
Java, leerlo

460
00:31:03,440 --> 00:31:05,500
no lo voy a repasar, que sepáis

461
00:31:05,500 --> 00:31:07,519
que en Java necesitamos un JDK

462
00:31:07,519 --> 00:31:09,380
que es donde está el compilado y luego

463
00:31:09,380 --> 00:31:11,420
un JRE donde teníamos la

464
00:31:11,420 --> 00:31:13,539
máquina virtual, acordaos que con

465
00:31:13,539 --> 00:31:15,140
el 25 LTS

466
00:31:15,140 --> 00:31:17,319
he utilizado solo JDK

467
00:31:17,319 --> 00:31:23,119
y hemos obviado el JR porque ya viene introducida la máquina virtual dentro de la JDK.

468
00:31:23,640 --> 00:31:26,039
Estas son las distintas plataformas de Java.

469
00:31:27,039 --> 00:31:37,019
Java 2.0, esto de entorno SAN, antiguamente Java pertenecía a SAN Microsystems, que era la empresa.

470
00:31:37,579 --> 00:31:42,180
Luego, posteriormente, la compró Oracle y es Oracle el que habla de esta.

471
00:31:42,180 --> 00:31:48,180
Aquí hablo también de los applets, de lo metido, pero bueno, los applets ya no se utilizan.

472
00:31:48,180 --> 00:31:58,180
Luego, el J2C es pensado para crear aplicaciones, esto sería para aplicaciones de escritorio, el J2C, pero el J2C sería para aplicaciones web empresariales,

473
00:31:58,180 --> 00:32:11,180
tanto en el lado servidor, a través del lado servidor, donde podemos crear una aplicación a nivel de con los servlets, los javabins, bueno.

474
00:32:11,180 --> 00:32:19,000
El JavaFX, que lo veremos, es para generar aplicaciones de Internet enriquecidas. Podríamos crear botones, menús, etc.

475
00:32:19,819 --> 00:32:28,279
Luego tenemos el Java embebido, para entremedio de las cosas, y el JavaCard, que es tecnología que permite la producción de pequeñas aplicaciones Java en tarjetas inteligentes.

476
00:32:28,279 --> 00:32:35,099
con respecto a la

477
00:32:35,099 --> 00:32:37,259
programación orientada

478
00:32:37,259 --> 00:32:38,839
a objetos y Java

479
00:32:38,839 --> 00:32:41,259
ya he dicho que todo se entiende

480
00:32:41,259 --> 00:32:42,000
como un objeto

481
00:32:42,000 --> 00:32:45,539
y

482
00:32:45,539 --> 00:32:48,420
lo único que vamos a hacer

483
00:32:48,420 --> 00:32:49,559
es que

484
00:32:49,559 --> 00:32:52,359
Java, la programación orientada a objetos

485
00:32:52,359 --> 00:32:53,819
se basa en la abstracción

486
00:32:53,819 --> 00:32:54,980
¿qué significa?

487
00:32:55,420 --> 00:32:57,440
que se generan clases

488
00:32:57,440 --> 00:32:59,799
que es como una abstracción

489
00:32:59,799 --> 00:33:03,660
por el mundo real, en el que en esas clases podemos instanciar objetos.

490
00:33:03,859 --> 00:33:08,240
Instanciar objetos de esa clase en el que cada uno tendrá una serie de propiedades

491
00:33:08,240 --> 00:33:09,940
y una serie de métodos diferentes.

492
00:33:11,000 --> 00:33:14,599
Aquí entran tres palabras fundamentales dentro de la promoción ambiental de objetos.

493
00:33:14,940 --> 00:33:20,079
Esto pasa igual tanto en Java, en C++, en Python, que son encapsulación, herencia y polivorcia.

494
00:33:21,900 --> 00:33:28,039
No me meto con encapsulaciones, tener resultados encapsulados de tal manera

495
00:33:28,039 --> 00:33:36,039
que accede a tus clases no tiene necesidad de verla, de ver esa información. Esas variables

496
00:33:36,039 --> 00:33:42,240
de miembro que tienes ocultas solo las pueden utilizar a través de métodos. En cuanto a

497
00:33:42,240 --> 00:33:46,299
la herencia es permitir utilizar una clase que hereda de otra, en la que puede ser utilizar

498
00:33:46,299 --> 00:33:53,200
sus métodos, etc. El polimorfismo lo veremos más adelante. Tampoco quiero que os metáis

499
00:33:53,200 --> 00:33:57,460
mucho con el polimorfismo porque tenemos que verlo como un ejemplo para que sepáis, pero

500
00:33:57,460 --> 00:34:06,839
que sepáis que polimorfismo, la misma palabra lo indica, son muchas formas. Aquí habla

501
00:34:06,839 --> 00:34:13,599
de la independencia de la plataforma y que además permite un trabajo en red. Independencia

502
00:34:13,599 --> 00:34:17,579
de la plataforma porque genera un bytecode que luego se puede ejecutar en cualquier lugar

503
00:34:17,579 --> 00:34:23,460
donde lo lleves donde haya una máquina virtual. Y que trabaja en red, sí, Java ofrece múltiples

504
00:34:23,460 --> 00:34:26,239
posibilidades con la comunicación vía TCP y IP.

505
00:34:31,760 --> 00:34:34,179
Aquí ya se mete con seguridad y simplicidad,

506
00:34:35,239 --> 00:34:37,000
que son dos características del lenguaje Java.

507
00:34:37,800 --> 00:34:40,800
Esto está relacionado tanto con la independencia como con el trabajo en red.

508
00:34:42,960 --> 00:34:45,880
Seguridad, ¿por qué? Porque los posibles accesos a zonas de memoria

509
00:34:45,880 --> 00:34:49,320
sensibles no suceden como sucedían C y C++.

510
00:34:49,940 --> 00:34:53,920
Acordaos, C y C++ utilizan los punteros. Aquí los accesos a memoria

511
00:34:53,920 --> 00:34:55,920
están camuflados, hay acceso a memoria

512
00:34:55,920 --> 00:34:58,159
pero tú no tienes un acceso

513
00:34:58,159 --> 00:34:59,159
directo a memoria

514
00:34:59,159 --> 00:35:02,179
esa es la gran diferencia con C++

515
00:35:02,179 --> 00:35:03,820
entonces en Java se ha eliminado

516
00:35:03,820 --> 00:35:05,559
esto pasa también en CESAR

517
00:35:05,559 --> 00:35:08,300
CESAR es un lenguaje que es muy parecido

518
00:35:08,300 --> 00:35:10,019
a Java, Microsoft, en el que

519
00:35:10,019 --> 00:35:11,760
también ha camuflado los punteros

520
00:35:11,760 --> 00:35:13,840
porque permite

521
00:35:13,840 --> 00:35:16,019
generar una gran seguridad, imaginaos

522
00:35:16,019 --> 00:35:17,199
en C++, si uno

523
00:35:17,199 --> 00:35:19,800
programa y ejecuta un programa que

524
00:35:19,800 --> 00:35:22,119
permite con punteros acceder directo

525
00:35:22,119 --> 00:35:23,659
a memoria y accede

526
00:35:23,659 --> 00:35:25,599
a lugares de memoria

527
00:35:25,599 --> 00:35:27,599
por ejemplo, los expertos en sistema operativo

528
00:35:27,599 --> 00:35:28,880
o un método a saber

529
00:35:28,880 --> 00:35:31,280
eso provocaba a veces

530
00:35:31,280 --> 00:35:33,639
muchos problemas cuando el que programaba

531
00:35:33,639 --> 00:35:35,320
en C++ no tenía una idea

532
00:35:35,320 --> 00:35:36,179
bien clara

533
00:35:36,179 --> 00:35:36,940
y entonces

534
00:35:36,940 --> 00:35:40,139
puedes producir

535
00:35:40,139 --> 00:35:42,320
grandes problemas de seguridad

536
00:35:42,320 --> 00:35:44,300
en cambio Java o César

537
00:35:44,300 --> 00:35:45,519
son lenguajes en el que

538
00:35:45,519 --> 00:35:47,920
tienen la misma propiedad desde la

539
00:35:47,920 --> 00:35:49,840
programación orientada a objetos pero

540
00:35:49,840 --> 00:35:52,280
al no tener un acceso directo

541
00:35:52,280 --> 00:35:59,360
a memoria pues le da una gran seguridad y luego la simplicidad java es tan potente como ceo temas

542
00:35:59,360 --> 00:36:04,639
más y además es bastante sencillo bueno al principio para poder hacer un poco complejo

543
00:36:04,639 --> 00:36:11,900
pero luego una vez como lo vas viendo ya veis como no es así además está relacionado fijaos

544
00:36:11,900 --> 00:36:17,000
aquí habla del recolector de basura el garbage colector en el que este es el que se va a encargar

545
00:36:17,000 --> 00:36:24,320
descargar de todos los pseudopunteros, que no son punteros, tenemos todos los accesos

546
00:36:24,320 --> 00:36:31,079
a determinados objetos, pues todo ese tipo que son accesos a memoria, va a haber un reconector

547
00:36:31,079 --> 00:36:36,239
de basura que cuando alguna referencia, que aquí lo llama, referencias a un determinado

548
00:36:36,239 --> 00:36:42,559
objeto, deja existir el objeto, pues el reconector de basura elimina esa memoria. Antes eso se

549
00:36:42,559 --> 00:36:45,800
tenía que hacer a través de los punteros por medio de enzimarlas.

550
00:36:47,000 --> 00:36:51,440
aquí tenemos el Java y los bytecodes

551
00:36:51,440 --> 00:36:54,139
y yo creo que voy a parar aquí

552
00:36:54,139 --> 00:36:56,079
y no voy a hablar mucho más

553
00:36:56,079 --> 00:36:57,980
lo único que quiero que veáis

554
00:36:57,980 --> 00:37:00,940
que una vez que implementas el código fuente

555
00:37:00,940 --> 00:37:04,719
lo que tenemos aquí, una vez que implementas este código fuente

556
00:37:04,719 --> 00:37:08,820
a continuación con Java C se produce la compilación

557
00:37:08,820 --> 00:37:10,440
y genera un bytecode

558
00:37:10,440 --> 00:37:14,000
un bytecode que es como un código intermedio

559
00:37:14,000 --> 00:37:26,980
Ese bytecode es el que luego tú puedes llevar a cualquier plataforma, con cualquier sistema operativo y con cualquiera que tenga la máquina virtual de Java, se puede ejecutar dicho bytecode.

560
00:37:27,139 --> 00:37:30,500
Y así funciona Java y en eso consiste el bytecode.

561
00:37:31,519 --> 00:37:37,039
Como dice aquí, es un conjunto de instrucciones en lenguaje de máquina que no son específicas a ningún procesador o sistema de cómputo.

562
00:37:37,039 --> 00:37:40,199
de código de bytes o bytecodes

563
00:37:40,199 --> 00:37:42,079
para una plataforma específica

564
00:37:42,079 --> 00:37:43,860
sería quien los ejecute

565
00:37:43,860 --> 00:37:46,179
independientemente

566
00:37:46,179 --> 00:37:47,559
de la plataforma

567
00:37:47,559 --> 00:37:49,880
todo depende de que tenga

568
00:37:49,880 --> 00:37:52,039
el intérprete de Java o lo que es la máquina

569
00:37:52,039 --> 00:37:54,909
virtual de Java

570
00:37:54,909 --> 00:37:56,630
¿hasta aquí alguna duda?

571
00:38:06,500 --> 00:38:07,559
a ver, separación

572
00:38:07,559 --> 00:38:12,010
ah, lo de separación después de las comillas

573
00:38:12,010 --> 00:38:13,309
es un efecto visual

574
00:38:13,309 --> 00:38:15,909
¿por qué? porque fijaos, yo cuando

575
00:38:15,909 --> 00:38:18,309
hago esto aquí, si le quito la separación

576
00:38:18,309 --> 00:38:21,130
me va a aparecer el nombre Paco pegado a llamas

577
00:38:21,130 --> 00:38:22,989
a los dos puntos y queda feo

578
00:38:22,989 --> 00:38:23,849
¿vale? yo siempre pongo

579
00:38:23,849 --> 00:38:26,550
¿esto qué pasa?

580
00:38:27,750 --> 00:38:33,000
que cuando lo hago aquí

581
00:38:33,000 --> 00:38:37,300
aquí se ha bloqueado

582
00:38:37,300 --> 00:38:39,440
pero bueno, básicamente es eso

583
00:38:39,440 --> 00:38:42,159
y cuando yo le pongo

584
00:38:42,159 --> 00:38:43,219
a ver aquí

585
00:38:43,219 --> 00:38:45,820
cerrar la ventana del editor

586
00:38:45,820 --> 00:38:51,969
ah, que cierre

587
00:38:51,969 --> 00:38:53,309
que cierre esto

588
00:38:53,309 --> 00:38:55,710
vale, si yo le quito el espacio

589
00:38:55,710 --> 00:38:57,289
es visual

590
00:38:57,289 --> 00:38:58,630
cuando le deje agotar

591
00:38:58,630 --> 00:39:03,010
no sé por qué

592
00:39:03,010 --> 00:39:03,929
como me ha quedado esto

593
00:39:03,929 --> 00:39:05,429
como así

594
00:39:05,429 --> 00:39:14,639
si yo le deje agotar

595
00:39:16,929 --> 00:39:39,260
veis

596
00:39:39,260 --> 00:39:41,780
te queda pegado esta

597
00:39:41,780 --> 00:39:42,320
a Paco

598
00:39:42,320 --> 00:39:44,900
le dejo ahí un espacio

599
00:39:44,900 --> 00:39:46,719
para que quede visualmente mejor

600
00:39:46,719 --> 00:39:48,059
nada más que eso

601
00:39:48,059 --> 00:39:49,500
no hay mucha más

602
00:39:49,500 --> 00:39:51,099
opaco

603
00:39:51,099 --> 00:39:54,320
aquí queda el espacio y la frase queda bien

604
00:39:54,320 --> 00:39:55,599
una tontería

605
00:39:55,599 --> 00:39:57,800
bueno, pues

606
00:39:57,800 --> 00:40:06,420
nos vamos a meter ahora con Java

607
00:40:06,420 --> 00:40:07,500
y vamos a ver un ejemplo

608
00:40:07,500 --> 00:40:10,679
aquí tengo lo que vamos a ver

609
00:40:10,679 --> 00:40:12,119
primero, tipos de datos

610
00:40:12,119 --> 00:40:13,480
vamos a poner aquí el 1

611
00:40:13,480 --> 00:40:16,219
y que vamos a ver, el único tipo de datos

612
00:40:16,219 --> 00:40:17,440
acordar de lo que era una variable

613
00:40:17,440 --> 00:40:26,440
Una variable que era un nombre que nosotros le damos donde algo, vamos a guardar algo.

614
00:40:26,599 --> 00:40:33,099
Y además, esa variable, ya que su nombre lo indica, es posible que pueda modificarse,

615
00:40:33,260 --> 00:40:35,079
pueda tener un diferente valor.

616
00:40:35,219 --> 00:40:38,739
La puedes modificar a lo largo de la ejecución del programa.

617
00:40:38,739 --> 00:40:57,440
Y si yo pongo esto, int nota igual a 10, aquí estoy definiendo una variable que se llama nota, la estoy declarando con un tipo entero, así es en Java, int, y con un valor de día.

618
00:40:57,440 --> 00:41:00,440
Lógicamente esto no tendría mucho sentido

619
00:41:00,440 --> 00:41:04,500
¿Por qué? Porque las notas pueden ser decimales

620
00:41:04,500 --> 00:41:07,440
Puedes tener un 4 con 3 o un 8 con 5

621
00:41:07,440 --> 00:41:15,300
Entonces yo no crearía una variable nota con un tipo entero

622
00:41:15,300 --> 00:41:17,019
Veis que aquí el formato es

623
00:41:17,019 --> 00:41:18,679
Entonces yo puedo poner por un double

624
00:41:18,679 --> 00:41:23,940
Que esto sería un tipo decimal

625
00:41:23,940 --> 00:41:25,440
También estaría float

626
00:41:25,440 --> 00:41:30,960
Doble sería para números de mayor tamaño que lo que es un float, pero bueno, en principio lo llamamos como un doble.

627
00:41:31,079 --> 00:41:34,820
Esto nos permite poner valores decimales.

628
00:41:35,320 --> 00:41:37,260
Con int nos daría error.

629
00:41:38,260 --> 00:41:41,559
Entonces, ¿qué partes tiene una variable?

630
00:41:41,840 --> 00:41:44,440
Si la ponemos aquí, tendría...

631
00:41:45,119 --> 00:41:47,960
Primero tienes que definir el tipo.

632
00:41:55,119 --> 00:41:57,019
Después, el nombre de la variable.

633
00:41:57,019 --> 00:42:04,179
y luego le asignamos un valor.

634
00:42:04,579 --> 00:42:07,239
El valor sería el valor que tiene aquí.

635
00:42:07,980 --> 00:42:10,699
Y esto sería para definir y declarar una variable.

636
00:42:11,679 --> 00:42:15,460
Vamos a utilizar el double, que sería para números decimales.

637
00:42:16,079 --> 00:42:19,260
Esto sería la primera parte y que sepáis cómo se define una variable

638
00:42:19,260 --> 00:42:21,800
y cómo se pone el tipo en Java.

639
00:42:22,599 --> 00:42:28,219
Este sería el ejemplo de cómo definir la variable nota con el tipo double.

640
00:42:29,739 --> 00:42:39,239
¿Qué tenemos en cuanto al punto 2?

641
00:42:39,500 --> 00:42:41,119
¿Qué vamos a ver aquí en el punto 2?

642
00:42:41,300 --> 00:42:42,739
Vamos a ver cómo crear un objeto.

643
00:42:42,900 --> 00:42:44,019
Cuando nosotros creamos un objeto,

644
00:42:44,219 --> 00:42:53,320
imaginamos que tenemos una clase que se llama clase perro.

645
00:42:55,300 --> 00:42:57,800
Si yo quiero generar un objeto de la clase perro,

646
00:42:57,960 --> 00:43:00,219
desde otra clase o incluyendo solo la misma clase,

647
00:43:00,219 --> 00:43:06,219
¿cómo se generaría un objeto para generar un objeto dentro de la...

648
00:43:06,219 --> 00:43:25,059
Para generar un objeto de tipo, o una estancia de un objeto perro, tendríamos que poner primero el nombre de la clase.

649
00:43:28,719 --> 00:43:34,139
Después, cómo vamos a llamar a ese objeto. Vamos a llamarle, por ejemplo, Tor.

650
00:43:34,139 --> 00:43:40,920
A continuación hay un operador que es el operador new, que nos está generando un objeto.

651
00:43:41,480 --> 00:43:46,139
Este new perro nos generaría el objeto.

652
00:43:46,139 --> 00:43:50,079
el objeto. Aquí estamos generando un objeto. Lo primero que tienes que poner

653
00:43:50,079 --> 00:43:54,079
es el nombre de la clase, el objeto y luego

654
00:43:54,079 --> 00:43:58,039
el operador name. El poner de nuevo el nombre de la clase

655
00:43:58,039 --> 00:44:02,119
con estos dos paréntesis, lo que nos está indicando es que estamos creando un objeto

656
00:44:02,119 --> 00:44:06,280
y estamos llamando a su constructor, que ya lo veremos, constructor sin parámetros.

657
00:44:06,719 --> 00:44:09,360
Pero que sepáis que este es el formato de cómo

658
00:44:09,360 --> 00:44:13,039
crear un objeto de una clase.

659
00:44:13,039 --> 00:44:29,320
Una vez que ya hemos generado ese objeto, ya con su nombre, con el propio objeto en sí, puedo llamar a métodos y a atributos de esa clase.

660
00:44:29,880 --> 00:44:37,840
Yo puedo decir, llamar al método ladrar, por ejemplo, de esa clase.

661
00:44:37,840 --> 00:44:48,119
Veis aquí, este objeto Tobi, hemos creado un objeto Tobi de la clase perro y a continuación con el cuadrado punto hemos llamado al método ladrar.

662
00:44:48,639 --> 00:44:55,079
¿Cómo sé que estoy llamando a un método? Por los paréntesis, es un método que no tiene parámetros en su interior.

663
00:44:55,079 --> 00:45:06,179
También puedo llamar si no tienen un nivel de restricción privado

664
00:45:06,179 --> 00:45:13,639
Podría llamar a su atributo

665
00:45:13,639 --> 00:45:17,920
Esto sería cómo crear una clase

666
00:45:17,920 --> 00:45:20,019
¿Por qué pongo aquí lo de la clase y lo adelanto?

667
00:45:21,179 --> 00:45:24,980
Más que nada lo adelanto porque cuando hagamos un ejemplo sencillo

668
00:45:24,980 --> 00:45:27,380
vamos a necesitar de la clase

669
00:45:27,380 --> 00:45:29,300
Scanner. Entonces, para

670
00:45:29,300 --> 00:45:31,320
utilizar la clase Scanner

671
00:45:31,320 --> 00:45:33,739
vamos a crear

672
00:45:33,739 --> 00:45:35,480
un objeto de la clase Scanner. ¿Por qué quiero

673
00:45:35,480 --> 00:45:37,579
la clase Scanner? Porque nos va a permitir escribir

674
00:45:37,579 --> 00:45:39,380
de una manera

675
00:45:39,380 --> 00:45:40,639
no muy compleja,

676
00:45:40,980 --> 00:45:43,619
permitir escribir, solicitar

677
00:45:43,619 --> 00:45:44,739
datos por el teclado.

678
00:45:45,320 --> 00:45:47,219
Vamos a hacer un programa en el que nos va a solicitar

679
00:45:47,219 --> 00:45:49,440
tres notas por el teclado y luego nos va a calcular

680
00:45:49,440 --> 00:45:51,300
la línea. Entonces, solo los he

681
00:45:51,300 --> 00:45:53,639
introducido. Ya os digo, todo esto

682
00:45:53,639 --> 00:45:57,719
lo vamos a ver mucho más adelante, pero mucho más adelante, entonces tampoco tenemos mucha

683
00:45:57,719 --> 00:46:01,460
prisa, pero que os vaya ya sonando, ¿vale?

684
00:46:01,559 --> 00:46:04,340
Lo que me interesa es que podamos hacer un programa sencillo.

685
00:46:05,300 --> 00:46:09,599
¿Qué más quiero ver? ¿Cómo crear un método? Un método en cualquier lengua de

686
00:46:09,599 --> 00:46:17,960
programación se va a crear. Aquí en Java, concretamente,

687
00:46:18,599 --> 00:46:21,460
primero se va a crear con un nivel de acceso a ese método.

688
00:46:22,179 --> 00:46:25,000
Que sepáis que existe el método de acceso público,

689
00:46:25,000 --> 00:46:28,059
el método privado

690
00:46:28,059 --> 00:46:34,940
y Protective

691
00:46:34,940 --> 00:46:40,699
el Protective ya lo veremos más adelante

692
00:46:40,699 --> 00:46:42,019
no quiero meter más de eso

693
00:46:42,019 --> 00:46:43,559
pero cuando creamos un método

694
00:46:43,559 --> 00:46:45,139
o un atributo

695
00:46:45,139 --> 00:46:49,940
veis aquí

696
00:46:49,940 --> 00:46:51,519
el método, esto es un método

697
00:46:51,519 --> 00:46:54,179
un método que tiene

698
00:46:54,179 --> 00:46:54,920
un nivel de acceso

699
00:46:54,920 --> 00:46:57,400
tiene

700
00:46:57,400 --> 00:46:59,639
un valor devuelto o void

701
00:46:59,639 --> 00:47:01,980
el nombre del método y luego una serie de parámetros

702
00:47:01,980 --> 00:47:03,920
que van entre paréntesis, esto sería un método

703
00:47:03,920 --> 00:47:04,900
un método por ejemplo

704
00:47:04,900 --> 00:47:07,159
vamos a

705
00:47:07,159 --> 00:47:09,780
definir por ejemplo el método

706
00:47:09,780 --> 00:47:10,219
ladrar

707
00:47:10,219 --> 00:47:13,840
vamos a hacer que sea público

708
00:47:13,840 --> 00:47:15,619
para que cuando alguien cree

709
00:47:15,619 --> 00:47:17,340
un objeto perro

710
00:47:17,340 --> 00:47:20,000
pueda acceder al método

711
00:47:20,000 --> 00:47:21,360
a continuación

712
00:47:21,360 --> 00:47:23,780
vamos a hacer que no devuelva

713
00:47:23,780 --> 00:47:24,820
nada a ese método

714
00:47:24,820 --> 00:47:27,699
y le ponemos siempre que no devuelve nada si le ponemos un point

715
00:47:27,699 --> 00:47:29,840
si devolviera algo pues tendríamos que

716
00:47:29,840 --> 00:47:32,019
poner el tipo que devolvió, si devuelve un entero

717
00:47:32,019 --> 00:47:34,400
pues tendríamos que poner un entero, si se le devuelve un double

718
00:47:34,400 --> 00:47:36,320
pues tendríamos que poner un double, lo que sea

719
00:47:36,320 --> 00:47:38,119
entonces vamos a ponerle void

720
00:47:38,119 --> 00:47:39,900
porque es un método que no va a devolver nada

721
00:47:39,900 --> 00:47:42,099
y le ponemos el nombre

722
00:47:42,099 --> 00:47:43,980
vamos a ponerle el nombre ladrar

723
00:47:43,980 --> 00:47:46,380
¿necesita

724
00:47:46,380 --> 00:47:47,980
parámetros este método? pues

725
00:47:47,980 --> 00:47:49,860
voy a ponerlo como que no necesita

726
00:47:49,860 --> 00:47:52,360
ningún parámetro, entonces se deja vacío

727
00:47:52,360 --> 00:47:54,340
pero lo que nos indica ya

728
00:47:54,340 --> 00:47:55,500
este

729
00:47:55,500 --> 00:47:58,119
este método es que

730
00:47:58,119 --> 00:48:00,340
no va a requerir parámetros ni va a devolver

731
00:48:00,340 --> 00:48:02,340
ningún parámetro, y que va a ser público

732
00:48:02,340 --> 00:48:04,239
¿vale? y a continuación

733
00:48:04,239 --> 00:48:06,239
cuando defines un método, le abres llave

734
00:48:06,239 --> 00:48:07,380
y le cierras llave

735
00:48:07,380 --> 00:48:12,219
y esto sería

736
00:48:12,219 --> 00:48:13,099
un método

737
00:48:13,099 --> 00:48:18,260
esto que aparece aquí

738
00:48:18,260 --> 00:48:20,239
sería un método

739
00:48:20,239 --> 00:48:22,440
lo que pasa es que este método no tiene ninguna línea

740
00:48:22,440 --> 00:48:23,840
adentro, habría que

741
00:48:23,840 --> 00:48:30,280
introducir aquí las líneas para ver

742
00:48:30,280 --> 00:48:32,340
que realiza ese método, entonces cada vez que yo

743
00:48:32,340 --> 00:48:34,340
cree un objeto Tobi, que pertenece

744
00:48:34,340 --> 00:48:35,940
a la clase perro,

745
00:48:36,320 --> 00:48:38,239
y le llame a ladrar, ejecutará

746
00:48:38,239 --> 00:48:40,320
las líneas que aparezcan aquí dentro de este

747
00:48:40,320 --> 00:48:42,340
método llamado ladrar. Esto es igual que aparece

748
00:48:42,340 --> 00:48:44,159
aquí. ¿Veis? Aquí

749
00:48:44,159 --> 00:48:46,719
para poder yo ejecutar una aplicación

750
00:48:46,719 --> 00:48:48,219
necesito de un método. Es

751
00:48:48,219 --> 00:48:50,099
estrictamente necesario. Y ese

752
00:48:50,099 --> 00:48:51,400
método se llama

753
00:48:51,400 --> 00:48:54,039
mail. Mail principal.

754
00:48:54,340 --> 00:48:56,300
O sea, cada vez que yo lo ejecute, va a ir

755
00:48:56,300 --> 00:48:58,300
directamente a ese mail y va a

756
00:48:58,300 --> 00:48:59,659
ejecutar lo que tenga dentro del mail.

757
00:49:00,960 --> 00:49:01,639
Es así.

758
00:49:01,639 --> 00:49:03,619
para las aplicaciones

759
00:49:03,619 --> 00:49:05,659
entonces, veis, es un método

760
00:49:05,659 --> 00:49:07,739
que se ha definido aquí, como público

761
00:49:07,739 --> 00:49:09,719
luego como estático, que veremos

762
00:49:09,719 --> 00:49:11,699
qué es eso, como void, que no devuelve ningún

763
00:49:11,699 --> 00:49:13,699
valor, que se llama main y que

764
00:49:13,699 --> 00:49:15,440
tiene dentro un array de

765
00:49:15,440 --> 00:49:17,340
objetos string, ¿vale?

766
00:49:17,420 --> 00:49:19,619
un array que indica con estos dos corchetes

767
00:49:19,619 --> 00:49:21,699
que ya veremos lo que es, no tenéis que saberlo

768
00:49:21,699 --> 00:49:23,920
aunque os aprendéis por ahora esto de memoria

769
00:49:23,920 --> 00:49:25,739
o sea, de memoria, que sepáis

770
00:49:25,739 --> 00:49:27,219
que es suficiente

771
00:49:27,219 --> 00:49:29,820
cuando yo ejecute de aquí, él directamente

772
00:49:29,820 --> 00:49:31,559
va a ir al main, va a buscar

773
00:49:31,559 --> 00:49:34,940
donde está el método main y va a ejecutar lo que esté dentro del main, ¿vale?

774
00:49:35,039 --> 00:49:35,800
Es lo único que va a hacer.

775
00:49:35,940 --> 00:49:42,639
Si os fijáis, esto, además, necesito siempre, para poder utilizar,

776
00:49:43,460 --> 00:49:46,360
para poder generar cualquier programa en Java, una publicación,

777
00:49:46,519 --> 00:49:47,940
necesito de una clase.

778
00:49:48,519 --> 00:49:51,900
Esta clase está definida aquí como pública, que puede hacer cualquiera,

779
00:49:52,599 --> 00:49:56,519
luego la palabra reservada class y el nombre de la clase.

780
00:49:56,900 --> 00:49:59,619
Y siempre sigue con una llave de apertura y una llave de cierre.

781
00:49:59,619 --> 00:50:01,719
y dentro, veis que está ahí indentado

782
00:50:01,719 --> 00:50:02,980
está el método main

783
00:50:02,980 --> 00:50:05,239
entonces cuando yo lo ejecute, irá a la clase

784
00:50:05,239 --> 00:50:07,199
project1 y ejecutará

785
00:50:07,199 --> 00:50:09,440
el método main y las líneas

786
00:50:09,440 --> 00:50:10,860
que hay adentro las ejecutará

787
00:50:10,860 --> 00:50:13,119
aquí hay un system.out.println que lo que hace es

788
00:50:13,119 --> 00:50:15,139
que llama al objeto out

789
00:50:15,139 --> 00:50:17,159
de la clase system y llama a su método

790
00:50:17,159 --> 00:50:19,340
println, veis que todo está separado por puntos

791
00:50:19,340 --> 00:50:21,059
llama al println para que?

792
00:50:21,159 --> 00:50:23,159
para escribir en pantalla, lo que ponga es

793
00:50:23,159 --> 00:50:24,559
entre comillas dobles, que es esto de aquí

794
00:50:24,559 --> 00:50:27,400
y luego el ln es para que haga un retorno

795
00:50:27,400 --> 00:50:29,599
de cargo y pase a la siguiente línea

796
00:50:29,599 --> 00:50:31,659
Cuando le doy a ejecutar

797
00:50:31,659 --> 00:50:33,360
¿Puedo hacer una pregunta?

798
00:50:33,920 --> 00:50:34,699
Sí, sí

799
00:50:34,699 --> 00:50:37,599
Estás diciendo que el void

800
00:50:37,599 --> 00:50:39,239
Se pone para que no devuelva nada

801
00:50:39,239 --> 00:50:41,880
Pero luego se mete dentro y devuelve

802
00:50:41,880 --> 00:50:42,780
Lo que esté dentro

803
00:50:42,780 --> 00:50:45,340
No, no es ese

804
00:50:45,340 --> 00:50:46,699
Te voy a poner un ejemplo

805
00:50:46,699 --> 00:50:52,380
Este, por ejemplo, no devuelve nada

806
00:50:52,380 --> 00:50:55,579
Pero se mete dentro y ejecuta sus líneas

807
00:50:55,579 --> 00:50:55,920
¿Vale?

808
00:50:57,139 --> 00:50:58,199
Las líneas que sea

809
00:50:58,199 --> 00:50:59,699
Instrucción

810
00:50:59,699 --> 00:51:14,940
Instrucción 2

811
00:51:14,940 --> 00:51:17,239
¿vale? cuando yo llamo

812
00:51:17,239 --> 00:51:19,559
genero el objeto Toby y le llamo

813
00:51:19,559 --> 00:51:21,539
a ladrar, ejecuta estas dos instrucciones

814
00:51:21,539 --> 00:51:23,019
y termina, ¿vale?

815
00:51:23,300 --> 00:51:25,079
ahora vamos a hacer un método

816
00:51:25,079 --> 00:51:27,920
que sea

817
00:51:27,920 --> 00:51:30,880
un método que devuelva

818
00:51:30,880 --> 00:51:31,360
algo, ¿vale?

819
00:51:32,420 --> 00:51:32,880
vamos a poner

820
00:51:32,880 --> 00:51:39,139
obtener

821
00:51:39,139 --> 00:51:40,760
nombre

822
00:51:40,760 --> 00:51:42,820
del perro

823
00:51:42,820 --> 00:51:44,239
¿vale? y aquí ponemos

824
00:51:44,239 --> 00:51:46,260
ahora este sí nos va a devolver

825
00:51:46,260 --> 00:51:47,659
¿el qué? nos va a devolver un string

826
00:51:47,659 --> 00:51:50,179
¿vale? este ejecutará

827
00:51:50,179 --> 00:51:51,880
las instrucciones que tiene dentro

828
00:51:51,880 --> 00:51:53,960
y a continuación tendrá una línea

829
00:51:53,960 --> 00:51:58,860
que ponga un return

830
00:51:58,860 --> 00:51:59,860
¿no? un return

831
00:51:59,860 --> 00:52:01,960
y el

832
00:52:01,960 --> 00:52:03,420
lo que sea ¿vale?

833
00:52:05,059 --> 00:52:06,960
¿veis? la diferencia entre este

834
00:52:06,960 --> 00:52:08,960
método que no devuelve nada y este

835
00:52:08,960 --> 00:52:10,699
método que es, esto es como

836
00:52:10,699 --> 00:52:12,579
los antiguos procedimientos y funciones

837
00:52:12,579 --> 00:52:14,559
el procedimiento no devolvía nada

838
00:52:14,559 --> 00:52:16,480
la función siempre devolvía un valor

839
00:52:16,480 --> 00:52:18,380
Pues aquí este método

840
00:52:18,380 --> 00:52:20,079
No devuelve nada

841
00:52:20,079 --> 00:52:22,340
¿Veis? Ejecuta las instrucciones que hay dentro y ya está

842
00:52:22,340 --> 00:52:24,519
O sea, entra en el método

843
00:52:24,519 --> 00:52:26,840
Primero, genera el objeto Toby

844
00:52:26,840 --> 00:52:28,579
Llama a ladrar, en cuanto lo lleva a ladrar

845
00:52:28,579 --> 00:52:29,699
Se va a este método

846
00:52:29,699 --> 00:52:32,639
Ejecuta la instrucción 1, ejecuta la instrucción 2

847
00:52:32,639 --> 00:52:34,460
Sale y vuelve aquí a esta línea

848
00:52:34,460 --> 00:52:36,420
Y sigue ejecutando las líneas que reviviera

849
00:52:36,420 --> 00:52:38,360
¿Vale? En cambio, si ahora

850
00:52:38,360 --> 00:52:39,219
Aquí en Toby

851
00:52:39,219 --> 00:52:41,099
Después le pongo

852
00:52:41,099 --> 00:52:44,480
Obtener

853
00:52:44,480 --> 00:52:46,639
nombre

854
00:52:46,639 --> 00:52:50,880
esto lógicamente

855
00:52:50,880 --> 00:52:52,599
habrá que ponerlo igualado a algo

856
00:52:52,599 --> 00:52:53,519
string

857
00:52:53,519 --> 00:52:56,219
nombre

858
00:52:56,219 --> 00:52:58,119
igual a todo

859
00:52:58,119 --> 00:52:59,880
¿qué estoy haciendo aquí?

860
00:53:00,519 --> 00:53:01,659
estoy llamando

861
00:53:01,659 --> 00:53:05,059
con el objeto toby al método obtenerNombre

862
00:53:05,059 --> 00:53:06,880
y lo tengo que

863
00:53:06,880 --> 00:53:08,360
igualar a un string, ¿por qué?

864
00:53:08,420 --> 00:53:09,780
porque me va a doblegar un string

865
00:53:09,780 --> 00:53:12,579
¿qué hace? llama al obtenerNombre

866
00:53:12,579 --> 00:53:14,940
ejecuta la sustitución 1, ejecuta la sustitución 2

867
00:53:14,940 --> 00:53:17,059
y luego nos retorna el nombre del perro

868
00:53:17,059 --> 00:53:18,639
y lo mete dentro de la base

869
00:53:18,639 --> 00:53:20,239
de la variable

870
00:53:20,239 --> 00:53:22,480
¿Vale?

871
00:53:23,639 --> 00:53:24,699
Se entiende más o menos

872
00:53:24,699 --> 00:53:26,039
la diferencia entre lo que es

873
00:53:26,039 --> 00:53:28,679
una función, un método con

874
00:53:28,679 --> 00:53:30,900
void y con, dependerá de lo que tú

875
00:53:30,900 --> 00:53:32,880
quieras hacer, si quieres devolver

876
00:53:32,880 --> 00:53:34,260
algo o no lo quieres devolver

877
00:53:34,260 --> 00:53:36,820
¿Hasta aquí bien?

878
00:53:38,320 --> 00:53:38,860
Más o menos

879
00:53:38,860 --> 00:53:40,539
¿Qué más quiero

880
00:53:40,539 --> 00:53:42,340
que veamos?

881
00:53:42,800 --> 00:53:44,380
Diferencia entre estático y no estático

882
00:53:44,380 --> 00:53:50,860
Aquí ya vienen curvas, ¿vale? Entonces, primero voy a hablar de la clase Scanner, ¿vale?

883
00:53:51,139 --> 00:53:57,780
La clase Scanner, solo vamos a saber cómo la clase Scanner, el 5.

884
00:53:59,199 --> 00:54:03,780
Para generar un objeto de la clase Scanner, pues que sepáis que es así, ¿vale?

885
00:54:04,960 --> 00:54:11,800
Vamos a llamarle sc igual a Scanner, a new, ¿recordaos? Estoy generando un objeto de la clase Scanner, ¿vale?

886
00:54:11,800 --> 00:54:34,159
La clase scanner tendrá sus métodos, utilizamos de la misma y requiere de un parámetro cuando crea su objeto, que es system.in, ¿vale? Esto es la clase system y dentro de la clase system el objeto in, in es el objeto que vamos a necesitar para poder pedir un dato y poderlo introducir por tecla, ¿vale?

887
00:54:34,159 --> 00:54:36,219
pero que sepáis que esto es lo que vamos a ver

888
00:54:36,219 --> 00:54:39,059
y esto es lo que va a aparecer en el programa

889
00:54:39,059 --> 00:54:40,800
¿vale? pero aquí

890
00:54:40,800 --> 00:54:42,599
sencillamente estamos llamando a un objeto

891
00:54:42,599 --> 00:54:44,320
de la clase Scanner que le llamamos ST

892
00:54:44,320 --> 00:54:46,280
y que le pasamos un parámetro que es el Systeming

893
00:54:46,280 --> 00:54:48,280
que por ahora, aunque sepáis que

894
00:54:48,280 --> 00:54:50,500
esto es para que podamos escribir en teclado, me vale

895
00:54:50,500 --> 00:54:52,920
¿vale? y luego nos quedaría

896
00:54:52,920 --> 00:54:54,900
la diferencia entre

897
00:54:54,900 --> 00:54:56,440
llamar a un método estático y a uno

898
00:54:56,440 --> 00:54:58,619
no estático, ¿qué significa eso?

899
00:54:59,340 --> 00:54:59,699
aquí

900
00:54:59,699 --> 00:55:02,019
vamos a ponerlo

901
00:55:02,019 --> 00:55:14,269
4, vamos a poner aquí static

902
00:55:14,269 --> 00:55:21,789
y no static. ¿Por qué

903
00:55:21,789 --> 00:55:26,070
quiero hablar un poquito sobre

904
00:55:26,070 --> 00:55:29,809
esto? Porque lo básico para poder empezar

905
00:55:29,809 --> 00:55:34,010
un programa, veis, está utilizando un método, el main es un método estático.

906
00:55:34,349 --> 00:55:37,050
Le pone una palabra reservada que se llama static.

907
00:55:37,650 --> 00:55:40,769
Es un método estático. ¿Eso qué quiere decir? Quiere decir que

908
00:55:40,769 --> 00:55:46,550
Una cosa es cuando yo creo un objeto y llamo a un método del objeto

909
00:55:46,550 --> 00:55:48,909
O un variable miembro del objeto

910
00:55:48,909 --> 00:55:52,349
Y otra cosa es cuando quiero llamar a un método estático

911
00:55:52,349 --> 00:55:56,909
La diferencia entre un método estático es que el método es general para toda la clase

912
00:55:56,909 --> 00:56:00,230
Entonces yo no le voy a llamar instanciando un objeto

913
00:56:00,230 --> 00:56:02,230
Le llamo con el nombre de la clase

914
00:56:02,230 --> 00:56:03,449
Esa es la diferencia

915
00:56:03,449 --> 00:56:08,650
Llamar a un método estático es que le voy a llamar con el nombre de la clase genérico

916
00:56:08,650 --> 00:56:10,409
No va a haber instancias de objetos

917
00:56:10,409 --> 00:56:13,090
es como crear como algo constante

918
00:56:13,090 --> 00:56:16,469
entonces yo cada vez que llame al método main

919
00:56:16,469 --> 00:56:21,050
lo voy a hacer a través del nombre de la clase

920
00:56:21,050 --> 00:56:24,389
no lo voy a hacer a través de la creación de un determinado objeto

921
00:56:24,389 --> 00:56:25,889
si esa palabra no existiera

922
00:56:25,889 --> 00:56:28,789
por ejemplo, imaginaos aquí en el ejemplo que os he puesto

923
00:56:28,789 --> 00:56:33,769
imaginaos que ahora ladrar es estático

924
00:56:33,769 --> 00:56:38,230
pues este método yo no le puedo llamar

925
00:56:38,230 --> 00:56:43,050
con Tobio, creando un objeto y luego llamar

926
00:56:43,050 --> 00:56:47,650
al método ladrar. No, habría que llamarle con el

927
00:56:47,650 --> 00:56:53,079
nombre de la clase. ¿Por qué? Porque va a haber

928
00:56:53,079 --> 00:56:57,019
uno solo para toda la clase. No es como los otros métodos

929
00:56:57,019 --> 00:57:01,280
en los que cada objeto que yo genero es una instancia de esa clase

930
00:57:01,280 --> 00:57:04,579
y esa instancia tendrá un

931
00:57:04,579 --> 00:57:08,719
método, una llamada al método diferente.

932
00:57:08,719 --> 00:57:25,079
No sé si me he explicado más o menos. Bueno, tampoco quiero que por ahora nos metamos mucho, pero que ya os vaya sonando todas estas cosas. Entonces, vamos a hacer un ejercicio que sería para calcular la nota media de tres notas.

933
00:57:25,079 --> 00:57:37,820
Entonces, lo primero que tenemos que hacer aquí sería definir, veis, lo primero que he hecho aquí es archivo, le he dicho nuevo proyecto

934
00:57:37,820 --> 00:57:46,320
Y dentro de nuevo proyecto he generado, mira, si le doy otro nuevo proyecto, he generado una Java with main, que sería una Java aplicación

935
00:57:46,320 --> 00:57:48,000
que es lo que tendría. Yo si le doy a siguiente

936
00:57:48,000 --> 00:57:50,019
me va a generar el nombre, le ponemos el nombre

937
00:57:50,019 --> 00:57:52,360
y veis que aquí ya nos va a

938
00:57:52,360 --> 00:57:54,219
generar una main aplicación con el

939
00:57:54,219 --> 00:57:56,239
propio public

940
00:57:56,239 --> 00:57:57,579
startup de main, ¿vale?

941
00:57:58,139 --> 00:58:00,059
Si le diera a finish nos generaría otro

942
00:58:00,059 --> 00:58:02,300
proyecto. Nos genera una clase

943
00:58:02,300 --> 00:58:04,599
automáticamente que sería con el

944
00:58:04,599 --> 00:58:06,219
nombre del proyecto

945
00:58:06,219 --> 00:58:08,139
y esta Java

946
00:58:08,139 --> 00:58:10,019
pues le llama además con el mismo nombre

947
00:58:10,019 --> 00:58:12,079
que le he puesto, ¿vale? Podríamos

948
00:58:12,079 --> 00:58:13,440
cambiar el nombre de la

949
00:58:13,440 --> 00:58:16,219
clase Java si luego

950
00:58:16,219 --> 00:58:18,219
Pues sí, ¿cómo se puede hacer?

951
00:58:18,320 --> 00:58:29,380
Tú le das al botón derecho y le dices que aquí en refactorizar le puedo renombrar y llamarle de otra manera, ¿vale?

952
00:58:29,519 --> 00:58:32,179
Él automáticamente te va a cambiar todo lo que sea necesario.

953
00:58:32,460 --> 00:58:35,440
Eso también sucede, ¿con qué? Pues con el proyecto.

954
00:58:35,639 --> 00:58:41,079
Yo puedo siempre lo meter en una carpeta .com en My Company Project, que sería el nombre que tiene el proyecto,

955
00:58:41,260 --> 00:58:45,400
pero veis, lo mete en un paquete .com y luego su paquete My Company y luego Project.

956
00:58:45,400 --> 00:58:47,900
Pero esto también lo podemos cambiar, ¿vale?

957
00:58:47,900 --> 00:58:49,659
esto lo podría formar como

958
00:58:49,659 --> 00:58:52,340
refactorizándole y llamándole con otro nombre

959
00:58:52,340 --> 00:58:57,579
vale, aquí sería

960
00:58:57,579 --> 00:59:06,750
vale, yo puedo llamarle y que

961
00:59:06,750 --> 00:59:08,889
venga la carpeta com, por ejemplo

962
00:59:08,889 --> 00:59:09,650
vamos a ver, de

963
00:59:09,650 --> 00:59:11,590
constanza

964
00:59:11,590 --> 00:59:14,210
y luego pues el proyecto

965
00:59:14,210 --> 00:59:15,469
pues lo voy a llamar proyecto

966
00:59:15,469 --> 00:59:17,769
vale

967
00:59:17,769 --> 00:59:20,750
todo esto lo refactoriza

968
00:59:20,750 --> 00:59:22,570
y te lo cambia todo completamente, vale

969
00:59:22,570 --> 00:59:24,670
pero él por defecto te va a generar todo esto

970
00:59:24,670 --> 00:59:26,590
vale, vamos a dejarlo igual

971
00:59:26,590 --> 00:59:28,809
y si veis

972
00:59:28,809 --> 00:59:30,369
aquí no tiene más que una clase

973
00:59:30,369 --> 00:59:32,130
como he dicho antes y tiene

974
00:59:32,130 --> 00:59:34,170
un System.OpenL

975
00:59:34,170 --> 00:59:36,690
le he dado a ejecutar y veis que aparece

976
00:59:36,690 --> 00:59:38,329
aquí el Hello World, que es que

977
00:59:38,329 --> 00:59:40,230
lo saca por pantalla y sale el Hello World

978
00:59:40,230 --> 00:59:40,769
nada más

979
00:59:40,769 --> 00:59:43,789
¿qué es lo que tenemos que hacer en lo primero?

980
00:59:44,010 --> 00:59:46,250
vamos a hacer, sin la clase Scanner, vamos a generar

981
00:59:46,250 --> 00:59:48,489
tres notas, entonces yo tengo que poner

982
00:59:48,489 --> 00:59:49,409
¿el qué? pues un

983
00:59:49,409 --> 00:59:51,170
puedo poner un double

984
00:59:51,170 --> 00:59:54,010
nota1

985
00:59:54,010 --> 00:59:58,030
igual a 5

986
00:59:58,030 --> 01:00:00,789
y a continuación les voy a poner

987
01:00:00,789 --> 01:00:04,789
veis, estoy creando la primera variable que he creado

988
01:00:04,789 --> 01:00:06,530
además son variables que están dentro del método

989
01:00:06,530 --> 01:00:09,690
fuera del método estas variables ya no existirán

990
01:00:09,690 --> 01:00:11,530
una vez que se salga de esta llave

991
01:00:11,530 --> 01:00:13,030
estas variables no existirán

992
01:00:13,030 --> 01:00:14,590
estarán dentro de este método

993
01:00:14,590 --> 01:00:16,610
su ámbito es este método, no están fuera

994
01:00:16,610 --> 01:00:18,090
no son variables miembros de la clase

995
01:00:18,090 --> 01:00:22,230
vamos a meterle una nota 2 y una nota 3

996
01:00:22,230 --> 01:00:25,389
aquí le ponemos un 10

997
01:00:25,389 --> 01:00:28,489
y aquí le ponemos flojero y saco un 1,5

998
01:00:28,489 --> 01:00:31,429
entonces, una vez que tenemos las tres notas

999
01:00:31,429 --> 01:00:34,789
a continuación, lo que queremos hacer

1000
01:00:34,789 --> 01:00:38,670
esto nos sirve para escribir en pantalla

1001
01:00:38,670 --> 01:00:42,170
le vamos a poner aquí el system

1002
01:00:42,170 --> 01:00:46,809
para que primero nos diga

1003
01:00:46,809 --> 01:00:54,780
voy a calcular la nota media

1004
01:00:54,780 --> 01:01:00,179
de tres notas

1005
01:01:00,179 --> 01:01:02,829
vale

1006
01:01:02,829 --> 01:01:05,570
a continuación tendremos que hacer la operación

1007
01:01:05,570 --> 01:01:06,829
de cálculo, vale, entonces

1008
01:01:06,829 --> 01:01:09,489
¿cómo le voy a llamar? si tengo tres

1009
01:01:09,489 --> 01:01:11,210
notas que son de tipo double

1010
01:01:11,210 --> 01:01:13,289
pues y quiero calcular la media tengo que crear

1011
01:01:13,289 --> 01:01:14,610
otra variable que se llame media

1012
01:01:14,610 --> 01:01:17,349
que tendrá que ser lógicamente

1013
01:01:17,349 --> 01:01:18,230
también de tipo double

1014
01:01:18,230 --> 01:01:20,489
entonces le vamos a poner media

1015
01:01:20,489 --> 01:01:22,750
y a esta ¿qué le vamos a hacer?

1016
01:01:23,010 --> 01:01:25,030
le vamos a decir que es nota

1017
01:01:25,030 --> 01:01:26,989
uno más

1018
01:01:26,989 --> 01:01:29,289
nota2 más

1019
01:01:29,289 --> 01:01:30,929
nota3

1020
01:01:30,929 --> 01:01:32,449
y dividido entre 3

1021
01:01:32,449 --> 01:01:35,190
¿Veis lo que he hecho aquí? Estoy utilizando

1022
01:01:35,190 --> 01:01:36,949
ya operadores. Los operadores los veremos

1023
01:01:36,949 --> 01:01:39,409
en el tema 2

1024
01:01:39,409 --> 01:01:41,269
pero bueno, para que podamos hacer

1025
01:01:41,269 --> 01:01:43,329
un pequeño programita tenemos que introducir

1026
01:01:43,329 --> 01:01:45,389
pequeñas cosas. Tenemos el operador más

1027
01:01:45,389 --> 01:01:47,030
que lo que hace es que suma esta variable

1028
01:01:47,030 --> 01:01:49,449
a esta otra variable y a esta otra variable

1029
01:01:49,449 --> 01:01:51,269
y luego lo que hace es una división

1030
01:01:51,269 --> 01:01:53,550
en la que luego la divide entre 3

1031
01:01:53,550 --> 01:01:54,869
y con eso obtiene el ángulo

1032
01:01:54,869 --> 01:02:14,650
A continuación, la sacaríamos por pantalla. Necesitaríamos otra vez el System.out.println. Acordaos, esta es la clase System que tiene un objeto que se llama out y que dicho objeto cuando lo he estanciado, si veis aquí además es una clase estática. O sea, es un objeto estático porque se le llama por el nombre. ¿Veis lo que habíamos visto anteriormente?

1033
01:02:14,650 --> 01:02:16,889
el objeto out

1034
01:02:16,889 --> 01:02:19,070
se le llama

1035
01:02:19,070 --> 01:02:21,150
a través de system

1036
01:02:21,150 --> 01:02:23,150
y luego se llama

1037
01:02:23,150 --> 01:02:24,550
a su método que se llama println

1038
01:02:24,550 --> 01:02:26,650
lo que hace es imprimir esto en pantalla y

1039
01:02:26,650 --> 01:02:28,750
hace un retorno de cargo posteriormente

1040
01:02:28,750 --> 01:02:31,190
si pusiéramos solo print en vez de ln

1041
01:02:31,190 --> 01:02:32,030
lo que haría es

1042
01:02:32,030 --> 01:02:33,989
aparecería esto en

1043
01:02:33,989 --> 01:02:37,210
la pantalla pero no habría retorno de cargo

1044
01:02:37,210 --> 01:02:38,489
si tuviera dos system

1045
01:02:38,489 --> 01:02:39,349
out print

1046
01:02:39,349 --> 01:02:42,949
escribiría esto y el siguiente system lo escribiría

1047
01:02:42,949 --> 01:02:46,769
al lado. Al poner el n nos permite que haga un retorno de carro

1048
01:02:46,769 --> 01:02:50,349
y que la siguiente línea aparezca abajo. Entonces le ponemos el n

1049
01:02:50,349 --> 01:02:54,969
y le voy a calcular la nota media

1050
01:02:54,969 --> 01:02:56,969
de las cerditas. Entonces, ¿a qué nos quedaría?

1051
01:02:57,030 --> 01:03:04,900
Nos quedaría imprimir la media.

1052
01:03:09,329 --> 01:03:14,210
La media es... y aquí tenemos

1053
01:03:14,210 --> 01:03:18,150
que imprimir la media es, pero a continuación de la media es

1054
01:03:18,150 --> 01:03:19,929
Tiene que aparecer la media real

1055
01:03:19,929 --> 01:03:23,289
Entonces, ¿cómo se concatenan cadenas en Java?

1056
01:03:23,429 --> 01:03:25,130
Se concatenan con el operador más

1057
01:03:25,130 --> 01:03:26,969
Yo al poner aquí media

1058
01:03:26,969 --> 01:03:27,929
¿Qué es lo que hace?

1059
01:03:28,190 --> 01:03:29,469
Él coge media

1060
01:03:29,469 --> 01:03:31,530
Y como es un double

1061
01:03:31,530 --> 01:03:33,250
Lo pasa a cadena

1062
01:03:33,250 --> 01:03:35,869
Y concatena esta cadena

1063
01:03:35,869 --> 01:03:36,969
Con esta otra cadena

1064
01:03:36,969 --> 01:03:38,550
Al darle a ejecutar

1065
01:03:38,550 --> 01:03:46,940
Nos sale que la media es 5,5

1066
01:03:46,940 --> 01:03:47,260
¿Lo veis?

1067
01:03:48,300 --> 01:03:50,900
Este sería un programa sencillo

1068
01:03:50,900 --> 01:03:52,079
¿Alguien no ha entendido este programa?

1069
01:03:52,079 --> 01:03:57,139
veis, necesitamos tanto el

1070
01:03:57,139 --> 01:03:59,260
main y una clase para poder ejecutar

1071
01:03:59,260 --> 01:04:00,500
un programa, aquí estamos

1072
01:04:00,500 --> 01:04:03,019
ejecutando un programa

1073
01:04:03,019 --> 01:04:04,880
o realizando un programa de manera imperativa, no estamos

1074
01:04:04,880 --> 01:04:07,199
utilizando, aunque necesitamos una clase para poderlo ejecutar

1075
01:04:07,199 --> 01:04:09,260
no estamos realizando

1076
01:04:09,260 --> 01:04:11,039
programación orientada a objetos

1077
01:04:11,039 --> 01:04:13,219
¿alguien tiene una

1078
01:04:13,219 --> 01:04:13,960
duda sobre esto?

1079
01:04:19,559 --> 01:04:20,420
bien, pues pasamos a

1080
01:04:20,420 --> 01:04:23,800
los decimales con punto siempre

1081
01:04:23,800 --> 01:04:24,000
¿no?

1082
01:04:24,860 --> 01:04:26,199
sí, vale

1083
01:04:26,199 --> 01:04:29,139
pero cuidado, ahora con la clase

1084
01:04:29,139 --> 01:04:30,780
escáner, que lo veremos

1085
01:04:30,780 --> 01:04:33,019
la clase escáner cuando nos lo pida por pantalla

1086
01:04:33,019 --> 01:04:35,199
si se lo pones con punto te da error

1087
01:04:35,199 --> 01:04:37,840
él solo lo lee con coma

1088
01:04:37,840 --> 01:04:38,599
y ahora lo veremos

1089
01:04:38,599 --> 01:04:41,320
entonces vamos a

1090
01:04:41,320 --> 01:04:42,619
convertir ahora este

1091
01:04:42,619 --> 01:04:46,739
este programa

1092
01:04:46,739 --> 01:04:48,559
bueno, no lo he dicho antes pero

1093
01:04:48,559 --> 01:04:51,000
yo si quiero escribir un system

1094
01:04:51,000 --> 01:04:53,840
cuando le doy al punto

1095
01:04:53,840 --> 01:04:55,619
él automáticamente te saca

1096
01:04:55,619 --> 01:04:58,440
aquí la línea

1097
01:04:58,440 --> 01:04:59,960
para que tú puedas encontrar

1098
01:04:59,960 --> 01:05:01,079
lo que tú deseas, ¿ves?

1099
01:05:01,500 --> 01:05:04,159
Un objeto out de la clase de printString, ¿vale?

1100
01:05:04,320 --> 01:05:05,699
Le das al out y el

1101
01:05:05,699 --> 01:05:07,900
automáticamente te lo genera, ¿vale?

1102
01:05:07,980 --> 01:05:10,059
Tú le puedes buscar aquí, buscas el método que quieres

1103
01:05:10,059 --> 01:05:12,019
utilizar, ¿veis? La cantidad de métodos que

1104
01:05:12,019 --> 01:05:13,920
tiene out, print con

1105
01:05:13,920 --> 01:05:15,980
un parámetro, printf,

1106
01:05:16,239 --> 01:05:17,420
println, ¿veis?

1107
01:05:18,119 --> 01:05:19,980
Etcétera. No sólo

1108
01:05:19,980 --> 01:05:22,059
estar println con un string, que es lo que

1109
01:05:22,059 --> 01:05:23,300
estamos haciendo nosotros todo el rato.

1110
01:05:23,300 --> 01:05:26,880
donde puede estar un char, un float, un entero, un log

1111
01:05:26,880 --> 01:05:32,639
vale, vamos a ver ahora

1112
01:05:32,639 --> 01:05:35,219
vamos a crear un objeto de la clase Scanner

1113
01:05:35,219 --> 01:05:39,719
si yo le pongo ScannerSC, le vamos a llamar SC

1114
01:05:39,719 --> 01:05:42,800
y le vamos a poner un new Scanner

1115
01:05:42,800 --> 01:05:48,059
esta clase es de objeto, necesita un parámetro

1116
01:05:48,059 --> 01:05:51,900
cuando su constructor necesita un parámetro para generar ese objeto

1117
01:05:51,900 --> 01:06:11,599
Y es system.it. Por ahora, que sepáis que es así y poco más. ¿Vale? Pero ¿qué sucede? Que no hemos importado el paquete que tiene Scanner. Aquí nos está diciendo que no puedo localizarlo. ¿Vale? ¿Por qué no lo puedo localizar? Porque no hemos importado el paquete donde está Scanner. ¿Vale?

1118
01:06:11,599 --> 01:06:27,500
Entonces habrá que importar, para importar paquetes se hace con import java.utscanner, lo veis, el mismo ya me lo va poniendo.

1119
01:06:28,119 --> 01:06:37,039
Yo, todas las librerías de Java no están por defecto, salvo javaland, pero el resto tienes que importarla.

1120
01:06:37,039 --> 01:06:41,960
Si yo quiero utilizar la clase escáner me tengo que ir a donde esté esa clase escáner. ¿Dónde la tengo?

1121
01:06:41,960 --> 01:06:46,760
en el paquete java.paqueteUtil

1122
01:06:46,760 --> 01:06:48,659
y dentro del paquete útil está la clase

1123
01:06:48,659 --> 01:06:49,860
escala, que la veis aquí

1124
01:06:49,860 --> 01:06:52,480
siempre se pone

1125
01:06:52,480 --> 01:06:54,500
el import, para importar una librería se pone

1126
01:06:54,500 --> 01:06:55,900
fuera de la clase

1127
01:06:55,900 --> 01:06:58,579
una vez que ya lo hemos importado

1128
01:06:58,579 --> 01:06:59,860
se nos ha quitado el

1129
01:06:59,860 --> 01:07:02,300
símbolo, y si yo le dejo voltar

1130
01:07:02,300 --> 01:07:04,539
no va a hacer nada, porque todavía

1131
01:07:04,539 --> 01:07:05,800
no hemos utilizado la clase escala

1132
01:07:05,800 --> 01:07:07,840
hará lo mismo que hemos hecho hasta ahora

1133
01:07:07,840 --> 01:07:09,360
no va a hacer nada

1134
01:07:09,360 --> 01:07:14,500
Entonces, ¿para qué quiero este objeto SC de la clase Scanner?

1135
01:07:14,739 --> 01:07:21,099
Pues lo quiero para que el programa nos solicite las notas

1136
01:07:21,099 --> 01:07:23,380
y yo las pueda teclear a través del teclado, ¿vale?

1137
01:07:24,340 --> 01:07:32,179
Entonces, aquí hemos utilizado Scanner,

1138
01:07:32,179 --> 01:07:34,880
voy a calcular la nota media de las tres

1139
01:07:34,880 --> 01:07:38,599
Y ahora le ponemos el System.out

1140
01:07:38,599 --> 01:07:52,769
Y nos va a solicitar la primera nota

1141
01:07:52,769 --> 01:07:53,610
¿Vale?

1142
01:07:53,690 --> 01:07:55,050
Para solicitar la primera nota

1143
01:07:55,050 --> 01:07:56,869
¿Qué es lo que hacemos?

1144
01:07:57,050 --> 01:07:58,210
Que ahora la primera nota

1145
01:07:58,210 --> 01:07:59,869
Que acordaos que era un doble

1146
01:07:59,869 --> 01:08:01,969
Y se llamaba nota 1

1147
01:08:01,969 --> 01:08:03,889
En vez de ponerle yo el valor

1148
01:08:03,889 --> 01:08:07,230
Solo va a poner el usuario que esté con el programa

1149
01:08:07,230 --> 01:08:09,050
Lo va a escribir en el teclado

1150
01:08:09,050 --> 01:08:11,909
Entonces para ello tenemos que utilizar la clase Scanner

1151
01:08:11,909 --> 01:08:14,369
que sería sc, que es el objeto que hemos utilizado

1152
01:08:14,369 --> 01:08:15,750
y vamos a utilizar un método sui

1153
01:08:15,750 --> 01:08:18,369
y vamos a decirle que nos proporcione

1154
01:08:18,369 --> 01:08:19,970
el próximo double

1155
01:08:19,970 --> 01:08:22,149
porque lo que queremos

1156
01:08:22,149 --> 01:08:24,390
es un valor

1157
01:08:24,390 --> 01:08:25,869
de tipo double, ¿qué va a hacer aquí?

1158
01:08:26,329 --> 01:08:28,050
la clase scanner tiene un método

1159
01:08:28,050 --> 01:08:30,310
que se llama next double, que lo que hace es que

1160
01:08:30,310 --> 01:08:32,189
permite a través del teclado

1161
01:08:32,189 --> 01:08:33,770
reintroducir un double

1162
01:08:33,770 --> 01:08:36,630
y a continuación lo captura

1163
01:08:36,630 --> 01:08:38,250
y lo mete dentro de la variable

1164
01:08:38,250 --> 01:08:40,409
nota1 que hemos creado de tipo double

1165
01:08:40,409 --> 01:08:41,189
¿vale?

1166
01:08:41,909 --> 01:08:55,310
Todo esto será exactamente igual en todas las líneas, igual en todas las líneas.

1167
01:08:55,310 --> 01:09:14,449
¿Veis? He cogido, vamos a comentarlo, creamos objeto de la clase escala.

1168
01:09:14,449 --> 01:09:48,989
A continuación, solicitamos la primera nota o teclado a través del objeto llamado sc.

1169
01:09:48,989 --> 01:10:21,859
Aquí le estamos diciendo que una vez obtenido el dato por teclado, lo almacena en la variable de tipo double llamada nota1.

1170
01:10:22,859 --> 01:10:25,819
Esto ya no lo pongo para estas dos líneas porque realmente es lo mismo.

1171
01:10:26,640 --> 01:10:31,560
Esto sería igual, lo voy a hacer para la segunda nota y para la tercera.

1172
01:10:31,560 --> 01:10:53,319
A continuación aquí, que es lo que hace, expresión que calcula la nota media de las tres notas introducidas en el teclado,

1173
01:10:53,319 --> 01:10:58,880
cuyo valor

1174
01:10:58,880 --> 01:11:00,439
lo

1175
01:11:00,439 --> 01:11:01,859
introduce

1176
01:11:01,859 --> 01:11:04,479
en la

1177
01:11:04,479 --> 01:11:06,359
variable

1178
01:11:06,359 --> 01:11:08,619
llamada

1179
01:11:08,619 --> 01:11:10,819
media

1180
01:11:10,819 --> 01:11:11,100
¿vale?

1181
01:11:24,579 --> 01:11:25,460
m

1182
01:11:25,460 --> 01:11:29,000
vale

1183
01:11:29,000 --> 01:11:31,619
a ver aquí

1184
01:11:31,619 --> 01:11:34,279
estoy comentando

1185
01:11:34,279 --> 01:11:35,880
incluso demasiado ¿no? pero

1186
01:11:35,880 --> 01:11:38,520
es para que lo veáis ¿vale?

1187
01:11:38,560 --> 01:11:39,100
este sería

1188
01:11:39,100 --> 01:11:45,020
método main

1189
01:11:45,020 --> 01:11:46,699
de la clase

1190
01:11:46,699 --> 01:11:51,710
project1

1191
01:11:51,710 --> 01:11:54,689
y aquí tendríamos

1192
01:11:54,689 --> 01:11:59,069
clase

1193
01:11:59,069 --> 01:12:02,710
project1

1194
01:12:02,710 --> 01:12:04,689
con

1195
01:12:04,689 --> 01:12:07,010
acceso público

1196
01:12:07,010 --> 01:12:17,199
vale, pues ya tenemos

1197
01:12:17,199 --> 01:12:19,239
claro que es todo lo que tenemos aquí

1198
01:12:19,239 --> 01:12:22,340
a través de la clase

1199
01:12:22,340 --> 01:12:24,119
project1, a través de su

1200
01:12:24,119 --> 01:12:26,260
public extractivo y main, que va a ser el método

1201
01:12:26,260 --> 01:12:28,500
principal que ha de ejecutar

1202
01:12:28,500 --> 01:12:29,760
va a ir hacia él

1203
01:12:29,760 --> 01:12:32,020
un método con un parámetro

1204
01:12:32,020 --> 01:12:34,119
que es este de aquí, lo que hace es que

1205
01:12:34,119 --> 01:12:35,600
primero genera un objeto scanner

1206
01:12:35,600 --> 01:12:38,159
para generar un objeto scanner necesitamos

1207
01:12:38,159 --> 01:12:40,060
el objeto in de la clase system

1208
01:12:40,060 --> 01:12:41,319
como parámetro

1209
01:12:41,319 --> 01:12:44,140
a continuación imprime

1210
01:12:44,140 --> 01:12:46,359
voy a calcular una nota media de 3 notas

1211
01:12:46,359 --> 01:12:47,840
a través del println

1212
01:12:47,840 --> 01:12:51,819
del objeto out, luego pone

1213
01:12:51,819 --> 01:12:56,140
primera nota, dos puntos y a continuación nos pedirá

1214
01:12:56,140 --> 01:12:59,619
la primera nota, luego nos pedirá la segunda y luego la tercera

1215
01:12:59,619 --> 01:13:04,250
¿vale? primera nota, segunda nota

1216
01:13:04,250 --> 01:13:12,739
y tercera nota, ¿vale? ¿cómo lo hace esto?

1217
01:13:13,359 --> 01:13:17,300
coge el objeto scanner que hemos creado y llama a su método next double

1218
01:13:17,300 --> 01:13:21,479
está diciendo, oye, dame el próximo número

1219
01:13:21,479 --> 01:13:27,840
de tipo decimal. ¿Y cómo lo hace? Pues a través del cursor, nos sale un cursor parpadeante

1220
01:13:27,840 --> 01:13:33,720
que nos va a indicar que nos pide que nosotros escribamos con el teclado la nota. Una vez

1221
01:13:33,720 --> 01:13:41,479
que escribimos la nota, él la va a introducir dentro de la variable nota1, que es de tipo

1222
01:13:41,479 --> 01:13:48,140
doble. Aquí la introduce dentro de la variable 2 y la de la nota 3. Después llega a la expresión

1223
01:13:48,140 --> 01:13:50,359
media que lo único que hace es

1224
01:13:50,359 --> 01:13:52,479
que calcula la suma de las tres notas

1225
01:13:52,479 --> 01:13:53,500
la divide entre tres

1226
01:13:53,500 --> 01:13:56,140
y todo eso lo introduce dentro de la variable

1227
01:13:56,140 --> 01:13:57,180
media

1228
01:13:57,180 --> 01:14:00,420
después con este sistema out.ln

1229
01:14:00,420 --> 01:14:01,840
lo que va a hacer es que va a imprimir

1230
01:14:01,840 --> 01:14:03,159
el valor de la nota

1231
01:14:03,159 --> 01:14:06,060
entonces yo cuando ahora lo voy a ejecutar

1232
01:14:06,060 --> 01:14:07,279
vamos a ver si está todo bien

1233
01:14:07,279 --> 01:14:13,119
fijaos

1234
01:14:13,119 --> 01:14:16,039
cuando lo voy a ejecutar

1235
01:14:16,039 --> 01:14:19,000
me ha puesto voy a calcular la nota media de tres notas

1236
01:14:19,000 --> 01:14:21,079
y aquí nos permite

1237
01:14:21,079 --> 01:14:21,720
escribir

1238
01:14:22,399 --> 01:14:27,199
Si yo le pongo la nota con un punto, me lo va a dar como error.

1239
01:14:27,380 --> 01:14:31,340
¿Por qué? Porque él lo coge como con coma.

1240
01:14:31,600 --> 01:14:33,239
Entonces le voy a poner un valor de 4,5.

1241
01:14:33,380 --> 01:14:35,539
Cuando le doy a Enter, nos pide la segunda nota.

1242
01:14:35,640 --> 01:14:38,039
Le voy a poner un 5,6.

1243
01:14:38,539 --> 01:14:40,960
Y cuando le doy a Enter, nos pide la tercera nota.

1244
01:14:41,079 --> 01:14:43,000
Le voy a poner un 9, lo voy mejorando.

1245
01:14:43,479 --> 01:14:44,539
Vamos a poner un 9,2.

1246
01:14:45,979 --> 01:14:51,819
Una vez que nos saca el decimal, la nota media, que sería de un 6,43.

1247
01:14:51,819 --> 01:14:53,699
periodo, ¿vale? Y este sería

1248
01:14:53,699 --> 01:14:55,060
el programa con

1249
01:14:55,060 --> 01:14:59,199
la clase Scanner.

1250
01:15:00,359 --> 01:15:01,359
Ya sé que he introducido

1251
01:15:01,359 --> 01:15:02,939
muchas cosas, muchos, pero

1252
01:15:02,939 --> 01:15:05,180
si queremos hacer algún programa

1253
01:15:05,180 --> 01:15:07,180
sencillito, necesito

1254
01:15:07,180 --> 01:15:09,159
introducir, y es que Java necesita de toda esta

1255
01:15:09,159 --> 01:15:10,380
parafernalia para poder hacer

1256
01:15:10,380 --> 01:15:13,319
una suma, una media de tres notas.

1257
01:15:14,220 --> 01:15:15,399
¿Alguna duda sobre esto?

1258
01:15:16,260 --> 01:15:17,060
¿Queréis que...

1259
01:15:17,060 --> 01:15:22,420
Vale, no sé...

1260
01:15:22,420 --> 01:15:24,279
Vale, lo pillo.

1261
01:15:24,279 --> 01:15:26,720
queréis que lo repase otra vez

1262
01:15:26,720 --> 01:15:28,399
el programa

1263
01:15:28,399 --> 01:15:33,010
pero si, a ver

1264
01:15:33,010 --> 01:15:35,869
el valor de una variable entera y de una variable double

1265
01:15:35,869 --> 01:15:37,510
se puede sumar

1266
01:15:37,510 --> 01:15:39,010
porque son números

1267
01:15:39,010 --> 01:15:40,949
claro, él lo que hace

1268
01:15:40,949 --> 01:15:42,949
si yo le pusiera una variable

1269
01:15:42,949 --> 01:15:44,869
le pusiera una variable, por ejemplo

1270
01:15:44,869 --> 01:15:46,449
a esta nota

1271
01:15:46,449 --> 01:15:47,409
y se la pusiera

1272
01:15:47,409 --> 01:15:50,590
a ver, no lo podemos hacer aquí

1273
01:15:50,590 --> 01:15:52,470
porque le estoy pidiendo, pero imaginaos

1274
01:15:52,470 --> 01:15:54,170
que en vez de pedirle a la nota 2

1275
01:15:54,170 --> 01:15:56,069
un next double

1276
01:15:56,069 --> 01:15:58,350
le voy a pedir un entero

1277
01:15:58,350 --> 01:15:59,390
¿vale? vamos a probarlo

1278
01:15:59,390 --> 01:16:02,109
entonces en vez de pedirle

1279
01:16:02,109 --> 01:16:03,609
un entero, le voy a pedir

1280
01:16:03,609 --> 01:16:06,229
un entero con el nextIn

1281
01:16:06,229 --> 01:16:07,649
¿vale? de la clase

1282
01:16:07,649 --> 01:16:09,529
del objeto de la clase Scanner

1283
01:16:09,529 --> 01:16:12,029
entonces claro, esto estaría mal porque como

1284
01:16:12,029 --> 01:16:14,010
va a recibir un entero, tendría que poner aquí

1285
01:16:14,010 --> 01:16:15,829
un tipo del tipo entero

1286
01:16:15,829 --> 01:16:17,890
¿creéis que funcionaría esto?

1287
01:16:18,069 --> 01:16:26,140
¿sí o no? sí, funcionaría

1288
01:16:26,140 --> 01:16:28,399
¿por qué? porque él lo va

1289
01:16:28,399 --> 01:16:30,060
en esta expresión

1290
01:16:30,060 --> 01:16:31,619
aquí va a tener un double

1291
01:16:31,619 --> 01:16:34,399
aquí va a tener un decimal, aquí tiene un entero

1292
01:16:34,399 --> 01:16:35,920
y aquí tiene un decimal

1293
01:16:35,920 --> 01:16:38,460
él automáticamente va a convertir las tres notas

1294
01:16:38,460 --> 01:16:39,739
y nos va a dar un resultado en decimal

1295
01:16:39,739 --> 01:16:40,619
si yo le meto

1296
01:16:40,619 --> 01:16:43,979
lo que pasa es que, cuidado

1297
01:16:43,979 --> 01:16:46,220
si ahora yo

1298
01:16:46,220 --> 01:16:47,399
fijaos

1299
01:16:47,399 --> 01:16:49,899
si hay un problema, si yo ahora

1300
01:16:49,899 --> 01:16:51,420
no me doy cuenta

1301
01:16:51,420 --> 01:16:53,880
y en vez de poner, aquí le vamos a poner un 2.3

1302
01:16:53,880 --> 01:16:55,979
pero la segunda nota, ¿qué pasa aquí?

1303
01:16:56,420 --> 01:16:58,460
¿qué sucede si le pongo un valor decimal?

1304
01:16:59,279 --> 01:17:00,279
¿funcionará o no funcionará?

1305
01:17:00,279 --> 01:17:09,619
no le puedo meter porque el objeto

1306
01:17:09,619 --> 01:17:13,180
sc de la clase scanner está utilizando el método

1307
01:17:13,180 --> 01:17:15,520
está utilizando el método

1308
01:17:15,520 --> 01:17:21,680
next in, te está pidiendo el próximo entero

1309
01:17:21,680 --> 01:17:25,819
no, te está pidiendo un valor decimal, si yo pusiera aquí un valor decimal

1310
01:17:25,819 --> 01:17:29,420
nos daría error, aquí tendría que ponerle un valor entero

1311
01:17:29,420 --> 01:17:33,699
para que me lo coja, yo tendría que ponerle por ejemplo 9 y no nos daría

1312
01:17:33,699 --> 01:17:37,340
ningún tipo de error, entonces ya nos pediría la tercera nota

1313
01:17:37,340 --> 01:17:41,579
y pondríamos un 4.2, también podríamos poner

1314
01:17:41,579 --> 01:17:46,060
un 4, él como es un double automáticamente lo va a convertir en un 4.0

1315
01:17:46,060 --> 01:17:49,520
¿vale? y nos sacaría la media, ¿qué sucede si yo le doy

1316
01:17:49,520 --> 01:17:53,079
a ejecutar y en vez de en la segunda le meto

1317
01:17:53,079 --> 01:17:57,460
2.3 y aquí le metemos un

1318
01:17:57,460 --> 01:18:04,619
4.5, ¿veis? nos da error

1319
01:18:04,619 --> 01:18:06,680
nos da esta excepción que falla

1320
01:18:06,680 --> 01:18:08,000
en el que nos dice pues que

1321
01:18:08,000 --> 01:18:10,079
fijaos la pila

1322
01:18:10,079 --> 01:18:12,560
de métodos

1323
01:18:12,560 --> 01:18:14,760
en el que va recorriendo, si lo fijáis

1324
01:18:14,760 --> 01:18:16,619
primero under the project

1325
01:18:16,619 --> 01:18:18,020
va al main, lo veis aquí

1326
01:18:18,020 --> 01:18:20,640
va al main, luego va al next

1327
01:18:20,640 --> 01:18:21,960
in y ahí es donde se produce

1328
01:18:21,960 --> 01:18:24,380
el error, el next in

1329
01:18:24,380 --> 01:18:26,560
es el que ha provocado pues que se genere

1330
01:18:26,560 --> 01:18:28,579
toda esta pila de errores

1331
01:18:28,579 --> 01:18:30,960
entonces, que necesito

1332
01:18:30,960 --> 01:18:31,760
darle a

1333
01:18:31,760 --> 01:18:34,300
necesito darle, esto sucede

1334
01:18:34,300 --> 01:18:39,260
también lo he dicho antes, si yo le meto la primera nota, le pongo un 3.4

1335
01:18:39,260 --> 01:18:42,159
también me da el error, ¿por qué?

1336
01:18:42,260 --> 01:18:46,260
porque los coge, como ya lo comentaba anteriormente, para tú poderle

1337
01:18:46,260 --> 01:18:50,100
introducir con la clase Scanner un valor decimal, tiene que ser con la coma

1338
01:18:50,100 --> 01:18:53,579
por teclado, si tú le metes un valor punto, nos va a generar también

1339
01:18:53,579 --> 01:18:57,279
el error, entonces sabemos por tanto que

1340
01:18:57,279 --> 01:19:02,039
vamos a cortarlo, sabemos por tanto que la primera nota

1341
01:19:02,039 --> 01:19:05,939
lógicamente tiene que ser un decimal

1342
01:19:05,939 --> 01:19:08,760
que la segunda tiene que ser un entero

1343
01:19:08,760 --> 01:19:11,500
y que la tercera tiene que ser un decimal

1344
01:19:11,500 --> 01:19:13,159
automáticamente ¿qué hará?

1345
01:19:13,739 --> 01:19:15,739
él automáticamente al hacer la expresión

1346
01:19:15,739 --> 01:19:18,479
esta expresión de suma y división

1347
01:19:18,479 --> 01:19:21,500
automáticamente convierte a nota 2

1348
01:19:21,500 --> 01:19:23,939
implícitamente la convierte en un double

1349
01:19:23,939 --> 01:19:26,819
suma tres doubles y lo divide entre tres

1350
01:19:26,819 --> 01:19:28,180
y realiza la A

1351
01:19:28,180 --> 01:19:30,420
aunque nosotros le hayamos metido un valor decimal

1352
01:19:30,420 --> 01:19:33,430
y calcula la media

1353
01:19:33,430 --> 01:19:35,270
que es 5.3

1354
01:19:35,270 --> 01:19:46,710
¿Algo que no

1355
01:19:46,710 --> 01:19:50,229
queráis que aclare sobre el programa?

1356
01:19:52,930 --> 01:19:53,710
¿Más o menos se entiende?

1357
01:19:54,289 --> 01:19:55,810
No es necesario que lo entendáis

1358
01:19:55,810 --> 01:19:56,630
entero, ¿vale?

1359
01:19:57,210 --> 01:19:59,350
Sí que vayamos viendo un poquito

1360
01:19:59,350 --> 01:19:59,949
cómo es Java

1361
01:19:59,949 --> 01:20:03,149
Básicamente quería que estas sesiones

1362
01:20:03,149 --> 01:20:05,090
nos sirvan un poquito para ir introduciendo

1363
01:20:05,090 --> 01:20:09,039
un poquito de Java

1364
01:20:09,039 --> 01:20:11,439
y que ya pues empecéis a tener

1365
01:20:11,439 --> 01:20:13,119
pues ligeras nociones

1366
01:20:13,119 --> 01:20:14,439
de qué va esto, ¿vale?

1367
01:20:14,439 --> 01:20:16,979
no quiero que esto, no es necesario

1368
01:20:16,979 --> 01:20:18,239
que lo sepáis, hacer

1369
01:20:18,239 --> 01:20:20,899
100% porque todavía no

1370
01:20:20,899 --> 01:20:22,920
hemos visto la mayoría de todo lo que hay

1371
01:20:22,920 --> 01:20:24,239
aquí, ¿vale? pero

1372
01:20:24,239 --> 01:20:27,159
que vayamos, fijaos

1373
01:20:27,159 --> 01:20:28,739
hemos hecho ya un programa

1374
01:20:28,739 --> 01:20:30,119
en el que hemos podido meter tres valores

1375
01:20:30,119 --> 01:20:32,899
un tipo doble por teclado y nos ha

1376
01:20:32,899 --> 01:20:34,500
calculado una mail, o sea que ya

1377
01:20:34,500 --> 01:20:35,979
hemos hecho alguna cosita

1378
01:20:35,979 --> 01:20:38,439
sin tener mucha idea de

1379
01:20:38,439 --> 01:20:39,500
de qué rango, ¿vale?

1380
01:20:40,439 --> 01:20:41,819
¿verdad? ¿alguna duda? ¿algo?

1381
01:20:42,760 --> 01:20:43,399
todavía, ¿no?

1382
01:20:46,460 --> 01:21:11,550
Vamos a introducir una mejora al programa y vamos a hacer ahora que el programa en vez de que lo calcule aquí directamente, fijaos, esta operación está aquí metida en el método y no os molesta un poco que podamos delegar esa operación a un método fuera y que cada vez que queramos utilizarla la podamos llamar.

1383
01:21:11,550 --> 01:21:38,789
Pues eso es lo que voy a hacer ahora. Ahora lo que voy a hacer es generar un método, para generar un método, acordaos de aquí, cómo se ha generado un método, fijaos, la sintaxis era el acceso al dicho método, public, private o protected, y luego el valor devuelto, vamos a olvidarnos del static, si tiene un valor devuelto o si no, void,

1384
01:21:38,789 --> 01:21:44,289
y luego el nombre del método y entre paréntesis si necesita algún parámetro dentro, ¿vale?

1385
01:21:45,289 --> 01:21:47,729
Luego se abre una llave y se cierra. Eso es lo que vamos a hacer aquí.

1386
01:21:47,909 --> 01:21:50,890
Vamos a crear un método aquí, ¿veis? Pero tiene que estar indentado.

1387
01:21:50,989 --> 01:21:52,369
Este método va a estar dentro de esta clase.

1388
01:21:52,729 --> 01:21:54,750
Acordaos que esta clase se abre aquí y se cierra aquí.

1389
01:21:55,229 --> 01:21:57,590
Y aquí tenemos el método main que se abre aquí y se cierra aquí,

1390
01:21:57,770 --> 01:22:00,550
pero que está a su vez dentro e indentado dentro de la clase.

1391
01:22:00,949 --> 01:22:03,310
Y aquí vamos a generar otro método dentro de la clase.

1392
01:22:03,310 --> 01:22:04,829
le vamos a decir que es un método público

1393
01:22:04,829 --> 01:22:07,010
y le vamos a decir que

1394
01:22:07,010 --> 01:22:09,409
nos va a devolver un valor de qué tipo

1395
01:22:09,409 --> 01:22:11,210
¿quién me puede decir de qué tipo

1396
01:22:11,210 --> 01:22:13,250
me va a devolver el valor? este método

1397
01:22:13,250 --> 01:22:17,479
¿es necesario que me devuelva algo?

1398
01:22:18,680 --> 01:22:19,579
un doble, muy bien

1399
01:22:19,579 --> 01:22:21,899
vamos a meterle un doble

1400
01:22:21,899 --> 01:22:25,180
y le vamos a llamar

1401
01:22:25,180 --> 01:22:29,069
obtener media

1402
01:22:29,069 --> 01:22:33,199
tenemos que abrir la llave

1403
01:22:33,199 --> 01:22:34,920
y cerrarla, ¿veis? ya está metido

1404
01:22:34,920 --> 01:22:37,000
la primera llave, aquí ¿por qué nos sale

1405
01:22:37,000 --> 01:22:38,880
este error? nos sale este error porque como devuelve

1406
01:22:38,880 --> 01:22:45,840
un doble y no le he puesto un retro pues me va a dar el error hasta que ponga el retro es lo

1407
01:22:45,840 --> 01:22:54,659
que lo único que me está indicando que quiero que quiero que tenga parámetros sí o no cuántos

1408
01:22:54,659 --> 01:23:03,720
parámetros y tiene la nota pues vamos a ponerle tres parámetros esos parámetros serán de tipo

1409
01:23:03,720 --> 01:23:05,560
doble también, ¿no? Entonces, doble

1410
01:23:05,560 --> 01:23:08,319
aquí

1411
01:23:08,319 --> 01:23:13,439
vamos a llamarle

1412
01:23:13,439 --> 01:23:14,380
no 1

1413
01:23:14,380 --> 01:23:19,180
no 2

1414
01:23:19,180 --> 01:23:20,659
y doble

1415
01:23:20,659 --> 01:23:23,159
3, ¿vale?

1416
01:23:24,460 --> 01:23:26,100
Y ahora, ¿qué es lo que quiero?

1417
01:23:26,380 --> 01:23:28,439
Que en vez de...

1418
01:23:33,000 --> 01:23:33,960
El cuidado que

1419
01:23:33,960 --> 01:23:36,039
la nota 2 la pusimos como

1420
01:23:36,039 --> 01:23:38,479
entera. ¿Cómo? ¿La pusimos

1421
01:23:38,479 --> 01:23:40,039
como? Ah, sí, como entera, vale.

1422
01:23:40,039 --> 01:23:41,340
Como entera. Aquí, es verdad.

1423
01:23:42,699 --> 01:23:43,500
No pasaría

1424
01:23:43,500 --> 01:23:45,420
nada porque él automáticamente si la llamamos

1425
01:23:45,420 --> 01:23:47,319
con el entero, él automáticamente

1426
01:23:47,319 --> 01:23:48,199
le pasaría un doble

1427
01:23:48,199 --> 01:23:51,600
si quieres luego lo probamos

1428
01:23:51,600 --> 01:23:54,600
porque él siempre

1429
01:23:54,600 --> 01:23:56,960
el cajón lo adapta

1430
01:23:56,960 --> 01:23:58,920
al cajón más grande, el cajón más grande

1431
01:23:58,920 --> 01:24:00,500
sea el doble, entonces lo adaptaría

1432
01:24:00,500 --> 01:24:02,819
cogería el entero y al ver

1433
01:24:02,819 --> 01:24:03,680
que esto es un

1434
01:24:03,680 --> 01:24:07,039
un doble, pues lo transformaría en un doble

1435
01:24:07,039 --> 01:24:07,880
entonces

1436
01:24:07,880 --> 01:24:10,939
tendríamos las tres notas, aquí tendríamos

1437
01:24:10,939 --> 01:24:15,619
que hacer esto, porque ahora

1438
01:24:15,619 --> 01:24:16,880
estamos delegando

1439
01:24:16,880 --> 01:24:23,239
esa expresión

1440
01:24:23,239 --> 01:24:26,420
a este método. Cada vez que le llamemos nos hará esto.

1441
01:24:26,979 --> 01:24:37,819
¿Y ahora qué va a retornar? ¿Qué es lo que retornará? Media. Muy bien.

1442
01:24:37,819 --> 01:24:41,659
Entonces le metemos media aquí. Media que sería la variable

1443
01:24:41,659 --> 01:24:45,720
que nos hace el cálculo y que es de tipo doble y que coincide

1444
01:24:45,720 --> 01:24:49,819
con el doble. Aquí nos está diciendo

1445
01:24:49,819 --> 01:24:53,359
el error. ¿Por qué? Porque aquí no se llama nota, se llama not.

1446
01:24:56,420 --> 01:24:59,399
que son los tres parámetros que hemos recibido

1447
01:24:59,399 --> 01:25:12,569
bien, tenemos nuestro método

1448
01:25:12,569 --> 01:25:14,689
¿qué es lo que hace este método? va a devolver un double

1449
01:25:14,689 --> 01:25:18,449
se llama obtenerMedia y recibe tres parámetros, uno de tipo double

1450
01:25:18,449 --> 01:25:21,550
otro y otro, entonces tres los coge, los suma

1451
01:25:21,550 --> 01:25:23,710
los divide entre tres y lo mete dentro de la variable media

1452
01:25:23,710 --> 01:25:26,909
y luego retorna la variable media que si vemos

1453
01:25:26,909 --> 01:25:29,670
el retorno coincide porque media es double

1454
01:25:29,670 --> 01:25:33,770
y el valor de retorno de la función es doble

1455
01:25:33,770 --> 01:25:37,369
además el método es público, o sea que puedo acceder a él

1456
01:25:37,369 --> 01:25:41,970
bien, ya tenemos

1457
01:25:41,970 --> 01:25:45,630
esto sería exactamente igual, por el teclado nos pediría

1458
01:25:45,630 --> 01:25:49,489
las tres notas y luego ahora lo que habría que hacer es

1459
01:25:49,489 --> 01:25:53,430
llamar, aquí llamaríamos

1460
01:25:53,430 --> 01:25:55,989
esto, este comentario

1461
01:25:55,989 --> 01:26:09,279
y aquí lo que haríamos que es

1462
01:26:09,279 --> 01:26:13,060
llamaríamos aquí al método

1463
01:26:13,060 --> 01:26:14,439
obtenerMedia

1464
01:26:14,439 --> 01:26:20,319
aquí si veis no hay

1465
01:26:20,319 --> 01:26:25,079
yo puedo generar aquí un robo

1466
01:26:25,079 --> 01:26:28,920
media y no habría problema porque esta variable

1467
01:26:28,920 --> 01:26:31,319
media, aunque tengan el mismo nombre

1468
01:26:31,319 --> 01:26:33,199
está dentro de un método

1469
01:26:33,199 --> 01:26:35,220
entonces fuera de ese método

1470
01:26:35,220 --> 01:26:37,359
media no aparecería, no había conflicto

1471
01:26:37,359 --> 01:26:39,220
entonces aquí podríamos poner igual

1472
01:26:39,220 --> 01:26:41,220
aquí

1473
01:26:41,220 --> 01:26:43,560
entonces tendríamos que llamar al propio

1474
01:26:43,560 --> 01:26:45,479
entonces aquí se puede

1475
01:26:45,479 --> 01:26:46,220
hacer de dos maneras

1476
01:26:46,220 --> 01:26:48,380
yo le puedo poner

1477
01:26:48,380 --> 01:26:58,840
y llamaríamos a obtener media

1478
01:26:58,840 --> 01:27:00,500
o incluso

1479
01:27:00,500 --> 01:27:25,720
vale, yo puedo hacerlo de dos maneras

1480
01:27:25,720 --> 01:27:27,539
como esto es un método estático

1481
01:27:27,539 --> 01:27:31,000
y estoy llamando a un método que no es estático

1482
01:27:31,000 --> 01:27:32,460
lo veis, aquí me está dando un error

1483
01:27:32,460 --> 01:27:36,039
nos está diciendo, este método es estático

1484
01:27:36,039 --> 01:27:40,159
y estoy llamando a un método estático

1485
01:27:40,159 --> 01:27:42,520
entonces, ¿cómo podemos resolver esto?

1486
01:27:42,859 --> 01:27:44,979
se puede hacer de varias maneras

1487
01:27:44,979 --> 01:27:47,920
una manera para poder llamar al método

1488
01:27:47,920 --> 01:27:50,060
tener media de esta misma

1489
01:27:50,060 --> 01:27:55,300
yo no puedo generar en un método estático

1490
01:27:55,300 --> 01:27:58,439
tendría que crear lo primero, se podría hacer de dos maneras

1491
01:27:58,439 --> 01:28:02,319
una, yo podría hacer un objeto de la propia clase

1492
01:28:02,319 --> 01:28:07,340
y llamar a obtener media

1493
01:28:07,340 --> 01:28:11,119
como aparece aquí, la otra manera

1494
01:28:11,119 --> 01:28:15,079
es, puedo llamar a este método estático y llamarle desde el nombre de la clase

1495
01:28:15,079 --> 01:28:18,920
si yo le puse aquí static, sé que esto

1496
01:28:18,920 --> 01:28:20,920
es más complejo de entender

1497
01:28:20,920 --> 01:28:22,720
si yo le puse a static

1498
01:28:22,720 --> 01:28:24,220
ya se me ha quitado el error

1499
01:28:24,220 --> 01:28:26,520
¿por qué? porque yo no puedo llamar

1500
01:28:26,520 --> 01:28:27,699
desde un método estático

1501
01:28:27,699 --> 01:28:30,140
a un método

1502
01:28:30,140 --> 01:28:32,779
yo no puedo llamar

1503
01:28:32,779 --> 01:28:34,880
a mi método obtenerMedia

1504
01:28:34,880 --> 01:28:36,560
con un dis por ejemplo

1505
01:28:36,560 --> 01:28:37,500
que ya veremos lo que es

1506
01:28:37,500 --> 01:28:40,279
yo no puedo llamar a mi propio método

1507
01:28:40,279 --> 01:28:41,479
de mi primera clase

1508
01:28:41,479 --> 01:28:45,260
porque estoy dentro de un método estático

1509
01:28:45,260 --> 01:28:46,600
que es un método

1510
01:28:46,600 --> 01:28:48,220
de clase, no es un método

1511
01:28:48,220 --> 01:28:52,000
de objeto, ¿vale? Esto es difícil de ver, pero

1512
01:28:52,000 --> 01:28:56,319
lo veremos bastante más adelante, ¿vale? Pero yo no puedo llamar desde un método

1513
01:28:56,319 --> 01:29:00,039
estático, no puedo llamar a otro método que no sea estático

1514
01:29:00,039 --> 01:29:03,800
a no ser que cree un objeto de esta misma clase, ¿vale?

1515
01:29:04,279 --> 01:29:08,159
Al poner static yo puedo llamar directamente a obtener

1516
01:29:08,159 --> 01:29:12,340
media sin tener que crear un objeto, ¿vale? Si yo quitara esto

1517
01:29:12,340 --> 01:29:15,500
vamos a poner, vamos a ver si funciona o no

1518
01:29:15,500 --> 01:29:31,800
nos dice

1519
01:29:31,800 --> 01:29:32,760
algo he puesto mal

1520
01:29:32,760 --> 01:29:33,239
a ver

1521
01:29:33,239 --> 01:29:34,939
4.3

1522
01:29:34,939 --> 01:29:38,069
segunda nota

1523
01:29:38,069 --> 01:29:39,090
nos dice que

1524
01:29:39,090 --> 01:29:40,289
javascan

1525
01:29:40,289 --> 01:29:41,409
ah que es un entero

1526
01:29:41,409 --> 01:29:41,670
vale

1527
01:29:41,670 --> 01:29:42,890
no ha quitado lo del entero

1528
01:29:42,890 --> 01:29:43,090
vale

1529
01:29:43,090 --> 01:29:47,260
es aquí

1530
01:29:47,260 --> 01:29:53,300
vamos a ajustarlo

1531
01:29:53,300 --> 01:29:58,979
bien

1532
01:29:58,979 --> 01:30:00,840
yo pongo 4.3

1533
01:30:00,840 --> 01:30:02,479
le ponemos 3.4

1534
01:30:02,479 --> 01:30:03,420
y le ponemos

1535
01:30:03,420 --> 01:30:04,739
5.4

1536
01:30:04,739 --> 01:30:05,960
y nos calcula

1537
01:30:05,960 --> 01:30:06,399
la media

1538
01:30:06,399 --> 01:30:06,739
¿la veis?

1539
01:30:06,840 --> 01:30:08,380
ahora está calculando la media

1540
01:30:08,380 --> 01:30:11,680
pero lo está haciendo llamando al método, ¿vale?

1541
01:30:12,340 --> 01:30:18,180
Está, cuando llega aquí, llama al método, le pasa las tres notas que hemos obtenido por teclado

1542
01:30:18,180 --> 01:30:26,119
y llama aquí, o sea, esta línea va aquí, recibe como parámetro nota 1 y lo mete dentro de no 1,

1543
01:30:26,939 --> 01:30:32,960
recibe nota 2 y lo mete dentro de no 2 y recibe nota 3 y lo mete dentro de no 3.

1544
01:30:33,239 --> 01:30:38,039
¿Qué hace luego? Esas tres notas, las suma y las divide entre 3, lo mete dentro de media

1545
01:30:38,039 --> 01:30:39,979
y retorna el valor de media

1546
01:30:39,979 --> 01:30:41,119
que era doble

1547
01:30:41,119 --> 01:30:43,840
ese valor aparecerá aquí

1548
01:30:43,840 --> 01:30:45,140
ese 5,33

1549
01:30:45,140 --> 01:30:48,000
en vez de todo esto, aparecerá un 5,33

1550
01:30:48,000 --> 01:30:49,800
lo mete dentro de esta onMedia

1551
01:30:49,800 --> 01:30:51,500
y a continuación

1552
01:30:51,500 --> 01:30:53,800
para que no se os haga lío

1553
01:30:53,800 --> 01:30:54,739
yo pongo

1554
01:30:54,739 --> 01:30:56,760
media total

1555
01:30:56,760 --> 01:31:00,579
y así diferenciamos de la otra variable

1556
01:31:00,579 --> 01:31:00,800
¿vale?

1557
01:31:04,750 --> 01:31:07,010
se entiende más o menos, esto me preocupa menos

1558
01:31:07,010 --> 01:31:08,810
que sepamos cómo llamar este método

1559
01:31:08,810 --> 01:31:10,789
me preocupa menos, pero se entiende que

1560
01:31:10,789 --> 01:31:12,090
hemos delegado

1561
01:31:12,090 --> 01:31:14,949
un algoritmo o una

1562
01:31:14,949 --> 01:31:16,890
expresión, la hemos delegado en un método

1563
01:31:16,890 --> 01:31:18,869
aparte, para que

1564
01:31:18,869 --> 01:31:21,130
la podemos llamar el número de veces que queramos

1565
01:31:21,130 --> 01:31:22,850
con el número de valores que

1566
01:31:22,850 --> 01:31:24,770
queramos, sin necesidad de que esté aquí dentro del

1567
01:31:24,770 --> 01:31:26,369
mail. ¿Se entiende eso?

1568
01:31:28,050 --> 01:31:29,109
Yo sí lo entiendo,

1569
01:31:29,270 --> 01:31:30,930
lo único que no entiendo es

1570
01:31:30,930 --> 01:31:32,829
por qué puedes llamar una cosa que

1571
01:31:32,829 --> 01:31:34,390
has declarado posteriormente.

1572
01:31:37,210 --> 01:31:40,079
Puedes llamar a una cosa que has

1573
01:31:40,079 --> 01:31:41,359
declarado posteriormente.

1574
01:31:41,359 --> 01:31:46,380
Claro, a ver

1575
01:31:46,380 --> 01:31:48,500
esto es como

1576
01:31:48,500 --> 01:31:50,460
una clase, dentro de una clase

1577
01:31:50,460 --> 01:31:52,020
hay una serie de métodos

1578
01:31:52,020 --> 01:31:54,220
y tú puedes llamar a cualquiera de esos

1579
01:31:54,220 --> 01:31:55,720
métodos, ¿vale?

1580
01:31:55,960 --> 01:31:57,439
da igual desde donde le llames

1581
01:31:57,439 --> 01:32:03,319
como una especie de

1582
01:32:03,319 --> 01:32:04,680
de... fijaos

1583
01:32:04,680 --> 01:32:06,699
de la indentación, yo puedo llamar

1584
01:32:06,699 --> 01:32:08,260
a cualquier método

1585
01:32:08,260 --> 01:32:11,079
aquí es que lo estamos haciendo desde esta clase

1586
01:32:11,079 --> 01:32:12,739
pero imagínate que lo estamos haciendo desde otra clase

1587
01:32:12,739 --> 01:32:40,560
Yo puedo llamar desde otro programa, puedo generar un objeto de Project 1 y llamar al método obtener media. No tiene por qué estar ese método delante, arriba. Yo sí cojo este método, si es lo que te preocupa, y yo le cojo aquí y le pongo aquí. Es lo mismo, ¿vale? Es lo mismo. No sé si es lo que te refieres.

1588
01:32:40,560 --> 01:32:41,520
que si no has leído

1589
01:32:41,520 --> 01:32:44,920
si lo hubiera visto así no te hubiera hecho la pregunta

1590
01:32:44,920 --> 01:32:46,380
porque como está declarado antes

1591
01:32:46,380 --> 01:32:47,479
y luego se llama después

1592
01:32:47,479 --> 01:32:49,039
como estaba

1593
01:32:49,039 --> 01:32:51,220
claro, pero la clase

1594
01:32:51,220 --> 01:32:54,119
una vez declarada la clase, cuando lo coge

1595
01:32:54,119 --> 01:32:56,060
el compilador para generar el bytecode

1596
01:32:56,060 --> 01:32:58,319
él ve cada uno

1597
01:32:58,319 --> 01:33:00,420
de los métodos

1598
01:33:00,420 --> 01:33:02,899
los ve, cada uno de los métodos, los lee

1599
01:33:02,899 --> 01:33:05,420
y es independiente

1600
01:33:05,420 --> 01:33:07,579
realmente la ejecución del programa

1601
01:33:07,579 --> 01:33:09,180
es esta, desde aquí

1602
01:33:09,180 --> 01:33:11,819
y él está ejecutando el programa desde aquí

1603
01:33:11,939 --> 01:33:15,340
Pero él, el programa, el compilador, ya ha leído todos los métodos que hay.

1604
01:33:15,439 --> 01:33:17,060
Da igual donde los ponga, ¿vale?

1605
01:33:17,600 --> 01:33:23,619
Sí, da igual donde estén.

1606
01:33:24,060 --> 01:33:25,239
Si está delante, si está detrás.

1607
01:33:25,500 --> 01:33:26,920
Él ya, el compilador, lo ha leído.

1608
01:33:27,159 --> 01:33:30,159
Sabe que tiene un método main y tiene un método obtenerMedia.

1609
01:33:30,279 --> 01:33:32,779
Que el método obtenerMedia tiene tres parámetros de tipo double

1610
01:33:32,779 --> 01:33:37,100
y que el método main tiene un parámetro...

1611
01:33:37,100 --> 01:33:37,720
Él ya lo sabe.

1612
01:33:38,159 --> 01:33:39,520
Pero luego la ejecución es esta.

1613
01:33:39,760 --> 01:33:40,880
Empieza aquí, ¿vale?

1614
01:33:40,880 --> 01:33:43,680
va directamente al Estatic Web Main

1615
01:33:43,680 --> 01:33:45,020
que es una aplicación

1616
01:33:45,020 --> 01:33:47,300
y empieza a leer esta línea

1617
01:33:47,300 --> 01:33:49,640
y luego esta otra, y luego esta otra

1618
01:33:49,640 --> 01:33:51,500
y luego esta otra, pero ya es

1619
01:33:51,500 --> 01:33:53,439
conocedor de los métodos que

1620
01:33:53,439 --> 01:33:54,460
tiene la clase, ¿vale?

1621
01:33:54,880 --> 01:33:57,439
Entonces, ¿qué pasa? Que cuando llama a obtener media

1622
01:33:57,439 --> 01:33:58,960
él sabe que tiene

1623
01:33:58,960 --> 01:34:01,020
que la clase Project 1 tiene

1624
01:34:01,020 --> 01:34:03,000
un método que se llama obtener media y que requiere

1625
01:34:03,000 --> 01:34:04,300
de tres parámetros de tipo doble

1626
01:34:04,300 --> 01:34:06,520
entonces, lo llama con esos tres

1627
01:34:06,520 --> 01:34:08,899
parámetros que coinciden además

1628
01:34:08,899 --> 01:34:10,340
con los de i

1629
01:34:10,340 --> 01:34:13,119
calcula la media total, se la devuelve

1630
01:34:13,119 --> 01:34:15,220
una vez que se la devuelve, pues la puedes imprimir

1631
01:34:15,220 --> 01:34:19,039
¿vale? ¿alguna duda más?

1632
01:34:19,880 --> 01:34:21,260
a ver, que me he metido en harina

1633
01:34:21,260 --> 01:34:23,460
¿sabéis que todo esto

1634
01:34:23,460 --> 01:34:25,199
no lo hemos dado? ¿vale? pero es porque

1635
01:34:25,199 --> 01:34:26,340
os vaya ya sonando

1636
01:34:26,340 --> 01:34:28,680
no tenéis por qué entenderlo todo

1637
01:34:28,680 --> 01:34:31,220
¿vale? no hemos dado todavía ni operadores, no hemos dado

1638
01:34:31,220 --> 01:34:32,460
ni tipos de datos, no hemos dado

1639
01:34:32,460 --> 01:34:35,100
ni variables, no hemos dado

1640
01:34:35,100 --> 01:34:37,279
y mucho menos lo que es un objeto

1641
01:34:37,279 --> 01:34:38,560
y mucho menos lo que es estático

1642
01:34:38,560 --> 01:34:40,159
¿vale? pero bueno que

1643
01:34:40,159 --> 01:34:42,319
es lo que tiene Java.

1644
01:34:42,460 --> 01:34:44,520
Para poder hacer un programa sencillito

1645
01:34:44,520 --> 01:34:45,880
necesitas toda esta

1646
01:34:45,880 --> 01:34:48,539
infraestructura. Quizás esto me lo puede

1647
01:34:48,539 --> 01:34:50,340
haber ahorrado, ¿vale? La función.

1648
01:34:50,479 --> 01:34:52,220
Pero me ha parecido oportuno que

1649
01:34:52,220 --> 01:34:54,579
veáis la operación matemática

1650
01:34:54,579 --> 01:34:56,560
que la podemos delegar en un método.

1651
01:34:56,720 --> 01:35:05,000
¿Vale? ¿Vale? ¿Alguna

1652
01:35:05,000 --> 01:35:05,279
duda?

1653
01:35:09,109 --> 01:35:09,829
¿Todo ok?

1654
01:35:11,670 --> 01:35:12,710
Pues yo, si queréis,

1655
01:35:12,789 --> 01:35:13,909
lo dejamos de aquí, ¿vale?

1656
01:35:14,350 --> 01:35:16,649
El próximo día, si queréis,

1657
01:35:16,649 --> 01:35:18,649
seguimos haciendo programas sencillitos

1658
01:35:18,649 --> 01:35:21,350
así tipo como este

1659
01:35:21,350 --> 01:35:22,989
y que ya os vaya sonando

1660
01:35:22,989 --> 01:35:24,489
el palo estético de InMain

1661
01:35:24,489 --> 01:35:27,289
que ya os vaya quedando

1662
01:35:27,289 --> 01:35:29,069
que veamos como generar

1663
01:35:29,069 --> 01:35:30,350
un método o una función

1664
01:35:30,350 --> 01:35:32,430
que utilicemos otro tipo

1665
01:35:32,430 --> 01:35:34,170
de valores de datos

1666
01:35:34,170 --> 01:35:36,909
y no nos vamos a meter

1667
01:35:36,909 --> 01:35:38,810
ni con estructura de control ni condicional

1668
01:35:38,810 --> 01:35:41,250
ni nada de eso, eso ya cuando lleguemos al tema 3

1669
01:35:41,250 --> 01:35:42,949
pero que hagamos

1670
01:35:42,949 --> 01:35:44,149
programas de estos

1671
01:35:44,149 --> 01:35:46,529
estos son los tipos de programas que se hacen

1672
01:35:46,529 --> 01:35:48,270
para cualquier lenguaje

1673
01:35:48,270 --> 01:35:50,909
de programación

1674
01:35:50,909 --> 01:35:52,609
procedimental, lo que parece que Java

1675
01:35:52,609 --> 01:35:54,649
es orientado a objetos, entonces requiere

1676
01:35:54,649 --> 01:35:56,590
como mínimo una clase, es que no podemos

1677
01:35:56,590 --> 01:35:58,409
ejecutar algo sin tener una clase

1678
01:35:58,409 --> 01:36:00,670
y un método main, es que eso

1679
01:36:00,670 --> 01:36:02,350
es impepinable, es así

1680
01:36:02,350 --> 01:36:04,670
no podemos ejecutar nada si no tenemos las dos cosas

1681
01:36:04,670 --> 01:36:06,029
entonces tenemos que saber de dónde viene

1682
01:36:06,029 --> 01:36:08,609
pero para hacer cualquier, si veis

1683
01:36:08,609 --> 01:36:09,510
aquí no estamos aplicando

1684
01:36:09,510 --> 01:36:11,529
programación orientada a objetos

1685
01:36:11,529 --> 01:36:14,989
La única es la extracción de este objeto

1686
01:36:14,989 --> 01:36:18,909
pero son programas sencillos, procedimentales

1687
01:36:18,909 --> 01:36:21,449
como se haría en cualquier lenguaje de programación que no sea orientado a objetos.

1688
01:36:27,289 --> 01:36:30,250
¿Alguna duda? Si queréis lo dejamos aquí.

1689
01:36:31,609 --> 01:36:35,590
Si se os ocurren dudas más adelante, no me escribís, lo podéis hacer en el foro o lo que sea.

1690
01:36:37,210 --> 01:36:39,250
Os colgaré esta videoconferencia grabada

1691
01:36:43,310 --> 01:36:46,600
pero más o menos bien.

1692
01:36:47,420 --> 01:36:49,180
no se metió mucha caña

1693
01:36:49,180 --> 01:36:51,239
pero es así

1694
01:36:51,239 --> 01:36:53,560
estas dos cosas las necesitamos

1695
01:36:53,560 --> 01:36:55,380
la clase

1696
01:36:55,380 --> 01:36:56,659
y el value statement

1697
01:36:56,659 --> 01:36:58,119
lo necesitamos para empezar

1698
01:36:58,119 --> 01:37:00,960
entonces que vayamos poco a poco metiendo cosas

1699
01:37:00,960 --> 01:37:03,319
y haciendo programas sencillos

1700
01:37:03,319 --> 01:37:04,760
por ejemplo el próximo día a lo mejor

1701
01:37:04,760 --> 01:37:06,119
hacemos uno, el calcular

1702
01:37:06,119 --> 01:37:07,579
una ecuación de

1703
01:37:07,579 --> 01:37:11,340
para calcular una ecuación de segundo grado

1704
01:37:11,340 --> 01:37:12,500
necesitaríamos un

1705
01:37:12,500 --> 01:37:13,979
bueno, lo podemos hacer

1706
01:37:13,979 --> 01:37:16,699
haremos otros ejercicios

1707
01:37:16,699 --> 01:37:25,380
pues nada, voy a dejar de grabar

1708
01:37:25,380 --> 01:37:32,319
y nos vemos el jueves

1709
01:37:32,319 --> 01:37:39,329
en cuanto a temas que debemos tener leídos hasta el momento

1710
01:37:39,329 --> 01:37:42,710
lo que tenéis que ir en cuanto a temas más que leeros el primero

1711
01:37:42,710 --> 01:37:45,369
que es lo único que me preocupa, hemos llegado casi a la mitad

1712
01:37:45,369 --> 01:37:48,810
en varias sesiones que las que quedan pues terminaré

1713
01:37:48,810 --> 01:37:52,170
que nos acordemos la próxima vez que estamos en Java y los bytecodes

1714
01:37:52,170 --> 01:37:53,729
veremos

1715
01:37:53,729 --> 01:37:56,390
y lo que quiero es que os miréis este tema

1716
01:37:56,390 --> 01:37:57,350
que es lo que me importa

1717
01:37:57,350 --> 01:37:59,649
el hacer ejercicios de Java es para

1718
01:37:59,649 --> 01:38:02,550
que la sesión sea un poquito más

1719
01:38:02,550 --> 01:38:04,090
más llevadera

1720
01:38:04,090 --> 01:38:06,329
y para ir adelantando

1721
01:38:06,329 --> 01:38:08,270
cosas de Java, aunque todavía no las hemos visto

1722
01:38:08,270 --> 01:38:09,989
¿vale? pero que os vaya sonando

1723
01:38:09,989 --> 01:38:10,609
nada más

1724
01:38:10,609 --> 01:38:21,189
pues nada

1725
01:38:21,189 --> 01:38:23,550
nos vemos el jueves que viene

1726
01:38:23,550 --> 01:38:24,250
¿vale?