Saltar navegación

Videoconferencia 15 de mayo - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 15 de mayo de 2025 por Enrique B.

14 visualizaciones

Más información Transcripción

Descargar la transcripción

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. 00:00:01
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. 00:00:11
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. 00:00:24
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. 00:00:40
También estuvimos viendo los comentarios de tipo YouTube, que es para que nosotros nos pongamos unos recordatorios como tareas pendientes por hacer. 00:01:04
Luego estuvimos viendo cómo se declaraban variables en Java. 00:01:16
Estuvimos viendo que cuando nosotros hacemos un programa, al programa le tenemos que suministrar unos datos, 00:01:22
estos datos los procesa y de vuelta nos muestra una salida de esos datos procesados. 00:01:31
El añadir los datos a los programas puede ser desde variables, desde estructuras de datos como ficheros, bases de datos, etc. 00:01:36
Lo más inmediato, lo más básico es que introduzcamos los datos mediante variables y de estas hay de muchos tipos. 00:01:49
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. 00:01:59
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. 00:02:25
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. 00:02:46
¿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. 00:02:57
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. 00:03:05
Más cositas que vimos aquí. Además de los tipos primitivos, existe un caso especial que no es un tipo primitivo, 00:03:18
sino que es una clase de lápiz de Java que es el de tipo string. 00:03:30
Lo utilizamos como si fuera una variable normal, como si fuera una variable primitiva, 00:03:38
pero realmente, cuando yo estoy declarando aquí la variable nombre, es un objeto de la clase string. 00:03:43
Estuvimos viendo diferentes clases del paquete java.lang, es decir, la API de java está formada por un montón de paquetes, 00:03:51
donde un paquete es una agrupación de clases y el paquete por defecto es el que se llama java.lang. 00:04:04
¿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. 00:04:13
¿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. 00:04:33
Más cosas que vimos. Estuvimos viendo dentro del paquete Havalan el uso de unos métodos que es el print, println y printf. 00:04:47
Estos métodos pertenecen a la clase System. 00:04:57
¿Qué diferencia hay entre print y println? Pues que print no hace un salto de línea y println sí. 00:05:01
Y bueno, ya estuvimos viendo que si pongo esto, en este caso es un print y en este caso es un println, 00:05:09
ahora lo ejecutaremos y veremos la diferencia, pero ya lo vimos también el otro día. 00:05:18
Y que teníamos que tener cuidado cuando yo dentro de un println puedo concatenar variables y puedo concatenar texto. 00:05:22
Si concateno variables que son de tipo numérico hay que tener cuidado y ponerlas entre paréntesis, por ejemplo, 00:05:35
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, 00:05:43
en lugar de realizar la suma de lo que contenga entero y de lo que contenga flotante. 00:05:53
Vamos a ejecutar hasta aquí para que veáis la diferencia antes de pasar al uso del PRI-NEC. 00:06:00
Para ejecutar existen diferentes formas. La más inmediata es desde aquí, con la flechita verde. 00:06:06
o pulsando F6, o con Room, Room Project, ¿vale? 00:06:13
Pulsamos la flechita, en la parte del panel de la consola, que es este de aquí abajo, 00:06:18
está compilando y muestra la información de salida que he puesto en el mail, 00:06:24
y pues esto es hasta aquí lo que hemos visto, que aquí tengo uso del paquete Java LAN, 00:06:32
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. 00:06:39
Como nombre se llama Carmelo, me pone Carmelo IN y luego he puesto aquí que me ponga el valor de la variable entero. 00:06:59
Como entero pone un 42, pues él me saca 42 entradas para un concierto. 00:07:10
Como esto es un print, a continuación de esta frase que hemos puesto aquí, me pone la frase siguiente. 00:07:16
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í. 00:07:24
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. 00:07:48
Sin embargo, cuando lo he puesto entre paréntesis, lo que me hace es la suma de lo que contienen las dos variables. 00:08:12
Luego estuvimos viendo el uso de printf. 00:08:23
Printf lo que nos permite es darle formato a la salida que muestro por consola, por pantalla, por lo que sea. 00:08:28
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. 00:08:37
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. 00:08:53
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, 00:09:04
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. 00:09:18
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. 00:09:29
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. 00:09:49
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. 00:10:10
Pues lógicamente el 10 no le está haciendo efecto. 00:10:28
Cuando le estoy diciendo esto, pues dice mostrar solo los cuatro caracteres de la cadena. 00:10:33
Y cuando estoy utilizando formato con número en decimal, le estoy diciendo sácame dos decimales. 00:10:40
Vamos a ver el resultado de cómo podemos poner esto de distinta forma. 00:10:49
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. 00:10:52
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. 00:11:11
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. 00:11:22
Y aquí lo estoy diciendo que lo alinee también a la izquierda. Aquí tenemos la salida. 00:11:37
veis que el printf nos permite hacer tabulaciones para que toda mi salida quede perfectamente ordenada. 00:11:46
Si yo, por ejemplo, en el salario del 3, ¿cuál es este? El segundo. 00:11:56
Si yo el salario este le pongo 50 solo, ejecutamos, vale. 00:12:03
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. 00:12:18
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 00:12:39
y así, aunque el número sea más pequeño uno que otro, pues la tabla me queda en condiciones. 00:12:50
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. 00:12:57
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? 00:13:15
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. 00:13:31
Luego profundizaremos más cuando vayamos a la parte de declarar un objeto de clase. 00:13:46
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. 00:13:50
Vamos a ver los distintos ejemplos o algunos ejemplos que vimos con la clase M. 00:14:06
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. 00:14:11
Aquí solamente hemos hecho la declaración y luego a dos de ellas le he puesto valor. 00:14:26
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. 00:14:32
Si, por ejemplo, esto me va a dar error porque no está declarado, ahora lo pone, bueno, sí, lo declaro a la vez. 00:14:43
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. 00:14:52
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? 00:15:05
¿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. 00:15:30
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. 00:15:57
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. 00:16:19
¿Qué significa esto? Que yo tengo una clase que se llama math y que tiene un método que se llama min. 00:16:27
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. 00:16:32
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. 00:16:42
Cuando yo estoy utilizando clases y métodos que retornan valores, ¿qué significa que retornan un valor? Que devuelven un valor. 00:17:03
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. 00:17:15
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. 00:17:35
Otro ejemplo de método que estuvimos viendo es el valor absoluto. 00:17:46
El valor absoluto es el valor de un número sin el signo. 00:17:52
Si yo me declaro una variable num3 que tiene el valor menos 200, el valor absoluto de menos 200 es 200. 00:17:55
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. 00:18:04
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. 00:18:22
¿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. 00:18:37
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. 00:19:02
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. 00:19:15
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. 00:19:35
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, 00:19:49
con dos decimales, la raíz cuadrada y ya está, del método de la clase MAP, más o menos vimos eso. 00:20:08
Luego, el System Outputing LN es la salida por consola, por pantalla, de la información. 00:20:20
Luego está interesante que le podamos meter nosotros información, porque lo que habíamos hecho aquí, 00:20:29
cuando estamos asignando valores a las variables 00:20:33
es que me declaraba la variable 00:20:37
pero ya le decía pues tiene el valor tal 00:20:39
o tiene el valor más cual. 00:20:43
Es más interesante que le pidamos al usuario 00:20:45
que introduzca el valor que quiera 00:20:49
porque si no yo tendría que modificar el programa 00:20:50
cada vez que quiero hacerlo con un número distinto. 00:20:54
¿Cómo utilizamos la entrada por teclado? 00:20:58
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. 00:21:03
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. 00:21:17
Y eso es lo que teníamos puesto aquí arriba. 00:21:29
En los import se pone. 00:21:34
¿Veis que si yo comento esta línea, con lo cual si está comentada ya no la trata Java, 00:21:36
me va a aparecer aquí un error que me está diciendo que aquí pretendía utilizar la clase, 00:21:42
pero no puedo hacerlo porque no me la he importado. 00:21:50
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. 00:21:53
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. 00:22:10
O podría decirle, dentro de Java útil, importamelo todo y eso se identifica con un asterisco. 00:22:32
Dejamos esto como estaba, quitamos el comentario para que no nos derrobe y ahora vamos a seguir explicando esto de la clase de Scanner. 00:22:45
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. 00:23:00
Entonces, para utilizar la clase Scanner y pedir valores por teclado, tengo que declararme un objeto de ese tipo, de esa clase. 00:23:13
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. 00:23:26
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. 00:23:40
Esto parece un trabalenguas, pero yo le digo, me quiero declarar una clase de tipo escáner y para eso invoca a su constructor. 00:24:02
El constructor de una clase es el que inicializa y reserva espacio para ese objeto. 00:24:13
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. 00:24:20
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. 00:24:37
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? 00:24:55
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. 00:25:11
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. 00:25:35
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. 00:25:48
Si voy a recoger un número entero, podría utilizar el método Nessie. 00:25:59
Vale, entonces, en función de lo que yo vaya a recoger, utilizaré un método u otro. 00:26:03
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. 00:26:12
A continuación, le estoy pidiendo que me, le estoy pidiendo por pantalla, introduzca su edad. 00:26:24
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. 00:26:31
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. 00:26:48
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. 00:27:06
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, 00:27:18
le puedo dar intro y él me concatena y me hace formatear esto. 00:27:25
Y luego, la variable escáner está bien que la cierre. 00:27:30
Más que nada porque la variable escáner se utiliza también para tratamiento de ficheros. 00:27:36
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. 00:27:41
Y bueno, hasta aquí creo que más o menos lo que estuvimos viendo el otro día. ¿Hay alguna duda de esto? 00:28:02
De momento ninguna. 00:28:12
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. 00:28:14
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. 00:28:32
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 00:28:57
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. 00:29:07
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. 00:29:26
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. 00:29:47
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. 00:30:01
¿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. 00:30:19
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. 00:30:39
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. 00:30:55
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. 00:31:17
Llave que abre y llave que cierra. 00:31:25
Bueno, pues hasta ahora lo único que tengo aquí es no devuelve nada, se llama suma y no acepta ningún parámetro. 00:31:31
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. 00:31:41
¿Y qué tipos de datos puede recibir? Exactamente los mismos. Tipos primitivos, estructuras de datos, objetos y todo lo que se nos ocurra. 00:32:02
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. 00:32:12
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… 00:32:28
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. 00:32:43
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. 00:33:04
Veréis que lo pone en cursiva porque no sabe lo que es. 00:33:30
¿Qué nos falta? Importar la clase. 00:33:34
La hemos importado y ya lo tenemos aquí. 00:33:36
Vale, ¿qué más cositas? 00:33:40
Bueno, pues introduzca el variable valor a sumar, lo tenemos que recoger en alguna variable. 00:33:42
Lo vamos a recoger en una de ellas. 00:33:48
Y le vamos a decir que el valor x es igual, ¿cómo se llama mi variable? 00:33:50
Teclado, punto, me aparecen todos los métodos que puedo utilizar, y como es un entero, le digo que me recoja el primer entero. 00:33:58
Repetimos lo mismo para el segundo. 00:34:12
Introduzca el segundo valor asumido. 00:34:16
Y aquí le voy a decir que la variable i va a ser el segundo que meta el señor. 00:34:19
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? 00:34:25
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. 00:35:05
x más y. Vale. Aquí hay que fijarse en una cosa. Yo aquí le estoy metiendo literales. 00:35:17
Bueno, pues hay que saber que si yo quiero que ponga la suma de y a continuación lo que contiene la variable x, 00:35:25
si yo no le dejo aquí un espacio 00:35:30
me va a poner 00:35:32
la suma de y el valor a continuación 00:35:34
entonces espacio 00:35:37
después de este valor le pongo otro literal 00:35:37
hay que dejar otro espacio 00:35:40
porque si no esto va a quedar feo 00:35:42
y después de aquí 00:35:44
hay algo que está mal, a ver 00:35:46
la suma de x 00:35:50
y la suma de y 00:35:51
te falta ponerle como variable y 00:35:54
ahí estamos, muy bien listo 00:35:56
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. 00:35:58
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. 00:36:24
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. 00:36:46
Más cositas 00:37:02
Probamos, ¿cómo llamamos al método suma? 00:37:05
Pues ¿cómo se llama? 00:37:08
Suma, ¿no? 00:37:10
Uy, ¿qué pasa si le pongo así? 00:37:13
Y eso no es un método 00:37:16
Porque yo le he llamado en minúsculas 00:37:18
Bueno, pues le voy a decir 00:37:20
Sum, a ver, perdón 00:37:23
Suma 00:37:24
Y como se define con paréntesis 00:37:25
Se va a decir suma 00:37:29
Y si no tiene parámetros, de la misma manera le tengo que poner los parámetros. 00:37:31
Vale, pero ¿qué me está diciendo este ahora? 00:37:39
Me está diciendo que yo no puedo llamar a un método que no sea estático. 00:37:43
Recordar que cuando estuvimos viendo la clase math existía el concepto de método estático. 00:37:53
desde un contexto que es estático. 00:38:00
Yo lo estoy llamando desde el main, que es estático. 00:38:06
Entonces, me está diciendo que no puedo llamar a suma porque suma no es estático. 00:38:10
¿Cómo lo resolvería? 00:38:16
Pues lo más inmediato sería poner aquí que este método es estático. 00:38:19
Es decir, lo convierto en un método de clase. 00:38:26
El siguiente le vamos a hacer no estático. 00:38:30
Bueno, y si yo ejecuto esto, ¿qué pasa? 00:38:35
Que cuando llegue a este punto, porque ya sabemos que el main es el programa que se ejecuta 00:38:40
cuando compilamos y ejecutamos, y se va a ejecutar desde la primera línea, 00:38:47
me pondrá Qt recalculadora y luego me llamará al método suma. 00:38:54
¿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. 00:39:00
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. 00:39:15
y efectivamente me ha dicho que la suma de 20 y la suma de 150 es 170 00:39:37
y esto es lo que decía que se ha quedado ahí fácil 00:39:43
y esto ya es manía, introduzca el valor a sumar 00:39:46
así queda más bonito, introduzca el valor a sumar 00:39:51
así queda más bonito 00:39:54
y el resultado es tal 00:39:56
y si me apuras en lugar de 00:39:59
como le estoy pidiendo un valor 00:40:02
en lugar del println para que yo tenga que introducir el valor aquí abajo, pues que se quede esperando aquí a la derecha. 00:40:05
Introduzca el valor a sumar, 250. 00:40:19
Introduzca el segundo valor a sumar, 300. 00:40:23
La suma es 250. La suma de 250, uy, qué feo, y de 300 es 150. 00:40:28
Vale. 00:40:40
¿Alguna duda hasta aquí? 00:40:42
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. 00:40:43
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. 00:41:00
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. 00:41:25
Para quitarme este error y para poner el retur, efectivamente yo le digo retur, devuélveme x menos y. 00:41:48
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. 00:41:59
¿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. 00:42:15
Es decir, solo se conocen en el sitio donde han sido declaradas. Por lo tanto, yo podría utilizarlas perfectamente desde aquí. 00:42:32
¿Cómo podemos llamar al método resta? 00:42:41
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. 00:42:47
vale pues 00:43:04
aquí tengo que utilizar 00:43:07
como aquí se los pedían 00:43:10
el método 00:43:12
aquí no se los estoy pidiendo 00:43:12
solo tengo que pedir de fuera 00:43:14
vamos a utilizar 00:43:16
salt 00:43:17
introduzca pues lo mismo 00:43:19
introduzca 00:43:26
num1 a restar 00:43:30
le pedimos el primer valor 00:43:33
le pedimos el segundo valor 00:43:38
bueno 00:43:45
Bueno, debería declararme alguna variable, ¿no? 00:43:47
Claro. 00:43:53
Control-C, control-V. 00:43:56
Primer número a restar, el segundo número a restar, primer número, primero a restar, primero a restar, segundo a restar. 00:44:05
¿Qué nos faltaría aquí? 00:44:24
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? 00:44:26
Este lo vamos a llamar Entrada, igual a New Entrada, New Scanner, perdón, System.in. 00:44:49
Vale. 00:45:04
Entonces, hemos hecho lo mismo que hemos hecho aquí arriba. 00:45:06
Me he declarado un objeto de tipo Scanner, le he dicho al señor que introduzca el primer valor a restar 00:45:09
y lo que el señor escriba yo quiero asignárselo al número 1, 00:45:19
luego le voy a pedir el segundo valor a restar 00:45:23
y lo que el señor escriba lo quiero asignar en la variable número 2, ¿vale? 00:45:25
Igual que antes, num1 es igual a entrada, 00:45:31
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. 00:45:41
Aquí, bueno, volvemos a meter los parámetros para resolver el error que nos está dando. 00:46:13
Réstame num1, num2. 00:46:19
¿Qué me va a decir, qué error me está diciendo? Pues lo mismo que me está diciendo de antes. 00:46:26
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. 00:46:32
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. 00:46:40
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. 00:46:58
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? 00:47:21
que si yo pongo el punto ya me está mostrando aquí 00:47:55
el método resta. 00:47:58
Si yo ejecuto esto, pues sí, vale, hace el cálculo, 00:48:06
pero en ningún sitio le estoy diciendo que lo muestre, 00:48:09
con lo cual le vamos a hacer aquí un show. 00:48:12
La resta es, y de esta forma, 00:48:16
en lugar de asignárselo a variable, 00:48:25
que ya sabéis que podríamos hacerlo, 00:48:28
llamamos al método. 00:48:32
¿Vale? 00:48:39
Bueno, pues vamos a ver, vamos a ejecutar. 00:48:40
Introduce el primer valor a sumar, claro, que me lo pide todo. 00:48:47
145, el segundo valor a sumar, 46, y es 181. 00:48:51
Ahora me dice el primer valor a restar, que le digo 250, 00:48:58
y el segundo valor a restar, que le voy a decir 50, para que me dé los círculos. 00:49:01
Y la resta es 200. 00:49:07
De momento mi calculadora va bien. 00:49:09
¿Vale? 00:49:11
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. 00:49:12
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. 00:49:42
Si no le pones nada, se llama que tiene visibilidad de paquete o visibilidad por defecto, default. 00:49:52
Si veis, aquí el main tiene una visibilidad pública. 00:50:01
Lógico, el método main es donde empieza mi aplicación. 00:50:08
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. 00:50:10
Si no ponemos nada, sería visibilidad de paquete. 00:50:28
Si ponemos public, sería público para utilizarlo por cualquiera. 00:50:32
Y hay otras visibilidades de acceso que veremos después, 00:50:36
que es private, para que no lo vea nadie, 00:50:39
solo desde la misma clase en la que está. 00:50:43
Y luego cuando veamos la herencia, protect, ¿vale? 00:50:45
Pero de momento nos vamos a quedar con que el método multiplicar 00:50:49
le voy a crear público, para ver cosas diferentes. 00:50:53
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. 00:50:58
Lo mismo que antes, me está diciendo que si yo he dicho que es entero, tengo que decir qué es lo que retorna. 00:51:24
Pues retorna lo que se meta en X por lo que se meta en Y. 00:51:33
Y ya está. 00:51:42
Probamos. 00:51:46
Para separar esto, le voy a poner aquí un primer en evasión. 00:51:49
Y, a ver, a ver, a ver, ¿desde dónde copio? 00:51:56
Aquí tenemos declarado esto. 00:52:06
Introduzco el primer valor a multiplicar. 00:52:21
En un 1 meto lo que escribe el usuario. 00:52:29
El segundo valor a multiplicar. 00:52:33
Lo que meta el usuario. 00:52:37
Y tengo mi variable cálculo declarada. 00:52:39
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. 00:52:44
¿Veis también una cosa interesante? Es que los simbolitos que me pone son diferentes en función del tipo que sea. 00:53:15
ponemos el multiplicar 00:53:26
y por último vamos a hacer 00:53:29
la de dividir, que esta va a ser rápida 00:53:32
y en el de 00:53:34
dividir pues lo mismo 00:53:38
lo que vamos a hacer va a ser 00:53:39
ponemos public también 00:53:41
public, pero para que veáis 00:53:45
un tipo distinto, esta le vamos a llamar 00:53:48
va a ser de tipo doble 00:53:50
es más fácil que una división 00:53:51
sea 00:53:53
de valores decimales, con lo cual es más 00:53:54
Interesante que sea doble porque si no, con int no lo podría poner. 00:53:58
Dividir. 00:54:02
Le metemos un entero, le metemos otro entero. 00:54:05
Valor que entra y valor que sale. 00:54:14
Lo mismo que antes. 00:54:16
¿Qué quieres retornar? 00:54:18
Pues quiero retornar x dividido entre y. 00:54:19
Esto es muy propenso a fallos. 00:54:23
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? 00:54:25
Si yo de numerador pongo un cero, no pasa nada porque el dividido entre uno sería cero. 00:54:36
Pero si el denominador fuese cero, ahí da error porque es un infinito. 00:54:45
Vale, separamos y copiamos. 00:54:50
Donde copiamos, introduzca el primer valor a dividir, introduzca el segundo valor a dividir 00:55:03
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. 00:55:19
NUM1 y NUM2 00:55:45
por Dios 00:55:49
NUM1 y NUM2 00:55:49
¿Vale? 00:55:53
También falta el NUM1 00:55:56
en la multiplicación, creo 00:55:57
Bien visto 00:55:59
Bueno, vamos a ver 00:56:03
Este recibe dos enteros 00:56:06
En lugar de multiplicar 00:56:08
efectivamente lo que tenía 00:56:10
NUM1 y NUM2, nos ha multiplicado 00:56:12
NUM2 por NUM2 00:56:14
Bueno, pues ejecutamos y 00:56:15
Y ya está, y vamos a ver. 00:56:19
Cutre calculadora, el valor 10, el valor 20, nos da 30, ¿vale? 00:56:27
El valor a restar, pues 30 menos 10 nos va a dar 20. 00:56:34
Quiero multiplicar 10 por 10. 00:56:39
¡Oh! ¿Qué ha pasado? 00:56:44
¿Qué he escrito? Pues que he escrito 10 por 10 en el primer valor. 00:56:50
¿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. 00:56:55
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. 00:57:08
Y si no, cuando estemos viendo las excepciones, también hay una forma de controlar estos valores, de que no nos pasen. 00:57:27
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. 00:57:38
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. 00:58:02
Esto no es la forma de proceder. 00:58:29
De hecho, yo voy a tener una aplicación que va a estar formada por muchísimas clases. 00:58:31
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 00:58:38
y luego que le llame, en este caso lo estoy llamando del método main, le llame desde otro punto. 00:58:47
Vamos a hacer una cosa. 00:58:53
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. 00:58:54
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. 00:59:08
tanto la calculadora como los cálculos, como la clase cálculo, están en el mismo paquete. 00:59:30
Y otra cosa interesante es que esta es una clase secundaria, 00:59:37
que quiere decir que no tiene el método main porque ya ha detectado que el método main está en otro ciclo. 00:59:42
Como solo puede haber una clase que tenga el método main, aquí no lo ha añadido. 00:59:48
Entonces nos vamos a ir a nuestra clase calculadora Java, que la tenemos aquí. 00:59:53
Vamos a coger todos los métodos hasta aquí, los voy a quitar de aquí y me la voy a llevar a cálculos. 00:59:56
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. 01:00:09
¿Veis? Se ha puesto en rojo porque esto tiene problemas. ¿Y qué problemas tiene? Pues que no conoce suma porque no está aquí declarado. 01:00:39
Y claro, no está aquí declarado y aunque sea estático no está aquí. Entonces, tengo que decirle que se llama… ¿Dónde está? 01:00:56
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. 01:01:03
¿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. 01:01:25
¿Y qué otro error me aparece? 01:01:34
Bueno, pues aquí me aparece otro error, que es, ¿cuál, cuál, cuál? Aquí. 01:01:38
Que no encuentra el método, el método resta. 01:01:47
¿Pero por qué no lo encuentra? Por lo mismo que antes. 01:01:51
El método resta lo habíamos declarado, porque no queríamos que fuera estático, 01:01:54
lo habíamos declarado de la clase calculadora, y ya no es la clase calculadora, 01:01:59
quien contiene el método resta, en la clase cálculos. 01:02:05
Entonces ahora, cálculos. 01:02:09
Mi variable cálculos, 01:02:13
ah, claro, mi variable cálculos tiene que ser de tipo cálculo. 01:02:17
Y aquí ya no es el constructor calculadora, 01:02:23
sino que es el constructor cálculos. 01:02:27
Se ha resuelto el problema. 01:02:32
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. 01:02:35
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. 01:02:47
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? 01:03:13
Esas son cositas que ya tenéis que ir viendo y declarar la variable en función del valor que va a retornar. 01:03:33
¿Alguna duda hasta aquí? 01:03:43
Una cosilla, ¿por qué ha salido la división con el coeficiente 7.0 en vez de 7.5? 01:03:47
¿7.0 o 7.5? ¿Por qué 7.0 o 7.5? ¿Qué tenía que poner? 01:03:53
7.5, ¿no? 01:03:57
Ah, sí, de verdad. 01:03:59
el cociente es 01:04:00
calculo dividir 01:04:04
y dividir me devolvía un double 01:04:06
¿no? 01:04:08
¿me dividía un double? 01:04:09
ah pues sí, porque no sé por qué me lo he puesto ahí 01:04:17
¿qué más le ha restado? 01:04:20
¿ha dividido o no? 01:04:22
sí, no sé 01:04:24
curioso 01:04:25
efectivamente tiene que ser 0,7.5 01:04:27
pues tiene que tener una explicación 01:04:30
no sé, lo miro y os digo 01:04:31
a ver por qué lo he puesto 01:04:33
tampoco es importante 01:04:34
no, pero a mí me pica la curiosidad 01:04:36
a lo mejor 01:04:38
ha redondeado o algo así 01:04:40
ha redondeado para arriba, bueno, a ver 01:04:42
ha redondeado para abajo 01:04:44
ha cogido la base 01:04:47
porque 7 dividido entre 10 01:04:49
si hubiera redondeado para arriba 01:04:51
debería ser 8 01:04:52
uy, qué pesado 01:04:53
lo tenía que haber comentado los otros 01:05:01
a ver, esto era en la división 01:05:04
vamos a poner 76 01:05:12
vale 01:05:17
que bonito 01:05:24
Manuela 01:05:25
no lo sé, ¿puedes ir donde está el 01:05:28
system println 01:05:30
de dividir? 01:05:33
sí, es que a ver 01:05:34
el system println de dividir está en 01:05:35
calculador 01:05:38
solo hago llamar a dividir 01:05:39
prueba 01:05:44
es que estoy 01:05:47
es que estoy leyendo 01:05:50
no, son dos enteros 01:05:51
en vez de poner 01:05:53
pin y n 01:05:56
ponlo con pin f 01:05:57
yo creo que os lo confirmo 01:05:58
pero va a ser esto 01:06:01
la división entre dos enteros te va a devolver un entero 01:06:02
si, claro 01:06:05
entonces lo que está haciendo 01:06:07
es devolviendo el entero en lugar de los decimales 01:06:09
si yo le digo aquí en vez de next int 01:06:11
le vamos a poner 01:06:16
punto next doble 01:06:17
next doble 01:06:18
¿dónde está? 01:06:23
next doble 01:06:29
y next doble 01:06:30
vamos a ver, quería que me lo escribiera 01:06:42
next doble 01:06:45
para escribir también 01:06:47
en un 1 01:06:51
en un 2 01:06:56
20 y aquí ponemos 01:06:57
y ahora 01:07:13
dividir que me devolvía 01:07:20
Amigo, vale 01:07:22
Dividir, dividir 01:07:27
Doble X y doble 01:07:32
Vale, sumamos 120 más 210 01:07:38
Restamos 200 menos 100 01:07:53
Multiplicamos 10 por 10 01:07:59
Y aquí dividimos 75 dividido entre 10 01:08:03
Ya está, ya tenemos nuestro 7,5. 01:08:09
La división de dos enteros, un entero. 01:08:13
¿Más cositas? 01:08:16
Bien, pues vamos a hacer ahora otra cosa. 01:08:18
Nosotros aquí tenemos nuestra clase principal, que es calculadora, y nuestra clase secundaria, que es cálculo. 01:08:23
Vamos a crear, las dos están dentro del mismo paquete. 01:08:30
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. 01:08:35
Vale. Ahora tenemos mi paquete calculadora, mi compañía este calculadora y aquí tenemos el paquete cálculo. 01:08:57
Lo que vamos a hacer va a ser llevarnos esta clase secundaria a este otro paquete. 01:09:10
Me pongo aquí, le digo cortar, le pongo aquí y le digo pegar. 01:09:16
Y al pegar que refactorice. Vale. 01:09:24
Bueno, vamos a ver qué dos errores nos aparecen aquí. 01:09:34
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. 01:09:39
Además, si veis, lo está diciendo en el mensaje. 01:09:53
Suma no es público, entonces no se puede acceder desde fuera de otro paquete, 01:09:56
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. 01:10:02
¿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. 01:10:22
Si queremos utilizarlo, oye, si no queremos utilizarlo, pues quitamos esa entrada de ahí y ya está. 01:10:36
Este lo ponemos público. 01:10:42
Esto lo ponemos público. 01:10:46
Y si nos vamos a calculadora, ya ha quitado los errores. 01:10:48
Y ahora tenemos en dos paquetes diferentes, desde la clase principal y en otro paquete adicional. 01:10:54
Ejecutamos y lo mismo. 01:11:06
Sumamos 2 más 2, sumáis 4, restamos 2 menos 2, 01:11:11
¡eh!, si no que me da error. 01:11:17
2 menos 2 me da 0, multiplicamos 10 por 2, 20, y dividimos 50 entre 5. 01:11:19
Y veis que aunque estén en paquetes diferentes, bien utilizado, funciona igual. 01:11:32
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. 01:11:42
que para poder utilizar cálculos dentro de calculadora para utilizar cálculos me ha tenido que importar el paquete cálculos. 01:12:00
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? 01:12:15
sería lo mismo 01:12:23
siempre podéis poner un asterisco 01:12:25
realmente no es porque tenga una clase 01:12:27
yo lo que estoy importando 01:12:28
es dentro del paquete cálculos 01:12:29
estoy importando los métodos 01:12:32
pero sí 01:12:34
aquí puedo poner el asterisco 01:12:36
y ya me importaría todo y ya está 01:12:38
y de hecho vamos a ver 01:12:40
que es muy normal 01:12:42
poner el asterisco 01:12:44
si la aplicación es de cierta 01:12:45
envergadura y te va a traer 200 paquetes 01:12:48
pues le pone, o bueno, 200 01:12:50
perdón, 200 clases 01:12:51
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. 01:12:53
La siguiente pregunta es que me podría hacer alguien es, ¿y si está en proyectos distintos? 01:13:25
Porque aquí todo está dentro del proyecto calculadora. 01:13:32
Bueno, pues eso ya lo veremos en otra versión. 01:13:35
Habría que hacer un ejecutable y incorporarlo al proyecto donde lo quiera utilizar. 01:13:39
Bien, pues hasta aquí es todo y muchas gracias por la atención. 01:13:48
Materias:
Inglés
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado medio
      • Primer Curso
      • Segundo Curso
    • Ciclo formativo de grado superior
      • Primer Curso
      • Segundo Curso
Subido por:
Enrique B.
Licencia:
Todos los derechos reservados
Visualizaciones:
14
Fecha:
15 de mayo de 2025 - 14:36
Visibilidad:
Clave
Centro:
IES CIFP a Distancia Ignacio Ellacuría
Duración:
1h′ 13′ 52″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
387.06 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid