1
00:00:01,330 --> 00:00:10,390
Bien, vamos a comenzar la videoconferencia de hoy, como os había dicho en la convocatoria, haciendo un repaso a lo que vimos en la última videoconferencia.

2
00:00:11,869 --> 00:00:24,309
En la última videoconferencia nos creamos un proyecto que se llamaba Video 1 y estuvimos viendo las partes que había cuando SEQ entraba a un proyecto nuevo en The Things.

3
00:00:24,309 --> 00:00:40,310
Entre las cosas que vimos era que el programa arranca con el método main, que es el método inicial en cualquier aplicación Java, y dentro de él podemos poner el código que nosotros consideremos.

4
00:00:40,310 --> 00:01:04,810
Consideremos. Estuvimos viendo que existían distintos tipos de comentarios en Java. Los había comentarios de una línea, por ejemplo, esto, que estoy marcando, que se pone con las dos barras, o existen comentarios de varias líneas, que se pone con la barra y el asterisco, y este que estoy marcando es un comentario de varias líneas.

5
00:01:04,810 --> 00:01:15,950
También estuvimos viendo los comentarios de tipo YouTube, que es para que nosotros nos pongamos unos recordatorios como tareas pendientes por hacer.

6
00:01:16,870 --> 00:01:21,930
Luego estuvimos viendo cómo se declaraban variables en Java.

7
00:01:22,750 --> 00:01:29,709
Estuvimos viendo que cuando nosotros hacemos un programa, al programa le tenemos que suministrar unos datos,

8
00:01:31,049 --> 00:01:36,950
estos datos los procesa y de vuelta nos muestra una salida de esos datos procesados.

9
00:01:36,950 --> 00:01:48,689
El añadir los datos a los programas puede ser desde variables, desde estructuras de datos como ficheros, bases de datos, etc.

10
00:01:49,650 --> 00:01:59,950
Lo más inmediato, lo más básico es que introduzcamos los datos mediante variables y de estas hay de muchos tipos.

11
00:01:59,950 --> 00:02:25,250
Las variables primitivas son las más básicas en Java y tenemos distintos tipos de variables primitivas, ya sean para números como pone aquí. Tenemos tipos enteros, quiere decir que no son decimales, desde el negativo hasta el positivo y para eso tenemos distintos tipos de variables, byte, short, int y long.

12
00:02:25,250 --> 00:02:45,789
Y luego tenemos variables de tipo decimal, que las tenemos como float y double. Cuando nosotros declaramos variables de tipo entero o de punto flotante, Java por defecto las de tipo entero las coge como int y las double para decimal.

13
00:02:46,550 --> 00:02:56,009
Entonces, en el caso de que queramos utilizar una variable float, le tenemos que indicar con una f al final y en el caso de que sea long, con una l al final.

14
00:02:57,330 --> 00:03:05,430
¿Cómo declaramos una variable en Java? Pues para declarar una variable lo primero que se pone es el tipo del que es esa variable.

15
00:03:05,430 --> 00:03:18,770
A continuación se le indica el nombre que le quiero dar a esa variable y después, si queremos declararla y a la vez darle un valor, le pondríamos igual al nombre del valor que le queremos dar.

16
00:03:18,770 --> 00:03:30,349
Más cositas que vimos aquí. Además de los tipos primitivos, existe un caso especial que no es un tipo primitivo,

17
00:03:30,349 --> 00:03:38,129
sino que es una clase de lápiz de Java que es el de tipo string.

18
00:03:38,930 --> 00:03:43,270
Lo utilizamos como si fuera una variable normal, como si fuera una variable primitiva,

19
00:03:43,270 --> 00:03:49,349
pero realmente, cuando yo estoy declarando aquí la variable nombre, es un objeto de la clase string.

20
00:03:51,889 --> 00:04:04,710
Estuvimos viendo diferentes clases del paquete java.lang, es decir, la API de java está formada por un montón de paquetes,

21
00:04:04,789 --> 00:04:13,349
donde un paquete es una agrupación de clases y el paquete por defecto es el que se llama java.lang.

22
00:04:13,349 --> 00:04:33,310
¿Qué significa que sea un paquete por defecto? Significa que cuando yo utilizo paquetes de la API de Java, tengo que declararlos al principio de mi aplicación. Sin embargo, todas las clases del paquete Java LAN puedo utilizarlas sin declarar el paquete.

23
00:04:33,310 --> 00:04:43,610
¿Vale? ¿Dónde lo declararía? Pues aquí, en la parte por encima del nombre de la clase, importaría todos los paquetes que yo necesite.

24
00:04:47,389 --> 00:04:57,110
Más cosas que vimos. Estuvimos viendo dentro del paquete Havalan el uso de unos métodos que es el print, println y printf.

25
00:04:57,990 --> 00:05:00,670
Estos métodos pertenecen a la clase System.

26
00:05:01,649 --> 00:05:07,889
¿Qué diferencia hay entre print y println? Pues que print no hace un salto de línea y println sí.

27
00:05:09,009 --> 00:05:18,350
Y bueno, ya estuvimos viendo que si pongo esto, en este caso es un print y en este caso es un println,

28
00:05:18,529 --> 00:05:22,170
ahora lo ejecutaremos y veremos la diferencia, pero ya lo vimos también el otro día.

29
00:05:22,170 --> 00:05:33,910
Y que teníamos que tener cuidado cuando yo dentro de un println puedo concatenar variables y puedo concatenar texto.

30
00:05:35,009 --> 00:05:43,370
Si concateno variables que son de tipo numérico hay que tener cuidado y ponerlas entre paréntesis, por ejemplo,

31
00:05:43,370 --> 00:05:53,129
que sería un método para que me lo escogiera, porque si no, lo que haría es concatenar el valor de entero y flotante, en este caso,

32
00:05:53,449 --> 00:05:59,389
en lugar de realizar la suma de lo que contenga entero y de lo que contenga flotante.

33
00:06:00,750 --> 00:06:06,029
Vamos a ejecutar hasta aquí para que veáis la diferencia antes de pasar al uso del PRI-NEC.

34
00:06:06,850 --> 00:06:13,269
Para ejecutar existen diferentes formas. La más inmediata es desde aquí, con la flechita verde.

35
00:06:13,370 --> 00:06:17,009
o pulsando F6, o con Room, Room Project, ¿vale?

36
00:06:18,870 --> 00:06:24,129
Pulsamos la flechita, en la parte del panel de la consola, que es este de aquí abajo,

37
00:06:24,870 --> 00:06:31,850
está compilando y muestra la información de salida que he puesto en el mail,

38
00:06:32,790 --> 00:06:39,790
y pues esto es hasta aquí lo que hemos visto, que aquí tengo uso del paquete Java LAN,

39
00:06:39,790 --> 00:06:59,069
Como lo había hecho un println, lo siguiente a escribir me lo pasa a la siguiente línea. Luego que había escrito, había declarado una variable de tipo nombre, le he puesto el valor carmelo, y en este system.out.println había puesto, escribe el contenido de la variable nombre.

40
00:06:59,069 --> 00:07:10,610
Como nombre se llama Carmelo, me pone Carmelo IN y luego he puesto aquí que me ponga el valor de la variable entero.

41
00:07:10,810 --> 00:07:15,870
Como entero pone un 42, pues él me saca 42 entradas para un concierto.

42
00:07:16,750 --> 00:07:24,769
Como esto es un print, a continuación de esta frase que hemos puesto aquí, me pone la frase siguiente.

43
00:07:24,769 --> 00:07:48,149
Que como esta frase tiene un println, cuando escribe esto, que lo que corresponde es a la salida esta que aparece en la ventana de output, pues esto ya me lo hace y me hace un salto de línea para escribirme lo siguiente, que lo siguiente es la línea que marco aquí.

44
00:07:48,149 --> 00:08:12,649
Y en esta, la diferencia que os comentaba antes, si yo pongo entero más flotante, entero tiene el valor 42 y flotante el valor de pi, pues aquí me pone en la salida que Carmelo tiene 42, que es el valor de entero, no más con la suma, sino concatenado con el valor que tenga flotante.

45
00:08:12,649 --> 00:08:20,610
Sin embargo, cuando lo he puesto entre paréntesis, lo que me hace es la suma de lo que contienen las dos variables.

46
00:08:23,089 --> 00:08:27,949
Luego estuvimos viendo el uso de printf.

47
00:08:28,670 --> 00:08:37,350
Printf lo que nos permite es darle formato a la salida que muestro por consola, por pantalla, por lo que sea.

48
00:08:37,350 --> 00:08:52,929
Lo que nos permite PringF es un método que tiene, te podemos poner una cadena de caracteres y luego una serie de identificadores, una serie de formatos o especificaciones de formato.

49
00:08:53,870 --> 00:09:04,830
El más utilizado es tanto por ciento S para cuando es string, tanto por ciento D para cuando es integer y tanto por ciento F para cuando es flotante.

50
00:09:04,830 --> 00:09:17,450
Me preguntaba una compañera que si se podía, porque esto por defecto lo que hace es alinear la variable que yo quiero que me saque por pantalla,

51
00:09:18,330 --> 00:09:29,169
me la alinea a la derecha o a la izquierda con ceros o sin ceros o con espacios en blanco, la longitud que yo le especifique.

52
00:09:29,169 --> 00:09:49,850
El otro día me preguntó una compañera vuestra que si podía alinear a la derecha y efectivamente se puede alinear a la derecha poniendo el menos. Vamos a ver qué significan cada una de estas especificaciones que yo le puedo dar, de estos especificadores que le puedo dar al formato.

53
00:09:49,850 --> 00:10:10,809
Si yo le pongo esto, lo que está haciendo es, como estoy utilizando la S, está trabajando con cadenas. La cadena yo le quiero que me la saque con un ancho de 10. ¿Qué significa esto? Que si mi cadena es más pequeña que 10, me va a dejar espacios.

54
00:10:10,809 --> 00:10:28,629
Con el menos le estoy diciendo que me lo alineé a la izquierda. En esto tenéis que tener cuidado porque a ver si le vais a decir que me saque, que me reserve para poner la variable 10 espacios y la variable que yo quiero mostrar tiene 20.

55
00:10:28,629 --> 00:10:31,730
Pues lógicamente el 10 no le está haciendo efecto.

56
00:10:33,269 --> 00:10:38,730
Cuando le estoy diciendo esto, pues dice mostrar solo los cuatro caracteres de la cadena.

57
00:10:40,110 --> 00:10:47,909
Y cuando estoy utilizando formato con número en decimal, le estoy diciendo sácame dos decimales.

58
00:10:49,049 --> 00:10:52,590
Vamos a ver el resultado de cómo podemos poner esto de distinta forma.

59
00:10:52,590 --> 00:11:11,230
Aquí tenemos declaradas tres variables, que son nombre, edad y salario, y de tres personas. Vamos a ver que para que esto salga alineado, pues le hemos dado formato.

60
00:11:11,230 --> 00:11:21,450
Yo quiero que salga empleado 1 y a continuación que salga su nombre, reservando 12 espacios para el nombre y que me lo alinee a la izquierda.

61
00:11:22,429 --> 00:11:37,059
Que luego me ponga, como es un entero, que me ponga la edad y por último que me ponga el salario con dos decimales y reservamos 10 espacios.

62
00:11:37,399 --> 00:11:45,559
Y aquí lo estoy diciendo que lo alinee también a la izquierda. Aquí tenemos la salida.

63
00:11:46,279 --> 00:11:53,580
veis que el printf nos permite hacer tabulaciones para que toda mi salida quede perfectamente ordenada.

64
00:11:56,480 --> 00:12:03,259
Si yo, por ejemplo, en el salario del 3, ¿cuál es este? El segundo.

65
00:12:03,639 --> 00:12:18,490
Si yo el salario este le pongo 50 solo, ejecutamos, vale.

66
00:12:18,490 --> 00:12:38,990
Y veis que lo normal es que yo los números no los alinee a la izquierda, porque estamos pensando, cuando nosotros vemos una relación de columnas que tienen caracteres y columnas que tienen, sobre todo si tienen decimales, porque si no tiene decimales, son enteros, pues da exactamente igual.

67
00:12:39,610 --> 00:12:50,110
Pero acostumbraros a que cuando estamos trabajando con decimales, la lectura más correcta es que los decimales se queden perfectamente alineados a la parte derecha

68
00:12:50,110 --> 00:12:56,490
y así, aunque el número sea más pequeño uno que otro, pues la tabla me queda en condiciones.

69
00:12:57,389 --> 00:13:13,450
Esto lo vamos a quitar para que lo alinee a la derecha. Ejecutamos. Bien. Y esta parece una lectura más correcta de números con decimales que la anterior.

70
00:13:15,330 --> 00:13:31,070
Vale, más cositas que vimos. Estuvimos viendo el uso de la clase MAC. Estuvimos viendo que en esta clase todos los métodos son estáticos. ¿Qué significa para nosotros a esta altura que sean estáticos?

71
00:13:31,070 --> 00:13:44,870
Bueno, pues significa que es un método de clase. En Java existen dos tipos de métodos así de carácter general, que son los métodos de clase y los métodos de instancia de clase.

72
00:13:46,330 --> 00:13:50,309
Luego profundizaremos más cuando vayamos a la parte de declarar un objeto de clase.

73
00:13:50,309 --> 00:14:04,549
Ahora mismo decir que cuando los métodos son de tipo estático, es decir, son de clase, no tengo que declararme una variable para utilizarlos y debo de emplear el nombre de la clase para acceder a sus métodos.

74
00:14:06,389 --> 00:14:11,990
Vamos a ver los distintos ejemplos o algunos ejemplos que vimos con la clase M.

75
00:14:11,990 --> 00:14:25,330
Aquí tenemos declaración de variables que como veis en este caso solo he hecho una declaración de variables y no como era como aquí arriba que hacíamos una declaración de la variable y le asignábamos ya un valor.

76
00:14:26,429 --> 00:14:31,009
Aquí solamente hemos hecho la declaración y luego a dos de ellas le he puesto valor.

77
00:14:32,629 --> 00:14:41,169
En este caso estamos utilizando un método dentro de la clase math que lo que hace es sacar el máximo entre dos números.

78
00:14:43,360 --> 00:14:48,779
Si, por ejemplo, esto me va a dar error porque no está declarado, ahora lo pone, bueno, sí, lo declaro a la vez.

79
00:14:52,980 --> 00:15:05,299
Inc mínimo es igual y aquí veíamos que si yo pongo el nombre de la clase y pongo un punto, me aparecen todos los métodos que yo puedo utilizar.

80
00:15:05,299 --> 00:15:30,080
Si le decimos, quiero sacar el mínimo de dos valores, pues aquí encuentro que dentro de, con el nombre de min, que es el mínimo de dos valores, puedo utilizar hasta cuatro métodos, utilizando valores enteros, dobles, flotantes y long, ¿vale?

81
00:15:30,080 --> 00:15:57,980
¿Cómo se llama esto en Java? Esto se llama sobrecarga de métodos. Es decir, yo puedo tener muchos métodos con el mismo nombre, siempre, como en este caso, en este caso es que los parámetros de entrada tienen tipos diferentes, pero también podría tener métodos con el mismo nombre, pero que devuelvan valores diferentes, que el retorno del método sea distinto.

82
00:15:57,980 --> 00:16:18,830
Pues en este caso digo esto, sácame el mínimo entre un 1 y un 2. Y otra cosa que veíamos es que Java nos suele dar ayudas cuando hay un error. Aquí nos está diciendo que nos falta un punto y coma.

83
00:16:19,830 --> 00:16:27,230
Recordamos que todas las instrucciones, todas las enciencias en Java terminan en punto y coma y que Java es sensible a mayúsculas y minúsculas.

84
00:16:27,909 --> 00:16:32,470
¿Qué significa esto? Que yo tengo una clase que se llama math y que tiene un método que se llama min.

85
00:16:32,929 --> 00:16:42,889
No tengo que escribir exactamente igual porque si yo pongo la clase math, esto, por mucho que le ponga un punto, él no entiende que es la clase math.

86
00:16:42,889 --> 00:17:03,809
Tiene que ser el nombre exacto para que lo entienda. Puesto que decimos que Java es sensible a mayúsculas y minúsculas. Esto pasa lo mismo en general cuando yo estoy declarando la variable. Una variable. Todos los identificadores, todas las clases, todo Java es sensible a mayúsculas y minúsculas.

87
00:17:03,809 --> 00:17:15,150
Cuando yo estoy utilizando clases y métodos que retornan valores, ¿qué significa que retornan un valor? Que devuelven un valor.

88
00:17:15,150 --> 00:17:35,390
Puedo asignárselo como en este caso se lo estoy asignando a una variable o puedo utilizar el nombre, la llamada de forma directa, pues como en este caso que estoy diciendo sácame valor máximo entre un 1 y un 2 es y aquí estoy haciendo la llamada.

89
00:17:35,390 --> 00:17:43,670
Es decir, no siempre tengo que asignárselo a una variable sino que también puedo utilizarlo directamente. Aquí tenéis los ejemplos para las dos cosas.

90
00:17:46,650 --> 00:17:52,589
Otro ejemplo de método que estuvimos viendo es el valor absoluto.

91
00:17:52,990 --> 00:17:55,789
El valor absoluto es el valor de un número sin el signo.

92
00:17:55,789 --> 00:18:04,869
Si yo me declaro una variable num3 que tiene el valor menos 200, el valor absoluto de menos 200 es 200.

93
00:18:04,869 --> 00:18:22,430
Y de la misma forma, pues lo hemos estado, lo he puesto asignándoselo a una variable el resultado de llamar a este método o bien poniendo directamente la llamada, la invocación al método.

94
00:18:22,430 --> 00:18:37,509
Aquí tenemos otra variable que, bueno, si un método me devuelve un determinado tipo de valor, pues se lo tengo que asignar a una variable de ese mismo tipo.

95
00:18:37,509 --> 00:19:02,549
¿Dónde veo eso? Pues estuvimos viendo la API de Java y en la API de Java tenemos aquí, por ejemplo, la clase math, donde vimos que estos son los métodos de la clase, coincide con los métodos estáticos porque son todos estáticos.

96
00:19:02,549 --> 00:19:15,410
Al ser estático, recuerdo que hay que llamarle con el nombre de la clase y, bueno, pues estuvimos dando también un vistazo a lo que son los valores que devuelven.

97
00:19:15,410 --> 00:19:35,289
En este caso, aquí está el tipo que era estático y aquí el valor que devuelve. Entonces, si yo quiero utilizar el método ABS, que me devuelve el valor absoluto, me está diciendo que le meta un double o uno menor y me va a retornar un double.

98
00:19:35,289 --> 00:19:49,809
Por lo tanto, si se lo voy a asignar a una variable, esa variable tiene que ser de tipo dable. Aparte de que los castings, que ya podemos hacer castings entre tipos de variables.

99
00:19:49,809 --> 00:20:08,490
Otra función que vimos, pues la de la raíz cuadrada, ¿vale? De la misma forma, o bien asimilándoselo, que en este caso, pues lo había hecho aquí con printf para que lo vierais,

100
00:20:08,490 --> 00:20:18,630
con dos decimales, la raíz cuadrada y ya está, del método de la clase MAP, más o menos vimos eso.

101
00:20:20,210 --> 00:20:28,549
Luego, el System Outputing LN es la salida por consola, por pantalla, de la información.

102
00:20:29,470 --> 00:20:33,769
Luego está interesante que le podamos meter nosotros información, porque lo que habíamos hecho aquí,

103
00:20:33,769 --> 00:20:37,269
cuando estamos asignando valores a las variables

104
00:20:37,269 --> 00:20:39,769
es que me declaraba la variable

105
00:20:39,769 --> 00:20:43,230
pero ya le decía pues tiene el valor tal

106
00:20:43,230 --> 00:20:44,329
o tiene el valor más cual.

107
00:20:45,670 --> 00:20:49,210
Es más interesante que le pidamos al usuario

108
00:20:49,210 --> 00:20:50,950
que introduzca el valor que quiera

109
00:20:50,950 --> 00:20:54,089
porque si no yo tendría que modificar el programa

110
00:20:54,089 --> 00:20:57,490
cada vez que quiero hacerlo con un número distinto.

111
00:20:58,910 --> 00:21:03,289
¿Cómo utilizamos la entrada por teclado?

112
00:21:03,769 --> 00:21:16,009
Para pedir valores por teclado hay varias clases. La más efectiva y la más utilizada es la clase Scanner, que está dentro del paquete Java Util.

113
00:21:17,250 --> 00:21:29,109
Entonces, esto ya no está dentro del paquete Java LAN. ¿Qué significa eso? Que si yo quiero utilizar la clase Scanner, tengo que importar el paquete Java Util.

114
00:21:29,109 --> 00:21:33,660
Y eso es lo que teníamos puesto aquí arriba.

115
00:21:34,440 --> 00:21:35,839
En los import se pone.

116
00:21:36,339 --> 00:21:42,240
¿Veis que si yo comento esta línea, con lo cual si está comentada ya no la trata Java,

117
00:21:42,859 --> 00:21:49,400
me va a aparecer aquí un error que me está diciendo que aquí pretendía utilizar la clase,

118
00:21:50,579 --> 00:21:53,539
pero no puedo hacerlo porque no me la he importado.

119
00:21:53,539 --> 00:22:09,519
Lo pongo aquí, dice no se encuentra, no se puede encontrar esto y me hace el favor de decirme, oye, ¿quieres importarla? Digo sí. Pues ya, aunque estaba comentada, él no la entendía, se la ha vuelto añadida.

120
00:22:10,319 --> 00:22:32,240
También comentamos aquí que si yo de un paquete que hemos dicho que teníamos muchas clases, si voy a trabajar con muchas de ellas, puedo decirle, impórtame dentro de Java útil escáner, impórtame dentro de Java útil los arrays, impórtame dentro de Java útil cualquier cosa que vayamos a utilizar.

121
00:22:32,240 --> 00:22:43,099
O podría decirle, dentro de Java útil, importamelo todo y eso se identifica con un asterisco.

122
00:22:45,019 --> 00:23:00,180
Dejamos esto como estaba, quitamos el comentario para que no nos derrobe y ahora vamos a seguir explicando esto de la clase de Scanner.

123
00:23:00,180 --> 00:23:11,779
Vale, me he declarado una variable que le he llamado tu nombre, porque el nombre ya lo tenía puesto arriba, y una variable entera que es de tipo edad.

124
00:23:13,240 --> 00:23:26,420
Entonces, para utilizar la clase Scanner y pedir valores por teclado, tengo que declararme un objeto de ese tipo, de esa clase.

125
00:23:26,420 --> 00:23:40,900
Cuando estábamos declarando una variable, veis que se pone primero el tipo de la variable y luego a continuación se pone el identificador, el nombre que yo quiero dar a esa variable.

126
00:23:40,900 --> 00:24:00,319
De la misma forma, si yo quiero declararme un objeto, una instancia o, para que lo entendamos todos, una variable del tipo de una clase, pongo primero el nombre de la clase y a continuación el nombre de la variable que quiero utilizar.

127
00:24:02,500 --> 00:24:12,259
Esto parece un trabalenguas, pero yo le digo, me quiero declarar una clase de tipo escáner y para eso invoca a su constructor.

128
00:24:13,920 --> 00:24:20,700
El constructor de una clase es el que inicializa y reserva espacio para ese objeto.

129
00:24:20,700 --> 00:24:37,119
Y se hace de esta forma. New, el nombre del constructor que realmente coincide con el nombre de la clase y los argumentos que ese constructor pide. En este caso, System.in es la entrada por teclado.

130
00:24:37,119 --> 00:24:55,160
Vale, ya he preparado un objeto de tipo escáner para que en ese objeto pueda utilizar los métodos apropiados del objeto para recoger lo que el usuario me va a escribir por teclado.

131
00:24:55,160 --> 00:25:11,779
A continuación, pongo un mensaje en pantalla donde le pido al usuario un texto. Introduzca su nombre. Y en la variable que me he declarado de tipo nombre, ¿qué quiero recoger?

132
00:25:11,779 --> 00:25:35,220
Pues, aquello que va a escribir el señor por teclado, que está en el objeto entrada, punto, y pues depende de lo que yo quiera recoger por teclado o lo que le haya pedido, puedo utilizar diferentes métodos del objeto escáner.

133
00:25:35,220 --> 00:25:47,220
Es decir, si yo pongo entrada, punto, como entrada es un objeto de la clase escáner, me salen todos los métodos que puedo utilizar de esa clase.

134
00:25:48,359 --> 00:25:59,220
Entonces, si yo quiero, es que voy a recoger un número decimal, pues puedo decir que voy a leer el siguiente double o el siguiente float.

135
00:25:59,900 --> 00:26:03,660
Si voy a recoger un número entero, podría utilizar el método Nessie.

136
00:26:03,660 --> 00:26:10,000
Vale, entonces, en función de lo que yo vaya a recoger, utilizaré un método u otro.

137
00:26:12,259 --> 00:26:23,680
En este caso, le estoy diciendo que lo que escriba el usuario hasta que de dentro, en toda la línea, me lo meta en la variable tu nombre, que es de tipo string.

138
00:26:24,500 --> 00:26:31,140
A continuación, le estoy pidiendo que me, le estoy pidiendo por pantalla, introduzca su edad.

139
00:26:31,140 --> 00:26:48,940
Y como la edad es un entero y yo lo voy a recoger en una variable de tipo entero, pues a esa variable, como habíamos visto antes, en lugar de ponerle, coge toda la línea, quiero que ponga solo el siguiente entero que se escriba.

140
00:26:48,940 --> 00:27:05,700
Y ya puedo sacar por pantalla lo que me ha escrito el señor. System.oprim.ln, hola, el contenido que esté en la variable tu nombre, que será lo que el usuario ha escrito por teclado.

141
00:27:06,119 --> 00:27:17,599
A continuación, quiero que me aparezca el literal, pareces muy joven para tener y a continuación lo que se ha recogido dentro de la variabilidad y un punto.

142
00:27:18,400 --> 00:27:25,339
Bueno, veis que en Java, que lo había puesto aquí para que lo vierais también, cuando me parece que ya estoy escribiendo muy largo,

143
00:27:25,339 --> 00:27:29,319
le puedo dar intro y él me concatena y me hace formatear esto.

144
00:27:30,700 --> 00:27:36,039
Y luego, la variable escáner está bien que la cierre.

145
00:27:36,920 --> 00:27:41,140
Más que nada porque la variable escáner se utiliza también para tratamiento de ficheros.

146
00:27:41,140 --> 00:28:00,680
A lo mejor con este tipo de variables no me hace falta mucho porque lo recoge, lo cierra Java si hace falta, lo quita Java si hace falta, pero cuando estoy trabajando con ficheros hay que acostumbrarse a que cerrar el objeto con el que me he declarado.

147
00:28:02,359 --> 00:28:08,500
Y bueno, hasta aquí creo que más o menos lo que estuvimos viendo el otro día. ¿Hay alguna duda de esto?

148
00:28:12,700 --> 00:28:13,640
De momento ninguna.

149
00:28:14,500 --> 00:28:32,000
Pues, si no hay ninguna duda de esto, vamos a pasar a lo que estaba preparado para hoy. Que lo que estaba preparado para hoy es trabajar con métodos. Vamos a crear un proyecto nuevo.

150
00:28:32,000 --> 00:28:56,329
de tipo Java y le vamos a llamar calculadora. Vamos a crear una calculadora. Vale. Bueno, voy a borrar esto para que deje más espacio para lo que estamos escribiendo.

151
00:28:57,329 --> 00:29:07,230
Bien, vamos a ver en primer lugar qué es un método. Un método es un trozo de código que tiene una funcionalidad

152
00:29:07,230 --> 00:29:26,309
Y que me permite, en lugar de tener un programa muy extenso, dividirlo en trocitos, que eso es una máxima de informática, el Divide y Vencerás, dividirlo en trocitos que además me dan muchas ventajas.

153
00:29:26,309 --> 00:29:47,410
Porque al tener dividido un problema grande en sus problemas, me va a permitir que si tengo un error sea más fácilmente localizable, porque no es lo mismo chequearse 5 líneas, 20 líneas, que un programa de 300 líneas.

154
00:29:47,410 --> 00:30:01,750
Y otra ventaja que tiene es que se puede reutilizar, es decir, yo puedo tener un método, esta calculadora, vamos a hacer un método que sume, otro que reste, otro que multiplique, otro que divide, que divida.

155
00:30:01,750 --> 00:30:19,250
Entonces, si yo tengo un método que sume, lo puedo utilizar en este programa, pero también en otro, en otro, en otro. Es decir, al estar modularizado, puedo utilizarlo desde distintas aplicaciones que yo quiero utilizar.

156
00:30:19,250 --> 00:30:39,109
¿Vale? Dentro de un método, bueno, vamos a ir probando ya las cositas. Vamos a crear un método, hemos dicho que vamos a hacer uno que sume, otro que resta, otro que multiplique y otro que divide.

157
00:30:39,109 --> 00:30:55,890
Vamos a dar a aplicarles distintos tipos de métodos. En un método tengo que indicarle como poco si devuelve o no devuelve un valor. Si devuelve un valor, además, tengo que indicarle qué tipo devuelve.

158
00:30:55,890 --> 00:31:17,250
Para indicar que no devuelve un valor, se le pone que es void. Void significa no es nada. A continuación, le voy a decir que mi método se va a llamar suma. Entre paréntesis se pone lo que se llaman parámetros, que ahora lo vemos.

159
00:31:17,250 --> 00:31:23,789
Y como hemos dicho que es un bloque de código, todos los bloques de código en Java se tienen que meter entre llaves.

160
00:31:25,069 --> 00:31:27,390
Llave que abre y llave que cierra.

161
00:31:31,329 --> 00:31:41,029
Bueno, pues hasta ahora lo único que tengo aquí es no devuelve nada, se llama suma y no acepta ningún parámetro.

162
00:31:41,029 --> 00:32:02,740
Porque si aceptara algún parámetro tendría que ponerlo aquí e indicarle de qué tipo es ese parámetro. ¿Qué tipo de datos puede devolver un método? Puede devolver cualquier tipo de dato primitivo, puede devolver estructuras de datos, puede devolver objetos, etc.

163
00:32:02,740 --> 00:32:11,940
¿Y qué tipos de datos puede recibir? Exactamente los mismos. Tipos primitivos, estructuras de datos, objetos y todo lo que se nos ocurra.

164
00:32:12,779 --> 00:32:28,420
Mi método suma, lo que voy a hacer va a ser pedirle al usuario que introduzca dos números y va a devolver la suma. No, porque le he dicho que no devuelve nada.

165
00:32:28,420 --> 00:32:43,049
Entonces, lo que voy a hacer va a ser que escriba la suma por pantalla. Por ejemplo, me voy a declarar dos variables y le voy a decir que introduzca…

166
00:32:43,049 --> 00:33:04,980
introduzca. Vale, pero ya le estoy pidiendo al señor que introduzca algo. Entonces, ¿qué necesito? Necesito utilizar una variable que me permita recoger lo que el usuario va a escribir por teclado.

167
00:33:04,980 --> 00:33:30,680
Entonces, claro, ya tengo que estar haciendo uso de la clase Scanner. Entonces, nos declaramos la clase Scanner. Por ejemplo, la voy a llamar teclado. Igual a newScannerSystem.in. ¿Y qué me está diciendo? Pues que qué es eso de clase Scanner.

168
00:33:30,680 --> 00:33:33,619
Veréis que lo pone en cursiva porque no sabe lo que es.

169
00:33:34,000 --> 00:33:35,920
¿Qué nos falta? Importar la clase.

170
00:33:36,819 --> 00:33:38,980
La hemos importado y ya lo tenemos aquí.

171
00:33:40,940 --> 00:33:42,019
Vale, ¿qué más cositas?

172
00:33:42,880 --> 00:33:48,240
Bueno, pues introduzca el variable valor a sumar, lo tenemos que recoger en alguna variable.

173
00:33:48,519 --> 00:33:49,859
Lo vamos a recoger en una de ellas.

174
00:33:50,599 --> 00:33:58,500
Y le vamos a decir que el valor x es igual, ¿cómo se llama mi variable?

175
00:33:58,500 --> 00:34:09,699
Teclado, punto, me aparecen todos los métodos que puedo utilizar, y como es un entero, le digo que me recoja el primer entero.

176
00:34:12,480 --> 00:34:14,239
Repetimos lo mismo para el segundo.

177
00:34:16,119 --> 00:34:18,260
Introduzca el segundo valor asumido.

178
00:34:19,760 --> 00:34:25,960
Y aquí le voy a decir que la variable i va a ser el segundo que meta el señor.

179
00:34:25,960 --> 00:35:05,739
Y ya puedo mostrar los valores por pantalla. ¿Por qué la suma? Porque hemos dicho que el método no devuelve nada. Vemos que podemos concatenar, por ejemplo, la suma de x más, ah, una cosa, la suma de y, de y, más, es, y aquí, ¿qué le pongo?

180
00:35:05,739 --> 00:35:16,340
Bueno, pues lo que quiero poner, recordar que si yo pongo x y si pongo y así, sino sin paréntesis, me va a concatenar los dos valores porque estoy concatenando con un string.

181
00:35:17,260 --> 00:35:24,059
x más y. Vale. Aquí hay que fijarse en una cosa. Yo aquí le estoy metiendo literales.

182
00:35:25,059 --> 00:35:30,820
Bueno, pues hay que saber que si yo quiero que ponga la suma de y a continuación lo que contiene la variable x,

183
00:35:30,820 --> 00:35:32,840
si yo no le dejo aquí un espacio

184
00:35:32,840 --> 00:35:34,960
me va a poner

185
00:35:34,960 --> 00:35:37,079
la suma de y el valor a continuación

186
00:35:37,079 --> 00:35:37,980
entonces espacio

187
00:35:37,980 --> 00:35:40,780
después de este valor le pongo otro literal

188
00:35:40,780 --> 00:35:42,300
hay que dejar otro espacio

189
00:35:42,300 --> 00:35:44,840
porque si no esto va a quedar feo

190
00:35:44,840 --> 00:35:46,980
y después de aquí

191
00:35:46,980 --> 00:35:50,199
hay algo que está mal, a ver

192
00:35:50,199 --> 00:35:51,940
la suma de x

193
00:35:51,940 --> 00:35:54,139
y la suma de y

194
00:35:54,139 --> 00:35:56,719
te falta ponerle como variable y

195
00:35:56,719 --> 00:35:58,880
ahí estamos, muy bien listo

196
00:35:58,880 --> 00:36:24,809
Listo. Es tal. Vamos a ver, hemos dicho que vamos a hacer el método suma, resta, multiplicación y división. ¿Qué es lo que se aconseja hacer? Bueno, pues en vez de ponernos a hacer todos los métodos a modo yo y luego voy a probar y llenarme de errores, pues lo que hay que hacer es ir poco a poco. Es decir, hago un método, le pruebo. Vamos a probarle.

197
00:36:24,809 --> 00:36:46,739
Aquí esto es una cutre calculadora. Ya os diré por qué es cutre. Bueno, desde el momento, aquí darían errores. Si yo no soy buena y meto lo que… O sea, si yo soy buena y introduzco por teclado lo que me piden por pantalla, esto va a funcionar.

198
00:36:46,739 --> 00:37:02,219
Pero si yo le digo, introduzca el primer valor de la suma y se lo estoy asignando una variable que es entera y le meto un carácter, esto va a fallar. Por eso lo voy a llamar putre calculadora y ya la iréis refinando a medida que vayáis aprendiendo.

199
00:37:02,219 --> 00:37:05,239
Más cositas

200
00:37:05,239 --> 00:37:08,360
Probamos, ¿cómo llamamos al método suma?

201
00:37:08,940 --> 00:37:09,719
Pues ¿cómo se llama?

202
00:37:10,099 --> 00:37:10,659
Suma, ¿no?

203
00:37:13,260 --> 00:37:15,139
Uy, ¿qué pasa si le pongo así?

204
00:37:16,800 --> 00:37:18,019
Y eso no es un método

205
00:37:18,019 --> 00:37:20,760
Porque yo le he llamado en minúsculas

206
00:37:20,760 --> 00:37:23,179
Bueno, pues le voy a decir

207
00:37:23,179 --> 00:37:24,639
Sum, a ver, perdón

208
00:37:24,639 --> 00:37:25,780
Suma

209
00:37:25,780 --> 00:37:29,980
Y como se define con paréntesis

210
00:37:29,980 --> 00:37:31,480
Se va a decir suma

211
00:37:31,480 --> 00:37:38,099
Y si no tiene parámetros, de la misma manera le tengo que poner los parámetros.

212
00:37:39,420 --> 00:37:41,519
Vale, pero ¿qué me está diciendo este ahora?

213
00:37:43,059 --> 00:37:52,320
Me está diciendo que yo no puedo llamar a un método que no sea estático.

214
00:37:53,599 --> 00:38:00,159
Recordar que cuando estuvimos viendo la clase math existía el concepto de método estático.

215
00:38:00,159 --> 00:38:05,159
desde un contexto que es estático.

216
00:38:06,860 --> 00:38:09,539
Yo lo estoy llamando desde el main, que es estático.

217
00:38:10,199 --> 00:38:15,199
Entonces, me está diciendo que no puedo llamar a suma porque suma no es estático.

218
00:38:16,639 --> 00:38:18,920
¿Cómo lo resolvería?

219
00:38:19,980 --> 00:38:24,800
Pues lo más inmediato sería poner aquí que este método es estático.

220
00:38:26,380 --> 00:38:29,480
Es decir, lo convierto en un método de clase.

221
00:38:30,159 --> 00:38:33,000
El siguiente le vamos a hacer no estático.

222
00:38:35,630 --> 00:38:38,269
Bueno, y si yo ejecuto esto, ¿qué pasa?

223
00:38:40,769 --> 00:38:47,369
Que cuando llegue a este punto, porque ya sabemos que el main es el programa que se ejecuta

224
00:38:47,369 --> 00:38:53,610
cuando compilamos y ejecutamos, y se va a ejecutar desde la primera línea,

225
00:38:54,289 --> 00:39:00,630
me pondrá Qt recalculadora y luego me llamará al método suma.

226
00:39:00,630 --> 00:39:15,309
¿Qué significa esto? Que en este orden se va a ir hasta aquí arriba, va a declarar estas dos variables y va a ejecutar de forma secuencial todo el contenido del método suma.

227
00:39:15,309 --> 00:39:37,679
Vamos a verlo. Ejecutamos. Vale. Y aquí lo tenemos. Introduzca el método a sumar. Perdón, el valor a sumar. 20. Introduzca el segundo valor a sumar. 150.

228
00:39:37,679 --> 00:39:43,800
y efectivamente me ha dicho que la suma de 20 y la suma de 150 es 170

229
00:39:43,800 --> 00:39:46,639
y esto es lo que decía que se ha quedado ahí fácil

230
00:39:46,639 --> 00:39:51,039
y esto ya es manía, introduzca el valor a sumar

231
00:39:51,039 --> 00:39:54,599
así queda más bonito, introduzca el valor a sumar

232
00:39:54,599 --> 00:39:56,480
así queda más bonito

233
00:39:56,480 --> 00:39:59,559
y el resultado es tal

234
00:39:59,559 --> 00:40:02,579
y si me apuras en lugar de

235
00:40:02,579 --> 00:40:05,840
como le estoy pidiendo un valor

236
00:40:05,840 --> 00:40:13,019
en lugar del println para que yo tenga que introducir el valor aquí abajo, pues que se quede esperando aquí a la derecha.

237
00:40:19,530 --> 00:40:21,750
Introduzca el valor a sumar, 250.

238
00:40:23,010 --> 00:40:25,730
Introduzca el segundo valor a sumar, 300.

239
00:40:28,489 --> 00:40:34,630
La suma es 250. La suma de 250, uy, qué feo, y de 300 es 150.

240
00:40:40,619 --> 00:40:40,880
Vale.

241
00:40:42,139 --> 00:40:43,179
¿Alguna duda hasta aquí?

242
00:40:43,179 --> 00:41:00,400
Bien, bueno, pues igual que hemos hecho la suma, vamos a hacer la resta, pero este en vez de la resta le vamos a aplicar otro tipo de valores, otro tipo de... va a retornar algo y lo vamos a hacer de otra forma.

243
00:41:00,400 --> 00:41:25,780
Entonces, vamos a hacer inResta, vamos a ponerle variables en parámetros de entrada, inX, inY y como es bloque de código, llave que abre y llave que cierra.

244
00:41:25,780 --> 00:41:48,340
Aquí dos cosas interesantes. Estamos declarando un método que retorna un valor. Entonces, aquí me aparece un error porque dice, pues si retorna un valor, tienes que utilizar retur. Utilizando retur, lo que viene a continuación es lo que va a retornar, lo que va a devolver ese método.

245
00:41:48,340 --> 00:41:58,460
Para quitarme este error y para poner el retur, efectivamente yo le digo retur, devuélveme x menos y.

246
00:41:59,559 --> 00:42:15,119
Aquí ya tenemos algo interesante que es, yo me he declarado aquí una variable int x, otra variable int y y la misma variable la estoy utilizando aquí dentro de suma.

247
00:42:15,119 --> 00:42:32,119
¿Esto no se hace un lío? Bueno, pues esto se llama el ámbito de las variables. Las variables que yo me estoy declarando dentro de suma se le llaman variables locales y solo las conoce dentro del método suma.

248
00:42:32,119 --> 00:42:39,860
Es decir, solo se conocen en el sitio donde han sido declaradas. Por lo tanto, yo podría utilizarlas perfectamente desde aquí.

249
00:42:41,380 --> 00:42:47,019
¿Cómo podemos llamar al método resta?

250
00:42:47,019 --> 00:43:04,840
Bueno, pues cuando yo llamaba, si yo le pongo ahora mismo resta así, ahí tengo que meterle valores, porque este método está recibiendo parámetros de entrada, concretamente dos valores enteros.

251
00:43:04,840 --> 00:43:07,239
vale pues

252
00:43:07,239 --> 00:43:10,099
aquí tengo que utilizar

253
00:43:10,099 --> 00:43:12,380
como aquí se los pedían

254
00:43:12,380 --> 00:43:12,900
el método

255
00:43:12,900 --> 00:43:14,900
aquí no se los estoy pidiendo

256
00:43:14,900 --> 00:43:16,019
solo tengo que pedir de fuera

257
00:43:16,019 --> 00:43:17,519
vamos a utilizar

258
00:43:17,519 --> 00:43:19,760
salt

259
00:43:19,760 --> 00:43:26,500
introduzca pues lo mismo

260
00:43:26,500 --> 00:43:30,980
introduzca

261
00:43:30,980 --> 00:43:33,519
num1 a restar

262
00:43:33,519 --> 00:43:38,320
le pedimos el primer valor

263
00:43:38,320 --> 00:43:45,429
le pedimos el segundo valor

264
00:43:45,429 --> 00:43:47,230
bueno

265
00:43:47,230 --> 00:43:52,949
Bueno, debería declararme alguna variable, ¿no?

266
00:43:53,389 --> 00:43:53,650
Claro.

267
00:43:56,130 --> 00:44:00,190
Control-C, control-V.

268
00:44:05,739 --> 00:44:23,559
Primer número a restar, el segundo número a restar, primer número, primero a restar, primero a restar, segundo a restar.

269
00:44:24,820 --> 00:44:26,280
¿Qué nos faltaría aquí?

270
00:44:26,280 --> 00:44:49,019
Bueno, pues aquí nos faltaría declararme un par de numeritos, por ejemplo, int num1, num2, los enteros, decirle que escáner, ¿cómo le llamamos?

271
00:44:49,019 --> 00:45:01,559
Este lo vamos a llamar Entrada, igual a New Entrada, New Scanner, perdón, System.in.

272
00:45:04,300 --> 00:45:04,539
Vale.

273
00:45:06,119 --> 00:45:09,340
Entonces, hemos hecho lo mismo que hemos hecho aquí arriba.

274
00:45:09,900 --> 00:45:19,159
Me he declarado un objeto de tipo Scanner, le he dicho al señor que introduzca el primer valor a restar

275
00:45:19,159 --> 00:45:23,280
y lo que el señor escriba yo quiero asignárselo al número 1,

276
00:45:23,579 --> 00:45:25,659
luego le voy a pedir el segundo valor a restar

277
00:45:25,659 --> 00:45:30,559
y lo que el señor escriba lo quiero asignar en la variable número 2, ¿vale?

278
00:45:31,480 --> 00:45:41,460
Igual que antes, num1 es igual a entrada,

279
00:45:41,460 --> 00:46:12,840
ya está, hemos llamado distinta, punto, vale, inundos, es igual a entrada, punto, y ahora llamo al restar, pero restar recibía dos parámetros.

280
00:46:13,659 --> 00:46:17,780
Aquí, bueno, volvemos a meter los parámetros para resolver el error que nos está dando.

281
00:46:19,199 --> 00:46:22,960
Réstame num1, num2.

282
00:46:26,820 --> 00:46:31,800
¿Qué me va a decir, qué error me está diciendo? Pues lo mismo que me está diciendo de antes.

283
00:46:32,400 --> 00:46:40,460
Que no es un método, que estoy intentando llamar a un método que no es estático dentro de un contexto estático.

284
00:46:40,460 --> 00:46:58,039
Bueno, antes lo resolvimos porque pusimos que el método era estático. Ahora lo vamos a hacer de otra forma. ¿De qué otra forma? Bueno, si yo, la forma es o bien me creo el método estático o bien me creo un objeto de mi clase.

285
00:46:58,039 --> 00:47:21,880
Entonces me voy a crear, ¿cómo se llama mi clase? ¿Cómo se llama? Calculadora. Me voy a crear un objeto de mi clase calculadora y voy a decir que calculadora, igual que utilicé antes el escáner, se ponía primero el nombre de la clase.

286
00:47:21,880 --> 00:47:55,960
A continuación, el nombre que quiero dar a mi objeto, lo voy a llamar cálculo. Es igual y le damos al constructor. ¿Vale? Calculadora es igual a tiquitiquitiqui. Esto me da error, pero si yo le digo cálculo, que es mi objeto, punto resta, ¿veis?

287
00:47:55,960 --> 00:47:58,800
que si yo pongo el punto ya me está mostrando aquí

288
00:47:58,800 --> 00:48:01,820
el método resta.

289
00:48:06,309 --> 00:48:09,630
Si yo ejecuto esto, pues sí, vale, hace el cálculo,

290
00:48:09,789 --> 00:48:11,769
pero en ningún sitio le estoy diciendo que lo muestre,

291
00:48:12,409 --> 00:48:14,550
con lo cual le vamos a hacer aquí un show.

292
00:48:16,670 --> 00:48:24,840
La resta es, y de esta forma,

293
00:48:25,440 --> 00:48:27,900
en lugar de asignárselo a variable,

294
00:48:28,019 --> 00:48:29,360
que ya sabéis que podríamos hacerlo,

295
00:48:32,480 --> 00:48:35,239
llamamos al método.

296
00:48:39,159 --> 00:48:39,360
¿Vale?

297
00:48:40,360 --> 00:48:42,119
Bueno, pues vamos a ver, vamos a ejecutar.

298
00:48:47,429 --> 00:48:50,329
Introduce el primer valor a sumar, claro, que me lo pide todo.

299
00:48:51,949 --> 00:48:58,570
145, el segundo valor a sumar, 46, y es 181.

300
00:48:58,829 --> 00:49:01,829
Ahora me dice el primer valor a restar, que le digo 250,

301
00:49:01,829 --> 00:49:06,750
y el segundo valor a restar, que le voy a decir 50, para que me dé los círculos.

302
00:49:07,969 --> 00:49:09,010
Y la resta es 200.

303
00:49:09,210 --> 00:49:11,110
De momento mi calculadora va bien.

304
00:49:11,369 --> 00:49:11,530
¿Vale?

305
00:49:12,630 --> 00:49:41,389
Bueno, pues vamos a seguir haciendo con el multiplicar. Ya hemos declarado un método estático. Por delante, bueno, por delante o por detrás, hay que ponerlo aquí. Hay una cosa de los métodos que se llaman modificadores de visibilidad. Es decir, desde dónde se va a poder llamar a mi método. Esos son los modificadores de visibilidad.

306
00:49:42,630 --> 00:49:52,730
Si no pones ninguno, como en este caso, nosotros hemos creado el método suma y no le hemos puesto ningún modificador de visibilidad, ni a la suma ni a la resta.

307
00:49:52,730 --> 00:50:00,389
Si no le pones nada, se llama que tiene visibilidad de paquete o visibilidad por defecto, default.

308
00:50:01,550 --> 00:50:06,630
Si veis, aquí el main tiene una visibilidad pública.

309
00:50:08,230 --> 00:50:10,869
Lógico, el método main es donde empieza mi aplicación.

310
00:50:10,869 --> 00:50:28,090
Y en realidad es lógico que también los métodos puestos, que son funcionalidades, yo los ponga públicos, excepto que yo quiera crear un método privado porque lo estoy utilizando como una funcionalidad dentro de mi clase y no quiero que se utilice desde fuera.

311
00:50:28,909 --> 00:50:31,670
Si no ponemos nada, sería visibilidad de paquete.

312
00:50:32,449 --> 00:50:35,869
Si ponemos public, sería público para utilizarlo por cualquiera.

313
00:50:36,630 --> 00:50:39,329
Y hay otras visibilidades de acceso que veremos después,

314
00:50:39,570 --> 00:50:42,150
que es private, para que no lo vea nadie,

315
00:50:43,110 --> 00:50:44,710
solo desde la misma clase en la que está.

316
00:50:45,329 --> 00:50:48,570
Y luego cuando veamos la herencia, protect, ¿vale?

317
00:50:49,010 --> 00:50:53,670
Pero de momento nos vamos a quedar con que el método multiplicar

318
00:50:53,670 --> 00:50:57,849
le voy a crear público, para ver cosas diferentes.

319
00:50:58,090 --> 00:51:24,219
Quiero que sea público, que devuelva un entero, se va a llamar multiplicar, va a recibir dos valores, x, cuando recibe parámetros hay que, igual que cuando declaro variables, primero el tipo y después el identificador, y con nuestro trozo de código ponemos llave que abre y llave que cierra.

320
00:51:24,219 --> 00:51:31,219
Lo mismo que antes, me está diciendo que si yo he dicho que es entero, tengo que decir qué es lo que retorna.

321
00:51:33,539 --> 00:51:40,539
Pues retorna lo que se meta en X por lo que se meta en Y.

322
00:51:42,199 --> 00:51:42,679
Y ya está.

323
00:51:46,000 --> 00:51:46,719
Probamos.

324
00:51:49,199 --> 00:51:54,079
Para separar esto, le voy a poner aquí un primer en evasión.

325
00:51:56,360 --> 00:52:01,920
Y, a ver, a ver, a ver, ¿desde dónde copio?

326
00:52:06,500 --> 00:52:08,559
Aquí tenemos declarado esto.

327
00:52:21,110 --> 00:52:23,449
Introduzco el primer valor a multiplicar.

328
00:52:29,610 --> 00:52:32,190
En un 1 meto lo que escribe el usuario.

329
00:52:33,289 --> 00:52:35,909
El segundo valor a multiplicar.

330
00:52:37,449 --> 00:52:39,010
Lo que meta el usuario.

331
00:52:39,010 --> 00:52:44,150
Y tengo mi variable cálculo declarada.

332
00:52:44,250 --> 00:53:15,320
Y debería haber conocido también esto. Bueno, escribimos. El producto es más, mi variable se llama cálculo, punto. ¿Y qué puedo utilizar? Pues mirad, puedo utilizar la resta porque la tengo aquí y puedo utilizar la multiplicación.

333
00:53:15,320 --> 00:53:26,840
¿Veis también una cosa interesante? Es que los simbolitos que me pone son diferentes en función del tipo que sea.

334
00:53:26,840 --> 00:53:29,880
ponemos el multiplicar

335
00:53:29,880 --> 00:53:32,139
y por último vamos a hacer

336
00:53:32,139 --> 00:53:34,079
la de dividir, que esta va a ser rápida

337
00:53:34,079 --> 00:53:38,179
y en el de

338
00:53:38,179 --> 00:53:39,340
dividir pues lo mismo

339
00:53:39,340 --> 00:53:41,360
lo que vamos a hacer va a ser

340
00:53:41,360 --> 00:53:45,599
ponemos public también

341
00:53:45,599 --> 00:53:48,119
public, pero para que veáis

342
00:53:48,119 --> 00:53:50,079
un tipo distinto, esta le vamos a llamar

343
00:53:50,079 --> 00:53:51,219
va a ser de tipo doble

344
00:53:51,219 --> 00:53:53,539
es más fácil que una división

345
00:53:53,539 --> 00:53:54,840
sea

346
00:53:54,840 --> 00:53:58,059
de valores decimales, con lo cual es más

347
00:53:58,059 --> 00:54:01,500
Interesante que sea doble porque si no, con int no lo podría poner.

348
00:54:02,880 --> 00:54:03,440
Dividir.

349
00:54:05,760 --> 00:54:09,179
Le metemos un entero, le metemos otro entero.

350
00:54:14,309 --> 00:54:15,670
Valor que entra y valor que sale.

351
00:54:16,550 --> 00:54:17,610
Lo mismo que antes.

352
00:54:18,610 --> 00:54:19,469
¿Qué quieres retornar?

353
00:54:19,630 --> 00:54:22,889
Pues quiero retornar x dividido entre y.

354
00:54:23,250 --> 00:54:25,329
Esto es muy propenso a fallos.

355
00:54:25,329 --> 00:54:35,050
Porque ¿qué pasa si yo en una división recuerdo que la parte de arriba se llama numerador, la parte de abajo se llama denominador?

356
00:54:36,570 --> 00:54:45,030
Si yo de numerador pongo un cero, no pasa nada porque el dividido entre uno sería cero.

357
00:54:45,670 --> 00:54:50,809
Pero si el denominador fuese cero, ahí da error porque es un infinito.

358
00:54:50,809 --> 00:55:00,289
Vale, separamos y copiamos.

359
00:55:03,739 --> 00:55:19,320
Donde copiamos, introduzca el primer valor a dividir, introduzca el segundo valor a dividir

360
00:55:19,320 --> 00:55:45,500
Y ahora llamamos a la función el cociente es. Y ya tenemos el dividir, el multiplicar, el restar. Y llamamos a dividir. ¿Y qué es lo que quieres dividir? Pues x.

361
00:55:45,500 --> 00:55:49,530
NUM1 y NUM2

362
00:55:49,530 --> 00:55:49,889
por Dios

363
00:55:49,889 --> 00:55:53,010
NUM1 y NUM2

364
00:55:53,010 --> 00:55:54,849
¿Vale?

365
00:55:56,070 --> 00:55:57,630
También falta el NUM1

366
00:55:57,630 --> 00:55:59,190
en la multiplicación, creo

367
00:55:59,190 --> 00:56:03,349
Bien visto

368
00:56:03,349 --> 00:56:06,610
Bueno, vamos a ver

369
00:56:06,610 --> 00:56:08,989
Este recibe dos enteros

370
00:56:08,989 --> 00:56:10,769
En lugar de multiplicar

371
00:56:10,769 --> 00:56:12,369
efectivamente lo que tenía

372
00:56:12,369 --> 00:56:14,489
NUM1 y NUM2, nos ha multiplicado

373
00:56:14,489 --> 00:56:15,469
NUM2 por NUM2

374
00:56:15,469 --> 00:56:19,820
Bueno, pues ejecutamos y

375
00:56:19,820 --> 00:56:22,099
Y ya está, y vamos a ver.

376
00:56:27,019 --> 00:56:34,079
Cutre calculadora, el valor 10, el valor 20, nos da 30, ¿vale?

377
00:56:34,159 --> 00:56:38,179
El valor a restar, pues 30 menos 10 nos va a dar 20.

378
00:56:39,800 --> 00:56:42,119
Quiero multiplicar 10 por 10.

379
00:56:44,219 --> 00:56:45,699
¡Oh! ¿Qué ha pasado?

380
00:56:50,900 --> 00:56:55,360
¿Qué he escrito? Pues que he escrito 10 por 10 en el primer valor.

381
00:56:55,360 --> 00:57:08,760
¿Veis? Lo que os decía, que si me está pidiendo un entero y yo resulta que no le estoy metiendo un entero, pues me está dando un error que Java útil, que son de distinto tipo de lo que esperas.

382
00:57:08,760 --> 00:57:27,559
Esto ya veremos que efectivamente se puede meter dentro de, por ejemplo, cuando estábamos viendo los métodos que recogían valores, existían métodos de que si es un entero o si no es un entero, puedas volver a pedir el valor.

383
00:57:27,559 --> 00:57:37,619
Y si no, cuando estemos viendo las excepciones, también hay una forma de controlar estos valores, de que no nos pasen.

384
00:57:38,760 --> 00:58:02,500
Bueno, volvemos a ejecutar, ahora lo hago más despacio para no... 10 y 10, la suma de 10, 20 y 10, el primer valor a multiplicar 15 y el segundo 10, y el primer valor a dividir va a ser 100 entre 5.

385
00:58:02,500 --> 00:58:28,380
Bueno, pues hasta ahora, hasta aquí, ya nos ha funcionado todo esto, ¿no? ¿Alguna duda de esto? Vale. Pues si no hay ninguna duda, vamos a seguir viendo cositas como hemos hecho una clase que se llama calculadora y todos los métodos los hemos metido dentro de ella.

386
00:58:29,340 --> 00:58:30,840
Esto no es la forma de proceder.

387
00:58:31,280 --> 00:58:37,400
De hecho, yo voy a tener una aplicación que va a estar formada por muchísimas clases.

388
00:58:38,360 --> 00:58:47,860
Solo una clase va a tener el método main y lo normal es que yo tenga lo que es el negocio separado por clases

389
00:58:47,860 --> 00:58:53,159
y luego que le llame, en este caso lo estoy llamando del método main, le llame desde otro punto.

390
00:58:53,780 --> 00:58:54,699
Vamos a hacer una cosa.

391
00:58:54,699 --> 00:59:08,699
Esta es nuestra clase principal, ¿veis? Pero dentro de nuestro proyecto no vamos a crear otra clase. La voy a llamar, voy a meter los cálculos, la voy a llamar cálculos.

392
00:59:08,699 --> 00:59:30,039
Cálculos. Perfecto. Si os dais cuenta, aquí hay varias cosas interesantes. Una de ellas es que, como me la he creado dentro de mi mismo paquete, me está diciendo que el paquete es ese.

393
00:59:30,039 --> 00:59:37,260
tanto la calculadora como los cálculos, como la clase cálculo, están en el mismo paquete.

394
00:59:37,880 --> 00:59:41,239
Y otra cosa interesante es que esta es una clase secundaria,

395
00:59:42,320 --> 00:59:47,860
que quiere decir que no tiene el método main porque ya ha detectado que el método main está en otro ciclo.

396
00:59:48,340 --> 00:59:52,000
Como solo puede haber una clase que tenga el método main, aquí no lo ha añadido.

397
00:59:53,260 --> 00:59:56,960
Entonces nos vamos a ir a nuestra clase calculadora Java, que la tenemos aquí.

398
00:59:56,960 --> 01:00:09,239
Vamos a coger todos los métodos hasta aquí, los voy a quitar de aquí y me la voy a llevar a cálculos.

399
01:00:09,239 --> 01:00:39,300
Y me dice, ¿quieres resolver todos los problemas que hemos encontrado? Que es que aquí estás utilizando la clase escáner, pero no tienes el paquete importado. Sí, hombre, resuélvelo. Ya nos ha importado el paquete escáner y aquí no me da ningún problema. ¿Veis? Pero vaya, han empezado a dar problemas en calculadora.

400
01:00:39,300 --> 01:00:55,619
¿Veis? Se ha puesto en rojo porque esto tiene problemas. ¿Y qué problemas tiene? Pues que no conoce suma porque no está aquí declarado.

401
01:00:56,320 --> 01:01:03,800
Y claro, no está aquí declarado y aunque sea estático no está aquí. Entonces, tengo que decirle que se llama… ¿Dónde está?

402
01:01:03,800 --> 01:01:25,019
Entonces, no voy a declarar un objeto porque yo quiero que siga siendo estático, pero como está en otra clase, al igual que hacíamos con la clase más, si quiero utilizar el método suma que está en la clase cálculos, tendré que decir que dentro de cálculos, punto suma.

403
01:01:25,019 --> 01:01:32,139
¿Veis? Me aparece el único método estático que hay en la clase. Si hubiera más métodos estáticos, podría utilizar más.

404
01:01:34,800 --> 01:01:38,079
¿Y qué otro error me aparece?

405
01:01:38,980 --> 01:01:44,260
Bueno, pues aquí me aparece otro error, que es, ¿cuál, cuál, cuál? Aquí.

406
01:01:47,050 --> 01:01:51,730
Que no encuentra el método, el método resta.

407
01:01:51,989 --> 01:01:54,250
¿Pero por qué no lo encuentra? Por lo mismo que antes.

408
01:01:54,869 --> 01:01:59,670
El método resta lo habíamos declarado, porque no queríamos que fuera estático,

409
01:01:59,670 --> 01:02:05,369
lo habíamos declarado de la clase calculadora, y ya no es la clase calculadora,

410
01:02:05,429 --> 01:02:09,309
quien contiene el método resta, en la clase cálculos.

411
01:02:09,969 --> 01:02:12,250
Entonces ahora, cálculos.

412
01:02:13,250 --> 01:02:14,670
Mi variable cálculos,

413
01:02:17,269 --> 01:02:22,929
ah, claro, mi variable cálculos tiene que ser de tipo cálculo.

414
01:02:23,230 --> 01:02:27,250
Y aquí ya no es el constructor calculadora,

415
01:02:27,250 --> 01:02:31,309
sino que es el constructor cálculos.

416
01:02:32,610 --> 01:02:34,150
Se ha resuelto el problema.

417
01:02:35,429 --> 01:02:47,869
Y ahora ya tengo dentro de mi clase principal la invocación a los métodos de mi clase cálculos y si esto lo ejecutamos vemos que se han quitado los errores que tenía.

418
01:02:47,869 --> 01:03:12,610
Y lo mismo. Suma 50, suma 75, resta 100, resta 25, multiplica 10 por 20. Ah, y una cosa que iba a decir aquí ahora. Y divide 75 entre 10 para que salga.

419
01:03:13,389 --> 01:03:33,469
Otra cosa que nos puede pasar es que yo he declarado de tipo integer, y bueno, a ver, tampoco que sean los cálculos muy exagerados, pero si yo le pongo aquí 1525 multiplicado por no sé cuánto mil, se me va a desbordar y no voy a poder utilizar el tipo integer, ¿vale?

420
01:03:33,469 --> 01:03:41,610
Esas son cositas que ya tenéis que ir viendo y declarar la variable en función del valor que va a retornar.

421
01:03:43,710 --> 01:03:44,829
¿Alguna duda hasta aquí?

422
01:03:47,829 --> 01:03:52,269
Una cosilla, ¿por qué ha salido la división con el coeficiente 7.0 en vez de 7.5?

423
01:03:53,610 --> 01:03:57,230
¿7.0 o 7.5? ¿Por qué 7.0 o 7.5? ¿Qué tenía que poner?

424
01:03:57,969 --> 01:03:59,769
7.5, ¿no?

425
01:03:59,769 --> 01:04:00,949
Ah, sí, de verdad.

426
01:04:00,949 --> 01:04:04,349
el cociente es

427
01:04:04,349 --> 01:04:06,789
calculo dividir

428
01:04:06,789 --> 01:04:08,670
y dividir me devolvía un double

429
01:04:08,670 --> 01:04:08,869
¿no?

430
01:04:09,909 --> 01:04:17,110
¿me dividía un double?

431
01:04:17,429 --> 01:04:20,170
ah pues sí, porque no sé por qué me lo he puesto ahí

432
01:04:20,170 --> 01:04:22,050
¿qué más le ha restado?

433
01:04:22,150 --> 01:04:23,250
¿ha dividido o no?

434
01:04:24,489 --> 01:04:25,829
sí, no sé

435
01:04:25,829 --> 01:04:27,769
curioso

436
01:04:27,769 --> 01:04:30,090
efectivamente tiene que ser 0,7.5

437
01:04:30,090 --> 01:04:31,250
pues tiene que tener una explicación

438
01:04:31,250 --> 01:04:33,650
no sé, lo miro y os digo

439
01:04:33,650 --> 01:04:34,690
a ver por qué lo he puesto

440
01:04:34,690 --> 01:04:36,269
tampoco es importante

441
01:04:36,269 --> 01:04:38,710
no, pero a mí me pica la curiosidad

442
01:04:38,710 --> 01:04:40,929
a lo mejor

443
01:04:40,929 --> 01:04:42,369
ha redondeado o algo así

444
01:04:42,369 --> 01:04:44,269
ha redondeado para arriba, bueno, a ver

445
01:04:44,269 --> 01:04:47,329
ha redondeado para abajo

446
01:04:47,329 --> 01:04:49,010
ha cogido la base

447
01:04:49,010 --> 01:04:51,070
porque 7 dividido entre 10

448
01:04:51,070 --> 01:04:52,710
si hubiera redondeado para arriba

449
01:04:52,710 --> 01:04:53,750
debería ser 8

450
01:04:53,750 --> 01:05:01,170
uy, qué pesado

451
01:05:01,170 --> 01:05:02,510
lo tenía que haber comentado los otros

452
01:05:02,510 --> 01:05:04,630
25

453
01:05:04,630 --> 01:05:12,940
a ver, esto era en la división

454
01:05:12,940 --> 01:05:17,679
vamos a poner 76

455
01:05:17,679 --> 01:05:24,480
vale

456
01:05:24,480 --> 01:05:25,980
que bonito

457
01:05:25,980 --> 01:05:28,980
Manuela

458
01:05:28,980 --> 01:05:30,760
no lo sé, ¿puedes ir donde está el

459
01:05:30,760 --> 01:05:33,000
system println

460
01:05:33,000 --> 01:05:33,760
de dividir?

461
01:05:34,320 --> 01:05:35,420
sí, es que a ver

462
01:05:35,420 --> 01:05:38,659
el system println de dividir está en

463
01:05:38,659 --> 01:05:39,139
calculador

464
01:05:39,139 --> 01:05:44,250
solo hago llamar a dividir

465
01:05:44,250 --> 01:05:47,730
prueba

466
01:05:47,730 --> 01:05:50,170
es que estoy

467
01:05:50,170 --> 01:05:51,210
es que estoy leyendo

468
01:05:51,210 --> 01:05:53,929
no, son dos enteros

469
01:05:53,929 --> 01:05:56,510
en vez de poner

470
01:05:56,510 --> 01:05:57,170
pin y n

471
01:05:57,170 --> 01:05:58,550
ponlo con pin f

472
01:05:58,550 --> 01:06:01,929
yo creo que os lo confirmo

473
01:06:01,929 --> 01:06:02,989
pero va a ser esto

474
01:06:02,989 --> 01:06:05,630
la división entre dos enteros te va a devolver un entero

475
01:06:05,630 --> 01:06:07,309
si, claro

476
01:06:07,309 --> 01:06:09,809
entonces lo que está haciendo

477
01:06:09,809 --> 01:06:11,989
es devolviendo el entero en lugar de los decimales

478
01:06:11,989 --> 01:06:16,090
si yo le digo aquí en vez de next int

479
01:06:16,090 --> 01:06:17,449
le vamos a poner

480
01:06:17,449 --> 01:06:18,769
punto next doble

481
01:06:18,769 --> 01:06:23,190
next doble

482
01:06:23,190 --> 01:06:23,710
¿dónde está?

483
01:06:29,250 --> 01:06:30,070
next doble

484
01:06:30,070 --> 01:06:42,960
y next doble

485
01:06:42,960 --> 01:06:45,960
vamos a ver, quería que me lo escribiera

486
01:06:45,960 --> 01:06:47,179
next doble

487
01:06:47,179 --> 01:06:51,519
para escribir también

488
01:06:51,519 --> 01:06:56,400
en un 1

489
01:06:56,400 --> 01:06:57,280
en un 2

490
01:06:57,280 --> 01:07:11,380
20 y aquí ponemos

491
01:07:11,380 --> 01:07:13,019
10

492
01:07:13,019 --> 01:07:20,170
y ahora

493
01:07:20,170 --> 01:07:22,610
dividir que me devolvía

494
01:07:22,610 --> 01:07:27,789
Amigo, vale

495
01:07:27,789 --> 01:07:32,889
Dividir, dividir

496
01:07:32,889 --> 01:07:38,730
Doble X y doble

497
01:07:38,730 --> 01:07:53,480
Vale, sumamos 120 más 210

498
01:07:53,480 --> 01:07:59,179
Restamos 200 menos 100

499
01:07:59,179 --> 01:08:03,139
Multiplicamos 10 por 10

500
01:08:03,139 --> 01:08:07,480
Y aquí dividimos 75 dividido entre 10

501
01:08:09,159 --> 01:08:11,340
Ya está, ya tenemos nuestro 7,5.

502
01:08:13,059 --> 01:08:15,159
La división de dos enteros, un entero.

503
01:08:16,500 --> 01:08:17,180
¿Más cositas?

504
01:08:18,640 --> 01:08:21,060
Bien, pues vamos a hacer ahora otra cosa.

505
01:08:23,060 --> 01:08:29,140
Nosotros aquí tenemos nuestra clase principal, que es calculadora, y nuestra clase secundaria, que es cálculo.

506
01:08:30,140 --> 01:08:35,319
Vamos a crear, las dos están dentro del mismo paquete.

507
01:08:35,319 --> 01:08:57,239
Vamos a crear un paquete nuevo. Para crear un paquete nuevo, nos ponemos en el proyecto, en las fuentes, y voy a decir que cree un nuevo paquete Java. ¿Qué nombre le damos al paquete? Le voy a llamar paquete cálculo.

508
01:08:57,239 --> 01:09:09,529
Vale. Ahora tenemos mi paquete calculadora, mi compañía este calculadora y aquí tenemos el paquete cálculo.

509
01:09:10,329 --> 01:09:14,710
Lo que vamos a hacer va a ser llevarnos esta clase secundaria a este otro paquete.

510
01:09:16,850 --> 01:09:22,409
Me pongo aquí, le digo cortar, le pongo aquí y le digo pegar.

511
01:09:24,489 --> 01:09:27,050
Y al pegar que refactorice. Vale.

512
01:09:34,479 --> 01:09:38,920
Bueno, vamos a ver qué dos errores nos aparecen aquí.

513
01:09:39,960 --> 01:09:53,359
Lo primero, si recordáis, el método suma era un método que era estático y que era de paquete, es decir, no es público.

514
01:09:53,359 --> 01:09:55,840
Además, si veis, lo está diciendo en el mensaje.

515
01:09:56,479 --> 01:10:02,119
Suma no es público, entonces no se puede acceder desde fuera de otro paquete,

516
01:10:02,119 --> 01:10:22,760
Porque la visibilidad que le habíamos puesto a suma era de paquete. Nos vamos a cálculos y aquí no teníamos puesto nada, con lo cual, lo que os comentaba antes, era por default.

517
01:10:22,760 --> 01:10:36,079
¿Y qué más cosas nos dice? Bueno, pues que resta tampoco es público. Las dos son de paquete, visibilidad paquete. ¿Cómo lo arreglamos? Pues lo ponemos público.

518
01:10:36,079 --> 01:10:41,779
Si queremos utilizarlo, oye, si no queremos utilizarlo, pues quitamos esa entrada de ahí y ya está.

519
01:10:42,539 --> 01:10:43,840
Este lo ponemos público.

520
01:10:46,100 --> 01:10:47,520
Esto lo ponemos público.

521
01:10:48,859 --> 01:10:52,960
Y si nos vamos a calculadora, ya ha quitado los errores.

522
01:10:54,800 --> 01:11:03,600
Y ahora tenemos en dos paquetes diferentes, desde la clase principal y en otro paquete adicional.

523
01:11:06,079 --> 01:11:07,800
Ejecutamos y lo mismo.

524
01:11:11,180 --> 01:11:17,220
Sumamos 2 más 2, sumáis 4, restamos 2 menos 2,

525
01:11:17,819 --> 01:11:19,039
¡eh!, si no que me da error.

526
01:11:19,899 --> 01:11:32,500
2 menos 2 me da 0, multiplicamos 10 por 2, 20, y dividimos 50 entre 5.

527
01:11:32,500 --> 01:11:42,079
Y veis que aunque estén en paquetes diferentes, bien utilizado, funciona igual.

528
01:11:42,079 --> 01:12:00,420
Y ojo, ¿qué nos ha pasado? Que como le he dicho que al cortar y pegar refactorice, él me lo recoloca. Que tenía que haber hecho no refactorizar para que os dierais cuenta de una cosa que nos ha añadido él.

529
01:12:00,420 --> 01:12:11,760
que para poder utilizar cálculos dentro de calculadora para utilizar cálculos me ha tenido que importar el paquete cálculos.

530
01:12:15,159 --> 01:12:23,720
En este caso, ¿se podría decir que en vez de la clase cálculo del paquete cálculo pudo tener un asterisco porque solamente tiene una sola clase dentro?

531
01:12:23,720 --> 01:12:25,399
sería lo mismo

532
01:12:25,399 --> 01:12:27,180
siempre podéis poner un asterisco

533
01:12:27,180 --> 01:12:28,800
realmente no es porque tenga una clase

534
01:12:28,800 --> 01:12:29,899
yo lo que estoy importando

535
01:12:29,899 --> 01:12:32,340
es dentro del paquete cálculos

536
01:12:32,340 --> 01:12:34,399
estoy importando los métodos

537
01:12:34,399 --> 01:12:36,319
pero sí

538
01:12:36,319 --> 01:12:38,699
aquí puedo poner el asterisco

539
01:12:38,699 --> 01:12:40,239
y ya me importaría todo y ya está

540
01:12:40,239 --> 01:12:42,319
y de hecho vamos a ver

541
01:12:42,319 --> 01:12:44,560
que es muy normal

542
01:12:44,560 --> 01:12:45,600
poner el asterisco

543
01:12:45,600 --> 01:12:48,460
si la aplicación es de cierta

544
01:12:48,460 --> 01:12:50,619
envergadura y te va a traer 200 paquetes

545
01:12:50,619 --> 01:12:51,800
pues le pone, o bueno, 200

546
01:12:51,800 --> 01:12:53,220
perdón, 200 clases

547
01:12:53,220 --> 01:13:24,739
Es un poco exagerado decirlo, pero si vas a meter muchas, en lugar de tener una ristra de import, también podrías ponerlas. ¿Alguna duda más? Bueno, pues por mi parte, esto es lo que os quería contar de los métodos y de lo que es la modularización, tanto lo hemos visto dentro de la misma clase como en clases diferentes, dentro del mismo paquete como en paquetes diferentes.

548
01:13:25,619 --> 01:13:30,300
La siguiente pregunta es que me podría hacer alguien es, ¿y si está en proyectos distintos?

549
01:13:32,039 --> 01:13:34,279
Porque aquí todo está dentro del proyecto calculadora.

550
01:13:35,520 --> 01:13:37,699
Bueno, pues eso ya lo veremos en otra versión.

551
01:13:39,840 --> 01:13:45,779
Habría que hacer un ejecutable y incorporarlo al proyecto donde lo quiera utilizar.

552
01:13:48,100 --> 01:13:52,319
Bien, pues hasta aquí es todo y muchas gracias por la atención.